Some algebraic concepts

geometry/pair.hpp

@@ -6,6 +6,7 @@
 #include "base/not_null.hpp"
 #include "geometry/barycentre_calculator.hpp"  // 🧙 For friendship.
 #include "geometry/traits.hpp"
+#include "quantities/concepts.hpp"
 #include "quantities/named_quantities.hpp"
 #include "serialization/geometry.pb.h"
 
@@ -24,7 +25,7 @@ namespace internal {
 using namespace principia::base::_concepts;
 using namespace principia::base::_not_constructible;
 using namespace principia::base::_not_null;
-using namespace principia::geometry::_traits;
+using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
 
 template<typename T1, typename T2>
@@ -50,7 +51,7 @@ struct enable_if_affine;
 template<typename T1, typename T2, typename U>
 struct enable_if_affine<
     Pair<T1, T2>, U,
-    std::enable_if_t<!std::conjunction_v<is_vector<T1>, is_vector<T2>>>>
+    std::enable_if_t<!(additive_group<T1> && additive_group<T2>)>>
     : not_constructible {
   using type = U;
 };
@@ -66,7 +67,7 @@ struct enable_if_vector;
 template<typename T1, typename T2, typename U>
 struct enable_if_vector<
     Pair<T1, T2>, U,
-    std::enable_if_t<std::conjunction_v<is_vector<T1>, is_vector<T2>>>>
+    std::enable_if_t<additive_group<T1> && additive_group<T2>>>
     : not_constructible {
   using type = U;
 };

numerics/polynomial_in_monomial_basis.hpp

@@ -73,6 +73,7 @@ using namespace principia::geometry::_hilbert;
 using namespace principia::geometry::_point;
 using namespace principia::geometry::_traits;
 using namespace principia::numerics::_polynomial;
+using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_tuples;
 
@@ -93,10 +94,8 @@ class PolynomialInMonomialBasis : public Polynomial<Value_, Argument_> {
   // powers of (argument - origin).
   constexpr PolynomialInMonomialBasis(Coefficients coefficients,
                                       Argument const& origin);
-  template<typename A = Argument,
-           typename = std::enable_if_t<is_vector_v<A>>>
-  explicit constexpr PolynomialInMonomialBasis(
-      Coefficients coefficients);
+  explicit constexpr PolynomialInMonomialBasis(Coefficients coefficients)
+    requires additive_group<Argument>;
 
   // A polynomial may be explicitly converted to a higher degree (possibly with
   // a different evaluator).
@@ -123,17 +122,14 @@ class PolynomialInMonomialBasis : public Polynomial<Value_, Argument_> {
   Derivative() const;
 
   // The constant term of the result is zero.
-  template<typename V = Value,
-           typename = std::enable_if_t<is_vector_v<V>>>
   PolynomialInMonomialBasis<Primitive<Value, Argument>,
                             Argument, degree_ + 1, Evaluator>
-  Primitive() const;
+  Primitive() const requires additive_group<Value>;
 
-  template<typename V = Value,
-           typename = std::enable_if_t<is_vector_v<V>>>
   quantities::_named_quantities::Primitive<Value, Argument> Integrate(
       Argument const& argument1,
-      Argument const& argument2) const;
+      Argument const& argument2) const
+    requires additive_group<Value>;
 
   PolynomialInMonomialBasis& operator+=(const PolynomialInMonomialBasis& right);
   PolynomialInMonomialBasis& operator-=(const PolynomialInMonomialBasis& right);

numerics/polynomial_in_monomial_basis_body.hpp

@@ -343,9 +343,9 @@ PolynomialInMonomialBasis(Coefficients coefficients,
 
 template<typename Value_, typename Argument_, int degree_,
          template<typename, typename, int> typename Evaluator>
-template<typename, typename>
 constexpr PolynomialInMonomialBasis<Value_, Argument_, degree_, Evaluator>::
 PolynomialInMonomialBasis(Coefficients coefficients)
+  requires additive_group<Argument>
     : coefficients_(std::move(coefficients)),
       origin_(Argument{}) {}
 
@@ -433,11 +433,12 @@ Derivative() const {
 
 template<typename Value_, typename Argument_, int degree_,
          template<typename, typename, int> typename Evaluator>
-template<typename, typename>
 PolynomialInMonomialBasis<Primitive<Value_, Argument_>, Argument_,
                           degree_ + 1, Evaluator>
-PolynomialInMonomialBasis<Value_, Argument_, degree_, Evaluator>::
-Primitive() const {
+PolynomialInMonomialBasis<Value_, Argument_, degree_, Evaluator>::Primitive()
+    const
+  requires additive_group<Value>
+{
   return PolynomialInMonomialBasis<
              quantities::_named_quantities::Primitive<Value, Argument>,
              Argument,
@@ -448,11 +449,12 @@ Primitive() const {
 
 template<typename Value_, typename Argument_, int degree_,
          template<typename, typename, int> typename Evaluator>
-template<typename, typename>
 Primitive<Value_, Argument_>
-PolynomialInMonomialBasis<Value_, Argument_, degree_, Evaluator>::
-Integrate(Argument const& argument1,
-          Argument const& argument2) const {
+PolynomialInMonomialBasis<Value_, Argument_, degree_, Evaluator>::Integrate(
+    Argument const& argument1,
+    Argument const& argument2) const
+  requires additive_group<Value>
+{
   // + 2 is to take into account the truncation resulting from integer division.
   return _quadrature::GaussLegendre<(degree_ + 2) / 2>(*this,
                                                        argument1, argument2);

quantities/concepts.hpp

@@ -14,13 +14,50 @@ namespace internal {
 using namespace base::_traits;
 using namespace quantities::_quantities;
 
+template<typename G>
+concept additive_group = requires(G x, G y) {
+  G{};
+  { -x } -> std::same_as<G>;
+  { x + y } -> std::same_as<G>;
+  { x - y } -> std::same_as<G>;
+  { x += y } -> std::same_as<G&>;
+  { x -= y } -> std::same_as<G&>;
+};
+
+template<typename V, typename K>
+concept vector_space = additive_group<V> && requires(K λ, V v) {
+  { λ * v } -> std::same_as<V>;
+  { v * λ } -> std::same_as<V>;
+  { v / λ } -> std::same_as<V>;
+  { v *= λ } -> std::same_as<V&>;
+  { v /= λ } -> std::same_as<V&>;
+};
+
+template<typename V>
+concept real_vector_space = vector_space<V, double>;
+
+template<typename A, typename K>
+concept affine_space = requires(A x, A y) {
+  { x - y } -> vector_space<K>;
+  { y + (x - y) } -> std::same_as<A>;
+  { y += (x - y) } -> std::same_as<A&>;
+};
+
+template<typename V>
+concept real_affine_space = affine_space<V, double>;
+
 template<typename T>
 concept quantity = std::integral<T> || std::floating_point<T> ||
                    is_instance_of_v<Quantity, std::remove_const_t<T>>;
 
 }  // namespace internal
 
+using internal::additive_group;
+using internal::affine_space;
+using internal::real_affine_space;
+using internal::real_vector_space;
 using internal::quantity;
+using internal::vector_space;
 
 }  // namespace _concepts
 }  // namespace quantities

quantities/concepts_test.cpp

@@ -8,6 +8,7 @@ namespace quantities {
 
 using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
+using namespace principia::quantities::_quantities;
 
 TEST(Traits, IsQuantityV) {
   static_assert(quantity<int>);