diff --git a/doc/DESIGN.md b/doc/DESIGN.md
index 6189f332..df07db83 100644
--- a/doc/DESIGN.md
+++ b/doc/DESIGN.md
@@ -413,8 +413,26 @@ template<Unit U, Scalar Rep = double>
 class quantity;
 ```
 
-`units::Quantity` is a concept that is satisfied by a type that is an instantiation of `units::quantity`
-class template:
+where `Scalar` is the following concept:
+
+```cpp
+template<typename T, typename U = T>
+concept basic-arithmetic = // exposition only
+  std::magma<std::ranges::plus, T, U> &&
+  std::magma<std::ranges::minus, T, U> &&
+  std::magma<std::ranges::times, T, U> &&
+  std::magma<std::ranges::divided_by, T, U>;
+
+template<typename T>
+concept Scalar =
+  (!Quantity<T>) &&
+  std::regular<T> &&
+  std::totally_ordered<T> &&
+  basic-arithmetic<T>;
+```
+
+`units::Quantity` is a concept that is satisfied by a type that is an instantiation of
+`units::quantity` class template:
 
 ```cpp
 template<typename T>
diff --git a/src/include/units/bits/concepts.h b/src/include/units/bits/concepts.h
index bf41edc4..78d67ec4 100644
--- a/src/include/units/bits/concepts.h
+++ b/src/include/units/bits/concepts.h
@@ -23,51 +23,31 @@
 #pragma once
 
 #include <units/bits/hacks.h>
+#include <units/bits/numeric_concepts.h>
+#include <units/bits/customization_points.h>
+#include <units/ratio.h>
 
 namespace units {
 
-#if __GNUC__ < 10
+  namespace detail {
 
-  template<typename T>
-  concept Number = std::regular<T> &&
-      std::totally_ordered<T> &&
-      requires(T a, T b) {
-        { a + b } -> T;
-        { a - b } -> T;
-        { a * b } -> T;
-        { a / b } -> T;
-        { +a } -> T;
-        { -a } -> T;
-        { a += b } -> T&;
-        { a -= b } -> T&;
-        { a *= b } -> T&;
-        { a /= b } -> T&;
-        { T{0} };    // can construct a T from a zero
-        // …
-  };
+    template<typename T, typename U = T>
+    concept basic_arithmetic = // exposition only 
+      std::magma<std::ranges::plus, T, U> &&
+      std::magma<std::ranges::minus, T, U> &&
+      std::magma<std::ranges::times, T, U> &&
+      std::magma<std::ranges::divided_by, T, U>;
 
-#else
+    template<typename From, typename To>
+    concept safe_convertible = // exposition only
+      std::convertible_to<From, To> &&
+      (treat_as_floating_point<To> || (!treat_as_floating_point<From>));
 
-  template<typename T>
-  concept Number = std::regular<T> &&
-      std::totally_ordered<T> &&
-      requires(T a, T b) {
-        { a + b } -> std::same_as<T>;
-        { a - b } -> std::same_as<T>;
-        { a * b } -> std::same_as<T>;
-        { a / b } -> std::same_as<T>;
-        { +a } -> std::same_as<T>;
-        { -a } -> std::same_as<T>;
-        { a += b } -> std::same_as<T&>;
-        { a -= b } -> std::same_as<T&>;
-        { a *= b } -> std::same_as<T&>;
-        { a /= b } -> std::same_as<T&>;
-        { T{0} };    // can construct a T from a zero
-        // …
-  };
+    template<typename Rep, typename unit_from, typename unit_to>
+    concept safe_divisible = // exposition only
+      treat_as_floating_point<Rep> ||
+      ratio_divide<typename unit_from::ratio, typename unit_to::ratio>::den == 1;
 
-#endif
-
-  // InstanceOf
+  }
 
 }  // namespace units
diff --git a/src/include/units/bits/hacks.h b/src/include/units/bits/hacks.h
index a587601b..92b71eb5 100644
--- a/src/include/units/bits/hacks.h
+++ b/src/include/units/bits/hacks.h
@@ -23,6 +23,7 @@
 #pragma once
 
 #include <concepts/concepts.hpp>
+#include <functional>
 
 #ifdef NDEBUG
 #define Expects(cond) (void)(cond);
@@ -33,17 +34,34 @@
 
 #if __GNUC__ > 9
 #define AUTO auto
+#define SAME_AS(T) std::same_as<T>
 #else
 #define AUTO
