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

Remove vector constants and remove tests for them. Fix formatting for GPU kernels.

parent dce97645

graph_framework/node.hpp

+3 −22
Original line number Diff line number Diff line
@@ -286,21 +286,13 @@ namespace graph { 
//------------------------------------------------------------------------------

///  @brief Construct a constant node from a vector.

///

///  @param[in] d Array buffer to initalize.

///  @param[in] d Array buffer.

//------------------------------------------------------------------------------

        constant_node(const std::vector<typename BACKEND::base> &d) :

        constant_node(const BACKEND &d) :

        data(d) {

            assert(d.size() == 1 && "Constants need to be scalar functions.");

        }



//------------------------------------------------------------------------------

///  @brief Construct a constant node from a vector.

///

///  @param[in] d Array buffer.

//------------------------------------------------------------------------------

        constant_node(const BACKEND &d) :

        data(d) {}



//------------------------------------------------------------------------------

///  @brief Evaluate method.

///
@@ -400,17 +392,6 @@ namespace graph { 
        return (std::make_shared<constant_node<BACKEND>> (d))->reduce();

    }



//------------------------------------------------------------------------------

///  @brief Construct a constant.

///

///  @param[in] d Array buffer.

///  @returns A reduced constant node.

//------------------------------------------------------------------------------

    template<class BACKEND>

    shared_leaf<BACKEND> constant(const std::vector<typename BACKEND::base> &d) {

        return (std::make_shared<constant_node<BACKEND>> (d))->reduce();

    }



//------------------------------------------------------------------------------

///  @brief Construct a constant.

///

graph_tests/arithmetic_test.cpp

+0 −264
Original line number Diff line number Diff line
@@ -54,69 +54,6 @@ template<typename BACKEND> void test_add() { 
           "Expected the evaluation of one.");

#endif



//  Test vector scalar quanties.

    auto vec_constant = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({3.0, 4.0}));

    auto vec_plus_zero = vec_constant + zero;

#ifdef USE_REDUCE

    assert(vec_plus_zero.get() == vec_constant.get() &&

           "Expected to retrive the left side.");

#else

    assert(graph::add_cast(vec_plus_zero).get() && "Expected an add node.");

    assert(vec_plus_zero->evaluate()[0] == backend::base_cast<BACKEND> (3.0) &&

           "Expected three for the first index");

    assert(vec_plus_zero->evaluate()[1] == backend::base_cast<BACKEND> (4.0) &&

           "Expected four for the second index");

#endif

    auto zero_plus_vec = zero + vec_constant;

#ifdef USE_REDUCE

    assert(zero_plus_vec.get() == vec_constant.get() &&

           "Expected to retrive the right side.");

#else

    assert(graph::add_cast(zero_plus_vec).get() && "Expected an add node.");

    assert(zero_plus_vec->evaluate()[0] == backend::base_cast<BACKEND> (3.0) &&

           "Expected three for the first index");

    assert(zero_plus_vec->evaluate()[1] == backend::base_cast<BACKEND> (4.0) &&

           "Expected four for the second index");

#endif



    auto vec_plus_one = vec_constant + one;

#ifdef USE_REDUCE

    assert(graph::constant_cast(vec_plus_one).get() &&

           "Expected a constant type.");

#else

    assert(graph::add_cast(vec_plus_one).get() && "Expected an add node.");

#endif

    auto vec_plus_one_result = vec_plus_one->evaluate();

    assert(vec_plus_one_result.size() == 2 && "Size mismatch in result.");

    assert(vec_plus_one_result.at(0) == backend::base_cast<BACKEND> (4.0) &&

           "Expected 3 + 1.");

    assert(vec_plus_one_result.at(1) == backend::base_cast<BACKEND> (5.0) &&

           "Expected 4 + 1.");



    auto one_plus_vec = one + vec_constant;

