From bab7acfe1bbb98022060234a38c731255483254e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Johel=20Ernesto=20Guerrero=20Pe=C3=B1a?=
 <johelegp@gmail.com>
Date: Tue, 19 Sep 2023 12:31:05 -0400
Subject: [PATCH] feat!: add number concepts

---
 example/include/ranged_representation.h       |  31 +-
 example/measurement.cpp                       |  24 +-
 .../mp-units/bits/external/type_list.h        |   1 +
 src/core/include/mp-units/bits/fwd.h          |  34 ++
 .../include/mp-units/bits/quantity_concepts.h |   4 +-
 .../mp-units/bits/quantity_point_concepts.h   |   1 +
 .../include/mp-units/customization_points.h   |   1 +
 src/core/include/mp-units/numbers.h           | 294 ++++++++++++++++++
 src/core/include/mp-units/quantity.h          | 106 ++-----
 src/core/include/mp-units/quantity_point.h    |  40 ++-
 src/core/include/mp-units/reference.h         |   4 +-
 src/utility/include/mp-units/math.h           |   2 +-
 .../unit_test/runtime/linear_algebra_test.cpp |   5 +
 .../static/custom_rep_test_min_impl.cpp       |  23 +-
 test/unit_test/static/quantity_point_test.cpp |   2 +
 test/unit_test/static/quantity_test.cpp       |   4 +
 16 files changed, 469 insertions(+), 107 deletions(-)
 create mode 100644 src/core/include/mp-units/bits/fwd.h
 create mode 100644 src/core/include/mp-units/numbers.h

diff --git a/example/include/ranged_representation.h b/example/include/ranged_representation.h
index 82f518468..103ad4233 100644
--- a/example/include/ranged_representation.h
+++ b/example/include/ranged_representation.h
@@ -38,7 +38,7 @@ template<std::movable T, MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_t
          MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Max>
 using is_in_range_t = decltype(is_in_range<T, Min, Max>);
 
-template<std::movable T, MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Min,
+template<mp_units::vector_space T, MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Min,
          MP_UNITS_CONSTRAINED_NTTP_WORKAROUND(std::convertible_to<T>) auto Max>
 class ranged_representation : public validated_type<T, is_in_range_t<T, Min, Max>> {
 public:
@@ -50,15 +50,44 @@ class ranged_representation : public validated_type<T, is_in_range_t<T, Min, Max
   {
     return ranged_representation(-this->value());
   }
+
+  friend constexpr ranged_representation operator-(const ranged_representation& lhs, const ranged_representation& rhs)
+  {
+    return ranged_representation(lhs.value() - rhs.value());
+  }
+
+  constexpr ranged_representation& operator+=(ranged_representation that)
+  {
+    this->value() += that.value();
+    gsl_Expects(validate(this->value()));
+    return *this;
+  }
+  constexpr ranged_representation& operator-=(ranged_representation that)
+  {
+    this->value() -= that.value();
+    gsl_Expects(validate(this->value()));
+    return *this;
+  }
+  constexpr ranged_representation& operator*=(T rhs)
+  {
+    this->value() *= rhs;
+    gsl_Expects(validate(this->value()));
+    return *this;
+  }
 };
 
 template<typename T, auto Min, auto Max>
 inline constexpr bool mp_units::is_scalar<ranged_representation<T, Min, Max>> = mp_units::is_scalar<T>;
 
+template<typename T, auto Min, auto Max>
+struct mp_units::number_scalar<ranged_representation<T, Min, Max>> : std::type_identity<T> {};
+
 template<typename T, auto Min, auto Max>
 inline constexpr bool mp_units::treat_as_floating_point<ranged_representation<T, Min, Max>> =
   mp_units::treat_as_floating_point<T>;
 
