Add more getters to the public interface

include/btwxt/regular-grid-interpolator.h

@@ -87,8 +87,17 @@ class RegularGridInterpolator {
     void set_axis_extrapolation_limits(std::size_t axis_index,
                                        const std::pair<double, double>& extrapolation_limits);
 
+    // Public getters
     std::size_t get_number_of_dimensions();
 
+    std::size_t get_number_of_grid_points();
+
+    std::size_t get_number_of_grid_point_data_sets();
+
+    const GridPointDataSet& get_grid_point_data_set(std::size_t data_set_index);
+
+    const GridAxis& get_grid_axis(std::size_t axis_index);
+
     // Public normalization methods
     double normalize_grid_point_data_set_at_target(std::size_t data_set_index, double scalar = 1.0);
 
@@ -134,7 +143,7 @@ class RegularGridInterpolator {
     [[nodiscard]] std::vector<std::size_t> get_neighboring_indices_at_target() const;
 
     std::vector<std::size_t> get_neighboring_indices_at_target(const std::vector<double>& target);
-    
+
     const std::vector<double>& get_target();
 
     [[nodiscard]] const std::vector<TargetBoundsStatus>& get_target_bounds_status() const;

src/regular-grid-interpolator-implementation.cpp

@@ -145,6 +145,7 @@ void RegularGridInterpolatorImplementation::normalize_grid_point_data_sets_at_ta
 double RegularGridInterpolatorImplementation::normalize_grid_point_data_set_at_target(
     std::size_t data_set_index, double scalar)
 {
+    check_data_set_index(data_set_index, "normalize grid point data set");
     if (!target_is_set) {
         send_error(fmt::format(
             "GridPointDataSet '{}': Cannot normalize grid point data set. No target has been set.",
@@ -163,6 +164,7 @@ double RegularGridInterpolatorImplementation::normalize_grid_point_data_set_at_t
 void RegularGridInterpolatorImplementation::normalize_grid_point_data_set(
     std::size_t data_set_index, double scalar)
 {
+    check_data_set_index(data_set_index, "normalize grid point data set");
     auto& data_set = grid_point_data_sets[data_set_index].data;
     if (scalar == 0.0) {
         send_error(
@@ -574,7 +576,7 @@ void RegularGridInterpolatorImplementation::calculate_interpolation_coefficients
             cubic_slope_coefficients[axis_index][ceiling]; // floor (0)
         weighting_factors[axis_index][2] =
             interpolation_coefficients[axis_index][ceiling] +
-            cubic_slope_coefficients[axis_index][floor];   // ceiling (1)
+            cubic_slope_coefficients[axis_index][floor]; // ceiling (1)
         weighting_factors[axis_index][3] =
             cubic_slope_coefficients[axis_index][ceiling]; // point above ceiling (2)
     }

src/regular-grid-interpolator-implementation.h

@@ -98,12 +98,24 @@ class RegularGridInterpolatorImplementation : public Courier::Sender {
         return number_of_grid_axes;
     };
 
+    [[nodiscard]] inline std::size_t get_number_of_grid_points() const
+    {
+        return number_of_grid_points;
+    };
+
     [[nodiscard]] inline const GridAxis& get_grid_axis(std::size_t axis_index) const
     {
         check_axis_index(axis_index, "get grid axis");
         return grid_axes[axis_index];
     };
 
+    [[nodiscard]] inline const GridPointDataSet&
+    get_grid_point_data_set(std::size_t data_set_index) const
+    {
+        check_data_set_index(data_set_index, "get grid point data set");
+        return grid_point_data_sets[data_set_index];
+    };
+
     [[nodiscard]] inline std::size_t get_number_of_grid_point_data_sets() const
     {
         return number_of_grid_point_data_sets;
@@ -258,6 +270,18 @@ class RegularGridInterpolatorImplementation : public Courier::Sender {
                 number_of_grid_axes));
         }
     }
+
+    void check_data_set_index(std::size_t data_set_index,
+                              const std::string& action_description) const
+    {
+        if (data_set_index > number_of_grid_point_data_sets - 1) {
+            send_error(fmt::format("Data set index, {}, does not exist. Unable to {}. Number of "
+                                   "grid point data sets = {}.",
+                                   data_set_index,
+                                   action_description,
+                                   number_of_grid_point_data_sets));
+        }
+    }
 };
 
 std::vector<GridAxis> construct_grid_axes(const std::vector<std::vector<double>>& grid,

src/regular-grid-interpolator.cpp

@@ -182,6 +182,26 @@ std::size_t RegularGridInterpolator::get_number_of_dimensions()
     return implementation->get_number_of_grid_axes();
 }
 
+std::size_t RegularGridInterpolator::get_number_of_grid_points()
+{
+    return implementation->get_number_of_grid_points();
+}
+
+std::size_t RegularGridInterpolator::get_number_of_grid_point_data_sets()
+{
+    return implementation->get_number_of_grid_point_data_sets();
+}
+
+const GridAxis& RegularGridInterpolator::get_grid_axis(std::size_t axis_index)
+{
+    return implementation->get_grid_axis(axis_index);
+}
+
+const GridPointDataSet& RegularGridInterpolator::get_grid_point_data_set(std::size_t data_set_index)
+{
+    return implementation->get_grid_point_data_set(data_set_index);
+}
+
 // Public normalization methods
 double RegularGridInterpolator::normalize_grid_point_data_set_at_target(
     std::size_t data_set_index, const std::vector<double>& target, const double scalar)

test/btwxt-tests.cpp

@@ -444,13 +444,25 @@ TEST(SimpleData, normalize_after_adding_grid_point_data_set)
     RegularGridInterpolator interpolator(grid);
     std::size_t data_set_index {0};
     interpolator.add_grid_point_data_set(data_sets[data_set_index]);
+    EXPECT_EQ(interpolator.get_number_of_grid_point_data_sets(), 1);
     interpolator.normalize_grid_point_data_set_at_target(data_set_index, {0.5, 0.5}, 1.0);
     data_set_index++;
     interpolator.add_grid_point_data_set(data_sets[data_set_index]);
+    EXPECT_EQ(interpolator.get_number_of_grid_point_data_sets(), 2);
     interpolator.normalize_grid_point_data_set_at_target(data_set_index, {0.5, 0.5}, 1.0);
     auto results = interpolator.get_values_at_target({1., 1.});
     EXPECT_NEAR(results[0], 2.0, 0.00001);
     EXPECT_NEAR(results[1], 1.0, 0.00001);
+
+    // Test other getters
+    EXPECT_EQ(interpolator.get_number_of_dimensions(), 2);
+    EXPECT_EQ(interpolator.get_number_of_grid_points(),
+              interpolator.get_grid_axis(0).get_length() *
+                  interpolator.get_grid_axis(1).get_length());
+    EXPECT_EQ(interpolator.get_number_of_grid_points(),
+              interpolator.get_grid_point_data_set(0).data.size());
+    EXPECT_EQ(interpolator.get_number_of_grid_points(),
+              interpolator.get_grid_point_data_set(1).data.size());
 }
 
 TEST_F(Function4DFixture, construct)