#ifdef USE_REDUCE

    assert(graph::constant_cast(one_plus_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::add_cast(one_plus_vec).get() && "Expected an add node.");

#endif

    auto one_plus_vec_result = one_plus_vec->evaluate();

    assert(one_plus_vec_result.size() == 2 && "Size mismatch in result.");

    assert(one_plus_vec_result.at(0) == backend::base_cast<BACKEND> (4.0) &&

           "Expected 1 + 3.");

    assert(one_plus_vec_result.at(1) == backend::base_cast<BACKEND> (5.0) &&

           "Expected 1 + 4.");



// Test vector vector quaties.

    auto vec_plus_vec = vec_constant + vec_constant;

    const BACKEND vec_plus_vec_result = vec_plus_vec->evaluate();

    assert(vec_plus_vec_result.size() == 2 &&

           "Size mismatch in result.");

    assert(vec_plus_vec_result.at(0) == backend::base_cast<BACKEND> (6.0) &&

           "Expected 3 + 3.");

    assert(vec_plus_vec_result.at(1) == backend::base_cast<BACKEND> (8.0) &&

           "Expected 4 + 4.");



//  Test variable quanities.

//  Any zero nodes should reduce to the other operand.

    auto variable = graph::variable<BACKEND> (1, "");
@@ -398,55 +335,6 @@ template<typename BACKEND> void test_subtract() { 
    assert(zero_minus_one->evaluate()[0] == backend::base_cast<BACKEND> (-1.0) &&

           "Expected a value of -1.");



//  Test vector scalar quantities.

    auto vec_constant_a = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({3.0, 4.0}));

    auto vec_minus_one = vec_constant_a - one;

#ifdef USE_REDUCE

    assert(graph::constant_cast(vec_minus_one).get() &&

           "Expected a constant type.");

#else

    assert(graph::subtract_cast(vec_minus_one).get() &&

           "Expected an subtract node.");

#endif

    auto vec_minus_one_result = vec_minus_one->evaluate();

    assert(vec_minus_one_result.size() == 2 && "Size mismatch in result.");

    assert(vec_minus_one_result.at(0) == backend::base_cast<BACKEND> (2.0) &&

           "Expected 3 - 1.");

    assert(vec_minus_one_result.at(1) == backend::base_cast<BACKEND> (3.0) &&

           "Expected 4 - 1.");



    auto vec_constant_b = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({2.0, 5.0}));

    auto one_minus_vec = one - vec_constant_b;

