After egg's review.

Author: pleroy

numerics/elementary_functions_body.hpp

@@ -29,7 +29,7 @@ using namespace principia::quantities::_si;
 // `FusedMultiplyAdd` and friends need to exist.
 namespace noncritical {
 
-template<cpp_bin_float Q1, cpp_bin_float Q2>
+template<boost_cpp_bin_float Q1, boost_cpp_bin_float Q2>
 Product<Q1, Q2> FusedMultiplyAdd(Q1 const& x,
                                  Q2 const& y,
                                  Product<Q1, Q2> const& z) {
@@ -43,12 +43,12 @@ Product<Q1, Q2> FusedMultiplyAdd(Q1 const& x,
   return x * y + z;
 }
 
-template<cpp_number Q>
+template<boost_cpp_number Q>
 Q Abs(Q const& x) {
   return abs(x);
 }
 
-template<cpp_number Q>
+template<boost_cpp_number Q>
 Q Round(Q const& x) {
   // TODO(phl): This is clunky.  Use `divide_qr` or something.
   return static_cast<Q>(round(static_cast<cpp_bin_float_50>(x)));

numerics/polynomial_in_monomial_basis_body.hpp

@@ -25,7 +25,6 @@ namespace numerics {
 namespace _polynomial_in_monomial_basis {
 namespace internal {
 
-using namespace boost::multiprecision;
 using namespace principia::base::_not_constructible;
 using namespace principia::geometry::_cartesian_product;
 using namespace principia::geometry::_serialization;
@@ -519,7 +518,7 @@ template<typename Value_, typename Argument_, int degree_>
 void PolynomialInMonomialBasis<Value_, Argument_, degree_>::
     WriteToMessage(not_null<serialization::Polynomial*> message) const {
   // No serialization for Boost types.
-  if constexpr (!cpp_number<Value>) {
+  if constexpr (!boost_cpp_number<Value>) {
     message->set_degree(degree_);
     auto* const extension = message->MutableExtension(
         serialization::PolynomialInMonomialBasis::extension);

quantities/cantor.hpp

@@ -13,43 +13,44 @@ namespace internal {
 using namespace boost::multiprecision;
 using namespace principia::base::_traits;
 
-// The `cpp_` concepts should be used sparingly, and only in places where the
-// Boost multiprecision API differs from ours or from the standard C++ API.  At
-// any rate, the multiprecision traits should never be used directly.
+// The `boost_cpp_` concepts should be used sparingly, and only in places where
+// the Boost multiprecision API differs from ours or from the standard C++ API.
+// At any rate, the multiprecision traits should never be used directly.
 
 template<typename T>
-concept cpp_number = (is_number<T>::value || is_number_expression<T>::value) &&
+concept boost_cpp_number = (is_number<T>::value || is_number_expression<T>::value) &&
                      number_category<T>::value != number_kind_unknown;
 
 template<typename T>
-concept cpp_bin_float =
-    cpp_number<T> && number_category<T>::value == number_kind_floating_point;
+concept boost_cpp_bin_float =
+    boost_cpp_number<T> && number_category<T>::value == number_kind_floating_point;
 
 template<typename T>
-concept cpp_int =
-    cpp_number<T> && number_category<T>::value == number_kind_integer;
+concept boost_cpp_int =
+    boost_cpp_number<T> && number_category<T>::value == number_kind_integer;
 
 template<typename T>
-concept cpp_rational =
-    cpp_number<T> && number_category<T>::value == number_kind_rational;
+concept boost_cpp_rational =
+    boost_cpp_number<T> && number_category<T>::value == number_kind_rational;
 
 
 template<typename T>
-concept discrete = std::integral<T> || cpp_int<T>;
+concept discrete = std::integral<T> || boost_cpp_int<T>;
 
 template<typename T>
-concept countable = discrete<T> || cpp_rational<T>;
+concept countable = discrete<T> || boost_cpp_rational<T>;
 
 template<typename T>
-concept continuum = std::floating_point<T> || cpp_bin_float<T>;
+concept continuum = std::floating_point<T> || boost_cpp_bin_float<T>;
 
 }  // namespace internal
 
-// `cpp_int` and `cpp_rational` are not exported on purpose.
+using internal::boost_cpp_bin_float;
+using internal::boost_cpp_int;
+using internal::boost_cpp_number;
+using internal::boost_cpp_rational;
 using internal::continuum;
 using internal::countable;
-using internal::cpp_bin_float;
-using internal::cpp_number;
 using internal::discrete;
 
 }  // namespace _cantor

quantities/quantities.hpp

@@ -144,10 +144,11 @@ __m128d ToM128D(Quantity<Dimensions> x);
 template<typename Q>
 constexpr Q Infinity = SIUnit<Q>() * std::numeric_limits<double>::infinity();
 
-// A quiet NaN of `Q`.  Note that NaN for `cpp_number` cannot be constexpr.
+// A quiet NaN of `Q`.  Note that NaN for `boost_cpp_number` cannot be
+// constexpr.
 template <typename Q>
 CONSTEXPR_NAN Q NaN = SIUnit<Q>() * std::numeric_limits<double>::quiet_NaN();
-template<cpp_number Q>
+template<boost_cpp_number Q>
 Q NaN<Q> = std::numeric_limits<Q>::quiet_NaN();
 
 template<typename Q>
@@ -164,7 +165,7 @@ template<typename D>
 std::string DebugString(
     Quantity<D> const& quantity,
     int precision = std::numeric_limits<double>::max_digits10);
-template<cpp_number N>
+template<boost_cpp_number N>
 std::string DebugString(
     N const& number,
     int precision = std::numeric_limits<double>::max_digits10);

quantities/quantities_body.hpp

@@ -171,11 +171,11 @@ inline constexpr double Pow<3>(double x) {
 
 template<int exponent, typename Q>
 constexpr Exponentiation<Q, exponent> Pow(Q const& x) {
-  if constexpr (number_category<Q>::value == number_kind_rational) {
+  if constexpr (boost_cpp_rational<Q>) {
     // It seems that Boost does not define `pow` for `cpp_rational`.
     return cpp_rational(pow(numerator(x), exponent),
                         pow(denominator(x), exponent));
-  } else if constexpr (is_number<Q>::value) {
+  } else if constexpr (boost_cpp_number<Q>) {
     return pow(x, exponent);
   } else {
     return SIUnit<Exponentiation<Q, exponent>>() *
@@ -243,7 +243,7 @@ std::string DebugString(Quantity<D> const& quantity, int const precision) {
          Format<D>();
 }
 
-template<cpp_number N>
+template<boost_cpp_number N>
 std::string DebugString(N const& number, int const precision) {
   return number.str();
 }