From 25c9c263e3c9e881ecc66160a2515f6668d22d85 Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Wed, 20 Nov 2019 16:14:32 -0700 Subject: [PATCH 1/7] Add return types for normalization factor. --- src/btwxt.cpp | 8 ++++---- src/btwxt.h | 4 ++-- src/gridpoint.cpp | 10 +++++++--- src/gridpoint.h | 4 ++-- 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/btwxt.cpp b/src/btwxt.cpp index 64ce0be..e76f719 100644 --- a/src/btwxt.cpp +++ b/src/btwxt.cpp @@ -45,13 +45,13 @@ std::vector RegularGridInterpolator::get_values_at_target() { return grid_point.get_results(); } -void RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const std::vector &target, const double scalar) { +double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const std::vector &target, const double scalar) { set_new_target(target); - normalize_values_at_target(table_index, scalar); + return normalize_values_at_target(table_index, scalar); } -void RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const double scalar) { - grid_point.normalize_grid_values_at_target(table_index, scalar); +double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const double scalar) { + return grid_point.normalize_grid_values_at_target(table_index, scalar); } void RegularGridInterpolator::normalize_values_at_target(const std::vector &target, const double scalar) { diff --git a/src/btwxt.h b/src/btwxt.h index a2bfd6c..89500a8 100644 --- a/src/btwxt.h +++ b/src/btwxt.h @@ -83,9 +83,9 @@ class RegularGridInterpolator { void normalize_values_at_target(const std::vector &target, const double scalar = 1.0); - void normalize_values_at_target(std::size_t table_index, const double scalar = 1.0); + double normalize_values_at_target(std::size_t table_index, const double scalar = 1.0); - void normalize_values_at_target(std::size_t table_index, const std::vector &target, const double scalar = 1.0); + double normalize_values_at_target(std::size_t table_index, const std::vector &target, const double scalar = 1.0); std::vector get_current_target(); diff --git a/src/gridpoint.cpp b/src/gridpoint.cpp index 1db8433..0bc3487 100644 --- a/src/gridpoint.cpp +++ b/src/gridpoint.cpp @@ -294,15 +294,19 @@ void GridPoint::normalize_grid_values_at_target(const double scalar) { set_results(); } -void GridPoint::normalize_grid_values_at_target(std::size_t table_num, const double scalar) { +double GridPoint::normalize_grid_values_at_target(std::size_t table_num, const double scalar) { if (!target_is_set) { showMessage(MsgLevel::MSG_WARN, stringify("Cannot normalize grid values. No target has been set.")); - return; + return scalar; } - grid_data->normalize_value_table(table_num,results[table_num]*scalar); + // create a scalar which represents the product of the inverted normalization factor and the value in the table at the independent variable reference value + double total_scalar = results[table_num]*scalar; + grid_data->normalize_value_table(table_num,total_scalar); hypercube_cache.clear(); set_results(); + + return total_scalar; } } // namespace Btwxt diff --git a/src/gridpoint.h b/src/gridpoint.h index de00527..f094179 100644 --- a/src/gridpoint.h +++ b/src/gridpoint.h @@ -44,10 +44,10 @@ class GridPoint { double get_vertex_weight(const std::vector &v); - void normalize_grid_values_at_target(std::size_t table_num, const double scalar = 1.0); - void normalize_grid_values_at_target(const double scalar = 1.0); + double normalize_grid_values_at_target(std::size_t table_num, const double scalar = 1.0); + void set_floor(); private: From da9b2dca51224592a5b0f7edfce76f7c9a8df75d Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Fri, 29 Nov 2019 12:58:37 -0700 Subject: [PATCH 2/7] Add basic normalization divisor return unit tests. --- test/btwxt_test.cpp | 45 +++++++++++++++++++++++++++++++++++++++++++++ test/fixtures.hpp | 2 +- 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/test/btwxt_test.cpp b/test/btwxt_test.cpp index ee0a021..aa1af42 100644 --- a/test/btwxt_test.cpp +++ b/test/btwxt_test.cpp @@ -199,3 +199,48 @@ TEST_F(TwoDFixture, normalize) { EXPECT_THAT(result, testing::ElementsAre(testing::DoubleEq(1.0), testing::DoubleEq(8.832))); Btwxt::LOG_LEVEL = 1; } + +TEST_F(TwoDFixture, normalization_return_scalar) { + + std::vector> my_grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; + // 1.0 2.0 3.0 + std::vector> lookup_table = {{ 2.0, 2.0, 6.0, // 2.0 + 7.0, 14.0, 21.0}}; // 7.0 + std::vectortarget = {7.0, 3.0}; + GriddedData test_gridded_data = GriddedData(my_grid, lookup_table); + test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); + RegularGridInterpolator test_rgi = RegularGridInterpolator(test_gridded_data); + test_rgi.set_new_target(target); + std::vector result = test_rgi.get_values_at_target(); + EXPECT_THAT(result, testing::ElementsAre(21.0)); + + std::vector normalization_target = {2.0, 3.0}; + double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); + test_rgi.set_new_target({7.0,3.0}); + result = test_rgi.get_values_at_target(); + EXPECT_THAT(return_scalar, testing::DoubleEq(6.0)); + EXPECT_THAT(result, testing::ElementsAre(3.5)); + +} + +TEST_F(TwoDFixture, normalization_return_compound_scalar) { + + std::vector> my_grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; + // 1.0 2.0 3.0 + std::vector> lookup_table = {{ 2.0, 2.0, 6.0, // 2.0 + 7.0, 14.0, 21.0}}; // 7.0 + std::vectortarget = {7.0, 3.0}; + GriddedData test_gridded_data = GriddedData(my_grid, lookup_table); + test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); + RegularGridInterpolator test_rgi = RegularGridInterpolator(test_gridded_data); + test_rgi.set_new_target(target); + std::vector result = test_rgi.get_values_at_target(); + EXPECT_THAT(result, testing::ElementsAre(21.0)); + + std::vector normalization_target = {2.0, 3.0}; + double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 4.0); + test_rgi.set_new_target({7.0,3.0}); + result = test_rgi.get_values_at_target(); + EXPECT_THAT(return_scalar, testing::DoubleEq(24.0)); + EXPECT_THAT(result, testing::ElementsAre(0.875)); +} diff --git a/test/fixtures.hpp b/test/fixtures.hpp index 43d28f4..95d833e 100644 --- a/test/fixtures.hpp +++ b/test/fixtures.hpp @@ -94,7 +94,7 @@ class TwoDFixture : public testing::Test { TwoDFixture() { std::vector> grid = {{0, 10, 15}, {4, 6}}; - // 4 6 + // 4 6 values = {{6, 3, // 0 2, 8, // 10 4, 2}, // 15 From 5184b382b1f2c5e255035e75d19c223c5a727d9a Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Fri, 29 Nov 2019 13:20:27 -0700 Subject: [PATCH 3/7] Refactor btwxt_test scalar return unit tests to include a new customized fixture for this case. --- test/btwxt_test.cpp | 59 +++++++++++++++------------------------------ test/fixtures.hpp | 19 +++++++++++++++ 2 files changed, 39 insertions(+), 39 deletions(-) diff --git a/test/btwxt_test.cpp b/test/btwxt_test.cpp index aa1af42..773918e 100644 --- a/test/btwxt_test.cpp +++ b/test/btwxt_test.cpp @@ -200,47 +200,28 @@ TEST_F(TwoDFixture, normalize) { Btwxt::LOG_LEVEL = 1; } -TEST_F(TwoDFixture, normalization_return_scalar) { - - std::vector> my_grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; - // 1.0 2.0 3.0 - std::vector> lookup_table = {{ 2.0, 2.0, 6.0, // 2.0 - 7.0, 14.0, 21.0}}; // 7.0 - std::vectortarget = {7.0, 3.0}; - GriddedData test_gridded_data = GriddedData(my_grid, lookup_table); - test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); - RegularGridInterpolator test_rgi = RegularGridInterpolator(test_gridded_data); - test_rgi.set_new_target(target); - std::vector result = test_rgi.get_values_at_target(); - EXPECT_THAT(result, testing::ElementsAre(21.0)); - +TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) { + double return_scalar; + std::vector results; + double expected_compound_divisor {6.0}; + double expected_value_at_target {3.5}; std::vector normalization_target = {2.0, 3.0}; - double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); - test_rgi.set_new_target({7.0,3.0}); - result = test_rgi.get_values_at_target(); - EXPECT_THAT(return_scalar, testing::DoubleEq(6.0)); - EXPECT_THAT(result, testing::ElementsAre(3.5)); - -} - -TEST_F(TwoDFixture, normalization_return_compound_scalar) { - - std::vector> my_grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; - // 1.0 2.0 3.0 - std::vector> lookup_table = {{ 2.0, 2.0, 6.0, // 2.0 - 7.0, 14.0, 21.0}}; // 7.0 - std::vectortarget = {7.0, 3.0}; - GriddedData test_gridded_data = GriddedData(my_grid, lookup_table); - test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); - RegularGridInterpolator test_rgi = RegularGridInterpolator(test_gridded_data); + return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); test_rgi.set_new_target(target); - std::vector result = test_rgi.get_values_at_target(); - EXPECT_THAT(result, testing::ElementsAre(21.0)); + results = test_rgi.get_values_at_target(); + EXPECT_THAT(return_scalar, testing::DoubleEq(expected_compound_divisor)); + EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target)); +} +TEST_F(TwoDSimpleNormalizationFixture, normalization_return_compound_scalar) { + double return_scalar; + std::vector results; + double expected_compound_divisor {6.0*4.0}; + double expected_value_at_target {0.875}; std::vector normalization_target = {2.0, 3.0}; - double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 4.0); - test_rgi.set_new_target({7.0,3.0}); - result = test_rgi.get_values_at_target(); - EXPECT_THAT(return_scalar, testing::DoubleEq(24.0)); - EXPECT_THAT(result, testing::ElementsAre(0.875)); + return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 4.0); + test_rgi.set_new_target(target); + results = test_rgi.get_values_at_target(); + EXPECT_THAT(return_scalar, testing::DoubleEq(expected_compound_divisor)); + EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target)); } diff --git a/test/fixtures.hpp b/test/fixtures.hpp index 95d833e..7f637e6 100644 --- a/test/fixtures.hpp +++ b/test/fixtures.hpp @@ -106,6 +106,25 @@ class TwoDFixture : public testing::Test { } }; +class TwoDSimpleNormalizationFixture : public testing::Test { +protected: + RegularGridInterpolator test_rgi; + GriddedData test_gridded_data; + std::vector> values; + std::vector target; + + TwoDSimpleNormalizationFixture() { + std::vector> grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; + // 1.0 2.0 3.0 + values = {{ 2.0, 2.0, 6.0, // 2.0 + 7.0, 14.0, 21.0}}; // 7.0 + target = {7.0, 3.0}; + test_gridded_data = GriddedData(grid, values); + test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); + test_rgi = RegularGridInterpolator(test_gridded_data); + } +}; + class CubicFixture : public testing::Test { protected: RegularGridInterpolator test_rgi; From 201bba86f76f0b42e2a80120e062cf9204e75fca Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Fri, 29 Nov 2019 14:17:59 -0700 Subject: [PATCH 4/7] Add unit tests for GridPoint scalar returns. --- test/btwxt_test.cpp | 4 ++-- test/gridpoint_test.cpp | 30 ++++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/test/btwxt_test.cpp b/test/btwxt_test.cpp index 773918e..1d7194b 100644 --- a/test/btwxt_test.cpp +++ b/test/btwxt_test.cpp @@ -203,13 +203,13 @@ TEST_F(TwoDFixture, normalize) { TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) { double return_scalar; std::vector results; - double expected_compound_divisor {6.0}; + double expected_divisor {6.0}; double expected_value_at_target {3.5}; std::vector normalization_target = {2.0, 3.0}; return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); test_rgi.set_new_target(target); results = test_rgi.get_values_at_target(); - EXPECT_THAT(return_scalar, testing::DoubleEq(expected_compound_divisor)); + EXPECT_THAT(return_scalar, testing::DoubleEq(expected_divisor)); EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target)); } diff --git a/test/gridpoint_test.cpp b/test/gridpoint_test.cpp index 9417d5c..7066b76 100644 --- a/test/gridpoint_test.cpp +++ b/test/gridpoint_test.cpp @@ -68,6 +68,36 @@ TEST_F(TwoDFixture, grid_point_interp_coeffs) { EXPECT_EQ(cubic_slope_coeffs[1][1], 0); } +TEST_F(TwoDSimpleNormalizationFixture, grid_point_scalar_return) { + GridPoint grid_point(test_gridded_data, target); + double return_scalar; + std::vector results; + double expected_divisor {6.0}; + double expected_value_at_target {1.5}; + std::vector normalize_target {2.0, 3.0}; + + grid_point.set_target(normalize_target); + return_scalar = grid_point.normalize_grid_values_at_target(0, 1.0); + EXPECT_EQ(return_scalar, expected_divisor); + + grid_point.set_target(normalize_target); + return_scalar = grid_point.normalize_grid_values_at_target(0, 4.0); + EXPECT_EQ(return_scalar, 4.0); +} + +TEST_F(TwoDSimpleNormalizationFixture, grid_point_compound_scalar_return) { + GridPoint grid_point(test_gridded_data, target); + double return_scalar; + std::vector results; + double expected_divisor {6.0*4.0}; + double expected_value_at_target {1.5}; + std::vector normalize_target {2.0, 3.0}; + + grid_point.set_target(normalize_target); + return_scalar = grid_point.normalize_grid_values_at_target(0, 4.0); + EXPECT_EQ(return_scalar, expected_divisor); +} + TEST_F(CubicFixture, grid_point_interp_coeffs) { GridPoint grid_point(test_gridded_data, target); From 8b08721ffb7cb1c69bbec5bdce7800211a22c5f5 Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Fri, 29 Nov 2019 14:31:56 -0700 Subject: [PATCH 5/7] Remove grid point scalar return test unnecessary second check. --- test/gridpoint_test.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/test/gridpoint_test.cpp b/test/gridpoint_test.cpp index 7066b76..70a212b 100644 --- a/test/gridpoint_test.cpp +++ b/test/gridpoint_test.cpp @@ -79,10 +79,6 @@ TEST_F(TwoDSimpleNormalizationFixture, grid_point_scalar_return) { grid_point.set_target(normalize_target); return_scalar = grid_point.normalize_grid_values_at_target(0, 1.0); EXPECT_EQ(return_scalar, expected_divisor); - - grid_point.set_target(normalize_target); - return_scalar = grid_point.normalize_grid_values_at_target(0, 4.0); - EXPECT_EQ(return_scalar, 4.0); } TEST_F(TwoDSimpleNormalizationFixture, grid_point_compound_scalar_return) { From 772c65ef96d1aef6c63cb011357c86b7d3f68d2a Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Thu, 12 Dec 2019 20:36:04 -0700 Subject: [PATCH 6/7] Increase the specificity of expected values in btwxt tests and remove redundant gridpoint tests. --- test/btwxt_test.cpp | 23 ++++++++++++++++------- test/fixtures.hpp | 2 +- test/gridpoint_test.cpp | 26 -------------------------- 3 files changed, 17 insertions(+), 34 deletions(-) diff --git a/test/btwxt_test.cpp b/test/btwxt_test.cpp index 1d7194b..2a5a0cb 100644 --- a/test/btwxt_test.cpp +++ b/test/btwxt_test.cpp @@ -203,9 +203,13 @@ TEST_F(TwoDFixture, normalize) { TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) { double return_scalar; std::vector results; - double expected_divisor {6.0}; - double expected_value_at_target {3.5}; - std::vector normalization_target = {2.0, 3.0}; + double x = target[0]; // 7.0 + double y = target[1]; // 3.0 + double x_n = 2.0; + double y_n = 3.0; + double expected_divisor {x_n*y_n}; + double expected_value_at_target {(x*y)/expected_divisor}; // (7.0 * 3.0) / 6.0 = 3.5 + std::vector normalization_target = {x_n, y_n}; return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); test_rgi.set_new_target(target); results = test_rgi.get_values_at_target(); @@ -216,10 +220,15 @@ TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) { TEST_F(TwoDSimpleNormalizationFixture, normalization_return_compound_scalar) { double return_scalar; std::vector results; - double expected_compound_divisor {6.0*4.0}; - double expected_value_at_target {0.875}; - std::vector normalization_target = {2.0, 3.0}; - return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 4.0); + double x = target[0]; // 7.0 + double y = target[1]; // 3.0 + double x_n = 2.0; + double y_n = 3.0; + double c_n = 4.0; + double expected_compound_divisor {x_n*y_n*c_n}; + double expected_value_at_target {(x*y)/expected_compound_divisor}; //0.875 + std::vector normalization_target = {x_n, y_n}; + return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, c_n); test_rgi.set_new_target(target); results = test_rgi.get_values_at_target(); EXPECT_THAT(return_scalar, testing::DoubleEq(expected_compound_divisor)); diff --git a/test/fixtures.hpp b/test/fixtures.hpp index 7f637e6..6d12563 100644 --- a/test/fixtures.hpp +++ b/test/fixtures.hpp @@ -116,7 +116,7 @@ class TwoDSimpleNormalizationFixture : public testing::Test { TwoDSimpleNormalizationFixture() { std::vector> grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; // 1.0 2.0 3.0 - values = {{ 2.0, 2.0, 6.0, // 2.0 + values = {{ 2.0, 4.0, 6.0, // 2.0 7.0, 14.0, 21.0}}; // 7.0 target = {7.0, 3.0}; test_gridded_data = GriddedData(grid, values); diff --git a/test/gridpoint_test.cpp b/test/gridpoint_test.cpp index 70a212b..9417d5c 100644 --- a/test/gridpoint_test.cpp +++ b/test/gridpoint_test.cpp @@ -68,32 +68,6 @@ TEST_F(TwoDFixture, grid_point_interp_coeffs) { EXPECT_EQ(cubic_slope_coeffs[1][1], 0); } -TEST_F(TwoDSimpleNormalizationFixture, grid_point_scalar_return) { - GridPoint grid_point(test_gridded_data, target); - double return_scalar; - std::vector results; - double expected_divisor {6.0}; - double expected_value_at_target {1.5}; - std::vector normalize_target {2.0, 3.0}; - - grid_point.set_target(normalize_target); - return_scalar = grid_point.normalize_grid_values_at_target(0, 1.0); - EXPECT_EQ(return_scalar, expected_divisor); -} - -TEST_F(TwoDSimpleNormalizationFixture, grid_point_compound_scalar_return) { - GridPoint grid_point(test_gridded_data, target); - double return_scalar; - std::vector results; - double expected_divisor {6.0*4.0}; - double expected_value_at_target {1.5}; - std::vector normalize_target {2.0, 3.0}; - - grid_point.set_target(normalize_target); - return_scalar = grid_point.normalize_grid_values_at_target(0, 4.0); - EXPECT_EQ(return_scalar, expected_divisor); -} - TEST_F(CubicFixture, grid_point_interp_coeffs) { GridPoint grid_point(test_gridded_data, target); From 46340572fccdf450444777e2b4cbf09d81c820f6 Mon Sep 17 00:00:00 2001 From: Tony Scimone Date: Fri, 13 Dec 2019 11:49:19 -0700 Subject: [PATCH 7/7] Refactor normalization fixture to exclude magic number type declarations and generate regular grid interpolator data using a function instead of hard coding values via a lookup table. --- test/btwxt_test.cpp | 36 +++++++++++++----------------------- test/fixtures.hpp | 21 ++++++++++++++------- 2 files changed, 27 insertions(+), 30 deletions(-) diff --git a/test/btwxt_test.cpp b/test/btwxt_test.cpp index 2a5a0cb..790f63f 100644 --- a/test/btwxt_test.cpp +++ b/test/btwxt_test.cpp @@ -201,36 +201,26 @@ TEST_F(TwoDFixture, normalize) { } TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) { - double return_scalar; - std::vector results; - double x = target[0]; // 7.0 - double y = target[1]; // 3.0 - double x_n = 2.0; - double y_n = 3.0; - double expected_divisor {x_n*y_n}; - double expected_value_at_target {(x*y)/expected_divisor}; // (7.0 * 3.0) / 6.0 = 3.5 - std::vector normalization_target = {x_n, y_n}; - return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); + std::vector target {7.0, 3.0}; + std::vector normalization_target = {2.0, 3.0}; + double expected_divisor {test_function(normalization_target)}; + double expected_value_at_target {test_function(target)/expected_divisor}; + double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, 1.0); test_rgi.set_new_target(target); - results = test_rgi.get_values_at_target(); + std::vector results = test_rgi.get_values_at_target(); EXPECT_THAT(return_scalar, testing::DoubleEq(expected_divisor)); EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target)); } TEST_F(TwoDSimpleNormalizationFixture, normalization_return_compound_scalar) { - double return_scalar; - std::vector results; - double x = target[0]; // 7.0 - double y = target[1]; // 3.0 - double x_n = 2.0; - double y_n = 3.0; - double c_n = 4.0; - double expected_compound_divisor {x_n*y_n*c_n}; - double expected_value_at_target {(x*y)/expected_compound_divisor}; //0.875 - std::vector normalization_target = {x_n, y_n}; - return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, c_n); + std::vector target {7.0, 3.0}; + std::vector normalization_target = {2.0, 3.0}; + double normalization_divisor = 4.0; + double expected_compound_divisor {test_function(normalization_target)*normalization_divisor}; + double expected_value_at_target {test_function(target)/expected_compound_divisor}; + double return_scalar = test_rgi.normalize_values_at_target(0, normalization_target, normalization_divisor); test_rgi.set_new_target(target); - results = test_rgi.get_values_at_target(); + std::vector results = test_rgi.get_values_at_target(); EXPECT_THAT(return_scalar, testing::DoubleEq(expected_compound_divisor)); EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target)); } diff --git a/test/fixtures.hpp b/test/fixtures.hpp index 6d12563..f2d291d 100644 --- a/test/fixtures.hpp +++ b/test/fixtures.hpp @@ -107,19 +107,26 @@ class TwoDFixture : public testing::Test { }; class TwoDSimpleNormalizationFixture : public testing::Test { + // TODO: Create a fixture which this one can inherit from + // takes a vector of functions as a parameter (these become separate value tables) + // takes a vector of vectors which is the data structure that stores the grid protected: RegularGridInterpolator test_rgi; GriddedData test_gridded_data; - std::vector> values; - std::vector target; + double test_function (std::vector target){ + assert(target.size() == 2); + return target[0]*target[1]; + } TwoDSimpleNormalizationFixture() { std::vector> grid = {{2.0, 7.0}, {1.0, 2.0, 3.0}}; - // 1.0 2.0 3.0 - values = {{ 2.0, 4.0, 6.0, // 2.0 - 7.0, 14.0, 21.0}}; // 7.0 - target = {7.0, 3.0}; - test_gridded_data = GriddedData(grid, values); + std::vector values; + for (auto x : grid[0]){ + for (auto y : grid[1] ){ + values.push_back(test_function({x,y})); + } + } + test_gridded_data = GriddedData(grid, {values}); test_gridded_data.set_axis_extrap_method(0, Method::LINEAR); test_rgi = RegularGridInterpolator(test_gridded_data); }