Merge pull request mockingbirdnest#3912 from eggrobin/concept-quantity

Add some algebraic concepts and remove geometry/traits

geometry/geometry.vcxproj

@@ -66,7 +66,6 @@
     <ClInclude Include="sphere_body.hpp" />
     <ClInclude Include="symmetric_bilinear_form.hpp" />
     <ClInclude Include="symmetric_bilinear_form_body.hpp" />
-    <ClInclude Include="traits.hpp" />
     <ClInclude Include="homothecy_body.hpp" />
   </ItemGroup>
   <ItemGroup>
@@ -95,6 +94,5 @@
     <ClCompile Include="signature_test.cpp" />
     <ClCompile Include="sign_test.cpp" />
     <ClCompile Include="symmetric_bilinear_form_test.cpp" />
-    <ClCompile Include="traits_test.cpp" />
   </ItemGroup>
 </Project>

geometry/geometry.vcxproj.filters

@@ -164,9 +164,6 @@
     <ClInclude Include="complexification_body.hpp">
       <Filter>Source Files</Filter>
     </ClInclude>
-    <ClInclude Include="traits.hpp">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="plane.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -259,9 +256,6 @@
     <ClCompile Include="complexification_test.cpp">
       <Filter>Test Files</Filter>
     </ClCompile>
-    <ClCompile Include="traits_test.cpp">
-      <Filter>Test Files</Filter>
-    </ClCompile>
     <ClCompile Include="plane_test.cpp">
       <Filter>Test Files</Filter>
     </ClCompile>

geometry/pair.hpp

@@ -5,7 +5,7 @@
 #include "base/not_constructible.hpp"
 #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 +24,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 +50,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 +66,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

@@ -18,7 +18,7 @@
 #include "base/traits.hpp"
 #include "geometry/hilbert.hpp"
 #include "geometry/point.hpp"
-#include "geometry/traits.hpp"
+#include "quantities/concepts.hpp"
 #include "quantities/named_quantities.hpp"
 #include "quantities/tuples.hpp"
 #include "serialization/numerics.pb.h"
@@ -71,8 +71,8 @@ using namespace principia::base::_not_null;
 using namespace principia::base::_traits;
 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 +93,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>;
 
   friend constexpr bool operator==(PolynomialInMonomialBasis const& left,
                                    PolynomialInMonomialBasis const& right) =
@@ -133,17 +131,15 @@ 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>;
 
   void WriteToMessage(
       not_null<serialization::Polynomial*> message) const override;

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{}) {}
 
@@ -451,11 +451,11 @@ 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 {
+Primitive() const
+  requires additive_group<Value> {
   return PolynomialInMonomialBasis<
              quantities::_named_quantities::Primitive<Value, Argument>,
              Argument,
@@ -466,11 +466,11 @@ 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 {
+          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,53 @@ 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 } -> 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&>;
+  { 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

@@ -2,12 +2,14 @@
 
 #include "gtest/gtest.h"
 #include "quantities/named_quantities.hpp"
+#include "quantities/quantities.hpp"
 
 namespace principia {
 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>);