Rename quantity to make way for an actual quantity concept

eggrobin · Mar 23, 2024 · 74d37d0 · 74d37d0
1 parent 467474b
commit 74d37d0
Show file tree

Hide file tree

Showing 15 changed files with 98 additions and 97 deletions.
diff --git a/geometry/grassmann.hpp b/geometry/grassmann.hpp
@@ -259,69 +259,69 @@ Multivector<Scalar, Frame, rank> operator-(
     Multivector<Scalar, Frame, rank> const& right);
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_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>
+  requires convertible_to_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>
+  requires convertible_to_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>
+  requires convertible_to_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>
-  requires quantity<RScalar>
+  requires convertible_to_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>
-  requires quantity<RScalar>
+  requires convertible_to_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>
-  requires quantity<RScalar>
+  requires convertible_to_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>
-  requires quantity<LScalar>
+  requires convertible_to_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>
-  requires quantity<LScalar>
+  requires convertible_to_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>
-  requires quantity<LScalar>
+  requires convertible_to_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>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,

diff --git a/geometry/grassmann_body.hpp b/geometry/grassmann_body.hpp
@@ -342,7 +342,7 @@ Multivector<Scalar, Frame, rank> operator-(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(LScalar const& left,
           Multivector<RScalar, Frame, rank> const& right) {
@@ -351,7 +351,7 @@ operator*(LScalar const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 operator*(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
@@ -360,7 +360,7 @@ operator*(Multivector<LScalar, Frame, rank> const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Quotient<LScalar, RScalar>, Frame, rank>
 operator/(Multivector<LScalar, Frame, rank> const& left,
           RScalar const& right) {
@@ -369,7 +369,7 @@ operator/(Multivector<LScalar, Frame, rank> const& left,
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -381,7 +381,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -393,7 +393,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     Multivector<LScalar, Frame, rank> const& a,
     RScalar const& b,
@@ -405,7 +405,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     Multivector<LScalar, Frame, rank> const& a,
@@ -418,7 +418,7 @@ FusedNegatedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -430,7 +430,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -442,7 +442,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
     LScalar const& a,
     Multivector<RScalar, Frame, rank> const& b,
@@ -454,7 +454,7 @@ Multivector<Product<LScalar, RScalar>, Frame, rank> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar, typename Frame, int rank>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 Multivector<Product<LScalar, RScalar>, Frame, rank>
 FusedNegatedMultiplySubtract(
     LScalar const& a,

diff --git a/geometry/hilbert.hpp b/geometry/hilbert.hpp
@@ -27,7 +27,7 @@ template<typename T1, typename T2 = T1>
 struct Hilbert;
 
 template<typename T1, typename T2>
-  requires quantity<T1> && quantity<T2>
+  requires convertible_to_quantity<T1> && convertible_to_quantity<T2>
 struct Hilbert<T1, T2> : not_constructible {
   static constexpr int dimension = 1;
 
@@ -36,7 +36,7 @@ struct Hilbert<T1, T2> : not_constructible {
 };
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 struct Hilbert<T, T> : not_constructible {
   static constexpr int dimension = 1;
 

diff --git a/geometry/hilbert_body.hpp b/geometry/hilbert_body.hpp
@@ -12,26 +12,26 @@ namespace internal {
 using namespace principia::quantities::_elementary_functions;
 
 template<typename T1, typename T2>
-  requires quantity<T1> && quantity<T2>
+  requires convertible_to_quantity<T1> && convertible_to_quantity<T2>
 auto Hilbert<T1, T2>::InnerProduct(T1 const& t1, T2 const& t2)
     -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::InnerProduct(T const& t1, T const& t2) -> InnerProductType {
   return t1 * t2;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::Norm²(T const& t) -> Norm²Type {
   return t * t;
 }
 
 template<typename T>
-  requires quantity<T>
+  requires convertible_to_quantity<T>
 auto Hilbert<T, T>::Norm(T const& t) -> NormType {
   return Abs(t);
 }

diff --git a/geometry/point.hpp b/geometry/point.hpp
@@ -75,23 +75,23 @@ class Point final {
       L const& a, R const& b, Point<Product<L, R>> const& c);
 
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator<(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator<=(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator>=(Point<V> const& left, Point<V> const& right);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr bool operator>(Point<V> const& left, Point<V> const& right);
 
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr Point<V> NextUp(Point<V> x);
   template<typename V>
-    requires quantity<V>
+    requires convertible_to_quantity<V>
   friend constexpr Point<V> NextDown(Point<V> x);
 
   template<typename V>
@@ -115,28 +115,28 @@ Point<Product<L, R>> FusedNegatedMultiplyAdd(L const& a,
                                              Point<Product<L, R>> const& c);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<(Point<Vector> const& left, Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<=(Point<Vector> const& left,
                           Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>=(Point<Vector> const& left,
                           Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>(Point<Vector> const& left, Point<Vector> const& right);
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextUp(Point<Vector> x);
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextDown(Point<Vector> x);
 
 template<typename Vector>

diff --git a/geometry/point_body.hpp b/geometry/point_body.hpp
@@ -145,42 +145,42 @@ Point<Product<L, R>> FusedNegatedMultiplyAdd(L const& a, R const& b,
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<(Point<Vector> const& left,
                          Point<Vector> const& right) {
   return left.coordinates_ < right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator<=(Point<Vector> const& left,
                           Point<Vector> const& right) {
   return left.coordinates_ <= right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>=(Point<Vector> const& left,
                           Point<Vector> const& right) {
   return left.coordinates_ >= right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr bool operator>(Point<Vector> const& left,
                          Point<Vector> const& right) {
   return left.coordinates_ > right.coordinates_;
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextUp(Point<Vector> const x) {
   using quantities::_elementary_functions::NextUp;
   return Point<Vector>(NextUp(x.coordinates_));
 }
 
 template<typename Vector>
-  requires quantity<Vector>
+  requires convertible_to_quantity<Vector>
 constexpr Point<Vector> NextDown(Point<Vector> const x) {
   using quantities::_elementary_functions::NextDown;
   return Point<Vector>(NextDown(x.coordinates_));