hilbert is a mess

eggrobin · Mar 16, 2024 · e25b153 · e25b153
1 parent 4f09547
commit e25b153
Show file tree

Hide file tree

Showing 18 changed files with 237 additions and 228 deletions.
diff --git a/geometry/grassmann.hpp b/geometry/grassmann.hpp
@@ -7,9 +7,9 @@
 #include "base/concepts.hpp"
 #include "base/not_null.hpp"
 #include "geometry/r3_element.hpp"
+#include "quantities/concepts.hpp"
 #include "quantities/named_quantities.hpp"
 #include "quantities/quantities.hpp"
-#include "quantities/traits.hpp"
 #include "serialization/geometry.pb.h"
 
 namespace principia {
@@ -20,9 +20,9 @@ namespace internal {
 using namespace principia::base::_concepts;
 using namespace principia::base::_not_null;
 using namespace principia::geometry::_r3_element;
+using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
-using namespace principia::quantities::_traits;
 
 // A multivector of rank |rank| on a three-dimensional real inner product
 // space bearing the dimensionality of |Scalar|, i.e., an element of
@@ -258,71 +258,70 @@ Multivector<Scalar, Frame, rank> operator-(
     Multivector<Scalar, Frame, rank> const& left,
     Multivector<Scalar, Frame, rank> const& right);
 
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<LScalar>>>
-Multivector<Product<LScalar, RScalar>, Frame, rank>
-operator*(LScalar const& left,
-          Multivector<RScalar, Frame, rank> const& right);
-
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
-Multivector<Product<LScalar, RScalar>, Frame, rank>
-operator*(Multivector<LScalar, Frame, rank> const& left,
-          RScalar const& right);
-
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
-Multivector<Quotient<LScalar, RScalar>, Frame, rank>
-operator/(Multivector<LScalar, Frame, rank> const& left,
-          RScalar const& right);
-
-
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
+Multivector<Product<LScalar, RScalar>, Frame, rank> operator*(
+    LScalar const& left,
+    Multivector<RScalar, Frame, rank> const& right);
+
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
+Multivector<Product<LScalar, RScalar>, Frame, rank> operator*(
+    Multivector<LScalar, Frame, rank> const& left,
+    RScalar const& right);
+
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
+Multivector<Quotient<LScalar, RScalar>, Frame, rank> operator/(
+    Multivector<LScalar, Frame, rank> const& left,
+    RScalar const& right);
+
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<RScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
 
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<LScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<LScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<LScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
     Multivector<Product<LScalar, RScalar>, Frame, rank> const& c);
-template<typename LScalar, typename RScalar, typename Frame, int rank,
-         typename = std::enable_if_t<is_quantity_v<LScalar>>>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,

diff --git a/geometry/grassmann_body.hpp b/geometry/grassmann_body.hpp
@@ -341,31 +341,35 @@ Multivector<Scalar, Frame, rank> operator-(
       left.coordinates() - right.coordinates());
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(LScalar const& left,
           Multivector<RScalar, Frame, rank> const& right) {
   return Multivector<Product<LScalar, RScalar>, Frame, rank>(
       left * right.coordinates());
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
   return Multivector<Product<LScalar, RScalar>, Frame, rank>(
       left.coordinates() * right);
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Quotient<LScalar, RScalar>, Frame, rank>
 operator/(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
   return Multivector<Quotient<LScalar, RScalar>, Frame, rank>(
       left.coordinates() / right);
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -376,7 +380,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
       FusedMultiplyAdd(a.coordinates(), b, c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -387,7 +392,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
       FusedMultiplySubtract(a.coordinates(), b, c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -398,7 +404,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
       FusedNegatedMultiplyAdd(a.coordinates(), b, c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
@@ -410,7 +417,8 @@ FusedNegatedMultiplySubtract(
       FusedNegatedMultiplySubtract(a.coordinates(), b, c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -421,7 +429,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
       FusedMultiplyAdd(a, b.coordinates(), c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -432,7 +441,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
       FusedMultiplySubtract(a, b.coordinates(), c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -443,7 +453,8 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
       FusedNegatedMultiplyAdd(a, b.coordinates(), c.coordinates()));
 }
 
-template<typename LScalar, typename RScalar, typename Frame, int rank, typename>
+template<typename LScalar, typename RScalar, typename Frame, int rank>
+  requires quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,

diff --git a/geometry/hilbert.hpp b/geometry/hilbert.hpp
@@ -5,8 +5,8 @@
 #include "base/not_constructible.hpp"
 #include "geometry/concepts.hpp"
 #include "geometry/grassmann.hpp"  // 🧙 For _grassmann::internal.
+#include "quantities/concepts.hpp"
 #include "quantities/named_quantities.hpp"
-#include "quantities/traits.hpp"
 
 namespace principia {
 namespace geometry {
@@ -15,31 +15,28 @@ namespace internal {
 
 using namespace principia::base::_not_constructible;
 using namespace principia::geometry::_concepts;
+using namespace principia::quantities::_concepts;
 using namespace principia::quantities::_named_quantities;
-using namespace principia::quantities::_traits;
 
 // A trait that represents a Hilbert space, i.e., a space with an inner product
 // and (possibly) a norm.  The struct Hilbert exports a type InnerProductType
 // (the result of the inner product) and a function InnerProduct.  In addition,
 // if only one parameter is given, or if the two parameters are identical, it
 // also exports a type NormType (the result of the norm) and a function Norm.
-template<typename T1, typename T2 = T1, typename = void>
+template<typename T1, typename T2 = T1>
 struct Hilbert;
 
 template<typename T1, typename T2>
-struct Hilbert<T1, T2,
-               std::enable_if_t<
-                   std::conjunction_v<is_quantity<T1>, is_quantity<T2>,
-                                      std::negation<std::is_same<T1, T2>>>>>
-    : not_constructible {
+  requires quantity<T1> && quantity<T2> && (!std::is_same_v<T1, T2>)
+struct Hilbert<T1, T2> : not_constructible {
   static constexpr int dimension = 1;
 
   using InnerProductType = Product<T1, T2>;
   static InnerProductType InnerProduct(T1 const& t1, T2 const& t2);
 };
 
-template<typename T>
-struct Hilbert<T, T, std::enable_if_t<is_quantity_v<T>>> : not_constructible {
+template<typename T> requires quantity<T>
+struct Hilbert<T, T> : not_constructible {
   static constexpr int dimension = 1;
 
   using InnerProductType = Square<T>;
@@ -55,7 +52,7 @@ struct Hilbert<T, T, std::enable_if_t<is_quantity_v<T>>> : not_constructible {
 };
 
 template<typename T1, typename T2>
-  requires hilbert<T1, T2>
+  requires hilbert<T1, T2> && (!std::is_same_v<T1, T2>)
 struct Hilbert<T1, T2> : not_constructible {
   static_assert(T1::dimension == T2::dimension);
   static constexpr int dimension = T1::dimension;

diff --git a/geometry/hilbert_body.hpp b/geometry/hilbert_body.hpp
@@ -12,29 +12,27 @@ namespace internal {
 using namespace principia::quantities::_elementary_functions;
 
 template<typename T1, typename T2>
-auto Hilbert<T1, T2,
-             std::enable_if_t<
-                 std::conjunction_v<is_quantity<T1>, is_quantity<T2>,
-                                    std::negation<std::is_same<T1, T2>>>>>::
-    InnerProduct(T1 const& t1, T2 const& t2) -> InnerProductType {
+  requires quantity<T1> && quantity<T2> && (!std::is_same_v<T1, T2>)
+auto Hilbert<T1, T2>::InnerProduct(T1 const& t1, T2 const& t2)
+    -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-auto Hilbert<T, T, std::enable_if_t<is_quantity_v<T>>>::
-    InnerProduct(T const& t1, T const& t2) -> InnerProductType {
+  requires quantity<T>
+auto Hilbert<T, T>::InnerProduct(T const& t1, T const& t2) -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-auto Hilbert<T, T, std::enable_if_t<is_quantity_v<T>>>::Norm²(T const& t)
-    -> Norm²Type {
+  requires quantity<T>
+auto Hilbert<T, T>::Norm²(T const& t) -> Norm²Type {
   return t * t;
 }
 
 template<typename T>
-auto Hilbert<T, T, std::enable_if_t<is_quantity_v<T>>>::Norm(
-    T const& t) -> NormType {
+  requires quantity<T>
+auto Hilbert<T, T>::Norm(T const& t) -> NormType {
   return Abs(t);
 }