From 894ef4f3eac38e1b058325ad24576cb3ddcbc04e Mon Sep 17 00:00:00 2001
From: Robin Leroy <egg.robin.leroy@gmail.com>
Date: Sat, 23 Mar 2024 19:53:18 +0100
Subject: [PATCH] Rename quantity to make way for an actual quantity concept

---
 geometry/grassmann.hpp                        | 22 +++++++++----------
 geometry/grassmann_body.hpp                   | 22 +++++++++----------
 geometry/hilbert.hpp                          |  4 ++--
 geometry/hilbert_body.hpp                     |  8 +++----
 geometry/point.hpp                            | 10 ++++-----
 geometry/point_body.hpp                       |  4 ++--
 geometry/r3_element.hpp                       | 22 +++++++++----------
 geometry/r3_element_body.hpp                  | 22 +++++++++----------
 geometry/r3x3_matrix.hpp                      | 12 +++++-----
 geometry/r3x3_matrix_body.hpp                 |  6 ++---
 numerics/double_precision_body.hpp            |  2 +-
 ...321\213\321\210\321\221\320\262_basis.hpp" |  6 ++---
 ...13\321\210\321\221\320\262_basis_body.hpp" | 10 ++++-----
 quantities/concepts.hpp                       |  7 +++---
 quantities/concepts_test.cpp                  | 16 +++++++-------
 15 files changed, 87 insertions(+), 86 deletions(-)

diff --git a/geometry/grassmann.hpp b/geometry/grassmann.hpp
index f0778c13f5..40b6b01096 100644
--- a/geometry/grassmann.hpp
+++ b/geometry/grassmann.hpp
@@ -253,43 +253,43 @@ 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,
@@ -297,25 +297,25 @@ FusedNegatedMultiplySubtract(
     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
index 5abb90c7b7..4843c56c65 100644
--- a/geometry/grassmann_body.hpp
+++ b/geometry/grassmann_body.hpp
@@ -426,7 +426,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) {
@@ -435,7 +435,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) {
@@ -444,7 +444,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) {
@@ -453,7 +453,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,
@@ -465,7 +465,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,
@@ -477,7 +477,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,
@@ -489,7 +489,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,
@@ -502,7 +502,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,
@@ -514,7 +514,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,
@@ -526,7 +526,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,
@@ -538,7 +538,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
index 6fca7c2470..ff5d50c6c6 100644
--- 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
index 1b3e190bb2..9e36e3ffe1 100644
--- 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
index cd7b83daff..39f4da15da 100644
--- a/geometry/point.hpp
+++ b/geometry/point.hpp
@@ -46,7 +46,7 @@ class Point final {
   constexpr friend bool operator!=(Point const& left,
                                    Point const& right) = default;
   constexpr friend auto operator<=>(Point const& left, Point const& right)
-    requires quantity<Vector> = default;
+    requires convertible_to_quantity<Vector> = default;
 
   constexpr Vector operator-(Point const& from) const;
 
@@ -79,10 +79,10 @@ 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 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>
@@ -106,10 +106,10 @@ 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 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
index d79878a350..20860a5802 100644
--- a/geometry/point_body.hpp
+++ b/geometry/point_body.hpp
@@ -135,14 +135,14 @@ Point<Product<L, R>> FusedNegatedMultiplyAdd(L const& a, R const& b,
 }
 
 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_));
