Commit 7e659a15 authored by Cianciosa, Mark's avatar Cianciosa, Mark
Browse files

Cast floats to the type in backend test.

parent c7013284

graph_tests/backend_test.cpp

+179 −67
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ template<typename T> void test_backend() { 
    assert(size_one[0] == static_cast<T> (10) &&

           "Expected a value of 10.");



    const backend::buffer<T> size_three(3, 2.0);

    const backend::buffer<T> size_three(3, static_cast<T> (2.0));

    assert(size_three.size() == 3 && "Expected a size of three.");

    for (size_t i = 0; i < 3; i++) {

        assert(size_three.at(i) == static_cast<T> (2.0) &&
@@ -33,7 +33,12 @@ template<typename T> void test_backend() { 
               "Expected a value of 10.");

    }



    backend::buffer<T> vector(std::vector<T> ({1.0, 2.0, 3.0, 4.0}));

    backend::buffer<T> vector(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0),

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    assert(vector.size() == 4 && "Expected a size of three.");

    for (size_t i = 0; i < 4; i++) {

        assert(vector.at(i) == static_cast<T> (i + 1) &&
@@ -51,7 +56,7 @@ template<typename T> void test_backend() { 
               "Expected a value one more than index.");

    }



    copy.set(5.0);

    copy.set(static_cast<T> (5.0));

    for (size_t i = 0; i < 3; i++) {

        assert(copy.at(i) == static_cast<T> (5.0) &&

               "Expected a value of 5.");
@@ -76,7 +81,12 @@ template<typename T> void test_backend() { 
               "Expected a value sqrt(one more than index).");

    }



    backend::buffer<T> vector2(std::vector<T> ({1.0, 2.0, 3.0, 4.0}));

    backend::buffer<T> vector2(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0),

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    vector2.exp();

    for (size_t i = 0; i < 4; i++) {

        assert(vector2.at(i) == std::exp(static_cast<T> (i + 1)) &&
@@ -84,8 +94,14 @@ template<typename T> void test_backend() { 
    }



//  Addition tests.

    backend::buffer<T> avec(std::vector<T> ({1.0, 2.0}));

    backend::buffer<T> bvec(std::vector<T> ({3.0, 4.0}));

    backend::buffer<T> avec(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    backend::buffer<T> bvec(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    const backend::buffer<T> add_vec_vec = avec + bvec;

    assert(add_vec_vec.size() == 2 && "Expected a size of 2");

    assert(add_vec_vec.at(0) == static_cast<T> (4.0) &&
@@ -93,8 +109,11 @@ template<typename T> void test_backend() { 
    assert(add_vec_vec.at(1) == static_cast<T> (6.0) &&

           "Expected a value of 6.");



    backend::buffer<T> bscalar(1, 3.0);

    avec.set(std::vector<T> ({1.0, 2.0}));

    backend::buffer<T> bscalar(1, static_cast<T> (3.0));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    const backend::buffer<T> add_vec_scale = avec + bscalar;

    assert(add_vec_scale.size() == 2 && "Expected a size of 2");

    assert(add_vec_scale.at(0) == static_cast<T> (4.0) &&
@@ -109,7 +128,7 @@ template<typename T> void test_backend() { 
    assert(add_scale_vec.at(1) == static_cast<T> (7.0) &&

           "Expected a value of 7.");



    backend::buffer<T> cscalar(1, -5.0);

    backend::buffer<T> cscalar(1, static_cast<T> (-5.0));

    const backend::buffer<T> add_scale_scale = bscalar + cscalar;

    assert(add_scale_scale.size() == 1 && "Expected a size of 1");

    assert(add_scale_scale.at(0) == static_cast<T> (-2.0) &&
@@ -123,8 +142,11 @@ template<typename T> void test_backend() { 
    assert(sub_vec_vec.at(1) == static_cast<T> (-2.0) &&

           "Expected a value of -2.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bscalar.set(3.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bscalar.set(static_cast<T> (3.0));

    const backend::buffer<T> sub_vec_scale = avec - bscalar;

    assert(sub_vec_scale.size() == 2 && "Expected a size of 2");

    assert(sub_vec_scale.at(0) == static_cast<T> (-2.0) &&
@@ -132,8 +154,11 @@ template<typename T> void test_backend() { 
    assert(sub_vec_scale.at(1) == static_cast<T> (-1.0) &&

           "Expected a value of -1.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    cscalar.set(-5.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    cscalar.set(static_cast<T> (-5.0));

    const backend::buffer<T> sub_scale_vec = cscalar - avec;

    assert(sub_scale_vec.size() == 2 && "Expected a size of 2");

    assert(sub_scale_vec.at(0) == static_cast<T> (-6.0) &&
@@ -147,8 +172,14 @@ template<typename T> void test_backend() { 
           "Expected a value of 8.");



//  Multiply tests.

    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    const backend::buffer<T> mul_vec_vec = avec*bvec;

    assert(mul_vec_vec.size() == 2 && "Expected a size of 2");

    assert(mul_vec_vec.at(0) == static_cast<T> (3.0) &&
@@ -156,8 +187,11 @@ template<typename T> void test_backend() { 
    assert(mul_vec_vec.at(1) == static_cast<T> (8.0) &&

           "Expected a value of 8.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bscalar.set(3.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bscalar.set(static_cast<T> (3.0));

    const backend::buffer<T> mul_vec_scale = avec*bscalar;

    assert(mul_vec_scale.size() == 2 && "Expected a size of 2");

    assert(mul_vec_scale.at(0) == static_cast<T> (3.0) &&
@@ -178,8 +212,14 @@ template<typename T> void test_backend() { 
           "Expected a value of -15.");



//  Divide tests.

    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    const backend::buffer<T> div_vec_vec = avec/bvec;

    assert(div_vec_vec.size() == 2 && "Expected a size of 2");

    assert(div_vec_vec.at(0) == static_cast<T> (1.0) /
@@ -189,8 +229,11 @@ template<typename T> void test_backend() { 
                                static_cast<T> (4.0) &&

           "Expected a value of 2/4.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bscalar.set(3.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bscalar.set(static_cast<T> (3.0));

    const backend::buffer<T> div_vec_scale = avec/bscalar;

    assert(div_vec_scale.size() == 2 && "Expected a size of 2");

    assert(div_vec_scale.at(0) == static_cast<T> (1.0) /
@@ -200,7 +243,10 @@ template<typename T> void test_backend() { 
                                  static_cast<T> (3.0) &&

           "Expected a value of 2/3.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    const backend::buffer<T> div_scale_vec = cscalar/avec;

    assert(div_scale_vec.size() == 2 && "Expected a size of 2");

    assert(div_scale_vec.at(0) == static_cast<T> (-5.0) &&
@@ -216,9 +262,18 @@ template<typename T> void test_backend() { 
           "Expected a value of -3/5.");



//  Fused multiply add tests.

    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    backend::buffer<T> cvec(std::vector<T> ({-2.0, 6.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    backend::buffer<T> cvec(std::vector<T> ({

        static_cast<T> (-2.0),

        static_cast<T> (6.0)

    }));

    const backend::buffer<T> fma_vec_vec_vec = backend::fma(avec, bvec, cvec);

    assert(fma_vec_vec_vec.size() == 2 && "Expected a size of 2");

    assert(fma_vec_vec_vec.at(0) == static_cast<T> (1.0) &&
@@ -226,9 +281,15 @@ template<typename T> void test_backend() { 
    assert(fma_vec_vec_vec.at(1) == static_cast<T> (14.0) &&

           "Expected a value of 14.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    bscalar.set(3.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    bscalar.set(static_cast<T> (3.0));

    const backend::buffer<T> fma_vec_vec_scale = backend::fma(avec, bvec, bscalar);

    assert(fma_vec_vec_scale.size() == 2 && "Expected a size of 2");

    assert(fma_vec_vec_scale.at(0) == static_cast<T> (6.0) &&
@@ -236,8 +297,14 @@ template<typename T> void test_backend() { 
    assert(fma_vec_vec_scale.at(1) == static_cast<T> (11.0) &&

           "Expected a value of 11.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    const backend::buffer<T> fma_vec_scale_vec = backend::fma(avec, bscalar, bvec);

    assert(fma_vec_scale_vec.size() == 2 && "Expected a size of 2");

    assert(fma_vec_scale_vec.at(0) == static_cast<T> (6.0) &&
@@ -245,8 +312,14 @@ template<typename T> void test_backend() { 
    assert(fma_vec_scale_vec.at(1) == static_cast<T> (10.0) &&

           "Expected a value of 10.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bvec.set(std::vector<T> ({3.0, 4.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bvec.set(std::vector<T> ({

        static_cast<T> (3.0),

        static_cast<T> (4.0)

    }));

    const backend::buffer<T> fma_scale_vec_vec = backend::fma(bscalar, avec, bvec);

    assert(fma_scale_vec_vec.size() == 2 && "Expected a size of 2");

    assert(fma_scale_vec_vec.at(0) == static_cast<T> (6.0) &&
@@ -254,7 +327,10 @@ template<typename T> void test_backend() { 
    assert(fma_scale_vec_vec.at(1) == static_cast<T> (10.0) &&

           "Expected a value of 10.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    const backend::buffer<T> fma_vec_scale_scale = backend::fma(avec, bscalar, cscalar);

    assert(fma_vec_scale_scale.size() == 2 && "Expected a size of 2");

    assert(fma_vec_scale_scale.at(0) == static_cast<T> (-2.0) &&
@@ -262,8 +338,11 @@ template<typename T> void test_backend() { 
    assert(fma_vec_scale_scale.at(1) == static_cast<T> (1.0) &&

           "Expected a value of -1.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    bscalar.set(3.0);

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    bscalar.set(static_cast<T> (3.0));

    const backend::buffer<T> fma_scale_vec_scale = backend::fma(bscalar, avec, cscalar);

    assert(fma_scale_vec_scale.size() == 2 && "Expected a size of 2");

    assert(fma_scale_vec_scale.at(0) == static_cast<T> (-2.0) &&
@@ -271,7 +350,10 @@ template<typename T> void test_backend() { 
    assert(fma_scale_vec_scale.at(1) == static_cast<T> (1.0) &&

           "Expected a value of 1.");



    avec.set(std::vector<T> ({1.0, 2.0}));

    avec.set(std::vector<T> ({

        static_cast<T> (1.0),

        static_cast<T> (2.0)

    }));

    const backend::buffer<T> fma_scale_scale_vec = backend::fma(bscalar, cscalar, avec);

    assert(fma_scale_scale_vec.size() == 2 && "Expected a size of 2");

    assert(fma_scale_scale_vec.at(0) == static_cast<T> (-14.0) &&
@@ -279,36 +361,36 @@ template<typename T> void test_backend() { 
    assert(fma_scale_scale_vec.at(1) == static_cast<T> (-13.0) &&

           "Expected a value of --13.");



    backend::buffer<T> ascalar(1, -4.0);

    cscalar.set(-5.0);

    backend::buffer<T> ascalar(1, static_cast<T> (-4.0));

    cscalar.set(static_cast<T> (-5.0));

    const backend::buffer<T> fma_scale_scale_scale = backend::fma(ascalar, bscalar, cscalar);

    assert(fma_scale_scale_scale.size() == 1 && "Expected a size of 1");

    assert(fma_scale_scale_scale.at(0) == static_cast<T> (-17.0) &&

           "Expected a value of -17.");



//  Pow tests.

    backend::buffer<T> base_scalar(1, 4.0);

    backend::buffer<T> exp_scalar(1, 0.5);

    backend::buffer<T> base_scalar(1, static_cast<T> (4.0));

    backend::buffer<T> exp_scalar(1, static_cast<T> (0.5));

    const backend::buffer<T> sqrt = backend::pow(base_scalar, exp_scalar);

    assert(sqrt.size() == 1 && "Expected a size of 1");

    assert(sqrt.at(0) == static_cast<T> (2.0) && "Expected 2.");



    base_scalar.set(4.0);

    exp_scalar.set(-0.5);

    base_scalar.set(static_cast<T> (4.0));

    exp_scalar.set(static_cast<T> (-0.5));

    const backend::buffer<T> one_over_sqrt = backend::pow(base_scalar, exp_scalar);

    assert(one_over_sqrt.size() == 1 && "Expected a size of 1");

    assert(one_over_sqrt.at(0) == static_cast<T> (0.5) &&

           "Expected 1/2.");



    base_scalar.set(4.0);

    exp_scalar.set(3.0);

    base_scalar.set(static_cast<T> (4.0));

    exp_scalar.set(static_cast<T> (3.0));

    const backend::buffer<T> x_cubed = backend::pow(base_scalar, exp_scalar);

    assert(x_cubed.size() == 1 && "Expected a size of 1");

    assert(x_cubed.at(0) == static_cast<T> (64.0) &&

           "Expected 64.");



    base_scalar.set(4.0);

    exp_scalar.set(-2.0);

    base_scalar.set(static_cast<T> (4.0));

    exp_scalar.set(static_cast<T> (-2.0));

    const backend::buffer<T> x_over_cubed = backend::pow(base_scalar, exp_scalar);

    assert(x_over_cubed.size() == 1 && "Expected a size of 1");

    assert(x_over_cubed.at(0) ==
@@ -316,16 +398,19 @@ template<typename T> void test_backend() { 
           (static_cast<T> (4.0)*static_cast<T> (4.0)) &&

           "Expected 1/(4*4).");



    base_scalar.set(4.0);

    exp_scalar.set(-0.23);

    base_scalar.set(static_cast<T> (4.0));

    exp_scalar.set(static_cast<T> (-0.23));

    const backend::buffer<T> pow_gen = backend::pow(base_scalar, exp_scalar);

    assert(pow_gen.size() == 1 && "Expected a size of 1");

    assert(pow_gen.at(0) == std::pow(static_cast<T> (4.0),

                                     static_cast<T> (-0.23)) &&

           "Expected 4^-0.23.");



    backend::buffer<T> base_vec(std::vector<T> ({4.0, 2.0}));

    exp_scalar.set(0.5);

    backend::buffer<T> base_vec(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    exp_scalar.set(static_cast<T> (0.5));

    const backend::buffer<T> sqrt_vec = backend::pow(base_vec, exp_scalar);

    assert(sqrt_vec.size() == 2 && "Expected a size of 2");

    assert(sqrt_vec.at(0) == static_cast<T> (2.0) &&
@@ -333,8 +418,11 @@ template<typename T> void test_backend() { 
    assert(sqrt_vec.at(1) == std::sqrt(static_cast<T> (2.0)) &&

           "Expected sqrt(2).");



    base_vec.set(std::vector<T> ({4.0, 2.0}));

    exp_scalar.set(-0.5);

    base_vec.set(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    exp_scalar.set(static_cast<T> (-0.5));

    const backend::buffer<T> one_over_sqrt_vec = backend::pow(base_vec, exp_scalar);

    assert(one_over_sqrt_vec.size() == 2 && "Expected a size of 2");

    assert(one_over_sqrt_vec.at(0) == static_cast<T> (0.5) &&
@@ -343,8 +431,11 @@ template<typename T> void test_backend() { 
                                               static_cast<T> (-0.5)) &&

           "Expected 1/sqrt(2).");



    base_vec.set(std::vector<T> ({4.0, 2.0}));

    exp_scalar.set(3.0);

    base_vec.set(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    exp_scalar.set(static_cast<T> (3.0));

    const backend::buffer<T> x_cubed_vec = backend::pow(base_vec, exp_scalar);

    assert(x_cubed_vec.size() == 2 && "Expected a size of 2");

    assert(x_cubed_vec.at(0) == static_cast<T> (64.0) &&
@@ -352,8 +443,11 @@ template<typename T> void test_backend() { 
    assert(x_cubed_vec.at(1) == static_cast<T> (8.0) &&

           "Expected 8.");



    base_vec.set(std::vector<T> ({4.0, 2.0}));

    exp_scalar.set(-0.23);

    base_vec.set(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    exp_scalar.set(static_cast<T> (-0.23));

    const backend::buffer<T> x_over_cubed_vec = backend::pow(base_vec, exp_scalar);

    assert(x_over_cubed_vec.size() == 2 && "Expected a size of 2");

    assert(x_over_cubed_vec.at(0) == std::pow(static_cast<T> (4.0),
@@ -363,8 +457,11 @@ template<typename T> void test_backend() { 
                                              static_cast<T> (-0.23)) &&

           "Expected 2^-0.23.");



    base_scalar.set(4.0);

    backend::buffer<T> exp_vec(std::vector<T> ({4.0, 2.0}));

    base_scalar.set(static_cast<T> (4.0));

    backend::buffer<T> exp_vec(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    backend::buffer<T> scale_base = backend::pow(base_scalar, exp_vec);

    assert(scale_base.size() == 2 && "Expected a size of 2");

    assert(scale_base.at(0) == std::pow(static_cast<T> (4.0),
@@ -376,22 +473,28 @@ template<typename T> void test_backend() { 


    const auto non_int = static_cast<T> (0.438763);

    base_scalar.set(non_int);

    exp_scalar.set(2.0);

    exp_scalar.set(static_cast<T> (2.0));

    scale_base = backend::pow(base_scalar, exp_scalar);

    assert(scale_base.at(0) == std::pow(non_int,

                                        static_cast<T> (2.0)) &&

           "Expected x*x.");

    assert(scale_base.at(0) == non_int*non_int && "Expected x*x.");



    base_scalar.set(10.0);

    exp_scalar.set(0.0);

    base_scalar.set(static_cast<T> (10.0));

    exp_scalar.set(static_cast<T> (0.0));

    const backend::buffer<T> pow_zero = backend::pow(base_scalar, exp_scalar);

    assert(pow_zero.at(0) == std::pow(static_cast<T> (10.0),

                                      static_cast<T> (0.0)) &&

           "Expected 10^0.");



    base_vec.set(std::vector<T> ({4.0, 2.0}));

    exp_vec.set(std::vector<T> ({-4.0, 0.30}));

    base_vec.set(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    exp_vec.set(std::vector<T> ({

        static_cast<T> (-4.0),

        static_cast<T> (0.30)

    }));

    const backend::buffer<T> vec_vec = backend::pow(base_vec, exp_vec);

    assert(vec_vec.size() == 2 && "Expected a size of 2");

    assert(vec_vec.at(0) == std::pow(static_cast<T> (4.0),
@@ -401,13 +504,16 @@ template<typename T> void test_backend() { 
                                     static_cast<T> (0.30)) &&

           "Expected 2^0.30.");



    base_scalar.set(4.0);

    base_scalar.set(static_cast<T> (4.0));

    base_scalar.log();

    assert(base_scalar.size() == 1 && "Expected a size of 1");

    assert(base_scalar.at(0) == std::log(static_cast<T> (4.0)) &&

           "Expected ln(4).");



    base_vec.set(std::vector<T> ({4.0, 2.0}));

    base_vec.set(std::vector<T> ({

        static_cast<T> (4.0),

        static_cast<T> (2.0)

    }));

    base_vec.log();

    assert(base_vec.size() == 2 && "Expected a size of 2");

    assert(base_vec.at(0) == std::log(static_cast<T> (4.0)) &&
@@ -415,9 +521,15 @@ template<typename T> void test_backend() { 
    assert(base_vec.at(1) == std::log(static_cast<T> (2.0)) &&

           "Expected ln(2).");

    

    base_vec.set(std::vector<T> ({-4.0, -2.0}));

    base_vec.set(std::vector<T> ({

        static_cast<T> (-4.0),

        static_cast<T> (-2.0)

    }));

    assert(base_vec.is_negative() && "Expected true.");

    base_vec.set(std::vector<T> ({-4.0, 2.0}));

    base_vec.set(std::vector<T> ({

        static_cast<T> (-4.0),

        static_cast<T> (2.0)

    }));

    assert(!base_vec.is_negative() && "Expected false.");

}