resolve comments

Signed-off-by: Martijn Govers <Martijn.Govers@Alliander.com>

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/common/statistics.hpp

@@ -218,7 +218,7 @@ template <std::ranges::view RandVarsView>
                           UniformComplexRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>> ||
              std::same_as<std::ranges::range_value_t<RandVarsView>,
                           IndependentComplexRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>>
-constexpr auto accumulate(RandVarsView rand_vars) {
+constexpr auto combine(RandVarsView rand_vars) {
     using RandVarType = std::ranges::range_value_t<RandVarsView>;
     using ValueType = decltype(RandVarType::value);
     using VarianceType = decltype(RandVarType::variance);
@@ -243,14 +243,14 @@ constexpr auto accumulate(RandVarsView rand_vars) {
 template <std::ranges::view RandVarsView>
     requires std::same_as<std::ranges::range_value_t<RandVarsView>,
                           DecomposedComplexRandVar<typename std::ranges::range_value_t<RandVarsView>::sym>>
-constexpr auto accumulate(RandVarsView rand_vars) {
+constexpr auto combine(RandVarsView rand_vars) {
     using sym = std::ranges::range_value_t<RandVarsView>::sym;
 
     DecomposedComplexRandVar<sym> result{
         .real_component =
-            accumulate(rand_vars | std::views::transform([](auto const& x) -> auto& { return x.real_component; })),
+            combine(rand_vars | std::views::transform([](auto const& x) -> auto& { return x.real_component; })),
         .imag_component =
-            accumulate(rand_vars | std::views::transform([](auto const& x) -> auto& { return x.imag_component; }))};
+            combine(rand_vars | std::views::transform([](auto const& x) -> auto& { return x.imag_component; }))};
 
     if (!(is_normal(result.real_component.variance) && is_normal(result.imag_component.variance))) {
         result.real_component.variance = RealValue<sym>{std::numeric_limits<double>::infinity()};

power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/measured_values.hpp

@@ -455,7 +455,7 @@ template <symmetry_tag sym> class MeasuredValues {
                                                             IdxRange const& sensors) {
         auto complex_measurements = sensors | std::views::transform([&data](Idx pos) -> auto& { return data[pos]; });
         if constexpr (only_magnitude) {
-            auto const weighted_average_magnitude_measurement = statistics::accumulate(
+            auto const weighted_average_magnitude_measurement = statistics::combine(
                 complex_measurements | std::views::transform([](auto const& measurement) {
                     return UniformRealRandVar<sym>{.value = detail::cabs_or_real<sym>(measurement.value),
                                                    .variance = measurement.variance};
@@ -469,14 +469,14 @@ template <symmetry_tag sym> class MeasuredValues {
                                                   }(),
                                               .variance = weighted_average_magnitude_measurement.variance};
         } else {
-            return statistics::accumulate(complex_measurements);
+            return statistics::combine(complex_measurements);
         }
     }
     template <bool only_magnitude = false>
         requires(!only_magnitude)
     static PowerSensorCalcParam<sym> combine_measurements(std::vector<PowerSensorCalcParam<sym>> const& data,
                                                           IdxRange const& sensors) {
-        return statistics::accumulate(sensors | std::views::transform([&data](Idx pos) -> auto& { return data[pos]; }));
+        return statistics::combine(sensors | std::views::transform([&data](Idx pos) -> auto& { return data[pos]; }));
     }
     template <bool only_magnitude = false>
         requires(!only_magnitude)
@@ -493,7 +493,7 @@ template <symmetry_tag sym> class MeasuredValues {
         }
 
         return {.angle_measurement_type = angle_measurement_type,
-                .measurement = statistics::accumulate(
+                .measurement = statistics::combine(
                     params | std::views::transform([](auto const& param) -> auto& { return param.measurement; }))};
     }
 

tests/cpp_unit_tests/test_measured_values.cpp

@@ -186,6 +186,7 @@ TEST_CASE_TEMPLATE("Measured Values - Accumulate branch flow sensors", sym, symm
             check_close(value.imag_component.variance, expected_imag_variance);
         } else {
             for (Idx phase : IdxRange(3)) {
+                // eigen index-based element access
                 check_close(value.value()(phase), expected_value);
                 check_close(value.real_component.variance(phase), expected_real_variance);
                 check_close(value.imag_component.variance(phase), expected_imag_variance);