diff --git a/geometry/r3_element.hpp b/geometry/r3_element.hpp
index d9e9c01d24..7d8836a762 100644
--- a/geometry/r3_element.hpp
+++ b/geometry/r3_element.hpp
@@ -115,41 +115,41 @@ R3Element<Scalar> operator-(R3Element<Scalar> const& left,
 // product LScalar ⊗ Scalar³. Since LScalar ⊗ Scalar³ ≅ (LScalar ⊗ Scalar)³,
 // the result is an R3Element<Product<LScalar, RScalar>>.
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> operator*(LScalar const& left,
                                                R3Element<RScalar> const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
                                                RScalar const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
                                                 RScalar const& right);
 
 // FMA for ±vector * scalar ± vector.
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -157,25 +157,25 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
 
 // FMA for ±scalar * vector ± vector.
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
     R3Element<Product<LScalar, RScalar>> const& c);
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
diff --git a/geometry/r3_element_body.hpp b/geometry/r3_element_body.hpp
index d244005f9f..74e7f79ba9 100644
--- a/geometry/r3_element_body.hpp
+++ b/geometry/r3_element_body.hpp
@@ -253,7 +253,7 @@ R3Element<Scalar> operator-(R3Element<Scalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3Element<RScalar> const& right) {
@@ -269,7 +269,7 @@ R3Element<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
                                                RScalar const& right) {
 #if PRINCIPIA_USE_SSE3_INTRINSICS()
@@ -284,7 +284,7 @@ R3Element<Product<LScalar, RScalar>> operator*(R3Element<LScalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
                                                 RScalar const& right) {
 #if PRINCIPIA_USE_SSE3_INTRINSICS()
@@ -299,7 +299,7 @@ R3Element<Quotient<LScalar, RScalar>> operator/(R3Element<LScalar> const& left,
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -314,7 +314,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -329,7 +329,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -344,7 +344,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     R3Element<LScalar> const& a,
     RScalar const& b,
@@ -359,7 +359,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -374,7 +374,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -389,7 +389,7 @@ R3Element<Product<LScalar, RScalar>> FusedMultiplySubtract(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
     LScalar const& a,
     R3Element<RScalar> const& b,
@@ -404,7 +404,7 @@ R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplyAdd(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3Element<Product<LScalar, RScalar>> FusedNegatedMultiplySubtract(
     LScalar const& a,
     R3Element<RScalar> const& b,
diff --git a/geometry/r3x3_matrix.hpp b/geometry/r3x3_matrix.hpp
index 460d7a5a2e..5abc7f7660 100644
--- a/geometry/r3x3_matrix.hpp
+++ b/geometry/r3x3_matrix.hpp
@@ -112,15 +112,15 @@ class R3x3Matrix final {
                                               R3x3Matrix<RS> const& right);
 
   template<typename LS, typename RS>
-    requires quantity<LS>
+    requires convertible_to_quantity<LS>
   friend R3x3Matrix<Product<LS, RS>> operator*(LS const& left,
                                                R3x3Matrix<RS> const& right);
   template<typename LS, typename RS>
-    requires quantity<RS>
+    requires convertible_to_quantity<RS>
   friend R3x3Matrix<Product<LS, RS>> operator*(R3x3Matrix<LS> const& left,
                                                RS const& right);
   template<typename LS, typename RS>
-    requires quantity<RS>
+    requires convertible_to_quantity<RS>
   friend R3x3Matrix<Quotient<LS, RS>> operator/(R3x3Matrix<LS> const& left,
                                                 RS const& right);
 
@@ -156,16 +156,16 @@ R3Element<Product<LScalar, RScalar>> operator*(
     R3x3Matrix<RScalar> const& right);
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3x3Matrix<RScalar> const& right);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(R3x3Matrix<LScalar> const& left,
                                                 RScalar const& right);
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Quotient<LScalar, RScalar>> operator/(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right);
diff --git a/geometry/r3x3_matrix_body.hpp b/geometry/r3x3_matrix_body.hpp
index 7aa40d56ad..fa86f9e4c5 100644
--- a/geometry/r3x3_matrix_body.hpp
+++ b/geometry/r3x3_matrix_body.hpp
@@ -342,7 +342,7 @@ R3Element<Product<LScalar, RScalar>> operator*(
 
 
 template<typename LScalar, typename RScalar>
-  requires quantity<LScalar>
+  requires convertible_to_quantity<LScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     LScalar const& left,
     R3x3Matrix<RScalar> const& right) {
@@ -355,7 +355,7 @@ R3x3Matrix<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Product<LScalar, RScalar>> operator*(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right) {
@@ -368,7 +368,7 @@ R3x3Matrix<Product<LScalar, RScalar>> operator*(
 }
 
 template<typename LScalar, typename RScalar>
-  requires quantity<RScalar>
+  requires convertible_to_quantity<RScalar>
 R3x3Matrix<Quotient<LScalar, RScalar>> operator/(
     R3x3Matrix<LScalar> const& left,
     RScalar const& right) {
diff --git a/numerics/double_precision_body.hpp b/numerics/double_precision_body.hpp
index cec2f7d831..bc5d6ed862 100644
--- a/numerics/double_precision_body.hpp
+++ b/numerics/double_precision_body.hpp
@@ -101,7 +101,7 @@ struct ComponentwiseComparator<R3Element<T>, R3Element<U>> : not_constructible {
 };
 
 template<typename T, typename U>
-  requires quantity<T> && quantity<U>
+  requires convertible_to_quantity<T> && convertible_to_quantity<U>
 struct ComponentwiseComparator<T, U> {
   static bool GreaterThanOrEqualOrZero(T const& left, U const& right) {
     return Abs(left) >= Abs(right) || left == T{};
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
index c2ef9d929a..b402055d82 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis.hpp"
@@ -83,12 +83,12 @@ class PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>
   // of |error_estimate| has no real roots.  This is useful if the series is an
   // approximation of some function with an L∞ error less than |error_estimate|.
   bool MayHaveRealRoots(Value error_estimate = Value{}) const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   // Returns the real roots of the polynomial, computed as the eigenvalues of
   // the Frobenius companion matrix.
   absl::btree_set<Argument> RealRoots(double ε) const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   // Compatibility deserialization: this class is the equivalent of the old
   // ЧебышёвSeries.
@@ -138,7 +138,7 @@ class PolynomialInЧебышёвBasis<Value_, Argument_, degree_>
 
   // Returns the Frobenius companion matrix suitable for the Чебышёв basis.
   FixedMatrix<double, degree_, degree_> FrobeniusCompanionMatrix() const
-    requires quantity<Value_>;
+    requires convertible_to_quantity<Value_>;
 
   void WriteToMessage(
       not_null<serialization::Polynomial*> message) const override;
diff --git "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp" "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
index 721be26b6d..a232511540 100644
--- "a/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
+++ "b/numerics/polynomial_in_\321\207\320\265\320\261\321\213\321\210\321\221\320\262_basis_body.hpp"
@@ -38,7 +38,7 @@ using namespace principia::quantities::_si;
 template<typename Value_, typename Argument_>
 bool PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>::
     MayHaveRealRoots(Value const error_estimate) const
-  requires quantity<Value_> {
+  requires convertible_to_quantity<Value_> {
   return MayHaveRealRootsOrDie(error_estimate);
 }
 
@@ -46,7 +46,7 @@ template<typename Value_, typename Argument_>
 absl::btree_set<Argument_>
 PolynomialInЧебышёвBasis<Value_, Argument_, std::nullopt>::RealRoots(
     double const ε) const
-  requires quantity<Value_> {
+  requires convertible_to_quantity<Value_> {
   return RealRootsOrDie(ε);
 }
 
@@ -212,7 +212,7 @@ PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::upper_bound() const
 template<typename Value_, typename Argument_, int degree_>
 FixedMatrix<double, degree_, degree_>
 PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::FrobeniusCompanionMatrix()
-    const requires quantity<Value_> {
+    const requires convertible_to_quantity<Value_> {
   int const N = degree();
   FixedMatrix<double, degree_, degree_> A(uninitialized);
 
@@ -304,7 +304,7 @@ PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::ReadFromMessage(
 template<typename Value_, typename Argument_, int degree_>
 bool PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::
 MayHaveRealRootsOrDie(Value const error_estimate) const {
-  if constexpr (quantity<Value>) {
+  if constexpr (convertible_to_quantity<Value>) {
     CHECK_LE(Value{}, error_estimate);
     // This code follow [Boy06], theorem 2.  Note that [Boy06] has another
     // criterion, B₁ and concludes: “There was no detectable difference between
@@ -332,7 +332,7 @@ template<typename Value_, typename Argument_, int degree_>
 absl::btree_set<Argument_>
 PolynomialInЧебышёвBasis<Value_, Argument_, degree_>::
 RealRootsOrDie(double const ε) const {
-  if constexpr (quantity<Value>) {
+  if constexpr (convertible_to_quantity<Value>) {
     auto const companion_matrix = FrobeniusCompanionMatrix();
     auto const real_schur_decomposition =
         RealSchurDecomposition(companion_matrix, ε);
diff --git a/quantities/concepts.hpp b/quantities/concepts.hpp
index 80a3f571ac..2b46b19bbf 100644
--- a/quantities/concepts.hpp
+++ b/quantities/concepts.hpp
@@ -50,8 +50,9 @@ 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>>;
+concept convertible_to_quantity =
+    std::convertible_to<T, double> ||
+    is_instance_of_v<Quantity, std::remove_cvref_t<T>>;
 
 }  // namespace internal
 
@@ -59,7 +60,7 @@ using internal::additive_group;
 using internal::affine_space;
 using internal::real_affine_space;
 using internal::real_vector_space;
-using internal::quantity;
+using internal::convertible_to_quantity;
 using internal::vector_space;
 
 }  // namespace _concepts
diff --git a/quantities/concepts_test.cpp b/quantities/concepts_test.cpp
index e6815c4461..a5f224531e 100644
--- a/quantities/concepts_test.cpp
+++ b/quantities/concepts_test.cpp
@@ -12,14 +12,14 @@ using namespace principia::quantities::_named_quantities;
 using namespace principia::quantities::_quantities;
 
 TEST(Traits, IsQuantityV) {
-  static_assert(quantity<int>);
-  static_assert(quantity<double>);
-  static_assert(quantity<Area>);
-  static_assert(quantity<Frequency const>);
-  // Not sure if the following is what we want, but at least let's nail it in a
-  // test.
-  static_assert(!quantity<Entropy&>);
-  static_assert(!quantity<float const&>);
+  static_assert(convertible_to_quantity<int>);
+  static_assert(convertible_to_quantity<double>);
+  static_assert(convertible_to_quantity<Area>);
+  static_assert(convertible_to_quantity<Frequency const>);
+  static_assert(convertible_to_quantity<Entropy&>);
+  static_assert(convertible_to_quantity<float const&>);
+
+  static_assert(!convertible_to_quantity<int*>);
 }
 
 }  // namespace quantities