Function sparseArithTesterDiv

test/sparse_arith.cpp:190–232

// Div
template<typename T>
void sparseArithTesterDiv(const int m, const int n, int factor,
                          const double eps) {
    deviceGC();

    SUPPORTED_TYPE_CHECK(T);

#if 1
    array A = cpu_randu<T>(dim4(m, n));
    array B = cpu_randu<T>(dim4(m, n));
#else
    array A = randu(m, n, (dtype)dtype_traits<T>::af_type);
    array B = randu(m, n, (dtype)dtype_traits<T>::af_type);
#endif

    A = makeSparse<T>(A, factor);

    array RA = sparse(A, AF_STORAGE_CSR);
    array OA = sparse(A, AF_STORAGE_COO);

    // Arith Op
    array resR = arith_op<af_div_t>()(RA, B);
    array resO = arith_op<af_div_t>()(OA, B);

    // Assert division by sparse is not allowed
    af_array out_temp = 0;
    ASSERT_EQ(AF_ERR_NOT_SUPPORTED,
              af_div(&out_temp, B.get(), RA.get(), false));
    ASSERT_EQ(AF_ERR_NOT_SUPPORTED,
              af_div(&out_temp, B.get(), OA.get(), false));
    if (out_temp != 0) af_release_array(out_temp);

    // We will test this by converting the COO to CSR and CSR to COO and
    // comparing them. In essense, we are comparing the resR and resO
    // TODO: Make a better comparison using dense

    // Check resR against conR
    array conR = sparseConvertTo(resR, AF_STORAGE_CSR);
    ASSERT_ARRAYS_EQ(resR, conR);

    // Check resO against conO
    array conO = sparseConvertTo(resR, AF_STORAGE_COO);
    ASSERT_ARRAYS_EQ(resO, conO);
}

#define ARITH_TESTS_OPS(T, M, N, F, EPS)              \
    TEST(SPARSE_ARITH, T##_ADD_##M##_##N) {           \