+#define SAME_AS(T) T
 #endif
 
 namespace std {
 
   // concepts
-  using concepts::same_as;
-  using concepts::derived_from;
-  using concepts::regular;
-  using concepts::totally_ordered;
+  using concepts::common_with;
+  using concepts::common_reference_with;
+  using concepts::constructible_from;
   using concepts::convertible_to;
+  using concepts::default_constructible;
+  using concepts::derived_from;
+  using concepts::equality_comparable_with;
+  using concepts::regular;
+  using concepts::same_as;
+  using concepts::totally_ordered;
+  using concepts::totally_ordered_with;
+
+  template<class F, class... Args>
+  concept invocable =
+  requires(F&& f, Args&&... args) {
+    std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
+  };
+
+  template<class F, class... Args>
+  concept regular_invocable = invocable<F, Args...>;
 
 }
diff --git a/src/include/units/bits/numeric_concepts.h b/src/include/units/bits/numeric_concepts.h
index 7575cca8..8d6cfdd5 100644
--- a/src/include/units/bits/numeric_concepts.h
+++ b/src/include/units/bits/numeric_concepts.h
@@ -117,14 +117,14 @@ namespace std {
 
   template<class BOp, class T, class U>
   concept magma =
-    std::common_with<T, U> &&
-    std::regular_invocable<BOp, T, T> &&
-    std::regular_invocable<BOp, U, U> &&
-    std::regular_invocable<BOp, T, U> &&
-    std::regular_invocable<BOp, U, T> &&
-    std::common_with<std::invoke_result_t<BOp&, T, U>, T> &&
-    std::common_with<std::invoke_result_t<BOp&, T, U>, U> &&
-    std::same_as<std::invoke_result_t<BOp&, T, U>, std::invoke_result_t<BOp&, U, T>>;
+    common_with<T, U> &&
+    regular_invocable<BOp, T, T> &&
+    regular_invocable<BOp, U, U> &&
+    regular_invocable<BOp, T, U> &&
+    regular_invocable<BOp, U, T> &&
+    common_with<invoke_result_t<BOp&, T, U>, T> &&
+    common_with<invoke_result_t<BOp&, T, U>, U> &&
+    same_as<invoke_result_t<BOp&, T, U>, invoke_result_t<BOp&, U, T>>;
 
   template<class BOp, class T, class U>
   concept semigroup = magma<BOp, T, U>;
@@ -166,7 +166,6 @@ namespace std {
     };
 
 
-
   namespace ranges {
 
     namespace detail {
@@ -200,7 +199,7 @@ namespace std {
 
       template<class T>
       concept negatable = // exposition only
-        summable_with <T, T> &&
+        summable_with<T, T> &&
         totally_ordered<T> &&
         requires(T&& t) {
           { -std::forward<T>(t) } -> common_with<T>;
@@ -231,7 +230,7 @@ namespace std {
           { std::forward<T>(t) - std::forward<U>(u) } -> common_with<T>;
           { std::forward<U>(u) - std::forward<T>(t) } -> common_with<U>;
           requires same_as<decltype(std::forward<T>(t) - std::forward<U>(u)),
-          decltype(std::forward<U>(u) - std::forward<T>(t))>;
+                           decltype(std::forward<U>(u) - std::forward<T>(t))>;
         };
 
     }
@@ -249,10 +248,10 @@ namespace std {
 
       template<class T, class U>
       concept multiplicable_with = // exposition only
-        detail::summable_with <T, U> &&
+        detail::summable_with<T, U> &&
         constructible_from<remove_cvref_t<T>, int> && // specifically T{0} and T{1}
         constructible_from<remove_cvref_t<U>, int> && // specifically U{0} and U{1}
-        constructible_from<remove_cvref_t<common_type<T, U>>, int> &&
+//        constructible_from<remove_cvref_t<common_type<T, U>>, int> &&   // TODO uncomment this when the problem is resolved
         common_reference_with<T, U> &&
         requires(T&& t, U&& u) {
           { std::forward<T>(t) * std::forward<T>(t) } -> common_with<T>;
@@ -260,7 +259,7 @@ namespace std {
           { std::forward<T>(t) * std::forward<U>(u) } -> common_with<T>;
           { std::forward<U>(u) * std::forward<T>(t) } -> common_with<U>;
           requires same_as<decltype(std::forward<T>(t) * std::forward<U>(u)),
-          decltype(std::forward<U>(u) * std::forward<T>(t))>;
+                           decltype(std::forward<U>(u) * std::forward<T>(t))>;
         };
   
     }
@@ -285,7 +284,7 @@ namespace std {
           { std::forward<T>(t) / std::forward<U>(u) } -> common_with<T>;
           { std::forward<U>(u) / std::forward<T>(t) } -> common_with<U>;
           requires same_as<decltype(std::forward<T>(t) / std::forward<U>(u)),
-          decltype(std::forward<U>(u) / std::forward<T>(t))>;
+                           decltype(std::forward<U>(u) / std::forward<T>(t))>;
         };
 
     }
@@ -300,14 +299,14 @@ namespace std {
 
       template<class T, class Q>
       concept modulo_with = // exposition only
-        divisible_with <T, Q> &&
+        divisible_with<T, Q> &&
         requires(T&& t, Q&& q) {
           { std::forward<T>(t) % std::forward<T>(t) } -> common_with<T>;
           { std::forward<Q>(q) % std::forward<Q>(q) } -> common_with<Q>;
           { std::forward<T>(t) % std::forward<Q>(q) } -> common_with<T>;
           { std::forward<Q>(q) % std::forward<T>(t) } -> common_with<Q>;
           requires same_as<decltype(std::forward<T>(t) % std::forward<Q>(q)),
-          decltype(std::forward<Q>(q) % std::forward<T>(t))>;
+                           decltype(std::forward<Q>(q) % std::forward<T>(t))>;
         };
 
     }
diff --git a/src/include/units/quantity.h b/src/include/units/quantity.h
index 67d93440..536d5847 100644
--- a/src/include/units/quantity.h
+++ b/src/include/units/quantity.h
@@ -23,7 +23,6 @@
 #pragma once
 
 #include <units/bits/concepts.h>
-#include <units/bits/customization_points.h>
 #include <units/unit.h>
 #include <limits>
 #include <ostream>
@@ -48,27 +47,13 @@ namespace units {
 
   // Scalar
   template<typename T>
-  concept Scalar = (!Quantity<T>) && Number<T>;
+  concept Scalar =
+    (!Quantity<T>) &&
+    std::regular<T> &&
+    std::totally_ordered<T> &&
+    detail::basic_arithmetic<T>;
 
-  // QuantityRep
-  template<typename T>
-  concept QuantityRep = Scalar<T> &&
-    // integral
-    ((treat_as_floating_point<T> == false &&
-      requires(T a, T b) {
-        { a % b } -> T;
-        { a++ } -> T;
-        { ++a } -> T&;
-        { a-- } -> T;
-        { --a } -> T&;
-      }) ||
-     // floating-point
-     requires(T&& a) {
-       ::units::isfinite(std::forward<T>(a));
-       ::units::isnan(std::forward<T>(a));
-     });
-
-  template<Unit U, QuantityRep Rep>
+  template<Unit U, Scalar Rep>
   class quantity;
 
   namespace detail {
@@ -99,7 +84,7 @@ namespace units {
 
   }  // namespace detail
 
-  template<Quantity Q1, Quantity Q2, QuantityRep Rep = std::common_type_t<typename Q1::rep, typename Q2::rep>>
+  template<Quantity Q1, Quantity Q2, Scalar Rep = std::common_type_t<typename Q1::rep, typename Q2::rep>>
   using common_quantity = detail::common_quantity_impl<Q1, Q2, Rep>::type;
 
   // quantity_cast
@@ -158,7 +143,8 @@ namespace units {
 
   template<Quantity To, typename U, typename Rep>
   [[nodiscard]] constexpr auto quantity_cast(const quantity<U, Rep>& q)
-      requires same_dim<typename To::dimension, typename U::dimension>
+      requires same_dim<typename To::dimension, typename U::dimension> &&
+               detail::basic_arithmetic<std::common_type_t<typename To::rep, Rep, intmax_t>>
   {
     using c_ratio = ratio_divide<typename U::ratio, typename To::unit::ratio>;
     using c_rep = std::common_type_t<typename To::rep, Rep, intmax_t>;
@@ -169,27 +155,31 @@ namespace units {
     return cast::cast(q);
   }
 
-  template<Unit ToU, QuantityRep ToRep, typename U, typename Rep>
+  template<Unit ToU, Scalar ToRep, typename U, typename Rep>
   [[nodiscard]] constexpr auto quantity_cast(const quantity<U, Rep>& q)
+      requires same_dim<typename ToU::dimension, typename U::dimension> &&
+               detail::basic_arithmetic<std::common_type_t<ToRep, Rep, intmax_t>>
   {
     return quantity_cast<quantity<ToU, ToRep>>(q);
   }
 
   template<Unit ToU, typename U, typename Rep>
   [[nodiscard]] constexpr auto quantity_cast(const quantity<U, Rep>& q)
+      requires same_dim<typename ToU::dimension, typename U::dimension>
   {
     return quantity_cast<quantity<ToU, Rep>>(q);
   }
 
-  template<QuantityRep ToRep, typename U, typename Rep>
+  template<Scalar ToRep, typename U, typename Rep>
   [[nodiscard]] constexpr auto quantity_cast(const quantity<U, Rep>& q)
+      requires detail::basic_arithmetic<std::common_type_t<ToRep, Rep, intmax_t>>
   {
     return quantity_cast<quantity<U, ToRep>>(q);
   }
 
   // quantity_values
 
-  template<QuantityRep Rep>
+  template<Scalar Rep>
   struct quantity_values {
     static constexpr Rep zero() noexcept { return Rep(0); }
     static constexpr Rep one() noexcept { return Rep(1); }
@@ -197,9 +187,10 @@ namespace units {
     static constexpr Rep min() noexcept { return std::numeric_limits<Rep>::lowest(); }
   };
 
+
   // quantity
 
-  template<Unit U, QuantityRep Rep = double>
+  template<Unit U, Scalar Rep = double>
   class quantity {
     Rep value_;
 
@@ -213,18 +204,15 @@ namespace units {
     quantity(quantity&&) = default;
 
     template<Scalar Value>
-        requires std::convertible_to<Value, rep> &&
-                (treat_as_floating_point<rep> || (!treat_as_floating_point<Value>))
+      requires detail::safe_convertible<Value, rep>
     constexpr explicit quantity(const Value& r): value_{static_cast<rep>(r)}
     {
     }
 
     template<Quantity Q2>
-        requires same_dim<dimension, typename Q2::dimension> &&
-                std::convertible_to<typename Q2::rep, rep> &&
-                (treat_as_floating_point<rep> ||
-                  (std::ratio_divide<typename Q2::unit::ratio, typename unit::ratio>::den == 1 &&
-                  !treat_as_floating_point<typename Q2::rep>))
+      requires same_dim<dimension, typename Q2::dimension> &&
+               detail::safe_convertible<typename Q2::rep, rep> &&
+               detail::safe_divisible<rep, typename Q2::unit, unit>
     constexpr quantity(const Q2& q): value_{quantity_cast<quantity>(q).count()}
     {
     }
@@ -234,68 +222,130 @@ namespace units {
 
     [[nodiscard]] constexpr rep count() const noexcept { return value_; }
 
-    [[nodiscard]] static constexpr quantity zero() noexcept { return quantity(quantity_values<Rep>::zero()); }
-    [[nodiscard]] static constexpr quantity one() noexcept { return quantity(quantity_values<Rep>::one()); }
-    [[nodiscard]] static constexpr quantity min() noexcept { return quantity(quantity_values<Rep>::min()); }
-    [[nodiscard]] static constexpr quantity max() noexcept { return quantity(quantity_values<Rep>::max()); }
+    template<typename T = Rep>
+    [[nodiscard]] static constexpr quantity zero() noexcept 
+      requires requires { quantity_values<T>::zero(); }
+      // requires requires { quantity_values<Rep>::zero(); }  // TODO gated by gcc-9 (fixed in gcc-10)
+    {
+      return quantity(quantity_values<Rep>::zero());
+    }
+
+    template<typename T = Rep>
+    [[nodiscard]] static constexpr quantity one() noexcept
+      requires requires { quantity_values<T>::one(); }
+//      requires requires { quantity_values<Rep>::one(); }  // TODO gated by gcc-9 (fixed in gcc-10)
+    {
+      return quantity(quantity_values<Rep>::one());
+    }
+
+    template<typename T = Rep>
+    [[nodiscard]] static constexpr quantity min() noexcept
+      requires requires { quantity_values<T>::min(); }
+//      requires requires { quantity_values<Rep>::min(); }  // TODO gated by gcc-9 (fixed in gcc-10)
+    {
+      return quantity(quantity_values<Rep>::min());
+    }
+
+    template<typename T = Rep>
+    [[nodiscard]] static constexpr quantity max() noexcept
+      requires requires { quantity_values<T>::max(); }
+//      requires requires { quantity_values<Rep>::max(); }  // TODO gated by gcc-9 (fixed in gcc-10)
+    {
+      return quantity(quantity_values<Rep>::max());
+    }
 
     [[nodiscard]] constexpr quantity operator+() const { return *this; }
-    [[nodiscard]] constexpr quantity operator-() const { return quantity(-count()); }
 
+    template<typename T = Rep>
+    [[nodiscard]] constexpr quantity operator-() const
+//      requires std::magma<std::ranges::negate, T, T>
+//      requires std::magma<std::ranges::negate, rep, rep>  // TODO gated by gcc-9 (fixed in gcc-10)
+    { 
+      return quantity(-count());
+    }
+
+    template<typename T = Rep>
     constexpr quantity& operator++()
-      // requires requires(rep v) { { ++v } -> std::same_as<rep&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
+      requires requires(T v) { { ++v } -> SAME_AS(T&); }
+//      requires requires(rep v) { { ++v } -> std::same_as<rep&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       ++value_;
       return *this;
     }
+
+    template<typename T = Rep>
+      requires requires(T v) { { v++ } -> SAME_AS(T); }
     constexpr quantity operator++(int)
       // requires requires(rep v) { { v++ } -> std::same_as<rep>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     { return quantity(value_++); }
 
+    template<typename T = Rep>
+     requires requires(T v) { { --v } -> SAME_AS(T&); }
     constexpr quantity& operator--()
       // requires requires(rep v) { { --v } -> std::same_as<rep&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       --value_;
       return *this;
     }
+
+    template<typename T = Rep>
+      requires requires(T v) { { v-- } -> SAME_AS(T); }
     constexpr quantity operator--(int)
       // requires requires(rep v) { { v-- } -> std::same_as<rep>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     { return quantity(value_--); }
 
+    template<typename T = Rep>
+      requires requires(T v1, T v2) { { v1 += v2 } -> SAME_AS(T&); }
     constexpr quantity& operator+=(const quantity& q)
+      // requires requires(rep v1, rep v2) { { v1 += v2 } -> std::same_as<T&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ += q.count();
       return *this;
     }
 
+    template<typename T = Rep>
+      requires requires(T v1, T v2) { { v1 -= v2 } -> SAME_AS(T&); }
     constexpr quantity& operator-=(const quantity& q)
+      // requires requires(rep v1, rep v2) { { v1 -= v2 } -> std::same_as<T&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ -= q.count();
       return *this;
     }
 
+    template<typename T = Rep>
+      requires requires(T v1, T v2) { { v1 *= v2 } -> SAME_AS(T&); }
     constexpr quantity& operator*=(const rep& rhs)
+      // requires requires(rep v1, rep v2) { { v1 *= v2 } -> std::same_as<T&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ *= rhs;
       return *this;
     }
 
+    template<typename T = Rep>
+      requires requires(T v1, T v2) { { v1 /= v2 } -> SAME_AS(T&); }
     constexpr quantity& operator/=(const rep& rhs)
+      // requires requires(rep v1, rep v2) { { v1 /= v2 } -> std::same_as<rep&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ /= rhs;
       return *this;
     }
 
-    template<Scalar Value>
+    template<Scalar Value, typename T = Rep>
     constexpr quantity& operator%=(const Value& rhs)
-        requires (!treat_as_floating_point<rep> && !treat_as_floating_point<Value>)
+      requires (!treat_as_floating_point<rep>) && 
+               (!treat_as_floating_point<Value>) &&
+               requires(T v1, Value v2) { { v1 %= v2 } -> SAME_AS(T&); }
+              //  requires(rep v1, Value v2) { { v1 %= v2 } -> SAME_AS(rep&); }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ %= rhs;
       return *this;
     }
 
+    template<typename T = Rep>
     constexpr quantity& operator%=(const quantity& q)
-        requires (!treat_as_floating_point<rep>)
+      requires (!treat_as_floating_point<rep>) &&
+                requires(T v1, T v2) { { v1 %= v2 } -> SAME_AS(T&); }
+              // requires(rep v1, rep v2) { { v1 %= v2 } -> std::same_as<rep&>; }  // TODO gated by gcc-9 (fixed in gcc-10)
     {
       value_ %= q.count();
       return *this;
@@ -310,7 +360,7 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr Quantity AUTO operator+(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> && detail::basic_arithmetic<Rep1, Rep2>
   {
     using common_rep = decltype(lhs.count() + rhs.count());
     using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
@@ -319,30 +369,32 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr Quantity AUTO operator-(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> && detail::basic_arithmetic<Rep1, Rep2>
   {
     using common_rep = decltype(lhs.count() - rhs.count());
     using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
     return ret(ret(lhs).count() - ret(rhs).count());
   }
 
-  template<typename U, typename Rep1, Scalar Value>
-  [[nodiscard]] constexpr Quantity AUTO operator*(const quantity<U, Rep1>& q, const Value& v)
+  template<typename U, typename Rep, Scalar Value>
+  [[nodiscard]] constexpr Quantity AUTO operator*(const quantity<U, Rep>& q, const Value& v)
+    requires detail::basic_arithmetic<Rep, Value>
   {
     using common_rep = decltype(q.count() * v);
     using ret = quantity<U, common_rep>;
     return ret(q.count() * v);
   }
 
-  template<Scalar Value, typename U, typename Rep2>
-  [[nodiscard]] constexpr Quantity AUTO operator*(const Value& v, const quantity<U, Rep2>& q)
+  template<Scalar Value, typename U, typename Rep>
+  [[nodiscard]] constexpr Quantity AUTO operator*(const Value& v, const quantity<U, Rep>& q)
+    requires detail::basic_arithmetic<Value, Rep>
   {
     return q * v;
   }
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
-  [[nodiscard]] constexpr QuantityRep AUTO operator*(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, dim_invert<typename U2::dimension>>
+  [[nodiscard]] constexpr Scalar AUTO operator*(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
+      requires same_dim<typename U1::dimension, dim_invert<typename U2::dimension>> && detail::basic_arithmetic<Rep1, Rep2>
   {
     using common_rep = decltype(lhs.count() * rhs.count());
     using ratio = ratio_multiply<typename U1::ratio, typename U2::ratio>;
@@ -353,7 +405,8 @@ namespace units {
   [[nodiscard]] constexpr Quantity AUTO operator*(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
       requires (!same_dim<typename U1::dimension, dim_invert<typename U2::dimension>>) &&
               (treat_as_floating_point<decltype(lhs.count() * rhs.count())> ||
-                (std::ratio_multiply<typename U1::ratio, typename U2::ratio>::den == 1))
+                (std::ratio_multiply<typename U1::ratio, typename U2::ratio>::den == 1)) &&
+              detail::basic_arithmetic<Rep1, Rep2>
   {
     using dim = dimension_multiply<typename U1::dimension, typename U2::dimension>;
     using common_rep = decltype(lhs.count() * rhs.count());
@@ -363,6 +416,7 @@ namespace units {
 
   template<Scalar Value, typename U, typename Rep>
   [[nodiscard]] constexpr Quantity AUTO operator/(const Value& v, const quantity<U, Rep>& q)
+    requires detail::basic_arithmetic<Value, Rep>
   {
     Expects(q != std::remove_cvref_t<decltype(q)>(0));
 
@@ -374,6 +428,7 @@ namespace units {
 
   template<typename U, typename Rep, Scalar Value>
   [[nodiscard]] constexpr Quantity AUTO operator/(const quantity<U, Rep>& q, const Value& v)
+    requires detail::basic_arithmetic<Rep, Value>
   {
     Expects(v != Value{0});
 
@@ -383,8 +438,8 @@ namespace units {
   }
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
-  [[nodiscard]] constexpr QuantityRep AUTO operator/(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+  [[nodiscard]] constexpr Scalar AUTO operator/(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
+    requires same_dim<typename U1::dimension, typename U2::dimension>  && detail::basic_arithmetic<Rep1, Rep2>
   {
     Expects(rhs != std::remove_cvref_t<decltype(rhs)>(0));
 
@@ -397,7 +452,8 @@ namespace units {
   [[nodiscard]] constexpr Quantity AUTO operator/(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
       requires (!same_dim<typename U1::dimension, typename U2::dimension>) &&
                (treat_as_floating_point<decltype(lhs.count() / rhs.count())> ||
-                (ratio_divide<typename U1::ratio, typename U2::ratio>::den == 1))
+                (ratio_divide<typename U1::ratio, typename U2::ratio>::den == 1)) &&
+               detail::basic_arithmetic<Rep1, Rep2>
   {
     Expects(rhs != std::remove_cvref_t<decltype(rhs)>(0));
 
@@ -409,7 +465,8 @@ namespace units {
 
   template<typename U, typename Rep, Scalar Value>
   [[nodiscard]] constexpr Quantity AUTO operator%(const quantity<U, Rep>& q, const Value& v)
-      requires (!treat_as_floating_point<Rep> && !treat_as_floating_point<Value>)
+      requires (!treat_as_floating_point<Rep>) && (!treat_as_floating_point<Value>) &&
+               detail::basic_arithmetic<Rep, Value> && std::magma<std::ranges::modulus, Rep, Value>
   {
     using common_rep = decltype(q.count() % v);
     using ret = quantity<U, common_rep>;
@@ -418,7 +475,8 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr Quantity AUTO operator%(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires (!treat_as_floating_point<Rep1> && !treat_as_floating_point<Rep2>)
+      requires (!treat_as_floating_point<Rep1>) && (!treat_as_floating_point<Rep2>) &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::magma<std::ranges::modulus, Rep1, Rep2>
   {
     using common_rep = decltype(lhs.count() % rhs.count());
     using ret = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>, common_rep>;
@@ -427,7 +485,8 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator==(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension>  &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::equality_comparable_with<Rep1, Rep2>
   {
     using cq = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>>;
     return cq(lhs).count() == cq(rhs).count();
@@ -435,14 +494,16 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator!=(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::equality_comparable_with<Rep1, Rep2>
   {
     return !(lhs == rhs);
   }
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator<(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::totally_ordered_with<Rep1, Rep2>
   {
     using cq = common_quantity<quantity<U1, Rep1>, quantity<U2, Rep2>>;
     return cq(lhs).count() < cq(rhs).count();
@@ -450,21 +511,24 @@ namespace units {
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator<=(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::totally_ordered_with<Rep1, Rep2>
   {
     return !(rhs < lhs);
   }
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator>(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::totally_ordered_with<Rep1, Rep2>
   {
     return rhs < lhs;
   }
 
   template<typename U1, typename Rep1, typename U2, typename Rep2>
   [[nodiscard]] constexpr bool operator>=(const quantity<U1, Rep1>& lhs, const quantity<U2, Rep2>& rhs)
-      requires same_dim<typename U1::dimension, typename U2::dimension>
+      requires same_dim<typename U1::dimension, typename U2::dimension> &&
+               detail::basic_arithmetic<Rep1, Rep2> && std::totally_ordered_with<Rep1, Rep2>
   {
     return !(lhs < rhs);
   }
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index 532d7769..cecaf798 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -37,13 +37,27 @@ namespace {
   public:
     my_value() = default;
     constexpr my_value(T v) : value_(std::move(v)) {}
-    constexpr my_value& operator+=(const my_value& other) { value_ += other.value_; return *this; }
-    constexpr my_value& operator-=(const my_value& other) { value_ -= other.value_; return *this; }
-    constexpr my_value& operator*=(const my_value& other) { value_ *= other.value_; return *this; }
-    constexpr my_value& operator/=(const my_value& other) { value_ /= other.value_; return *this; }
+    [[nodiscard]] constexpr my_value operator-() const { return my_value(-value_); }
+
+    [[nodiscard]] friend constexpr my_value operator+(my_value lhs, my_value rhs) { return my_value(lhs.value_ + rhs.value_); }
+    [[nodiscard]] friend constexpr my_value operator-(my_value lhs, my_value rhs) { return my_value(lhs.value_ - rhs.value_); }
+    [[nodiscard]] friend constexpr my_value operator*(my_value lhs, my_value rhs) { return my_value(lhs.value_ * rhs.value_); }
+    [[nodiscard]] friend constexpr my_value operator/(my_value lhs, my_value rhs) { return my_value(lhs.value_ / rhs.value_); }
+
+    [[nodiscard]] friend constexpr bool operator==(my_value lhs, my_value rhs) { return lhs.value_ == rhs.value_; }
+    [[nodiscard]] friend constexpr bool operator!=(my_value lhs, my_value rhs) { return !(lhs == rhs); }
+    [[nodiscard]] friend constexpr bool operator<(my_value lhs, my_value rhs) { return lhs.value_ < rhs.value_; }
+    [[nodiscard]] friend constexpr bool operator>(my_value lhs, my_value rhs) { return rhs < lhs; }
+    [[nodiscard]] friend constexpr bool operator<=(my_value lhs, my_value rhs) { return !(rhs < lhs); }
+    [[nodiscard]] friend constexpr bool operator>=(my_value lhs, my_value rhs) { return !(lhs < rhs); }
+
     constexpr operator const T&() const & { return value_; }
   };
 
+  static_assert(units::Scalar<my_value<float>>);
+  static_assert(std::convertible_to<my_value<float>, float>);
+  static_assert(std::convertible_to<float, my_value<float>>);
+
 }  // namespace
 
 namespace units {
@@ -96,6 +110,9 @@ namespace {
 
   // constructors
 
+  using my_int = my_value<int>;
+  using my_double = my_value<double>;
+
   static_assert(quantity<metre, int>().count() == 0);
   constexpr quantity<metre, int> km{1000};
   static_assert(km.count() == 1000);
@@ -103,7 +120,7 @@ namespace {
 
   static_assert(quantity<metre, int>(1).count() == 1);
   static_assert(quantity<metre, int>(my_value(1)).count() == 1);
-  static_assert(quantity<metre, my_value<int>>(1).count() == 1);
+  static_assert(quantity<metre, my_int>(1).count() == my_int{1});
   //  static_assert(quantity<metre, int>(1.0).count() == 1);   // should not compile
   //  static_assert(quantity<metre, int>(my_value(1.0)).count() == 1); // should not compile
   //  static_assert(quantity<metre, my_value>(1.0).count() == 1);   // should not compile
@@ -112,24 +129,24 @@ namespace {
   static_assert(quantity<metre, double>(1).count() == 1.0);
   static_assert(quantity<metre, double>(my_value(1)).count() == 1.0);
   static_assert(quantity<metre, double>(3.14).count() == 3.14);
-  static_assert(quantity<metre, my_value<double>>(1.0).count() == 1.0);
-  static_assert(quantity<metre, my_value<double>>(1).count() == 1.0);
-  static_assert(quantity<metre, my_value<double>>(3.14).count() == 3.14);
+  static_assert(quantity<metre, my_double>(1.0).count() == my_double{1.0});
+  static_assert(quantity<metre, my_double>(1).count() == my_double{1.0});
+  static_assert(quantity<metre, my_double>(3.14).count() == my_double{3.14});
 
   static_assert(quantity<metre, int>(km).count() == 1000);
   //  static_assert(quantity<metre, int>(quantity<metre, double>(3.14)).count() == 3);   // should not compile
-  static_assert(quantity<metre, int>(quantity_cast<quantity<metre, my_value<int>>>(3.14m)).count() == 3);
-  //  static_assert(quantity<metre, int>(quantity<metre, my_value<double>>(1000.0)).count() == 1000);   // should not compile
+  static_assert(quantity<metre, int>(quantity_cast<quantity<metre, my_int>>(3.14m)).count() == 3);
+  //  static_assert(quantity<metre, int>(quantity<metre, my_double>(1000.0)).count() == 1000);   // should not compile
   //  static_assert(quantity<metre, my_value>(1000.0m).count() == 1000);   // should not compile
   static_assert(quantity<metre, double>(1000.0m).count() == 1000.0);
-  static_assert(quantity<metre, double>(quantity<metre, my_value<double>>(1000.0)).count() == 1000.0);
-  static_assert(quantity<metre, my_value<double>>(1000.0m).count() == 1000.0);
+  static_assert(quantity<metre, double>(quantity<metre, my_double>(1000.0)).count() == 1000.0);
+  static_assert(quantity<metre, my_double>(1000.0m).count() == my_double{1000.0});
   static_assert(quantity<metre, double>(km).count() == 1000.0);
-  static_assert(quantity<metre, my_value<double>>(km).count() == 1000.0);
+  static_assert(quantity<metre, my_double>(km).count() == my_double{1000.0});
   static_assert(quantity<metre, int>(1km).count() == 1000);
   //  static_assert(quantity<metre, int>(1_s).count() == 1);   // should not compile
   //  static_assert(quantity<kilometre, int>(1010m).count() == 1);   // should not compile
-  static_assert(quantity<kilometre, int>(quantity_cast<quantity<kilometre, my_value<int>>>(1010m)).count() == 1);
+  static_assert(quantity<kilometre, int>(quantity_cast<quantity<kilometre, my_int>>(1010m)).count() == 1);
 
   // assignment operator
 
@@ -146,12 +163,12 @@ namespace {
   static_assert(quantity<metre, double>::zero().count() == 0.0);
   static_assert(quantity<metre, double>::min().count() == std::numeric_limits<double>::lowest());
   static_assert(quantity<metre, double>::max().count() == std::numeric_limits<double>::max());
-  static_assert(quantity<metre, my_value<int>>::zero().count() == 0);
-  static_assert(quantity<metre, my_value<int>>::min().count() == std::numeric_limits<int>::lowest());
-  static_assert(quantity<metre, my_value<int>>::max().count() == std::numeric_limits<int>::max());
-  static_assert(quantity<metre, my_value<double>>::zero().count() == 0.0);
-  static_assert(quantity<metre, my_value<double>>::min().count() == std::numeric_limits<double>::lowest());
-  static_assert(quantity<metre, my_value<double>>::max().count() == std::numeric_limits<double>::max());
+  static_assert(quantity<metre, my_int>::zero().count() == my_int{0});
+  static_assert(quantity<metre, my_int>::min().count() == my_int{std::numeric_limits<int>::lowest()});
+  static_assert(quantity<metre, my_int>::max().count() == my_int{std::numeric_limits<int>::max()});
+  static_assert(quantity<metre, my_double>::zero().count() == my_double{0.0});
+  static_assert(quantity<metre, my_double>::min().count() == my_double{std::numeric_limits<double>::lowest()});
+  static_assert(quantity<metre, my_double>::max().count() == my_double{std::numeric_limits<double>::max()});
 
   // unary member operators