#ifdef USE_REDUCE

    assert(graph::constant_cast(one_minus_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::subtract_cast(one_minus_vec).get() &&

           "Expected an subtract node.");

#endif

    auto one_minus_vec_result = one_minus_vec->evaluate();

    assert(one_minus_vec_result.size() == 2 && "Size mismatch in result.");

    assert(one_minus_vec_result.at(0) == backend::base_cast<BACKEND> (-1.0) &&

           "Expected 1 - 2.");

    assert(one_minus_vec_result.at(1) == backend::base_cast<BACKEND> (-4.0) &&

           "Expected 1 - 5.");



//  Test vector vector quanties.

    auto vec_minus_vec = vec_constant_a - vec_constant_b;

#ifdef USE_REDUCE

    assert(graph::constant_cast(vec_minus_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::subtract_cast(vec_minus_vec).get() &&

           "Expected an subtract node.");

#endif

    const BACKEND vec_minus_vec_result = vec_minus_vec->evaluate();

    assert(vec_minus_vec_result.size() == 2 && "Expected a constant type.");

    assert(vec_minus_vec_result.at(0) == backend::base_cast<BACKEND> (1.0) &&

           "Expected 3 - 1 for result.");

    assert(vec_minus_vec_result.at(1) == backend::base_cast<BACKEND> (-1.0) &&

           "Expected 4 - 5 for result.");



//  Test variable quanities.

//  Any right side zero nodes should reduce to the other operand.

    auto variable = graph::variable<BACKEND> (1, "");
@@ -710,95 +598,6 @@ template<typename BACKEND> void test_multiply() { 
    assert(three_times_two_result.at(0) == two_times_three_result.at(0) &&

           "Expected 3*2 == 2*3.");



//  Test vec times constant.

    auto vec = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({4.0, 5.0}));

#ifdef USE_REDUCE

    assert((zero*vec).get() == zero.get() && "Expected left side zero.");

    assert((vec*zero).get() == zero.get() && "Expected right side zero.");

    assert((one*vec).get() == vec.get() && "Expected right side vec.");

    assert((vec*one).get() == vec.get() && "Expected left side vec.");

    assert((vec*zero)->evaluate().size() == 1 && "Expected size of zero.");

#else

    assert(graph::multiply_cast(zero*vec).get() && "Expected a multiply node.");

    assert(graph::multiply_cast(vec*zero).get() && "Expected a multiply node.");

    assert(graph::multiply_cast(one*vec).get() && "Expected a multiply node.");

    assert(graph::multiply_cast(vec*one).get() && "Expected a multiply node.");

    assert((vec*zero)->evaluate().size() == 2 && "Expected size of two.");

#endif

    assert((zero*vec)->evaluate().size() == 1 && "Expected size of zero.");

    assert((zero*vec)->evaluate()[0] == backend::base_cast<BACKEND> (0.0) &&

           "Expected value of zero.");

    assert((vec*zero)->evaluate()[0] == backend::base_cast<BACKEND> (0.0) &&

           "Expected value of zero.");

#ifndef USE_REDUCE

    assert((vec*zero)->evaluate()[1] == backend::base_cast<BACKEND> (0.0) &&

           "Expected value of zero.");

#endif

    assert((one*vec)->evaluate()[0] == backend::base_cast<BACKEND> (4.0) &&

           "Expected value of four.");

    assert((one*vec)->evaluate()[1] == backend::base_cast<BACKEND> (5.0) &&

           "Expected value of five.");

    assert((vec*one)->evaluate()[0] == backend::base_cast<BACKEND> (4.0) &&

           "Expected value of four.");

    assert((vec*one)->evaluate()[1] == backend::base_cast<BACKEND> (5.0) &&

           "Expected value of five.");



    auto two_times_vec = two*vec;

#ifdef USE_REDUCE

    assert(graph::constant_cast(two_times_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::multiply_cast(two_times_vec).get() &&

           "Expected a multiply mode.");

#endif



    auto vec_times_two = vec*two;

    const BACKEND two_times_vec_result = two_times_vec->evaluate();

    const BACKEND vec_times_two_result = vec_times_two->evaluate();

    assert(two_times_vec_result.size() == 2 && "Expected two values.");

    assert(vec_times_two_result.size() == 2 && "Expected two values.");

    assert(two_times_vec_result.at(0) == backend::base_cast<BACKEND> (8.0) &&

           "Expected 2*4 for result.");

    assert(two_times_vec_result.at(1) == backend::base_cast<BACKEND> (10.0) &&

           "Expected 2*5 for result.");

    assert(two_times_vec_result.at(0) == vec_times_two_result.at(0) &&

           "Expected 2*4 == 4*2.");

    assert(two_times_vec_result.at(1) == vec_times_two_result.at(1) &&

           "Expected 2*5 == 5*2.");



//  Test vec times vec.

    auto vec_times_vec = vec*vec;

#ifdef USE_REDUCE

    assert(graph::constant_cast(vec_times_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::multiply_cast(vec_times_vec).get() &&

           "Expected a multiply mode.");

#endif

    const BACKEND vec_times_vec_result = vec_times_vec->evaluate();

    assert(vec_times_vec_result.size() == 2 && "Expected two values.");

    assert(vec_times_vec_result.at(0) == backend::base_cast<BACKEND> (16.0) &&

           "Expected 4*4 for result.");

    assert(vec_times_vec_result.at(1) == backend::base_cast<BACKEND> (25.0) &&

           "Expected 5*5 for result.");



//  Test reduction short cut. If all the elements in the numerator are zero, an

//  denominator does not need to be evaluated. This test makes sure that a sum

//  or product is not used to avoid cases like {-1, 0, 1} which sum and product

//  are zero.

    auto vec_sum_prod = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({-1.0, 0.0, 1.0}));

    auto vec_sum_prod_multiply_two = vec_sum_prod*two;

    const BACKEND vec_sum_prod_multiply_two_result =

        vec_sum_prod_multiply_two->evaluate();

    assert(vec_sum_prod_multiply_two_result.at(0) == backend::base_cast<BACKEND> (-1.0) *

                                                     backend::base_cast<BACKEND> (2.0) &&

           "Expected -1/2 for result.");

    assert(vec_sum_prod_multiply_two_result.at(1) == backend::base_cast<BACKEND> (0.0) &&

           "Expected 0/2 for result.");

    assert(vec_sum_prod_multiply_two_result.at(2) == backend::base_cast<BACKEND> (1.0) *

                                                     backend::base_cast<BACKEND> (2.0) &&

           "Expected 1/2 for result.");



//  Test variable quanities.

//  Any zero should reduce back to zero.

    auto variable = graph::variable<BACKEND> (1, "");
@@ -1353,69 +1152,6 @@ template<typename BACKEND> void test_divide() { 
    assert(two_divided_three->evaluate()[0] == backend::base_cast<BACKEND> (2.0/3.0) &&

           "Expected 2/3 for result");



//  Test vector constants.

    auto vec = graph::constant<BACKEND>(std::vector<typename BACKEND::base> ({4.0, 3.0}));

#ifdef USE_REDUCE

    assert((zero/vec).get() == zero.get() && "Expected to recover zero.");

    assert((vec/one).get() == vec.get() && "Expected to recover numerator.");

#else

    assert(graph::divide_cast(zero/vec).get() && "Expected a divide node.");

    assert(graph::divide_cast(vec/one).get() && "Expected a divide node.");

#endif

    assert((zero/vec)->evaluate()[0] == backend::base_cast<BACKEND> (0.0) &&

           "Expected a value of zero.");

    assert((vec/one)->evaluate()[0] == backend::base_cast<BACKEND> (4.0) &&

           "Expected a value of zero.");

    assert((vec/one)->evaluate()[1] == backend::base_cast<BACKEND> (3.0) &&

           "Expected a value of zero.");

    auto vec_divided_vec = vec/vec;

#ifdef USE_REDUCE

    auto vec_divided_vec_cast = graph::constant_cast(vec_divided_vec);

    assert(vec_divided_vec_cast.get() && "Expected a constant type.");

    assert(vec_divided_vec_cast->is(1) && "Expected 1 for result");

#else

    assert(graph::divide_cast(vec_divided_vec).get() &&

           "Expected a constant type.");

    assert(vec_divided_vec->evaluate()[1] == backend::base_cast<BACKEND> (1.0) &&

           "Expected a value of zero.");

#endif

    assert(vec_divided_vec->evaluate()[0] == backend::base_cast<BACKEND> (1.0) &&

           "Expected a value of zero.");

    auto two_divided_vec = two/vec;

#ifdef USE_REDUCE

    assert(graph::constant_cast(two_divided_vec).get() &&

           "Expected a constant type.");

#else

    assert(graph::divide_cast(two_divided_vec).get() &&

           "Expected a divide node.");

#endif

    const BACKEND two_divided_vec_result =

        two_divided_vec->evaluate();

    assert(two_divided_vec_result.size() == 2 && "Size mismatch in result.");

    assert(two_divided_vec_result.at(0) == backend::base_cast<BACKEND> (2.0) /

                                           backend::base_cast<BACKEND> (4.0) &&

           "Expected 2/4 for result.");

    assert(two_divided_vec_result.at(1) == backend::base_cast<BACKEND> (2.0) /

                                           backend::base_cast<BACKEND> (3.0) &&

           "Expected 2/3 for result.");



//  Test reduction short cut. If all the elements in the numerator are zero, an

//  denominator does not need to be evaluated. This test makes sure that a sum

//  or product is not used to avoid cases like {-1, 0, 1} which sum and product

//  are zero.

    auto vec_sum_prod = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({-1.0, 0.0, 1.0}));

    auto vec_sum_prod_divided_two = vec_sum_prod/two;

    const BACKEND vec_sum_prod_divided_two_result =

        vec_sum_prod_divided_two->evaluate();

    assert(vec_sum_prod_divided_two_result.at(0) == backend::base_cast<BACKEND> (-1.0) /

                                                    backend::base_cast<BACKEND> (2.0) &&

           "Expected -1/2 for result.");

    assert(vec_sum_prod_divided_two_result.at(1) == backend::base_cast<BACKEND> (0.0) &&

           "Expected 0/2 for result.");

    assert(vec_sum_prod_divided_two_result.at(2) == backend::base_cast<BACKEND> (1.0) /

                                                    backend::base_cast<BACKEND> (2.0) &&

           "Expected 1/2 for result.");



//  Test variables.

    auto variable = graph::variable<BACKEND> (1, "");

#ifdef USE_REDUCE

graph_tests/math_test.cpp

+0 −14
Original line number Diff line number Diff line
@@ -28,13 +28,6 @@ void test_sqrt() { 
    assert(graph::sqrt_cast(sqrt_ten).get() && "Expected a sqrt node.");

#endif



    auto vec = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({5.0, 3.0}));

    auto sqrt_vec = graph::sqrt(vec);

    const BACKEND sqrt_vec_result = sqrt_vec->evaluate();

    assert(sqrt_vec_result.size() == 2);

    assert(sqrt_vec_result.at(0) == std::sqrt(backend::base_cast<BACKEND> (5.0)));

    assert(sqrt_vec_result.at(1) == std::sqrt(backend::base_cast<BACKEND> (3.0)));



    auto var = graph::variable<BACKEND> (1, "");

    auto sqrt_var = graph::sqrt(var);

    assert(graph::sqrt_cast(sqrt_var).get() &&"Expected a variable type.");
@@ -140,13 +133,6 @@ void test_exp() { 
    assert(graph::exp_cast(exp_ten).get() && "Expected a sqrt node.");

#endif



    auto vec = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({5.0, 3.0}));

    auto exp_vec = graph::exp(vec);

    const BACKEND exp_vec_result = exp_vec->evaluate();

    assert(exp_vec_result.size() == 2);

    assert(exp_vec_result.at(0) == std::exp(backend::base_cast<BACKEND> (5.0)));

    assert(exp_vec_result.at(1) == std::exp(backend::base_cast<BACKEND> (3.0)));



    auto var = graph::variable<BACKEND> (1, "");

    auto exp_var = graph::exp(var);

    assert(graph::exp_cast(exp_var).get() && "Expected a variable type.");

graph_tests/node_test.cpp

+2 −22
Original line number Diff line number Diff line
@@ -36,40 +36,20 @@ void test_constant() { 
    zero->set(backend::base_cast<BACKEND> (1.0));

    assert(zero_cast->is(0) && "Constant value expeced zero.");



    auto one = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({1.0, 1.0}));

    auto one = graph::constant<BACKEND> (1.0);

    auto one_cast = graph::constant_cast(one);

    assert(one_cast.get() && "Expected a constant type.");

#ifdef USE_REDUCE

    assert(one_cast->is(1) && "Constant value expeced zero.");

#endif

    const BACKEND one_result = one->evaluate();

#ifdef USE_REDUCE

    assert(one_result.size() == 1 && "Expected single value.");

    assert(one_result.at(0) == backend::base_cast<BACKEND> (1.0) &&

           "Constant value evalute expeced one.");

#else

    assert(one_result.size() == 2 && "Expected two values.");

    assert(one_result.at(0) == backend::base_cast<BACKEND> (1.0) &&

           "Constant value evalute expeced one.");

    assert(one_result.at(1) == backend::base_cast<BACKEND> (1.0) &&

           "Constant value evalute expeced one.");

#endif



    auto done = one->df(zero);

    auto done_cast = graph::constant_cast(done);

    assert(done_cast.get() && "Expected a constant type for derivative.");

    assert(done_cast->is(0) && "Constant value expeced zero.");



    auto one_two = graph::constant<BACKEND> (std::vector<typename BACKEND::base> ({1.0, 2.0}));

    auto one_two_cast = graph::constant_cast(one_two);

    assert(one_two_cast.get() && "Expected a constant type.");

    assert(!one_two_cast->is(1) && "Constant expected to not be one.");

    const BACKEND one_two_result = one_two->evaluate();

    assert(one_two_result.size() == 2 && "Expected two elements in constant");

    assert(one_two_result.at(0) == backend::base_cast<BACKEND> (1.0) &&

           "Expected one for first elememt");

    assert(one_two_result.at(1) == backend::base_cast<BACKEND> (2.0) &&

           "Expected two for second elememt");



//  Test is_match

    auto c1 = graph::constant<BACKEND> (5);

    auto c2 = graph::constant<BACKEND> (5);

graph_framework/trigonometry.hpp

+2 −2

File changed.

Contains only whitespace changes.

graph_framework/arithmetic.hpp

+5 −5

File changed.

Contains only whitespace changes.

graph_framework/jit.hpp

+3 −3

File changed.

Contains only whitespace changes.

graph_framework/math.hpp

+4 −4

File changed.

Contains only whitespace changes.