Add return types for normalization factor.

src/btwxt.cpp

@@ -45,13 +45,13 @@ std::vector<double> RegularGridInterpolator::get_values_at_target() {
   return grid_point.get_results();
 }
 
-void RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const std::vector<double> &target, const double scalar) {
+double RegularGridInterpolator::normalize_values_at_target(std::size_t table_index, const std::vector<double> &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<double> &target, const double scalar) {

src/btwxt.h

@@ -83,9 +83,9 @@ class RegularGridInterpolator {
 
   void normalize_values_at_target(const std::vector<double> &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<double> &target, const double scalar = 1.0);
+  double normalize_values_at_target(std::size_t table_index, const std::vector<double> &target, const double scalar = 1.0);
 
   std::vector<double> get_current_target();
 

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

src/gridpoint.h

@@ -44,10 +44,10 @@ class GridPoint {
 
   double get_vertex_weight(const std::vector<short> &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:

test/btwxt_test.cpp

@@ -199,3 +199,38 @@ TEST_F(TwoDFixture, normalize) {
   EXPECT_THAT(result, testing::ElementsAre(testing::DoubleEq(1.0), testing::DoubleEq(8.832)));
   Btwxt::LOG_LEVEL = 1;
 }
+
+TEST_F(TwoDSimpleNormalizationFixture, normalization_return_scalar) {
+    double return_scalar;
+    std::vector<double> 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<double> 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();
+    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<double> 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<double> 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));
+    EXPECT_THAT(results, testing::ElementsAre(expected_value_at_target));
+}

test/fixtures.hpp

@@ -94,7 +94,7 @@ class TwoDFixture : public testing::Test {
 
   TwoDFixture() {
     std::vector<std::vector<double>> grid = {{0, 10, 15}, {4, 6}};
-    //  4   6
+    //         4  6
     values = {{6, 3,  // 0
                2, 8,  // 10
                4, 2}, // 15
@@ -106,6 +106,25 @@ class TwoDFixture : public testing::Test {
   }
 };
 
+class TwoDSimpleNormalizationFixture : public testing::Test {
+protected:
+    RegularGridInterpolator test_rgi;
+    GriddedData test_gridded_data;
+    std::vector<std::vector<double>> values;
+    std::vector<double> target;
+
+    TwoDSimpleNormalizationFixture() {
+        std::vector<std::vector<double>> 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);
+        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;