+static_assert(mp_units::vector_space<ranged_representation<int, 17, 29>>);
+
 template<typename T, auto Min, auto Max>
 struct MP_UNITS_STD_FMT::formatter<ranged_representation<T, Min, Max>> : formatter<T> {
   template<typename FormatContext>
diff --git a/example/measurement.cpp b/example/measurement.cpp
index b67416273..617266679 100644
--- a/example/measurement.cpp
+++ b/example/measurement.cpp
@@ -30,7 +30,7 @@
 
 namespace {
 
-template<typename T>
+template<mp_units::vector_space T>
 class measurement {
 public:
   using value_type = T;
@@ -65,6 +65,18 @@ class measurement {
     return measurement(lhs.value() - rhs.value(), hypot(lhs.uncertainty(), rhs.uncertainty()));
   }
 
+  constexpr measurement& operator+=(measurement that)
+  {
+    value_ = *this + that;
+    return *this;
+  }
+
+  constexpr measurement& operator-=(measurement that)
+  {
+    value_ = *this - that;
+    return *this;
+  }
+
   [[nodiscard]] friend constexpr measurement operator*(const measurement& lhs, const measurement& rhs)
   {
     const auto val = lhs.value() * rhs.value();
@@ -78,6 +90,12 @@ class measurement {
     return measurement(val, val * lhs.relative_uncertainty());
   }
 
+  constexpr measurement& operator*=(const value_type& value)
+  {
+    value_ = *this * value;
+    return *this;
+  }
+
   [[nodiscard]] friend constexpr measurement operator*(const value_type& value, const measurement& rhs)
   {
     const auto val = rhs.value() * value;
@@ -125,7 +143,11 @@ inline constexpr bool mp_units::is_scalar<measurement<T>> = true;
 template<class T>
 inline constexpr bool mp_units::is_vector<measurement<T>> = true;
 
+template<typename T>
+struct mp_units::number_scalar<measurement<T>> : std::type_identity<T> {};
+
 static_assert(mp_units::RepresentationOf<measurement<double>, mp_units::quantity_character::scalar>);
+static_assert(mp_units::vector_space<measurement<double>>);
 
 namespace {
 
diff --git a/src/core/include/mp-units/bits/external/type_list.h b/src/core/include/mp-units/bits/external/type_list.h
index 5369ce18d..80b66e060 100644
--- a/src/core/include/mp-units/bits/external/type_list.h
+++ b/src/core/include/mp-units/bits/external/type_list.h
@@ -24,6 +24,7 @@
 
 #include <mp-units/bits/external/hacks.h>  // IWYU pragma: keep
 #include <cstddef>
+#include <type_traits>
 #include <utility>
 
 MP_UNITS_DIAGNOSTIC_PUSH
diff --git a/src/core/include/mp-units/bits/fwd.h b/src/core/include/mp-units/bits/fwd.h
new file mode 100644
index 000000000..22ac3247a
--- /dev/null
+++ b/src/core/include/mp-units/bits/fwd.h
@@ -0,0 +1,34 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <mp-units/bits/reference_concepts.h>
+#include <mp-units/bits/representation_concepts.h>
+
+namespace mp_units {
+
+template<Reference auto R, RepresentationOf<get_quantity_spec(R).character> Rep>
+  requires vector_space<Rep>
+class quantity;
+
+}  // namespace mp_units
diff --git a/src/core/include/mp-units/bits/quantity_concepts.h b/src/core/include/mp-units/bits/quantity_concepts.h
index 437d64e30..f9bdaeb0b 100644
--- a/src/core/include/mp-units/bits/quantity_concepts.h
+++ b/src/core/include/mp-units/bits/quantity_concepts.h
@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <mp-units/bits/fwd.h>
 #include <mp-units/bits/quantity_spec_concepts.h>
 #include <mp-units/bits/reference_concepts.h>
 #include <mp-units/bits/representation_concepts.h>
@@ -29,9 +30,6 @@
 
 namespace mp_units {
 
-template<Reference auto R, RepresentationOf<get_quantity_spec(R).character> Rep>
-class quantity;
-
 #if defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 17
 template<auto R, typename Rep>
 #else
diff --git a/src/core/include/mp-units/bits/quantity_point_concepts.h b/src/core/include/mp-units/bits/quantity_point_concepts.h
index 90a9e85be..f0cebea18 100644
--- a/src/core/include/mp-units/bits/quantity_point_concepts.h
+++ b/src/core/include/mp-units/bits/quantity_point_concepts.h
@@ -107,6 +107,7 @@ concept PointOriginFor = PointOrigin<T> && QuantitySpecOf<std::remove_const_t<de
 
 template<Reference auto R, PointOriginFor<get_quantity_spec(R)> auto PO,
          RepresentationOf<get_quantity_spec(R).character> Rep>
+  requires vector_space<Rep>
 class quantity_point;
 
 #if defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 17
diff --git a/src/core/include/mp-units/customization_points.h b/src/core/include/mp-units/customization_points.h
index e4c169169..0ddd4eea7 100644
--- a/src/core/include/mp-units/customization_points.h
+++ b/src/core/include/mp-units/customization_points.h
@@ -24,6 +24,7 @@
 
 #include <mp-units/bits/external/hacks.h>
 #include <mp-units/bits/external/type_traits.h>
+#include <mp-units/numbers.h>
 #include <limits>
 #include <type_traits>
 
diff --git a/src/core/include/mp-units/numbers.h b/src/core/include/mp-units/numbers.h
new file mode 100644
index 000000000..7b72b4831
--- /dev/null
+++ b/src/core/include/mp-units/numbers.h
@@ -0,0 +1,294 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include <complex>
+#include <concepts>
+#include <type_traits>
+#include <utility>
+
+namespace mp_units {
+
+template<typename T>
+struct number_scalar;
+
+namespace detail {
+
+template<typename T>
+struct inferred_number_zero {};
+template<typename T>
+struct inferred_number_one {};
+
+}  // namespace detail
+
+template<typename T>
+using number_difference_t = decltype(std::declval<const T>() - std::declval<const T>());
+template<typename T>
+using number_scalar_t = number_scalar<T>::type;
+
+template<typename T>
+concept is_inferred_number = std::regular<number_scalar_t<T>>;
+
+template<typename T>
+struct is_number : std::bool_constant<is_inferred_number<T>> {};
+template<typename T>
+struct is_complex_number : std::false_type {};
+template<typename T>
+struct number_zero : detail::inferred_number_zero<T> {};
+template<typename T>
+struct number_one : detail::inferred_number_one<T> {};
+template<typename T>
+struct number_scalar {};
+
+template<typename T>
+constexpr bool is_number_v = is_number<T>::value;
+template<typename T>
+constexpr bool is_complex_number_v = is_complex_number<T>::value;
+
+template<typename T>
+constexpr T number_zero_v = number_zero<T>::value;
+template<typename T>
+constexpr T number_one_v = number_one<T>::value;
+
+template<typename T>
+concept number = is_number_v<T> && std::regular<T>;
+
+template<typename T>
+concept ordered_number = number<T> && std::totally_ordered<T>;
+
+template<typename T>
+concept number_line =  // clang-format off
+  ordered_number<T> &&
+  requires(T& v) {
+    number_one_v<number_difference_t<T>>;
+    { ++v } -> std::same_as<T&>;
+    { --v } -> std::same_as<T&>;
+    { v-- } -> std::same_as<T>;
+    { v-- } -> std::same_as<T>;
+  };  // clang-format on
+
+namespace detail {
+
+template<typename T, typename U>
+concept addition_with =  // clang-format off
+  number<T> &&
+  number<U> &&
+  requires( const T & c,  const U & d) {
+    { c + d } -> std::common_with<T>;
+    { d + c } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept compound_addition_with =  // clang-format off
+  addition_with<T,U> &&
+  requires(T& l,  const U & d) {
+    { l += d } -> std::same_as<T&>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept subtraction_with =  // clang-format off
+  addition_with<T,U> &&
+  requires( const T & c,  const U & d) {
+    { c - d } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept compound_subtraction_with =  // clang-format off
+  subtraction_with<T,U> &&
+  compound_addition_with<T,U> &&
+  requires(T& l,  const U & d) {
+    { l -= d } -> std::same_as<T&>;
+  };  // clang-format on
+
+template<typename T, typename U, typename V>
+concept multiplication_with =  // clang-format off
+  number<T> &&
+  number<U> &&
+  number<V> &&
+  requires( const T & c,  const U & u) {
+    { (c * u) } -> std::common_with<V>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept compound_multiplication_with =  // clang-format off
+  multiplication_with<T,U,T> &&
+  requires(T& l,  const U & u) {
+    { l *= u } -> std::same_as<T&>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept division_with =  // clang-format off
+  multiplication_with<T,U,T> &&
+  multiplication_with<U,T,T> &&
+  requires( const T & c,  const U & u) {
+    { c / u } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept compound_division_with =  // clang-format off
+  division_with<T,U> &&
+  compound_multiplication_with<T,U> &&
+  requires(T& l,  const U & u) {
+    { l /= u } -> std::same_as<T&>;
+  };  // clang-format on
+
+}  // namespace detail
+
+template<typename T, typename U>
+concept modulo_with =  // clang-format off
+  number<T> &&
+  number<U> &&
+  requires( const T & c,  const U & u) {
+    { (c % u) } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept compound_modulo_with =  // clang-format off
+  modulo_with<T,U> &&
+  requires(T& l,  const U & u) {
+    { l %= u } -> std::same_as<T&>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept modulus_for = modulo_with<U, T>;
+template<typename T, typename U>
+concept compound_modulus_for = compound_modulo_with<U, T>;
+
+template<typename T>
+concept negative =  // clang-format off
+  detail::compound_addition_with<T,T> &&
+  requires( const T & c) {
+    number_zero_v<T>;
+    { -c } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T>
+concept set_with_inverse =  // clang-format off
+  detail::compound_multiplication_with<T,T> &&
+  requires( const T & c) {
+    { number_one_v<T> / c } -> std::common_with<T>;
+  };  // clang-format on
+
+template<typename T, typename U>
+concept point_space_for = detail::subtraction_with<T, U> && negative<U> && std::common_with<number_difference_t<T>, U>;
+template<typename T, typename U>
+concept compound_point_space_for = point_space_for<T, U> && detail::compound_subtraction_with<T, U>;
+template<typename T>
+concept point_space = compound_point_space_for<T, number_difference_t<T>>;
+
+template<typename T, typename U>
+concept vector_space_for = point_space_for<U, T>;
+template<typename T, typename U>
+concept compound_vector_space_for = compound_point_space_for<U, T>;
+
+namespace detail {
+
+template<typename T>
+concept weak_scalar = std::common_with<T, number_difference_t<T>> && point_space<T> && negative<T>;
+
+template<typename T, typename U>
+concept scales_with =
+  std::common_with<U, number_scalar_t<T>> && weak_scalar<U> && multiplication_with<T, U, T> && set_with_inverse<U>;
+template<typename T, typename U>
+concept compound_scales_with = scales_with<T, U> && detail::compound_multiplication_with<T, U>;
+
+}  // namespace detail
+
+template<typename T, typename U>
+concept scalar_for = detail::scales_with<U, T>;
+template<typename T, typename U>
+concept field_for = scalar_for<T, U> && detail::division_with<U, T>;
+template<typename T, typename U>
+concept compound_scalar_for = detail::compound_scales_with<U, T>;
+template<typename T, typename U>
+concept compound_field_for = compound_scalar_for<T, U> && detail::compound_division_with<U, T>;
+
+template<typename T>
+concept vector_space = point_space<T> && detail::compound_scales_with<T, number_scalar_t<T>>;
+template<typename T>
+concept f_vector_space = vector_space<T> && detail::compound_division_with<T, number_scalar_t<T>>;
+
+template<typename T>
+concept field_number = f_vector_space<T> && detail::compound_scales_with<T, T>;
+
+template<typename T>
+concept field_number_line = field_number<T> && number_line<T>;
+
+template<typename T>
+concept scalar_number = field_number<T> && (field_number_line<T> || is_complex_number_v<T>);
+
+template<typename T>
+struct is_number<const T> : is_number<T> {};
+template<typename T, typename U>
+struct is_number<std::chrono::time_point<T, U>> : std::true_type {};
+#if __cpp_lib_chrono >= 201803
+template<>
+struct is_number<std::chrono::day> : std::true_type {};
+template<>
+struct is_number<std::chrono::month> : std::true_type {};
+template<>
+struct is_number<std::chrono::year> : std::true_type {};
+template<>
+struct is_number<std::chrono::weekday> : std::true_type {};
+template<>
+struct is_number<std::chrono::year_month> : std::true_type {};
+#endif
+
+template<typename T>
+struct is_complex_number<const T> : is_complex_number<T> {};
+template<typename T>
+struct is_complex_number<std::complex<T>> : std::true_type {};
+
+namespace detail {
+
+template<typename T>
+concept inferable_identities = std::common_with<T, number_difference_t<T>> && std::constructible_from<T, int>;
+
+template<detail::inferable_identities T>
+struct inferred_number_zero<T> {
+  auto static constexpr value = T(0);
+};
+template<detail::inferable_identities T>
+struct inferred_number_one<T> {
+  auto static constexpr value = T(1);
+};
+
+}  // namespace detail
+
+template<typename T>
+struct number_zero<const T> : number_zero<T> {};
+template<typename T>
+struct number_one<const T> : number_one<T> {};
+
+template<typename T>
+struct number_scalar<const T> : number_scalar<T> {};
+template<std::integral T>
+struct number_scalar<T> : std::type_identity<T> {};
+template<std::floating_point T>
+struct number_scalar<T> : std::type_identity<T> {};
+template<typename T>
+struct number_scalar<std::complex<T>> : std::type_identity<T> {};
+template<typename T, typename U>
+struct number_scalar<std::chrono::duration<T, U>> : std::type_identity<T> {};
+
+}  // namespace mp_units
diff --git a/src/core/include/mp-units/quantity.h b/src/core/include/mp-units/quantity.h
index e1e989cd5..48a4ea9ad 100644
--- a/src/core/include/mp-units/quantity.h
+++ b/src/core/include/mp-units/quantity.h
@@ -83,6 +83,7 @@ using common_quantity_for = quantity<common_reference(Q1::reference, Q2::referen
  * @tparam Rep a type to be used to represent values of a quantity
  */
 template<Reference auto R, RepresentationOf<get_quantity_spec(R).character> Rep = double>
+  requires vector_space<Rep>
 class quantity {
 public:
   Rep numerical_value_;  // needs to be public for a structural type
@@ -201,92 +202,60 @@ class quantity {
   }
 
   [[nodiscard]] constexpr Quantity auto operator-() const
-    requires requires(rep v) {
-      {
-        -v
-      } -> std::common_with<rep>;
-    }
+    requires negative<rep>
   {
     return make_quantity<reference>(-numerical_value_);
   }
 
   template<typename Q>
-  friend constexpr decltype(auto) operator++(Q&& q)
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && requires(rep v) {
-      {
-        ++v
-      } -> std::same_as<rep&>;
-    }
+  friend constexpr decltype(auto) operator++(Q && q)
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && number_line<rep>
   {
     ++q.numerical_value_;
     return std::forward<Q>(q);
   }
 
   [[nodiscard]] constexpr Quantity auto operator++(int)
-    requires requires(rep v) {
-      {
-        v++
-      } -> std::common_with<rep>;
-    }
+    requires number_line<rep>
   {
     return make_quantity<reference>(numerical_value_++);
   }
 
   template<typename Q>
-  friend constexpr decltype(auto) operator--(Q&& q)
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && requires(rep v) {
-      {
-        --v
-      } -> std::same_as<rep&>;
-    }
+  friend constexpr decltype(auto) operator--(Q && q)
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && number_line<rep>
   {
     --q.numerical_value_;
     return std::forward<Q>(q);
   }
 
   [[nodiscard]] constexpr Quantity auto operator--(int)
-    requires requires(rep v) {
-      {
-        v--
-      } -> std::common_with<rep>;
-    }
+    requires number_line<rep>
   {
     return make_quantity<reference>(numerical_value_--);
   }
 
   // compound assignment operators
   template<typename Q>
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && requires(rep a, rep b) {
-      {
-        a += b
-      } -> std::same_as<rep&>;
-    }
-  friend constexpr decltype(auto) operator+=(Q&& lhs, const quantity& rhs)
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity>
+  friend constexpr decltype(auto) operator+=(Q && lhs, const quantity & rhs)
   {
     lhs.numerical_value_ += rhs.numerical_value_;
     return std::forward<Q>(lhs);
   }
 
   template<typename Q>
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && requires(rep a, rep b) {
-      {
-        a -= b
-      } -> std::same_as<rep&>;
-    }
-  friend constexpr decltype(auto) operator-=(Q&& lhs, const quantity& rhs)
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity>
+  friend constexpr decltype(auto) operator-=(Q && lhs, const quantity & rhs)
   {
     lhs.numerical_value_ -= rhs.numerical_value_;
     return std::forward<Q>(lhs);
   }
 
   template<typename Q>
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && (!treat_as_floating_point<rep>) &&
-             requires(rep a, rep b) {
-               {
-                 a %= b
-               } -> std::same_as<rep&>;
-             }
-  friend constexpr decltype(auto) operator%=(Q&& lhs, const quantity& rhs)
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity> &&
+             (!treat_as_floating_point<rep>) && compound_modulus_for<rep, rep>
+  friend constexpr decltype(auto) operator%=(Q && lhs, const quantity & rhs)
 
   {
     gsl_ExpectsAudit(rhs != zero());
@@ -294,40 +263,26 @@ class quantity {
     return std::forward<Q>(lhs);
   }
 
-  template<typename Q, typename Value>
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && (!Quantity<Value>) &&
-             requires(rep a, const Value b) {
-               {
-                 a *= b
-               } -> std::same_as<rep&>;
-             }
-  friend constexpr decltype(auto) operator*=(Q&& lhs, const Value& v)
+  template<typename Q, compound_scalar_for<rep> Value>
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity>
+  friend constexpr decltype(auto) operator*=(Q && lhs, const Value & v)
   {
     lhs.numerical_value_ *= v;
     return std::forward<Q>(lhs);
   }
 
   template<typename Q1, QuantityOf<dimension_one> Q2>
-    requires std::derived_from<std::remove_cvref_t<Q1>, quantity> && (Q2::unit == ::mp_units::one) &&
-             requires(rep a, const typename Q2::rep b) {
-               {
-                 a *= b
-               } -> std::same_as<rep&>;
-             }
-  friend constexpr decltype(auto) operator*=(Q1&& lhs, const Q2& rhs)
+    requires std::derived_from<std::remove_cvref_t<Q1>, quantity> &&
+             (Q2::unit == ::mp_units::one) && compound_scalar_for<typename Q2::rep, rep>
+  friend constexpr decltype(auto) operator*=(Q1 && lhs, const Q2 & rhs)
   {
     lhs.numerical_value_ *= rhs.numerical_value_;
     return std::forward<Q1>(lhs);
   }
 
-  template<typename Q, typename Value>
-    requires std::derived_from<std::remove_cvref_t<Q>, quantity> && (!Quantity<Value>) &&
-             requires(rep a, const Value b) {
-               {
-                 a /= b
-               } -> std::same_as<rep&>;
-             }
-  friend constexpr decltype(auto) operator/=(Q&& lhs, const Value& v)
+  template<typename Q, compound_field_for<rep> Value>
+    requires std::derived_from<std::remove_cvref_t<Q>, quantity>
+  friend constexpr decltype(auto) operator/=(Q && lhs, const Value & v)
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
     lhs.numerical_value_ /= v;
@@ -335,13 +290,9 @@ class quantity {
   }
 
   template<typename Q1, QuantityOf<dimension_one> Q2>
-    requires std::derived_from<std::remove_cvref_t<Q1>, quantity> && (Q2::unit == ::mp_units::one) &&
-             requires(rep a, const typename Q2::rep b) {
-               {
-                 a /= b
-               } -> std::same_as<rep&>;
-             }
-  friend constexpr decltype(auto) operator/=(Q1&& lhs, const Q2& rhs)
+    requires std::derived_from<std::remove_cvref_t<Q1>, quantity> &&
+             (Q2::unit == ::mp_units::one) && compound_field_for<typename Q2::rep, rep>
+  friend constexpr decltype(auto) operator/=(Q1 && lhs, const Q2 & rhs)
   {
     gsl_ExpectsAudit(rhs != rhs.zero());
     lhs.numerical_value_ /= rhs.numerical_value_;
@@ -472,6 +423,9 @@ template<Reference auto R, typename Rep>
   return quantity<R, std::remove_cvref_t<Rep>>(std::forward<Rep>(v));
 }
 
+template<Quantity Q>
+struct number_scalar<Q> : number_scalar<typename Q::rep> {};
+
 }  // namespace mp_units
 
 namespace std {
diff --git a/src/core/include/mp-units/quantity_point.h b/src/core/include/mp-units/quantity_point.h
index 3a8dd8bd1..2d9de72f7 100644
--- a/src/core/include/mp-units/quantity_point.h
+++ b/src/core/include/mp-units/quantity_point.h
@@ -70,6 +70,7 @@ namespace detail {
  */
 template<Reference auto R, PointOriginFor<get_quantity_spec(R)> auto PO,
          RepresentationOf<get_quantity_spec(R).character> Rep = double>
+  requires vector_space<Rep>
 class quantity_point {
 public:
   // member types and values
@@ -184,47 +185,45 @@ class quantity_point {
 
   // member unary operators
   template<typename QP>
-  friend constexpr decltype(auto) operator++(QP&& qp)
-    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> && requires { ++qp.quantity_from_origin_; }
+  friend constexpr decltype(auto) operator++(QP && qp)
+    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> && number_line<rep>
   {
     ++qp.quantity_from_origin_;
     return std::forward<QP>(qp);
   }
 
   [[nodiscard]] constexpr quantity_point operator++(int)
-    requires requires { quantity_from_origin_++; }
+    requires number_line<rep>
   {
     return quantity_point(quantity_from_origin_++);
   }
 
   template<typename QP>
-  friend constexpr decltype(auto) operator--(QP&& qp)
-    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> && requires { --qp.quantity_from_origin_; }
+  friend constexpr decltype(auto) operator--(QP && qp)
+    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> && number_line<rep>
   {
     --qp.quantity_from_origin_;
     return std::forward<QP>(qp);
   }
 
   [[nodiscard]] constexpr quantity_point operator--(int)
-    requires requires { quantity_from_origin_--; }
+    requires number_line<rep>
   {
     return quantity_point(quantity_from_origin_--);
   }
 
   // compound assignment operators
   template<typename QP>
-    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> &&
-             requires(quantity_type q) { quantity_from_origin_ += q; }
-  friend constexpr decltype(auto) operator+=(QP&& qp, const quantity_type& q)
+    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point>
+  friend constexpr decltype(auto) operator+=(QP && qp, const quantity_type & q)
   {
     qp.quantity_from_origin_ += q;
     return std::forward<QP>(qp);
   }
 
   template<typename QP>
-    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point> &&
-             requires(quantity_type q) { quantity_from_origin_ -= q; }
-  friend constexpr decltype(auto) operator-=(QP&& qp, const quantity_type& q)
+    requires std::derived_from<std::remove_cvref_t<QP>, quantity_point>
+  friend constexpr decltype(auto) operator-=(QP && qp, const quantity_type & q)
   {
     qp.quantity_from_origin_ -= q;
     return std::forward<QP>(qp);
@@ -253,22 +252,20 @@ explicit quantity_point(QP)
   -> quantity_point<quantity_point_like_traits<QP>::reference, quantity_point_like_traits<QP>::point_origin,
                     typename quantity_point_like_traits<QP>::rep>;
 
-template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
+template<auto R1, auto PO1, typename Rep1, auto R2, vector_space_for<Rep1> Rep2>
 // TODO simplify when gcc catches up
   requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity_point<R1, PO1, Rep1>& qp,
                                                      const quantity<R2, Rep2>& q)
-  requires requires { qp.quantity_ref_from(PO1) + q; }
 {
   return make_quantity_point<PO1>(qp.quantity_ref_from(PO1) + q);
 }
 
-template<auto R1, typename Rep1, auto R2, auto PO2, typename Rep2>
+template<auto R1, typename Rep2, auto R2, auto PO2, vector_space_for<Rep2> Rep1>
 // TODO simplify when gcc catches up
   requires ReferenceOf<std::remove_const_t<decltype(R1)>, PO2.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity<R1, Rep1>& q,
                                                      const quantity_point<R2, PO2, Rep2>& qp)
-  requires requires { q + qp.quantity_ref_from(PO2); }
 {
   return qp + q;
 }
@@ -287,12 +284,11 @@ template<Quantity Q, PointOrigin PO>
   return po + std::forward<Q>(q);
 }
 
-template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
+template<auto R1, auto PO1, typename Rep1, auto R2, vector_space_for<Rep1> Rep2>
 // TODO simplify when gcc catches up
   requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator-(const quantity_point<R1, PO1, Rep1>& qp,
                                                      const quantity<R2, Rep2>& q)
-  requires requires { qp.quantity_ref_from(PO1) - q; }
 {
   return make_quantity_point<PO1>(qp.quantity_ref_from(PO1) - q);
 }
@@ -300,15 +296,14 @@ template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
 template<PointOrigin PO, Quantity Q>
   requires ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO::quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator-(PO po, const Q& q)
-  requires requires { -q; }
 {
   return po + (-q);
 }
 
 template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2>
+// TODO consider constraining it for both branches
+  requires vector_space_for<typename QP1::quantity_type, typename QP2::quantity_type>
 [[nodiscard]] constexpr Quantity auto operator-(const QP1& lhs, const QP2& rhs)
-  // TODO consider constraining it for both branches
-  requires requires { lhs.quantity_ref_from(QP1::point_origin) - rhs.quantity_ref_from(QP2::point_origin); }
 {
   if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>,
                           std::remove_const_t<decltype(QP2::point_origin)>>)
@@ -398,4 +393,7 @@ template<PointOrigin auto PO, Quantity Q>
   return quantity_point<Q::reference, PO, typename Q::rep>(std::forward<Q>(q));
 }
 
+template<QuantityPoint QP>
+struct is_number<QP> : std::true_type {};
+
 }  // namespace mp_units
diff --git a/src/core/include/mp-units/reference.h b/src/core/include/mp-units/reference.h
index 032c4192a..bf896e502 100644
--- a/src/core/include/mp-units/reference.h
+++ b/src/core/include/mp-units/reference.h
@@ -22,6 +22,7 @@
 
 #pragma once
 
+#include <mp-units/bits/fwd.h>
 #include <mp-units/bits/get_associated_quantity.h>
 #include <mp-units/bits/quantity_concepts.h>
 #include <mp-units/bits/reference_concepts.h>
@@ -155,9 +156,6 @@ struct reference {
   }
 };
 
-template<Reference auto R, RepresentationOf<get_quantity_spec(R).character> Rep>
-class quantity;
-
 template<typename Rep, Reference R>
 [[nodiscard]] constexpr quantity<R{}, std::remove_cvref_t<Rep>> operator*(Rep&& lhs, R)
 {
diff --git a/src/utility/include/mp-units/math.h b/src/utility/include/mp-units/math.h
index 29254672e..635ab496e 100644
--- a/src/utility/include/mp-units/math.h
+++ b/src/utility/include/mp-units/math.h
@@ -274,7 +274,7 @@ template<Unit auto To, auto R, typename Rep>
 /**
  * @brief Computes the inverse of a quantity in a provided unit
  */
-template<Unit auto To, auto R, typename Rep>
+template<Unit auto To, auto R, set_with_inverse Rep>
 [[nodiscard]] constexpr QuantityOf<dimensionless / get_quantity_spec(R)> auto inverse(const quantity<R, Rep>& q)
   requires requires {
     quantity_values<Rep>::one();
diff --git a/test/unit_test/runtime/linear_algebra_test.cpp b/test/unit_test/runtime/linear_algebra_test.cpp
index ad9fb31f4..b0be693b5 100644
--- a/test/unit_test/runtime/linear_algebra_test.cpp
+++ b/test/unit_test/runtime/linear_algebra_test.cpp
@@ -34,12 +34,17 @@
 template<typename Rep = double>
 using vector = STD_LA::fixed_size_column_vector<Rep, 3>;
 
+static_assert(mp_units::vector_space<decltype(vector<int>{3, 2, 1})>);
+
 template<class Rep>
 inline constexpr bool mp_units::treat_as_floating_point<vector<Rep>> = mp_units::treat_as_floating_point<Rep>;
 
 template<typename Rep>
 inline constexpr bool mp_units::is_vector<vector<Rep>> = true;
 
+template<typename Rep>
+constexpr bool mp_units::is_number_v<vector<Rep>> = mp_units::is_number_v<Rep>;
+
 template<typename Rep>
 std::ostream& operator<<(std::ostream& os, const vector<Rep>& v)
 {
diff --git a/test/unit_test/static/custom_rep_test_min_impl.cpp b/test/unit_test/static/custom_rep_test_min_impl.cpp
index 7d18effd7..a137437da 100644
--- a/test/unit_test/static/custom_rep_test_min_impl.cpp
+++ b/test/unit_test/static/custom_rep_test_min_impl.cpp
@@ -32,7 +32,7 @@ namespace {
  *
  * @tparam T element type
  */
-template<typename T>
+template<mp_units::vector_space T>
 class min_impl {
   T value_;
 public:
@@ -45,6 +45,22 @@ class min_impl {
   {
   }
   constexpr explicit(false) operator T() const noexcept { return value_; }
+
+  constexpr min_impl& operator+=(min_impl that)
+  {
+    value_ += that.value_;
+    return *this;
+  }
+  constexpr min_impl& operator-=(min_impl that)
+  {
+    value_ -= that.value_;
+    return *this;
+  }
+  constexpr min_impl& operator*=(T rhs)
+  {
+    value_ *= rhs;
+    return *this;
+  }
 };
 
 }  // namespace
@@ -52,6 +68,9 @@ class min_impl {
 template<typename T>
 inline constexpr bool mp_units::is_scalar<min_impl<T>> = true;
 
+template<typename Rep>
+struct mp_units::number_scalar<min_impl<Rep>> : std::type_identity<Rep> {};
+
 template<typename T, typename U>
 struct std::common_type<min_impl<T>, min_impl<U>> : std::type_identity<min_impl<std::common_type_t<T, U>>> {};
 template<typename T, typename U>
@@ -65,6 +84,8 @@ using namespace mp_units;
 
 static_assert(Representation<min_impl<int>>);
 static_assert(Representation<min_impl<double>>);
+static_assert(vector_space<min_impl<int>>);
+static_assert(vector_space<min_impl<double>>);
 
 // construction from a value is not allowed
 static_assert(!std::constructible_from<quantity<si::metre, min_impl<int>>, min_impl<int>>);
diff --git a/test/unit_test/static/quantity_point_test.cpp b/test/unit_test/static/quantity_point_test.cpp
index feb633d65..e71003690 100644
--- a/test/unit_test/static/quantity_point_test.cpp
+++ b/test/unit_test/static/quantity_point_test.cpp
@@ -130,6 +130,8 @@ static_assert(std::regular<quantity_point<si::metre, mean_sea_level>>);
 
 static_assert(std::three_way_comparable<quantity_point<si::metre, mean_sea_level>>);
 
+static_assert(point_space<quantity_point<si::metre, mean_sea_level>>);
+
 
 //////////////////
 // member values
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index 77091cb73..dd78b975e 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -85,6 +85,10 @@ static_assert(std::regular<quantity<isq::length[m]>>);
 
 static_assert(std::three_way_comparable<quantity<isq::length[m]>>);
 
+static_assert(f_vector_space<quantity<isq::length[m]>>);
+static_assert(!scalar_number<quantity<dimensionless[one]>>,
+              "`std::common_with<quantity<dimensionless[one]>, double>` is `false`.");
+
 
 //////////////////
 // member values