A single-parameter overload of Barycentre.

geometry/barycentre_calculator.hpp

@@ -46,6 +46,8 @@ template<affine Point, homogeneous_field Weight, std::size_t size>
 Point Barycentre(Point const (&points)[size], Weight const (&weights)[size]);
 template<real_affine_space Point, std::size_t size>
 Point Barycentre(Point const (&points)[size], double const (&weights)[size]);
+template<real_affine_space Point, std::size_t size>
+Point Barycentre(Point const (&points)[size]);
 
 template<typename T, typename Weight, template<typename...> class Container>
 T Barycentre(Container<T> const& ts, Container<Weight> const& weights);

geometry/barycentre_calculator_body.hpp

@@ -71,6 +71,24 @@ Point Barycentre(Point const (&points)[size], double const (&weights)[size]) {
   return Barycentre<Point, double>(points, weights);
 }
 
+template<real_affine_space Point, std::size_t size>
+Point Barycentre(Point const (&points)[size]) {
+  static_assert(size != 0);
+  Difference<Point> total{};
+  for (int i = 0; i < size; ++i) {
+    if constexpr (additive_group<Point>) {
+      total += points[i];
+    } else {
+      total += points[i] - Point{};
+    }
+  }
+  if constexpr (additive_group<Point>) {
+    return total / size;
+  } else {
+    return total / size + Point{};
+  }
+}
+
 template<typename T, typename Scalar, template<typename...> class Container>
 T Barycentre(Container<T> const& ts, Container<Scalar> const& weights) {
   CHECK_EQ(ts.size(), weights.size()) << "Ts and weights of unequal sizes";

geometry/point_test.cpp

@@ -185,7 +185,7 @@ TEST_F(PointTest, Barycentres) {
   Instant const t1 = mjd0 + 1 * Day;
   Instant const t2 = mjd0 - 3 * Day;
   Instant const b1 = Barycentre({t1, t2}, {3 * Litre, 1 * Litre});
-  Instant const b2 = Barycentre({t2, t1}, {1, 1});
+  Instant const b2 = Barycentre({t2, t1});
   EXPECT_THAT(b1, AlmostEquals(mjd0, 1));
   EXPECT_THAT(b2, Eq(mjd0 - 1 * Day));
 }

ksp_plugin_test/flight_plan_optimizer_test.cpp

@@ -533,7 +533,7 @@ class MetricTest
     EXPECT_OK(ephemeris_->Prolong(desired_final_time));
     auto const earth_dof = solar_system_1950_.degrees_of_freedom("Earth");
     auto const mars_dof = solar_system_1950_.degrees_of_freedom("Mars");
-    auto const midway = Barycentre({earth_dof, mars_dof}, {1, 1});
+    auto const midway = Barycentre({earth_dof, mars_dof});
     EXPECT_OK(root_.Append(epoch_, midway));
     flight_plan_ = std::make_unique<FlightPlan>(
         /*initial_mass=*/1 * Kilogram,

mathematica/mathematica_body.hpp

@@ -125,7 +125,7 @@ std::string ToMathematicaBody(
     OptionalExpressIn express_in) {
   auto const& a = polynomial.lower_bound();
   auto const& b = polynomial.upper_bound();
-  auto const midpoint = Barycentre({a, b}, {0.5, 0.5});
+  auto const midpoint = Barycentre({a, b});
   std::string const argument = RawApply(
       "Divide",
       {RawApply("Subtract", {"#", ToMathematica(midpoint, express_in)}),

numerics/apodization_body.hpp

@@ -29,7 +29,7 @@ PoissonSeries<double, 0, 0, Evaluator> Dirichlet(Instant const& t_min,
                                                  Instant const& t_max) {
   using Result = PoissonSeries<double, 0, 0, Evaluator>;
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({1}, t_mid), {});
 }
 
@@ -40,7 +40,7 @@ PoissonSeries<double, 0, 0, Evaluator> Sine(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -54,7 +54,7 @@ PoissonSeries<double, 0, 0, Evaluator> Hann(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0.5}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -68,7 +68,7 @@ PoissonSeries<double, 0, 0, Evaluator> Hamming(Instant const& t_min,
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({25.0 / 46.0}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -82,7 +82,7 @@ PoissonSeries<double, 0, 0, Evaluator> Blackman(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0.42}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -99,7 +99,7 @@ PoissonSeries<double, 0, 0, Evaluator> ExactBlackman(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({3969.0 / 9304.0}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -116,7 +116,7 @@ PoissonSeries<double, 0, 0, Evaluator> Nuttall(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0.355768}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -136,7 +136,7 @@ PoissonSeries<double, 0, 0, Evaluator> BlackmanNuttall(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0.3635819}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -156,7 +156,7 @@ PoissonSeries<double, 0, 0, Evaluator> BlackmanHarris(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({0.35875}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),
@@ -176,7 +176,7 @@ PoissonSeries<double, 0, 0, Evaluator> ISO18431_2(Instant const& t_min,
   using AperiodicPolynomial = typename Result::AperiodicPolynomial;
   using PeriodicPolynomial = typename Result::PeriodicPolynomial;
   AngularFrequency const ω = 2 * π * Radian / (t_max - t_min);
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return Result(AperiodicPolynomial({1.0 / 4.63867187}, t_mid),
                 {{ω,
                   {.sin = PeriodicPolynomial({0}, t_mid),

numerics/approximation_body.hpp

@@ -56,7 +56,7 @@ not_null<std::unique_ptr<
     FixedVector<Value<Argument, Function>, N / 2 + 1> const& previous_aⱼ,
     Difference<Value<Argument, Function>>* const error_estimate) {
   // This implementation follows [Boy13], section 4 and appendix A.
-  auto const midpoint = Barycentre({a, b}, {0.5, 0.5});
+  auto const midpoint = Barycentre({a, b});
 
   auto чебышёв_lobato_point =
       [&a, &b, &midpoint](std::int64_t const k) -> Argument {
@@ -149,7 +149,7 @@ bool StreamingAdaptiveЧебышёвPolynomialInterpolantImplementation(
             << full_error_estimate;
     Difference<Value<Argument, Function>> upper_error_estimate;
     Difference<Value<Argument, Function>> lower_error_estimate;
-    auto const midpoint = Barycentre({lower_bound, upper_bound}, {1, 1});
+    auto const midpoint = Barycentre({lower_bound, upper_bound});
     bool const lower_interpolants_stop =
         StreamingAdaptiveЧебышёвPolynomialInterpolantImplementation<max_degree>(
             f,

numerics/nearest_neighbour_body.hpp

@@ -158,8 +158,7 @@ PrincipalComponentPartitioningTree<Value_>::BuildTree(
   auto const mid_lower = std::max_element(begin, mid_upper, projection_less);
 
   auto const anchor = Barycentre(
-      {displacements_[mid_lower->index], displacements_[mid_upper->index]},
-      {1, 1});
+      {displacements_[mid_lower->index], displacements_[mid_upper->index]});
 
   auto first_child = BuildTree(begin, mid_upper, size / 2);
   auto second_child = BuildTree(mid_upper, end, size - size / 2);

numerics/newhall_body.hpp

@@ -321,7 +321,7 @@ NewhallApproximationInMonomialBasis(std::vector<Value> const& q,
     qv[j + 1] = v[i] * duration_over_two;
   }
 
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return (origin +
           Dehomogeneize<Difference<Value>, degree, Evaluator>(
               NewhallMonomialApproximator<

numerics/poisson_series_basis_body.hpp

@@ -173,7 +173,7 @@ std::array<Series, sizeof...(indices)> AperiodicSeriesGenerator<
     degree, dimension,
     std::index_sequence<indices...>>::BasisElements(Instant const& t_min,
                                                     Instant const& t_max) {
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   return {(Series(
       PolynomialGenerator<typename Series::AperiodicPolynomial,
                           dimension>::template UnitPolynomial<indices>(t_min,
@@ -221,7 +221,7 @@ std::array<Series, sizeof...(indices)> PeriodicSeriesGenerator<
     std::index_sequence<indices...>>::BasisElements(AngularFrequency const& ω,
                                                     Instant const& t_min,
                                                     Instant const& t_max) {
-  Instant const t_mid = Barycentre({t_min, t_max}, {1, 1});
+  Instant const t_mid = Barycentre({t_min, t_max});
   typename Series::AperiodicPolynomial const aperiodic_zero{{}, t_mid};
   return {Series(
       aperiodic_zero,

numerics/polynomial_in_чебышёв_basis_body.hpp

@@ -341,7 +341,7 @@ RealRootsOrDie(double const ε) const {
 
     // Rescale from [-1, 1] to [lower_bound_, upper_bound_].
     absl::btree_set<Argument> real_roots;
-    auto const midpoint = Barycentre({lower_bound_, upper_bound_}, {1, 1});
+    auto const midpoint = Barycentre({lower_bound_, upper_bound_});
     auto const half_width = 0.5 * (upper_bound_ - lower_bound_);
     for (auto const& scaled_real_root : scaled_real_roots) {
       // Чебышёв polynomials don't make sense outside of [-1, 1] but they may

numerics/root_finders_body.hpp

@@ -43,7 +43,7 @@ Argument Bisect(Function f,
   Argument lower = lower_bound;
   Argument upper = upper_bound;
   for (;;) {
-    Argument const middle = Barycentre({lower, upper}, {1, 1});
+    Argument const middle = Barycentre({lower, upper});
     // The size of the interval has reached one ULP.
     if (middle == lower || middle == upper) {
       return middle;
@@ -205,7 +205,7 @@ Argument GoldenSectionSearch(Function f,
       f_upper_interior = f(upper_interior);
     }
   }
-  return Barycentre({lower, upper}, {1, 1});
+  return Barycentre({lower, upper});
 }
 
 // The implementation is translated from the ALGOL 60 in [Bre73], chapter 5,
@@ -266,7 +266,7 @@ Argument Brent(Function f,
     Difference<Argument> e{};
     f_v = f_w = f_x = f(x);
     for (;;) {
-      Argument const m = Barycentre({a, b}, {1, 1});
+      Argument const m = Barycentre({a, b});
       Difference<Argument> const tol = eps * Abs(x - Argument{}) + t;
       Difference<Argument> const t2 = 2 * tol;
       // Check stopping criterion.

physics/ephemeris_test.cpp

@@ -198,7 +198,7 @@ TEST_P(EphemerisTest, ProlongSpecialCases) {
   EXPECT_OK(ephemeris.Prolong(t0_ + period / 2));
   EXPECT_EQ(t_max, ephemeris.t_max());
 
-  Instant const last_t = Barycentre({t0_ + period, t_max}, {0.5, 0.5});
+  Instant const last_t = Barycentre({t0_ + period, t_max});
   ephemeris.Prolong(last_t).IgnoreError();
   EXPECT_EQ(t_max, ephemeris.t_max());
 }