diff --git a/src/core/include/mp_units/quantity.h b/src/core/include/mp_units/quantity.h
index 72fe9e81..b340812f 100644
--- a/src/core/include/mp_units/quantity.h
+++ b/src/core/include/mp_units/quantity.h
@@ -43,9 +43,6 @@ namespace mp_units {
 
 namespace detail {
 
-template<typename T>
-concept QuantityOne = QuantityOf<T, dimensionless[one]>;
-
 template<QuantityLike Q>
 using quantity_like_type = quantity<quantity_like_traits<Q>::reference, typename quantity_like_traits<Q>::rep>;
 
@@ -53,21 +50,22 @@ template<typename T, typename Arg>
 concept RepSafeConstructibleFrom =  // exposition only
   std::constructible_from<T, Arg> && (treat_as_floating_point<T> || !treat_as_floating_point<Arg>);
 
-// QFrom ratio is an exact multiple of QTo
-template<typename QFrom, typename QTo>
+// UFrom ratio is an exact multiple of UTo
+template<auto UFrom, auto UTo>
 concept Harmonic =  // exposition only
-  Quantity<QFrom> && Quantity<QTo> &&
-  is_integral(get_canonical_unit(QFrom::unit).mag / get_canonical_unit(QTo::unit).mag);
+  Unit<decltype(UFrom)> && Unit<decltype(UTo)> &&
+  is_integral(get_canonical_unit(UFrom).mag / get_canonical_unit(UTo).mag);
 
 template<typename QFrom, typename QTo>
 concept QuantityConvertibleTo =  // exposition only
   Quantity<QFrom> && Quantity<QTo> && implicitly_convertible_to(QFrom::quantity_spec, QTo::quantity_spec) &&
-  requires(QFrom q) { detail::sudo_cast<QTo>(q); } &&
+  convertible_to(QFrom::unit, QTo::unit) && requires(QFrom q) { detail::sudo_cast<QTo>(q); } &&
   (treat_as_floating_point<typename QTo::rep> ||
-   (!treat_as_floating_point<typename QFrom::rep> && Harmonic<QFrom, QTo>));
+   (!treat_as_floating_point<typename QFrom::rep> && Harmonic<QFrom::unit, QTo::unit>));
 
 template<quantity_character Ch, typename Func, typename T, typename U>
-concept InvokeResultOf = std::regular_invocable<Func, T, U> && RepresentationOf<std::invoke_result_t<Func, T, U>, Ch>;
+concept InvokeResultIsRepresentationOf =
+  std::regular_invocable<Func, T, U> && RepresentationOf<std::invoke_result_t<Func, T, U>, Ch>;
 
 }  // namespace detail
 
@@ -163,15 +161,13 @@ public:
       } -> std::common_with<rep>;
     }
   {
-    using ret = quantity<R, decltype(+number())>;
-    return ret(+number());
+    return +number() * reference;
   }
 
   [[nodiscard]] constexpr Quantity auto operator-() const
     requires std::regular_invocable<std::negate<>, rep>
   {
-    using ret = quantity<R, decltype(-number())>;
-    return ret(-number());
+    return -number() * reference;
   }
 
   constexpr quantity& operator++()
@@ -239,49 +235,49 @@ public:
   }
 
   template<typename Rep2>
-  constexpr quantity& operator*=(const Rep2& rhs)
-    requires requires(rep a, const Rep2 b) {
+    requires(!Quantity<Rep2>) && requires(rep a, const Rep2 b) {
       {
         a *= b
       } -> std::same_as<rep&>;
     }
+  constexpr quantity& operator*=(const Rep2& rhs)
   {
     number_ *= rhs;
     return *this;
   }
 
-  template<detail::QuantityOne Q>
-  constexpr quantity& operator*=(const Q& rhs)
-    requires requires(rep a, const typename Q::rep b) {
+  template<QuantityOf<dimension_one> Q>
+    requires(Q::unit == ::mp_units::one) && requires(rep a, const typename Q::rep b) {
       {
         a *= b
       } -> std::same_as<rep&>;
     }
+  constexpr quantity& operator*=(const Q& rhs)
   {
     number_ *= rhs.number();
     return *this;
   }
 
   template<typename Rep2>
-  constexpr quantity& operator/=(const Rep2& rhs)
-    requires requires(rep a, const Rep2 b) {
+    requires(!Quantity<Rep2>) && requires(rep a, const Rep2 b) {
       {
         a /= b
       } -> std::same_as<rep&>;
     }
+  constexpr quantity& operator/=(const Rep2& rhs)
   {
     gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
     number_ /= rhs;
     return *this;
   }
 
-  template<detail::QuantityOne Q>
-  constexpr quantity& operator/=(const Q& rhs)
-    requires requires(rep a, const typename Q::rep b) {
+  template<QuantityOf<dimension_one> Q>
+    requires(Q::unit == ::mp_units::one) && requires(rep a, const typename Q::rep b) {
       {
         a /= b
       } -> std::same_as<rep&>;
     }
+  constexpr quantity& operator/=(const Q& rhs)
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
     number_ /= rhs.number();
@@ -289,26 +285,27 @@ public:
   }
 
   template<typename Rep2>
+    requires(!Quantity<Rep2>) && (!treat_as_floating_point<rep>) && (!treat_as_floating_point<Rep2>) &&
+            requires(rep a, const Rep2 b) {
+              {
+                a %= b
+              } -> std::same_as<rep&>;
+            }
   constexpr quantity& operator%=(const Rep2& rhs)
-    requires(!treat_as_floating_point<rep>) && (!treat_as_floating_point<Rep2>) && requires(rep a, const Rep2 b) {
-      {
-        a %= b
-      } -> std::same_as<rep&>;
-    }
   {
     gsl_ExpectsAudit(rhs != quantity_values<Rep2>::zero());
     number_ %= rhs;
     return *this;
   }
 
-  template<detail::QuantityOne Q>
-  constexpr quantity& operator%=(const Q& rhs)
-    requires(!treat_as_floating_point<rep>) && (!treat_as_floating_point<typename Q::rep>) &&
-            requires(rep a, const typename Q::rep b) {
+  template<QuantityOf<dimension_one> Q>
+    requires(Q::unit == ::mp_units::one) && (!treat_as_floating_point<rep>) &&
+            (!treat_as_floating_point<typename Q::rep>) && requires(rep a, const typename Q::rep b) {
               {
                 a %= b
               } -> std::same_as<rep&>;
             }
+  constexpr quantity& operator%=(const Q& rhs)
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
     number_ %= rhs.number();
@@ -329,106 +326,200 @@ public:
 
   // Hidden Friends
   // Below friend functions are to be found via argument-dependent lookup only
-  template<typename Value>
-  [[nodiscard]] friend constexpr Quantity auto operator+(const quantity& lhs, const Value& rhs)
-    requires requires {  // TODO: Simplify when Clang catches up.
-      requires !Quantity<Value>;
-      requires dimension == dimension_one;
-      requires detail::InvokeResultOf<quantity_spec.character, std::plus<>, rep, Value>;
-    }
+  template<Quantity Q>
+    requires requires { common_reference(reference, Q::reference); } &&
+             detail::InvokeResultIsRepresentationOf<common_quantity_spec(quantity_spec, Q::quantity_spec).character,
+                                                    std::plus<>, rep, typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator+(const quantity& lhs, const Q& rhs)
   {
-    return lhs + rhs * ::mp_units::one;
+    constexpr auto ref = common_reference(reference, Q::reference);
+    using ret = quantity<ref, decltype(lhs.number() + rhs.number())>;
+    return (ret(lhs).number() + ret(rhs).number()) * ref;
+  }
+
+  template<Quantity Q>
+    requires requires { common_reference(reference, Q::reference); } &&
+             detail::InvokeResultIsRepresentationOf<common_quantity_spec(quantity_spec, Q::quantity_spec).character,
+                                                    std::minus<>, rep, typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator-(const quantity& lhs, const Q& rhs)
+  {
+    constexpr auto ref = common_reference(reference, Q::reference);
+    using ret = quantity<ref, decltype(lhs.number() - rhs.number())>;
+    return (ret(lhs).number() - ret(rhs).number()) * ref;
+  }
+
+  template<Quantity Q>
+    requires detail::InvokeResultIsRepresentationOf<(quantity_spec * Q::quantity_spec).character, std::multiplies<>,
+                                                    rep, typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator*(const quantity& lhs, const Q& rhs)
+  {
+    return lhs.number() * rhs.number() * (reference * Q::reference);
   }
 
   template<typename Value>
-  [[nodiscard]] friend constexpr Quantity auto operator+(const Value& lhs, const quantity& rhs)
-    requires requires {  // TODO: Simplify when Clang catches up.
-      requires !Quantity<Value>;
-      requires dimension == dimension_one;
-      requires detail::InvokeResultOf<quantity_spec.character, std::plus<>, Value, rep>;
-    }
-  {
-    return lhs * ::mp_units::one + rhs;
-  }
-
-  template<typename Value>
-  [[nodiscard]] friend constexpr Quantity auto operator-(const quantity& lhs, const Value& rhs)
-    requires requires {  // TODO: Simplify when Clang catches up.
-      requires !Quantity<Value>;
-      requires dimension == dimension_one;
-      requires detail::InvokeResultOf<quantity_spec.character, std::minus<>, rep, Value>;
-    }
-  {
-    return lhs - rhs * ::mp_units::one;
-  }
-
-  template<typename Value>
-  [[nodiscard]] friend constexpr Quantity auto operator-(const Value& lhs, const quantity& rhs)
-    requires requires {  // TODO: Simplify when Clang catches up.
-      requires !Quantity<Value>;
-      requires dimension == dimension_one;
-      requires detail::InvokeResultOf<quantity_spec.character, std::minus<>, Value, rep>;
-    }
-  {
-    return lhs * ::mp_units::one - rhs;
-  }
-
-  template<Representation Value>
-    requires detail::InvokeResultOf<quantity_spec.character, std::multiplies<>, rep, const Value&>
+    requires(!Quantity<Value>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::multiplies<>, rep, const Value&>
   [[nodiscard]] friend constexpr Quantity auto operator*(const quantity& q, const Value& v)
   {
-    return q.number() * v * R;
-  }
-
-  template<Representation Value>
-    requires detail::InvokeResultOf<quantity_spec.character, std::multiplies<>, const Value&, rep>
-  [[nodiscard]] friend constexpr Quantity auto operator*(const Value& v, const quantity& q)
-  {
-    return v * q.number() * R;
+    return q.number() * v * reference;
   }
 
   template<typename Value>
-    requires(!Quantity<Value>) && detail::InvokeResultOf<quantity_spec.character, std::divides<>, rep, const Value&>
+    requires(!Quantity<Value>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::multiplies<>, const Value&, rep>
+  [[nodiscard]] friend constexpr Quantity auto operator*(const Value& v, const quantity& q)
+  {
+    return v * q.number() * reference;
+  }
+
+  template<Quantity Q>
+    requires detail::InvokeResultIsRepresentationOf<(quantity_spec / Q::quantity_spec).character, std::divides<>, rep,
+                                                    typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator/(const quantity& lhs, const Q& rhs)
+  {
+    gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
+    return lhs.number() / rhs.number() * (reference / Q::reference);
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::divides<>, rep, const Value&>
   [[nodiscard]] friend constexpr Quantity auto operator/(const quantity& q, const Value& v)
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
-    return q.number() / v * R;
+    return q.number() / v * reference;
   }
 
   template<typename Value>
-    requires(!Quantity<Value>) && detail::InvokeResultOf<quantity_spec.character, std::divides<>, const Value&, rep>
+    requires(!Quantity<Value>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::divides<>, const Value&, rep>
   [[nodiscard]] friend constexpr Quantity auto operator/(const Value& v, const quantity& q)
   {
-    return v / q.number() * (dimensionless[::mp_units::one] / reference);
+    return v / q.number() * (::mp_units::one / reference);
   }
 
   template<typename Value>
     requires(!Quantity<Value>) && (!treat_as_floating_point<rep>) && (!treat_as_floating_point<Value>) &&
-            detail::InvokeResultOf<quantity_spec.character, std::modulus<>, rep, const Value&>
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::modulus<>, rep, Value>
   [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& q, const Value& v)
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
-    return q.number() % v * R;
+    return (q.number() % v) * reference;
   }
 
   [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& lhs, const quantity& rhs)
-    requires(!treat_as_floating_point<rep>) && detail::InvokeResultOf<quantity_spec.character, std::modulus<>, rep, rep>
+    requires(!treat_as_floating_point<rep>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::modulus<>, rep, rep>
   {
     gsl_ExpectsAudit(rhs.number() != quantity_values<rep>::zero());
-    return lhs.number() % rhs.number() * R;
+    return (lhs.number() % rhs.number()) * reference;
   }
 
-  [[nodiscard]] friend constexpr auto operator<=>(const quantity& lhs, const quantity& rhs)
-    requires std::three_way_comparable<rep>
-#if __cpp_impl_three_way_comparison
-  = default;
-#else
+  template<Quantity Q>
+    requires(!treat_as_floating_point<rep>) && (!treat_as_floating_point<typename Q::rep>) &&
+            requires {
+              common_reference(reference, Q::reference);
+            } && detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::modulus<>, rep, typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& lhs, const Q& rhs)
   {
-    return lhs.number() <=> rhs.number();
+    gsl_ExpectsAudit(rhs.number() != quantity_values<rep>::zero());
+    constexpr auto ref = common_reference(reference, Q::reference);
+    using ret = quantity<ref, decltype(lhs.number() % rhs.number())>;
+    return (ret(lhs).number() % ret(rhs).number()) * ref;
   }
-#endif
 
-  [[nodiscard]] friend constexpr bool operator==(const quantity& lhs, const quantity& rhs) = default;
+  template<Quantity Q>
+    requires(!treat_as_floating_point<rep>) && (!treat_as_floating_point<typename Q::rep>) &&
+            (Q::dimension == dimension_one) && (Q::unit == ::mp_units::one) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::modulus<>, rep, typename Q::rep>
+  [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& lhs, const Q& rhs)
+  {
+    gsl_ExpectsAudit(rhs.number() != quantity_values<rep>::zero());
+    return (lhs.number() % rhs.number()) * reference;
+  }
+
+  template<Quantity Q>
+    requires requires { common_reference(reference, Q::reference); } &&
+             std::equality_comparable_with<rep, typename Q::rep>
+  [[nodiscard]] friend constexpr bool operator==(const quantity& lhs, const Q& rhs)
+  {
+    using ct = std::common_type_t<quantity, Q>;
+    return ct(lhs).number() == ct(rhs).number();
+  }
+
+  template<Quantity Q>
+    requires requires { common_reference(reference, Q::reference); } &&
+             std::three_way_comparable_with<rep, typename Q::rep>
+  [[nodiscard]] friend constexpr auto operator<=>(const quantity& lhs, const Q& rhs)
+  {
+    using ct = std::common_type_t<quantity, Q>;
+    return ct(lhs).number() <=> ct(rhs).number();
+  }
+
+
+  // dimensionless quantities support for interacting with raw values
+  template<typename Value>
+    requires(dimension == dimension_one) &&
+            (unit == ::mp_units::one) && detail::RepSafeConstructibleFrom<rep, std::remove_cvref_t<Value>>
+  constexpr explicit(false) quantity(Value&& v) : number_(std::forward<Value>(v))
+  {
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::plus<>, rep, Value>
+  [[nodiscard]] friend constexpr Quantity auto operator+(const quantity& q, const Value& v)
+  {
+    return q + v * ::mp_units::one;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::plus<>, Value, rep>
+  [[nodiscard]] friend constexpr Quantity auto operator+(const Value& v, const quantity& q)
+  {
+    return v * ::mp_units::one + q;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::minus<>, rep, Value>
+  [[nodiscard]] friend constexpr Quantity auto operator-(const quantity& q, const Value& v)
+  {
+    return q - v * ::mp_units::one;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::minus<>, Value, rep>
+  [[nodiscard]] friend constexpr Quantity auto operator-(const Value& v, const quantity& q)
+  {
+    return v * ::mp_units::one - q;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) && (unit == ::mp_units::one) &&
+            (!treat_as_floating_point<Value>) && (!treat_as_floating_point<rep>) &&
+            detail::InvokeResultIsRepresentationOf<quantity_spec.character, std::modulus<>, Value, rep>
+  [[nodiscard]] friend constexpr Quantity auto operator%(const Value& v, const quantity& q)
+  {
+    gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
+    return (v % q.number()) * reference;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) && std::equality_comparable_with<rep, Value>
+  [[nodiscard]] friend constexpr bool operator==(const quantity& q, const Value& v)
+  {
+    return q == v * ::mp_units::one;
+  }
+
+  template<typename Value>
+    requires(!Quantity<Value>) && (dimension == dimension_one) && std::three_way_comparable_with<rep, Value>
+  [[nodiscard]] friend constexpr auto operator<=>(const quantity& q, const Value& v)
+  {
+    return q <=> v * ::mp_units::one;
+  }
 
 private:
   template<Reference R2, typename Rep2>
@@ -436,100 +527,16 @@ private:
   friend constexpr quantity<R2{}, std::remove_cvref_t<Rep2>> operator*(Rep2&& lhs, R2);
 
   template<typename Value>
-    requires detail::RepSafeConstructibleFrom<rep, Value>
+    requires detail::RepSafeConstructibleFrom<rep, std::remove_cvref_t<Value>>
   constexpr explicit quantity(Value&& v) : number_(std::forward<Value>(v))
   {
   }
 };
 
 // CTAD
-template<auto R, typename Rep>
-explicit(false) quantity(quantity<R, Rep>) -> quantity<R, Rep>;
-
-template<RepresentationOf<mp_units::quantity_character::scalar> Rep>
-explicit(false) quantity(Rep) -> quantity<dimensionless[one], Rep>;
-
-#if !UNITS_COMP_CLANG || UNITS_COMP_CLANG > 16
-template<auto R, RepresentationOf<R.quantity_spec.character> Rep>
-explicit(false) quantity(Rep&&) -> quantity<R, Rep>;
-#endif
-
 template<QuantityLike Q>
 explicit quantity(Q) -> quantity<quantity_like_traits<Q>::reference, typename quantity_like_traits<Q>::rep>;
 
-// non-member binary operators
-template<Quantity Q1, Quantity Q2>
-  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
-           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
-          detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::plus<>,
-                                 typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr Quantity auto operator+(const Q1& lhs, const Q2& rhs)
-{
-  constexpr auto ref = common_reference(Q1::reference, Q2::reference);
-  using ret = quantity<ref, decltype(lhs.number() + rhs.number())>;
-  return (ret(lhs).number() + ret(rhs).number()) * ref;
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
-           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
-          detail::InvokeResultOf<common_quantity_spec(Q1::quantity_spec, Q2::quantity_spec).character, std::minus<>,
-                                 typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr Quantity auto operator-(const Q1& lhs, const Q2& rhs)
-{
-  constexpr auto ref = common_reference(Q1::reference, Q2::reference);
-  using ret = quantity<ref, decltype(lhs.number() - rhs.number())>;
-  return (ret(lhs).number() - ret(rhs).number()) * ref;
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires detail::InvokeResultOf<(Q1::quantity_spec * Q2::quantity_spec).character, std::multiplies<>,
-                                  typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr Quantity auto operator*(const Q1& lhs, const Q2& rhs)
-{
-  return lhs.number() * rhs.number() * (Q1::reference * Q2::reference);
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires detail::InvokeResultOf<(Q1::quantity_spec / Q2::quantity_spec).character, std::divides<>, typename Q1::rep,
-                                  typename Q2::rep>
-[[nodiscard]] constexpr Quantity auto operator/(const Q1& lhs, const Q2& rhs)
-{
-  gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q2::rep>::zero());
-  return lhs.number() / rhs.number() * (Q1::reference / Q2::reference);
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires(!treat_as_floating_point<typename Q1::rep>) && (!treat_as_floating_point<typename Q2::rep>) &&
-          (interconvertible(Q1::reference, Q2::reference) || QuantityOf<Q2, dimensionless>) &&
-          detail::InvokeResultOf<Q1::reference.character, std::modulus<>, typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr Quantity auto operator%(const Q1& lhs, const Q2& rhs)
-{
-  gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q2::rep>::zero());
-  using ret = quantity<Q1::reference, std::invoke_result_t<std::modulus<>, typename Q1::rep, typename Q2::rep>>;
-  return ret(lhs.number() % rhs.number());
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
-           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
-          std::three_way_comparable_with<typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr auto operator<=>(const Q1& lhs, const Q2& rhs)
-{
-  constexpr auto ref = common_reference(Q1::reference, Q2::reference);
-  return quantity<ref, typename Q1::rep>(lhs).number() <=> quantity<ref, typename Q2::rep>(rhs).number();
-}
-
-template<Quantity Q1, Quantity Q2>
-  requires(implicitly_convertible_to(get_kind(Q1::quantity_spec), get_kind(Q2::quantity_spec)) ||
-           implicitly_convertible_to(get_kind(Q2::quantity_spec), get_kind(Q1::quantity_spec))) &&
-          std::equality_comparable_with<typename Q1::rep, typename Q2::rep>
-[[nodiscard]] constexpr bool operator==(const Q1& lhs, const Q2& rhs)
-{
-  constexpr auto ref = common_reference(Q1::reference, Q2::reference);
-  return quantity<ref, typename Q1::rep>(lhs).number() == quantity<ref, typename Q2::rep>(rhs).number();
-}
-
 }  // namespace mp_units
 
 namespace std {
@@ -547,4 +554,19 @@ public:
                                   common_type_t<typename Q1::rep, typename Q2::rep>>;
 };
 
+// dimensionless quantities support for interacting with raw values
+template<mp_units::Quantity Q, typename Value>
+  requires(!mp_units::Quantity<Value>) && (Q::dimension == mp_units::dimension_one) && (Q::unit == mp_units::one) &&
+          requires { typename common_type_t<typename Q::rep, Value>; }
+struct common_type<Q, Value> {
+public:
+  using type = mp_units::quantity<mp_units::one, common_type_t<typename Q::rep, Value>>;
+};
+
+template<mp_units::Quantity Q, typename Value>
+  requires(!mp_units::Quantity<Value>) && (Q::dimension == mp_units::dimension_one) && (Q::unit == mp_units::one) &&
+          requires { typename common_type_t<typename Q::rep, Value>; }
+struct common_type<Value, Q> : common_type<Q, Value> {
+};
+
 }  // namespace std
diff --git a/src/core/include/mp_units/quantity_point.h b/src/core/include/mp_units/quantity_point.h
index 080199bc..ae4a0705 100644
--- a/src/core/include/mp_units/quantity_point.h
+++ b/src/core/include/mp_units/quantity_point.h
@@ -224,9 +224,6 @@ public:
 };
 
 // CTAD
-template<Representation Rep>
-explicit quantity_point(Rep) -> quantity_point<dimensionless[one], absolute_point_origin<dimensionless>{}, Rep>;
-
 template<Quantity Q>
 explicit quantity_point(Q) -> quantity_point<Q::reference, absolute_point_origin<Q::quantity_spec>{}, typename Q::rep>;
 
diff --git a/test/unit_test/static/CMakeLists.txt b/test/unit_test/static/CMakeLists.txt
index aabf8647..434da241 100644
--- a/test/unit_test/static/CMakeLists.txt
+++ b/test/unit_test/static/CMakeLists.txt
@@ -22,16 +22,16 @@
 
 cmake_minimum_required(VERSION 3.2)
 
-# add_library(unit_tests_static_truncating quantity_test.cpp)
+add_library(unit_tests_static_truncating quantity_test.cpp)
 
 # if(NOT ${projectPrefix}LIBCXX)
 # target_sources(unit_tests_static_truncating PRIVATE quantity_kind_test.cpp quantity_point_kind_test.cpp)
 # endif()
 
-# target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
-# target_compile_options(
-# unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
-# )
+target_link_libraries(unit_tests_static_truncating PRIVATE mp-units::mp-units)
+target_compile_options(
+unit_tests_static_truncating PRIVATE $<IF:$<CXX_COMPILER_ID:MSVC>,/wd4242 /wd4244,-Wno-conversion>
+)
 add_library(
     unit_tests_static
     angle_test.cpp
@@ -72,5 +72,4 @@ add_library(
 # target_sources(unit_tests_static PRIVATE custom_rep_test_min_impl.cpp quantity_point_test.cpp)
 # endif()
 target_link_libraries(unit_tests_static PRIVATE mp-units::mp-units)
-
-# target_link_libraries(unit_tests_static PRIVATE unit_tests_static_truncating mp-units::mp-units)
+target_link_libraries(unit_tests_static PRIVATE unit_tests_static_truncating mp-units::mp-units)
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index f510e2b4..89939539 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -21,235 +21,248 @@
 // SOFTWARE.
 
 #include "test_tools.h"
-#include <units/bits/dimension_op.h>
-#include <units/bits/external/type_traits.h>
-#include <units/exponent.h>
-#include <units/generic/dimensionless.h>
-#include <units/isq/si/area.h>
-#include <units/isq/si/cgs/length.h>
-#include <units/isq/si/fps/length.h>
-#include <units/isq/si/frequency.h>
-#include <units/isq/si/prefixes.h>
-#include <units/isq/si/speed.h>
-#include <units/isq/si/time.h>
-#include <units/isq/si/volume.h>
-#include <units/unit.h>
+#include <mp_units/chrono.h>
+#include <mp_units/systems/si/si.h>
 #include <limits>
-#include <type_traits>
 #include <utility>
 
 namespace {
 
-using namespace units;
-namespace si = isq::si;
-using namespace si;
-using namespace references;
-
-constexpr auto cgs_cm = cgs::references::cm;
-
+using namespace mp_units;
+using namespace mp_units::si::unit_symbols;
 
 //////////////////////////////
 // quantity class invariants
 //////////////////////////////
 
-static_assert(sizeof(length<metre>) == sizeof(double));
-static_assert(sizeof(length<metre, short>) == sizeof(short));
+static_assert(sizeof(quantity<si::metre>) == sizeof(double));
+static_assert(sizeof(quantity<isq::length[m]>) == sizeof(double));
+static_assert(sizeof(quantity<si::metre, short>) == sizeof(short));
+static_assert(sizeof(quantity<isq::length[m], short>) == sizeof(short));
 
 #if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
-template<template<typename, typename, typename> typename Q>
+template<template<auto, typename> typename Q>
 concept invalid_types = requires {
-                          requires !requires { typename Q<dim_length, second, int>; };  // unit of a different dimension
-                          requires !requires { typename Q<dim_length, metre, length<metre>>; };  // quantity used as Rep
-                          requires !requires { typename Q<metre, dim_length, double>; };         // reordered arguments
-                          requires !requires { typename Q<metre, double, dim_length>; };         // reordered arguments
-                        };
+  requires !requires { typename Q<isq::dim_length, double>; };  // dimension instead of reference
+  requires !requires { typename Q<isq::length, double>; };      // quantity_spec instead of reference
+  requires !requires { typename Q<isq::length[m], bool>; };     // bool is not a valid representation type
+  requires !requires { typename Q<isq::length[m], quantity<isq::length[m]>>; };  // quantity used as Rep
+  requires !requires { typename Q<isq::position_vector[si::metre], double>; };   // vector representation expected
+};
 static_assert(invalid_types<quantity>);
 #endif
 
-static_assert(std::is_trivially_default_constructible_v<length<metre>>);
-static_assert(std::is_trivially_copy_constructible_v<length<metre>>);
-static_assert(std::is_trivially_move_constructible_v<length<metre>>);
-static_assert(std::is_trivially_copy_assignable_v<length<metre>>);
-static_assert(std::is_trivially_move_assignable_v<length<metre>>);
-static_assert(std::is_trivially_destructible_v<length<metre>>);
+static_assert(std::is_trivially_default_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_trivially_copy_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_trivially_move_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_trivially_copy_assignable_v<quantity<isq::length[m]>>);
+static_assert(std::is_trivially_move_assignable_v<quantity<isq::length[m]>>);
+static_assert(std::is_trivially_destructible_v<quantity<isq::length[m]>>);
 
-static_assert(std::is_nothrow_default_constructible_v<length<metre>>);
-static_assert(std::is_nothrow_copy_constructible_v<length<metre>>);
-static_assert(std::is_nothrow_move_constructible_v<length<metre>>);
-static_assert(std::is_nothrow_copy_assignable_v<length<metre>>);
-static_assert(std::is_nothrow_move_assignable_v<length<metre>>);
-static_assert(std::is_nothrow_destructible_v<length<metre>>);
+static_assert(std::is_nothrow_default_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_nothrow_copy_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_nothrow_move_constructible_v<quantity<isq::length[m]>>);
+static_assert(std::is_nothrow_copy_assignable_v<quantity<isq::length[m]>>);
+static_assert(std::is_nothrow_move_assignable_v<quantity<isq::length[m]>>);
+static_assert(std::is_nothrow_destructible_v<quantity<isq::length[m]>>);
 
-static_assert(std::is_trivially_copyable_v<length<metre>>);
-static_assert(std::is_standard_layout_v<length<metre>>);
+static_assert(std::is_trivially_copyable_v<quantity<isq::length[m]>>);
+static_assert(std::is_standard_layout_v<quantity<isq::length[m]>>);
 
-static_assert(std::default_initializable<length<metre>>);
-static_assert(std::move_constructible<length<metre>>);
-static_assert(std::copy_constructible<length<metre>>);
-static_assert(std::equality_comparable<length<metre>>);
-static_assert(std::totally_ordered<length<metre>>);
-static_assert(std::regular<length<metre>>);
+static_assert(std::default_initializable<quantity<isq::length[m]>>);
+static_assert(std::move_constructible<quantity<isq::length[m]>>);
+static_assert(std::copy_constructible<quantity<isq::length[m]>>);
+static_assert(std::equality_comparable<quantity<isq::length[m]>>);
+static_assert(std::totally_ordered<quantity<isq::length[m]>>);
+static_assert(std::regular<quantity<isq::length[m]>>);
 
-static_assert(std::three_way_comparable<length<metre>>);
+static_assert(std::three_way_comparable<quantity<isq::length[m]>>);
+
+
+//////////////////
+// member values
+//////////////////
+
+static_assert(quantity<isq::length[m]>::reference == isq::length[m]);
+static_assert(quantity<isq::length[m]>::quantity_spec == isq::length);
+static_assert(quantity<isq::length[m]>::dimension == isq::dim_length);
+static_assert(quantity<isq::length[m]>::unit == si::metre);
 
 
 //////////////////
 // member types
 //////////////////
 
-static_assert(is_same_v<length<metre, int>::dimension, dim_length>);
-static_assert(is_same_v<fps::length<fps::mile>::dimension, fps::dim_length>);
-static_assert(is_same_v<length<metre, int>::unit, metre>);
-static_assert(is_same_v<fps::length<fps::mile>::unit, fps::mile>);
-static_assert(is_same_v<length<metre, int>::rep, int>);
-static_assert(is_same_v<fps::length<fps::mile>::rep, double>);
+static_assert(is_same_v<quantity<isq::length[m]>::rep, double>);
+static_assert(is_same_v<quantity<isq::length[m], int>::rep, int>);
 
 
 ////////////////////////////
 // static member functions
 ////////////////////////////
 
-static_assert(length<metre, int>::zero().number() == 0);
-static_assert(length<metre, int>::min().number() == std::numeric_limits<int>::lowest());
-static_assert(length<metre, int>::max().number() == std::numeric_limits<int>::max());
-static_assert(length<metre, double>::zero().number() == 0.0);
-static_assert(length<metre, double>::min().number() == std::numeric_limits<double>::lowest());
-static_assert(length<metre, double>::max().number() == std::numeric_limits<double>::max());
+static_assert(quantity<isq::length[m], int>::zero().number() == 0);
+static_assert(quantity<isq::length[m], int>::min().number() == std::numeric_limits<int>::lowest());
+static_assert(quantity<isq::length[m], int>::max().number() == std::numeric_limits<int>::max());
+static_assert(quantity<isq::length[m], double>::zero().number() == 0.0);
+static_assert(quantity<isq::length[m], double>::min().number() == std::numeric_limits<double>::lowest());
+static_assert(quantity<isq::length[m], double>::max().number() == std::numeric_limits<double>::max());
 
 
 //////////////////////////////
 // construction from a value
 //////////////////////////////
 
-// only explicit construction from a value
-static_assert(std::constructible_from<length<metre>, double>);
-static_assert(!std::convertible_to<double, length<metre>>);
+// construction from a value is private
+static_assert(!std::constructible_from<quantity<isq::length[m]>, double>);
+static_assert(!std::convertible_to<double, quantity<isq::length[m]>>);
 
-static_assert(std::constructible_from<length<metre>, float>);
-static_assert(!std::convertible_to<float, length<metre>>);
-
-static_assert(
-  std::constructible_from<length<metre, float>, double>);  // truncating implicit conversions double -> float allowed
-static_assert(!std::convertible_to<double, length<metre, float>>);
-
-static_assert(std::constructible_from<length<metre>, int>);
-static_assert(!std::convertible_to<int, length<metre>>);
-
-static_assert(std::constructible_from<length<metre>, short>);
-static_assert(!std::convertible_to<short, length<metre>>);
-
-static_assert(
-  std::constructible_from<length<metre, short>, int>);  // truncating implicit conversions int -> short allowed
-static_assert(!std::convertible_to<int, length<metre, short>>);
+static_assert(!std::constructible_from<quantity<isq::length[m], int>, int>);
+static_assert(!std::convertible_to<int, quantity<isq::length[m], int>>);
 
 // exception, implicit construction from a value allowed for a dimensionless quantity
-static_assert(std::constructible_from<dimensionless<one>, double>);
-static_assert(std::convertible_to<double, dimensionless<one>>);
+static_assert(std::constructible_from<quantity<dimensionless[one]>, double>);
+static_assert(std::convertible_to<double, quantity<dimensionless[one]>>);
 
-static_assert(std::constructible_from<dimensionless<one>, float>);
-static_assert(std::convertible_to<float, dimensionless<one>>);
+static_assert(std::constructible_from<quantity<dimensionless[one]>, float>);
+static_assert(std::convertible_to<float, quantity<dimensionless[one]>>);
 
-static_assert(std::constructible_from<dimensionless<one, float>, double>);
-static_assert(std::convertible_to<double, dimensionless<one, float>>);
+static_assert(std::constructible_from<quantity<dimensionless[one], float>, double>);
+static_assert(std::convertible_to<double, quantity<dimensionless[one], float>>);
 
-static_assert(std::constructible_from<dimensionless<one>, int>);
-static_assert(std::convertible_to<int, dimensionless<one>>);
+static_assert(std::constructible_from<quantity<dimensionless[one]>, int>);
+static_assert(std::convertible_to<int, quantity<dimensionless[one]>>);
 
-static_assert(std::constructible_from<dimensionless<one>, short>);
-static_assert(std::convertible_to<short, dimensionless<one>>);
+static_assert(std::constructible_from<quantity<dimensionless[one]>, short>);
+static_assert(std::convertible_to<short, quantity<dimensionless[one]>>);
 
-static_assert(std::constructible_from<dimensionless<one, short>, int>);
-static_assert(std::convertible_to<int, dimensionless<one, short>>);
+static_assert(std::constructible_from<quantity<dimensionless[one], short>, int>);
+static_assert(std::convertible_to<int, quantity<dimensionless[one], short>>);
 
 // but only if a dimensionless quantity has a ratio(1)
-static_assert(std::constructible_from<dimensionless<percent>, double>);
-static_assert(!std::convertible_to<double, dimensionless<percent>>);
+static_assert(!std::constructible_from<quantity<dimensionless[percent]>, double>);
+static_assert(!std::convertible_to<double, quantity<dimensionless[percent]>>);
 
-static_assert(std::constructible_from<dimensionless<percent>, float>);
-static_assert(!std::convertible_to<float, dimensionless<percent>>);
+static_assert(!std::constructible_from<quantity<dimensionless[percent]>, float>);
+static_assert(!std::convertible_to<float, quantity<dimensionless[percent]>>);
 
-static_assert(std::constructible_from<dimensionless<percent, float>,
-                                      double>);  // truncating implicit conversions double -> float allowed
-static_assert(!std::convertible_to<double, dimensionless<percent, float>>);
+static_assert(!std::constructible_from<quantity<dimensionless[percent], float>, double>);
+static_assert(!std::convertible_to<double, quantity<dimensionless[percent], float>>);
 
-static_assert(std::constructible_from<dimensionless<percent>, int>);
-static_assert(!std::convertible_to<int, dimensionless<percent>>);
+static_assert(!std::constructible_from<quantity<dimensionless[percent]>, int>);
+static_assert(!std::convertible_to<int, quantity<dimensionless[percent]>>);
 
-static_assert(std::constructible_from<dimensionless<percent>, short>);
-static_assert(!std::convertible_to<short, dimensionless<percent>>);
+static_assert(!std::constructible_from<quantity<dimensionless[percent]>, short>);
+static_assert(!std::convertible_to<short, quantity<dimensionless[percent]>>);
 
-static_assert(
-  std::constructible_from<dimensionless<percent, short>, int>);  // truncating implicit conversions int -> short allowed
-static_assert(!std::convertible_to<int, dimensionless<percent, short>>);
-
-// floating-point to integral truncating conversion not allowed
-static_assert(!std::constructible_from<length<metre, int>, double>);
-static_assert(!std::convertible_to<double, length<metre, int>>);
-
-static_assert(!std::constructible_from<dimensionless<one, int>, double>);
-static_assert(!std::convertible_to<double, dimensionless<one, int>>);
-
-static_assert(length<metre, int>().number() == 0);  // value initialization
-static_assert(length<metre, int>(1).number() == 1);
-static_assert(length<metre, double>(1.0).number() == 1.0);
-static_assert(length<metre, double>(1).number() == 1.0);
-static_assert(length<metre, double>(3.14).number() == 3.14);
+static_assert(!std::constructible_from<quantity<dimensionless[percent], short>,
+                                       int>);  // truncating implicit conversions int -> short allowed
+static_assert(!std::convertible_to<int, quantity<dimensionless[percent], short>>);
 
 
 ///////////////////////////////////////
 // construction from another quantity
 ///////////////////////////////////////
 
-// conversion only between equivalent dimensions
-static_assert(std::constructible_from<length<metre>, length<metre>>);
-static_assert(std::convertible_to<length<metre>, length<metre>>);
-static_assert(std::constructible_from<length<centimetre>, cgs::length<cgs::centimetre>>);
-static_assert(std::convertible_to<cgs::length<cgs::centimetre>, length<centimetre>>);
-static_assert(std::constructible_from<fps::length<fps::foot>, cgs::length<cgs::centimetre>>);
-static_assert(std::convertible_to<cgs::length<cgs::centimetre>, fps::length<fps::foot>>);
+// conversion only between convertible quantities
+static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m]>>);
+static_assert(std::convertible_to<quantity<isq::length[m]>, quantity<isq::length[m]>>);
+static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::distance[m]>>);
+static_assert(std::convertible_to<quantity<isq::distance[m]>, quantity<isq::length[m]>>);
+static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km]>>);
+static_assert(std::convertible_to<quantity<isq::length[km]>, quantity<isq::length[m]>>);
 
-// conversion between different dimensions not allowed
-static_assert(!std::constructible_from<length<metre>, isq::si::time<second>>);
-static_assert(!std::convertible_to<isq::si::time<second>, length<metre>>);
-static_assert(!std::constructible_from<length<metre>, speed<metre_per_second>>);
-static_assert(!std::convertible_to<speed<metre_per_second>, length<metre>>);
+// conversion between different quantities not allowed
+static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::time[s]>>);
+static_assert(!std::convertible_to<quantity<isq::time[s]>, quantity<isq::length[m]>>);
+static_assert(!std::constructible_from<quantity<isq::length[m]>, quantity<isq::speed[m / s]>>);
+static_assert(!std::convertible_to<quantity<isq::speed[m / s]>, quantity<isq::length[m]>>);
 
 // implicit conversion from another quantity only if non-truncating
-static_assert(std::constructible_from<length<metre>, length<metre, int>>);  // int -> double OK
-static_assert(std::convertible_to<length<metre, int>, length<metre>>);      // int -> double OK
+static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[m], int>>);  // int -> double OK
+static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[m]>>);      // int -> double OK
 
-static_assert(!std::constructible_from<length<metre, int>, length<metre>>);  // truncating double -> int not allowed
-static_assert(!std::convertible_to<length<metre>, length<metre, int>>);      // truncating double -> int not allowed
+static_assert(!std::constructible_from<quantity<isq::length[m], int>,
+                                       quantity<isq::length[m]>>);  // truncating double -> int not allowed
+static_assert(!std::convertible_to<quantity<isq::length[m]>,
+                                   quantity<isq::length[m], int>>);  // truncating double -> int not allowed
 
-static_assert(std::constructible_from<length<metre, int>, length<kilometre, int>>);  // kilometre<int> -> metre<int> OK
-static_assert(std::convertible_to<length<kilometre, int>, length<metre, int>>);      // kilometre<int> -> metre<int> OK
+static_assert(std::constructible_from<quantity<isq::length[m], int>,
+                                      quantity<isq::length[km], int>>);  // kilometre<int> -> metre<int> OK
+static_assert(std::convertible_to<quantity<isq::length[km], int>,
+                                  quantity<isq::length[m], int>>);  // kilometre<int> -> metre<int> OK
 
-static_assert(!std::constructible_from<length<kilometre, int>,
-                                       length<metre, int>>);  // truncating metre<int> -> kilometre<int> not allowed
-static_assert(!std::convertible_to<length<metre, int>,
-                                   length<kilometre, int>>);  // truncating metre<int> -> kilometre<int> not allowed
+static_assert(!std::constructible_from<quantity<isq::length[km], int>,
+                                       quantity<isq::length[m], int>>);  // truncating metre<int> ->
+                                                                         // kilometre<int> not allowed
+static_assert(
+  !std::convertible_to<quantity<isq::length[m], int>,
+                       quantity<isq::length[km], int>>);  // truncating metre<int> -> kilometre<int> not allowed
 
 // converting to double always OK
-static_assert(std::constructible_from<length<metre>, length<kilometre, int>>);
-static_assert(std::convertible_to<length<kilometre, int>, length<metre>>);
-static_assert(std::constructible_from<length<kilometre>, length<metre, int>>);
-static_assert(std::convertible_to<length<metre, int>, length<kilometre>>);
+static_assert(std::constructible_from<quantity<isq::length[m]>, quantity<isq::length[km], int>>);
+static_assert(std::convertible_to<quantity<isq::length[km], int>, quantity<isq::length[m]>>);
+static_assert(std::constructible_from<quantity<isq::length[km]>, quantity<isq::length[m], int>>);
+static_assert(std::convertible_to<quantity<isq::length[m], int>, quantity<isq::length[km]>>);
+
+
+///////////////////////
+// obtaining a number
+///////////////////////
+
+static_assert(quantity<isq::length[m], int>(123 * m).number() == 123);
+static_assert(quantity<isq::length[m], int>(2 * km).number() == 2000);
+static_assert(quantity<isq::length[km], int>(2 * km).number() == 2);
+static_assert(quantity<isq::length[km]>(1500 * m).number() == 1.5);
+
+
+///////////////////////////////////
+// converting to a different unit
+///////////////////////////////////
+
+static_assert(quantity<isq::length[km]>(2. * km)[km].number() == 2.);
+static_assert(quantity<isq::length[km]>(2. * km)[m].number() == 2000.);
+static_assert(quantity<isq::length[m]>(2000. * m)[km].number() == 2.);
+static_assert(quantity<isq::length[km], int>(2 * km)[km].number() == 2);
+static_assert(quantity<isq::length[km], int>(2 * km)[m].number() == 2000);
+
+#if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
+template<template<auto, typename> typename Q>
+concept invalid_unit_conversion = requires {
+  requires !requires { Q<isq::length[m], int>(2000 * m)[km]; };  // truncating conversion
+  requires !requires { Q<isq::length[m], int>(2 * m)[s]; };      // invalid unit
+};
+static_assert(invalid_unit_conversion<quantity>);
+#endif
+
+static_assert(quantity<isq::length[km]>(2. * km).number_in(km) == 2.);
+static_assert(quantity<isq::length[km]>(2. * km).number_in(m) == 2000.);
+static_assert(quantity<isq::length[m]>(2000. * m).number_in(km) == 2.);
+static_assert(quantity<isq::length[km], int>(2 * km).number_in(km) == 2);
+static_assert(quantity<isq::length[km], int>(2 * km).number_in(m) == 2000);
+
+#if UNITS_COMP_GCC != 10 || UNITS_COMP_GCC_MINOR > 2
+template<template<auto, typename> typename Q>
+concept invalid_getter_with_unit_conversion = requires {
+  requires !requires { Q<isq::length[m], int>(2000 * m).number_in(km); };  // truncating conversion
+  requires !requires { Q<isq::length[m], int>(2 * m).number_in(s); };      // invalid unit
+};
+static_assert(invalid_getter_with_unit_conversion<quantity>);
+#endif
 
-static_assert(length<metre, int>(123_q_m).number() == 123);
-static_assert(length<kilometre, int>(2_q_km).number() == 2);
-static_assert(length<metre, int>(2_q_km).number() == 2000);
-static_assert(length<kilometre>(1500_q_m).number() == 1.5);
 
 ///////////////////////////////////////
 // derived quantities
 ///////////////////////////////////////
 
 template<Representation Rep, Quantity Q, const basic_fixed_string additional_nttp_argument>
-struct derived_quantity : quantity<typename Q::dimension, typename Q::unit, Rep> {
-  using dimension = typename Q::dimension;
-  using unit = typename Q::unit;
+struct derived_quantity : quantity<Q::reference, Rep> {
+  static constexpr auto reference = Q::reference;
+  static constexpr auto quantity_spec = Q::quantity_spec;
+  static constexpr auto dimension = Q::dimension;
+  static constexpr auto unit = Q::unit;
   using rep = Rep;
-  using R = quantity<dimension, unit, Rep>;
+  using R = quantity<reference, Rep>;
 
   derived_quantity() = default;
   constexpr explicit(!std::is_trivial_v<Rep>) derived_quantity(const R& t) : R(t) {}
@@ -272,47 +285,54 @@ struct derived_quantity : quantity<typename Q::dimension, typename Q::unit, Rep>
   constexpr operator const R&&() const&& noexcept { return *this; }
 };
 
-static_assert(detail::is_quantity<derived_quantity<double, si::length<metre>, "NTTP type description">>);
-constexpr isq::Length auto get_length_derived_quantity() noexcept
+static_assert(Quantity<derived_quantity<double, quantity<isq::length[m]>, "NTTP type description">>);
+
+constexpr QuantityOf<isq::length> auto get_length_derived_quantity() noexcept
 {
-  derived_quantity<double, si::length<metre>, "NTTP type description"> dist{};
-  dist += 1_q_m;
-  dist = dist + 1_q_m;
+  derived_quantity<double, quantity<isq::length[m]>, "NTTP type description"> dist{};
+  dist += 1 * m;
+  dist = dist + 1 * m;
   dist *= 0.5;
   return dist;
 }
-static_assert(get_length_derived_quantity() == 1_q_m);
+static_assert(get_length_derived_quantity() == 1 * m);
+
 
 /////////
 // CTAD
 /////////
 
-#if UNITS_COMP_GCC >= 11 || UNITS_COMP_CLANG > 16
-static_assert(std::is_same_v<decltype(aliases::isq::si::m(123))::rep, int>);
-static_assert(std::is_same_v<decltype(aliases::isq::si::m(123.))::rep, double>);
-static_assert(
-  std::is_same_v<decltype(aliases::isq::si::m3(aliases::isq::si::m2{2} * aliases::isq::si::m{3}))::rep, int>);
-#endif
+static_assert(std::is_same_v<decltype(quantity{123 * m})::rep, int>);
+static_assert(std::is_same_v<decltype(quantity{123. * m})::rep, double>);
+static_assert(quantity{123. * m}.unit == si::metre);
+static_assert(quantity{123. * m}.quantity_spec == kind_of<isq::length>);
+static_assert(quantity{123. * h}.unit == si::hour);
+static_assert(quantity{123. * h}.quantity_spec == kind_of<isq::time>);
 
-static_assert(is_same_v<decltype(quantity{length<metre, int>(123)}), length<metre, int>>);
-static_assert(is_same_v<decltype(quantity{speed<metre_per_second>(123)}), speed<metre_per_second>>);
-// static_assert(is_same_v<decltype(length{length<metre, int>(123)}), length<metre, int>>);   // TODO gcc ICE
-static_assert(is_same_v<decltype(quantity{123_q_m}), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(quantity{1}), dimensionless<one, int>>);
-static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
+using namespace std::chrono_literals;
+static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
+static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
+static_assert(quantity{24h}.unit == si::hour);
+static_assert(quantity{24h}.quantity_spec == kind_of<isq::time>);
 
 
 ////////////////////////
 // assignment operator
 ////////////////////////
 
-static_assert([]() {
-  length<metre, int> l1(1), l2(2);
+static_assert([] {
+  auto l1(1 * m), l2(2 * m);
+  return l2 = l1;
+}()
+                .number() == 1);
+static_assert([] {
+  const auto l1(1 * m);
+  auto l2(2 * m);
   return l2 = l1;
 }()
                 .number() == 1);
 static_assert([]() {
-  length<metre, int> l1(1), l2(2);
+  auto l1(1 * m), l2(2 * m);
   return l2 = std::move(l1);
 }()
                 .number() == 1);
@@ -322,27 +342,27 @@ static_assert([]() {
 // unary operators
 ////////////////////
 
-static_assert((+123_q_m).number() == 123);
-static_assert((-123_q_m).number() == -123);
-static_assert((+(-123_q_m)).number() == -123);
-static_assert((-(-123_q_m)).number() == 123);
+static_assert((+123 * m).number() == 123);
+static_assert((-123 * m).number() == -123);
+static_assert((+(-123 * m)).number() == -123);
+static_assert((-(-123 * m)).number() == 123);
 
 static_assert([](auto v) {
   auto vv = v++;
   return std::pair(v, vv);
-}(123_q_m) == std::pair(124_q_m, 123_q_m));
+}(123 * m) == std::pair(124 * m, 123 * m));
 static_assert([](auto v) {
   auto vv = ++v;
   return std::pair(v, vv);
-}(123_q_m) == std::pair(124_q_m, 124_q_m));
+}(123 * m) == std::pair(124 * m, 124 * m));
 static_assert([](auto v) {
   auto vv = v--;
   return std::pair(v, vv);
-}(123_q_m) == std::pair(122_q_m, 123_q_m));
+}(123 * m) == std::pair(122 * m, 123 * m));
 static_assert([](auto v) {
   auto vv = --v;
   return std::pair(v, vv);
-}(123_q_m) == std::pair(122_q_m, 122_q_m));
+}(123 * m) == std::pair(122 * m, 122 * m));
 
 static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
 
@@ -352,32 +372,32 @@ static_assert(is_same_v<decltype((+(short{0} * m)).number()), int&&>);
 ////////////////////////
 
 // same type
-static_assert((1_q_m += 1_q_m).number() == 2);
-static_assert((2_q_m -= 1_q_m).number() == 1);
-static_assert((1_q_m *= 2).number() == 2);
-static_assert((2_q_m /= 2).number() == 1);
-static_assert((7_q_m %= 2).number() == 1);
-static_assert((1_q_m *= quantity(2)).number() == 2);
-static_assert((2_q_m /= quantity(2)).number() == 1);
-static_assert((7_q_m %= quantity(2)).number() == 1);
-static_assert((7_q_m %= 2_q_m).number() == 1);
+static_assert((1 * m += 1 * m).number() == 2);
+static_assert((2 * m -= 1 * m).number() == 1);
+static_assert((1 * m *= 2).number() == 2);
+static_assert((2 * m /= 2).number() == 1);
+static_assert((7 * m %= 2).number() == 1);
+static_assert((1 * m *= 2 * one).number() == 2);
+static_assert((2 * m /= 2 * one).number() == 1);
+static_assert((7 * m %= 2 * one).number() == 1);
+static_assert((7 * m %= 2 * m).number() == 1);
 
 // different types
-static_assert((2.5_q_m += 3_q_m).number() == 5.5);
-static_assert((123_q_m += 1_q_km).number() == 1123);
-static_assert((5.5_q_m -= 3_q_m).number() == 2.5);
-static_assert((1123_q_m -= 1_q_km).number() == 123);
-static_assert((2.5_q_m *= 3).number() == 7.5);
-static_assert((7.5_q_m /= 3).number() == 2.5);
-static_assert((2.5_q_m *= quantity(3)).number() == 7.5);
-static_assert((7.5_q_m /= quantity(3)).number() == 2.5);
-static_assert((3500_q_m %= 1_q_km).number() == 500);
+static_assert((2.5 * m += 3 * m).number() == 5.5);
+static_assert((123 * m += 1 * km).number() == 1123);
+static_assert((5.5 * m -= 3 * m).number() == 2.5);
+static_assert((1123 * m -= 1 * km).number() == 123);
+static_assert((2.5 * m *= 3).number() == 7.5);
+static_assert((7.5 * m /= 3).number() == 2.5);
+static_assert((2.5 * m *= 3 * one).number() == 7.5);
+static_assert((7.5 * m /= 3 * one).number() == 2.5);
+static_assert((3500 * m %= 1 * km).number() == 500);
 
 static_assert((std::uint8_t(255) * m %= 256).number() == [] {
   std::uint8_t ui(255);
   return ui %= 256;
 }());
-static_assert((std::uint8_t(255) * m %= quantity(256)).number() == [] {
+static_assert((std::uint8_t(255) * m %= 256 * one).number() == [] {
   std::uint8_t ui(255);
   return ui %= 256;
 }());
@@ -387,7 +407,7 @@ static_assert((std::uint8_t(255) * m %= 257).number() == [] {
   std::uint8_t ui(255);
   return ui %= 257;
 }());
-static_assert((std::uint8_t(255) * m %= quantity(257)).number() == [] {
+static_assert((std::uint8_t(255) * m %= 257 * one).number() == [] {
   std::uint8_t ui(255);
   return ui %= 257;
 }());
@@ -397,109 +417,124 @@ static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] {
   return ui %= 257;
 }());
 
-#ifndef UNITS_COMP_MSVC  // TODO ICE
-                         // (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
+// TODO ICE
+// (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
+#ifndef UNITS_COMP_MSVC
 // next two lines trigger conversions warnings
 // (warning disabled in CMake for this file)
-static_assert((22_q_m *= 33.33).number() == 733);
-static_assert((22_q_m /= 3.33).number() == 6);
-static_assert((22_q_m *= quantity(33.33)).number() == 733);
-static_assert((22_q_m /= quantity(3.33)).number() == 6);
+static_assert((22 * m *= 33.33).number() == 733);
+static_assert((22 * m /= 3.33).number() == 6);
+static_assert((22 * m *= 33.33 * one).number() == 733);
+static_assert((22 * m /= 3.33 * one).number() == 6);
 #endif
 
-template<typename Metre, typename Kilometre>
-concept invalid_compound_assignments =
-  requires() {
-    // truncating not allowed
-    requires !requires(length<Metre, int> l) { l += 2.5_q_m; };
-    requires !requires(length<Metre, int> l) { l -= 2.5_q_m; };
-    requires !requires(length<Kilometre, int> l) { l += length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l -= length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= length<Metre, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, int>(2); };
-    requires !requires(length<Kilometre, int> l) { l %= dimensionless<percent, double>(2); };
+template<template<auto, typename> typename Q>
+concept invalid_compound_assignments = requires() {
+  // truncating not allowed
+  requires !requires(Q<isq::length[m], int> l) { l += 2.5 * m; };
+  requires !requires(Q<isq::length[m], int> l) { l -= 2.5 * m; };
+  requires !requires(Q<isq::length[km], int> l) { l += 2 * isq::length[m]; };
+  requires !requires(Q<isq::length[km], int> l) { l -= 2 * isq::length[m]; };
+  requires !requires(Q<isq::length[km], int> l) { l %= 2 * isq::length[m]; };
+  requires !requires(Q<isq::length[km], int> l) { l %= 2 * percent; };
+  requires !requires(Q<isq::length[km], int> l) { l %= 2. * percent; };
 
-    // TODO: accept non-truncating argument
-    requires !requires(length<Kilometre, int> l) { l *= 1 * (km / m); };
-    requires !requires(length<Kilometre, int> l) { l /= 1 * (km / m); };
-    requires !requires(length<Kilometre, int> l) { l %= 1 * (km / m); };
+  // TODO: accept non-truncating argument
+  requires !requires(Q<isq::length[km], int> l) { l *= 1 * (km / m); };
+  requires !requires(Q<isq::length[km], int> l) { l /= 1 * (km / m); };
+  requires !requires(Q<isq::length[km], int> l) { l %= 1 * (km / m); };
 
-    // only quantities can be added or subtracted
-    requires !requires(length<Metre, int> l) { l += 2; };
-    requires !requires(length<Metre, int> l) { l -= 2; };
+  // only quantities can be added or subtracted
+  requires !requires(Q<isq::length[m], int> l) { l += 2; };
+  requires !requires(Q<isq::length[m], int> l) { l -= 2; };
 
-    // compound multiply/divide by another quantity not allowed
-    requires !requires(length<Metre, int> l) { l *= 2_q_m; };
-    requires !requires(length<Metre, int> l) { l /= 2_q_m; };
+  // compound multiply/divide by another quantity not allowed
+  requires !requires(Q<isq::length[m], int> l) { l *= 2 * m; };
+  requires !requires(Q<isq::length[m], int> l) { l /= 2 * m; };
 
-    // modulo operations on a floating point representation not allowed
-    requires !requires(length<Metre, double> l) { l %= 2.; };
-    requires !requires(length<Metre, double> l) { l %= 2; };
-    requires !requires(length<Metre, double> l) { l %= 2._q_m; };
-    requires !requires(length<Metre, double> l) { l %= 2_q_m; };
-    requires !requires(length<Metre, int> l) { l %= 2._q_m; };
+  // modulo operations on a floating point representation not allowed
+  requires !requires(Q<isq::length[m], double> l) { l %= 2.; };
+  requires !requires(Q<isq::length[m], double> l) { l %= 2; };
+  requires !requires(Q<isq::length[m], double> l) { l %= 2. * m; };
+  requires !requires(Q<isq::length[m], double> l) { l %= 2 * m; };
+  requires !requires(Q<isq::length[m], int> l) { l %= 2. * m; };
 
-    // no unit constants
-    requires !requires(length<Metre, int> l) { l += m; };
-    requires !requires(length<Metre, int> l) { l -= m; };
-    requires !requires(length<Metre, int> l) { l *= m; };
-    requires !requires(length<Metre, int> l) { l /= m; };
-    requires !requires(length<Metre, int> l) { l %= m; };
-  };
-static_assert(invalid_compound_assignments<metre, kilometre>);
+  // no unit constants
+  requires !requires(Q<isq::length[m], int> l) { l += m; };
+  requires !requires(Q<isq::length[m], int> l) { l -= m; };
+  requires !requires(Q<isq::length[m], int> l) { l *= m; };
+  requires !requires(Q<isq::length[m], int> l) { l /= m; };
+  requires !requires(Q<isq::length[m], int> l) { l %= m; };
+};
+static_assert(invalid_compound_assignments<quantity>);
 
 
 ////////////////////
 // binary operators
 ////////////////////
 
-template<typename Metre>
+template<template<auto, typename> typename Q>
 concept invalid_binary_operations = requires {
-                                      // no crossdimensional addition and subtraction
-                                      requires !requires { 1_q_s + length<Metre, int>(1); };
-                                      requires !requires { 1_q_s - length<Metre, int>(1); };
+  // no crossdimensional addition and subtraction
+  requires !requires { 1 * s + Q<isq::length[m], int>(1 * m); };
+  requires !requires { 1 * s - Q<isq::length[m], int>(1 * m); };
 
-                                      // no floating-point modulo
-                                      requires !requires(length<Metre, double> a) { a % 2_q_m; };
-                                      requires !requires(length<Metre, double> a) { 2_q_m % a; };
-                                      requires !requires(length<Metre, double> a) { a % 2; };
-                                      requires !requires(length<Metre, double> a, length<Metre, double> b) { a % b; };
-                                      requires !requires(length<Metre, double> a, length<Metre, int> b) { a % b; };
-                                      requires !requires(length<Metre, double> a, length<Metre, int> b) { b % a; };
+  // no floating-point modulo
+  requires !requires(Q<isq::length[m], double> a) { a % 2 * m; };
+  requires !requires(Q<isq::length[m], double> a) { 2 * m % a; };
+  requires !requires(Q<isq::length[m], double> a) { a % 2; };
+  requires !requires(Q<isq::length[m], double> a, Q<isq::length[m], double> b) { a % b; };
+  requires !requires(Q<isq::length[m], double> a, Q<isq::length[m], int> b) { a % b; };
+  requires !requires(Q<isq::length[m], double> a, Q<isq::length[m], int> b) { b % a; };
 
-                                      // unit constants
-                                      requires !requires { length<Metre, int>(1) + m; };
-                                      requires !requires { length<Metre, int>(1) - m; };
-                                      requires !requires { length<Metre, int>(1) % m; };
-                                      requires !requires { m + length<Metre, int>(1); };
-                                      requires !requires { m - length<Metre, int>(1); };
-                                      requires !requires { m % length<Metre, int>(1); };
-                                    };
-static_assert(invalid_binary_operations<metre>);
+  // unit constants
+  requires !requires { Q<isq::length[m], int>(1) + m; };
+  requires !requires { Q<isq::length[m], int>(1) - m; };
+  requires !requires { Q<isq::length[m], int>(1) % m; };
+  requires !requires { m + Q<isq::length[m], int>(1); };
+  requires !requires { m - Q<isq::length[m], int>(1); };
+  requires !requires { m % Q<isq::length[m], int>(1); };
+};
+static_assert(invalid_binary_operations<quantity>);
 
 // same representation type
-static_assert(is_same_v<decltype(1_q_m + 1_q_m), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m - 1_q_m), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m * 1), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m * quantity{1}), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1 * 1_q_m), length<metre, std::int64_t>>);
-static_assert(compare<decltype(quantity{1} * 1_q_m), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m / 1), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m / quantity{1}), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m % 1), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m % quantity{1}), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_m % 1_q_m), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, std::int64_t>>);
-static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1_q_m), length<centimetre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m % dimensionless<percent, std::int64_t>(1)), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m * 1_q_m), area<square_metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m / 1_q_m), dimensionless<one, std::int64_t>>);
-static_assert(compare<decltype(1 / 1_q_s), frequency<hertz, std::int64_t>>);
-static_assert(compare<decltype(quantity{1} / 1_q_s), frequency<hertz, std::int64_t>>);
-static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1_q_s),
-                      frequency<scaled_unit<mag<ratio(1, 100)>(), hertz>, std::int64_t>>);
+static_assert(is_of_type<1 * m + 1 * m, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m + 1 * km, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * km + 1 * m, quantity<si::metre, int>>);
 
+static_assert(is_of_type<1 * m - 1 * m, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * km - 1 * m, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m - 1 * km, quantity<si::metre, int>>);
+
+static_assert(is_of_type<1 * N * (1 * m), quantity<derived_unit<struct si::newton, struct si::metre>{}, int>>);
+
+static_assert(is_of_type<1 * m * 1, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m * (1 * one), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m * (1 * percent), quantity<derived_unit<struct percent, struct si::metre>{}, int>>);
+
+static_assert(is_of_type<1 * (1 * m), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * one * (1 * m), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * percent * (1 * m), quantity<derived_unit<struct percent, struct si::metre>{}, int>>);
+
+static_assert(is_of_type<1 * m / (1 * s), quantity<derived_unit<struct si::metre, per<struct si::second>>{}, int>>);
+static_assert(is_of_type<1 * m / (1 * m), quantity<one, int>>);
+static_assert(is_of_type<1 * km / (1 * m), quantity<derived_unit<si::kilo_<si::metre>, per<struct si::metre>>{}, int>>);
+
+static_assert(is_of_type<1 * m / 1, quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m / (1 * one), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * m / (1 * percent), quantity<derived_unit<struct si::metre, per<struct percent>>{}, int>>);
+
+static_assert(is_of_type<1 / (1 * s), quantity<derived_unit<struct one, per<struct si::second>>{}, int>>);
+static_assert(is_of_type<1 * one / (1 * s), quantity<derived_unit<struct one, per<struct si::second>>{}, int>>);
+static_assert(is_of_type<1 * percent / (1 * s), quantity<derived_unit<struct percent, per<struct si::second>>{}, int>>);
+
+static_assert(is_of_type<4 * m % (2 * m), quantity<si::metre, int>>);
+static_assert(is_of_type<1'234 * m % (1 * km), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * km % (300 * m), quantity<si::metre, int>>);
+static_assert(is_of_type<4 * one % (2 * one), quantity<one, int>>);
+static_assert(is_of_type<4 * one % 2, quantity<one, int>>);
+
+// check for integral types promotion
 static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).number()), int&&>);
 static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).number()), int&&>);
 static_assert((std::uint8_t(128) * m + std::uint8_t(128) * m).number() == std::uint8_t(128) + std::uint8_t(128));
@@ -509,399 +544,158 @@ static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m))
                         decltype(std::uint8_t(0) % std::uint8_t(0))&&>);
 
 // different representation types
-static_assert(is_same_v<decltype(1_q_m + 1._q_m), length<metre, long double>>);
-static_assert(is_same_v<decltype(1_q_m - 1._q_m), length<metre, long double>>);
-static_assert(
-  is_same_v<decltype(1_q_m * 1.L), length<metre, long double>>);  // TODO should we address fundamental types implicit
-                                                                  // truncating conversions with concepts?
-static_assert(is_same_v<decltype(1 * 1._q_m), length<metre, long double>>);
-static_assert(compare<decltype(1_q_m * quantity{1.L}),
-                      length<metre, long double>>);  // TODO should we address fundamental types implicit truncating
-                                                     // conversions with concepts?
-static_assert(compare<decltype(quantity{1} * 1._q_m), length<metre, long double>>);
-static_assert(is_same_v<decltype(1_q_m / 1.L), length<metre, long double>>);
-static_assert(compare<decltype(1_q_m / quantity{1.L}), length<metre, long double>>);
-static_assert(compare<decltype(1_q_m * dimensionless<percent, long double>(1)), length<centimetre, long double>>);
-static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) * 1._q_m), length<centimetre, long double>>);
-static_assert(compare<decltype(1_q_m * 1._q_m), area<square_metre, long double>>);
-static_assert(compare<decltype(1_q_m / dimensionless<percent, long double>(1)), length<hectometre, long double>>);
-static_assert(compare<decltype(1_q_m / 1._q_m), dimensionless<one, long double>>);
-static_assert(compare<decltype(1 / 1._q_s), frequency<hertz, long double>>);
-static_assert(compare<decltype(quantity{1} / 1._q_s), frequency<hertz, long double>>);
-static_assert(compare<decltype(dimensionless<percent, std::int64_t>(1) / 1._q_s),
-                      frequency<scaled_unit<mag<ratio(1, 100)>(), hertz>, long double>>);
-static_assert(compare<decltype(1_q_m % short(1)), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m % quantity{short(1)}), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m % dimensionless<percent, short>(1)), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m % length<metre, short>(1)), length<metre, std::int64_t>>);
+static_assert(is_of_type<1. * m + 1 * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m + 1. * km, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * km + 1. * m, quantity<si::metre, double>>);
 
-static_assert(is_same_v<decltype(1._q_m + 1_q_m), length<metre, long double>>);
-static_assert(is_same_v<decltype(1._q_m - 1_q_m), length<metre, long double>>);
-static_assert(is_same_v<decltype(1._q_m * 1), length<metre, long double>>);
-static_assert(is_same_v<decltype(1.L * 1_q_m), length<metre, long double>>);
-static_assert(compare<decltype(1._q_m * quantity{1}), length<metre, long double>>);
-static_assert(compare<decltype(quantity{1.L} * 1_q_m), length<metre, long double>>);
-static_assert(is_same_v<decltype(1._q_m / 1), length<metre, long double>>);
-static_assert(compare<decltype(1._q_m / quantity{1}), length<metre, long double>>);
-static_assert(compare<decltype(1._q_m * dimensionless<percent, std::int64_t>(1)), length<centimetre, long double>>);
-static_assert(compare<decltype(dimensionless<percent, long double>(1) * 1_q_m), length<centimetre, long double>>);
-static_assert(compare<decltype(1._q_m / dimensionless<percent, std::int64_t>(1)), length<hectometre, long double>>);
-static_assert(compare<decltype(1._q_m * 1_q_m), area<square_metre, long double>>);
-static_assert(compare<decltype(1._q_m / 1_q_m), dimensionless<one, long double>>);
-static_assert(compare<decltype(1.L / 1_q_s), frequency<hertz, long double>>);
-static_assert(compare<decltype(quantity{1.L} / 1_q_s), frequency<hertz, long double>>);
-static_assert(compare<decltype(dimensionless<percent, long double>(1) / 1_q_s),
-                      frequency<scaled_unit<mag<ratio(1, 100)>(), hertz>, long double>>);
+static_assert(is_of_type<1 * m - 1. * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * km - 1 * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * m - 1 * km, quantity<si::metre, double>>);
+
+static_assert(is_of_type<1. * N * (1 * m), quantity<derived_unit<struct si::newton, struct si::metre>{}, double>>);
+
+static_assert(is_of_type<1 * m * 1., quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m * (1. * one), quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m * (1. * percent), quantity<derived_unit<struct percent, struct si::metre>{}, double>>);
+
+static_assert(is_of_type<1 * (1. * m), quantity<si::metre, double>>);
+static_assert(is_of_type<1. * one * (1 * m), quantity<si::metre, double>>);
+static_assert(is_of_type<1 * percent * (1. * m), quantity<derived_unit<struct percent, struct si::metre>{}, double>>);
+
+static_assert(is_of_type<1 * m / (1. * s), quantity<derived_unit<struct si::metre, per<struct si::second>>{}, double>>);
+static_assert(is_of_type<1. * m / (1 * m), quantity<one, double>>);
+static_assert(
+  is_of_type<1. * km / (1 * m), quantity<derived_unit<si::kilo_<si::metre>, per<struct si::metre>>{}, double>>);
+
+static_assert(is_of_type<1. * m / 1, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m / (1. * one), quantity<si::metre, double>>);
+static_assert(
+  is_of_type<1 * m / (1. * percent), quantity<derived_unit<struct si::metre, per<struct percent>>{}, double>>);
+
+static_assert(is_of_type<1 / (1. * s), quantity<derived_unit<struct one, per<struct si::second>>{}, double>>);
+static_assert(is_of_type<1. * one / (1 * s), quantity<derived_unit<struct one, per<struct si::second>>{}, double>>);
+static_assert(
+  is_of_type<1 * percent / (1. * s), quantity<derived_unit<struct percent, per<struct si::second>>{}, double>>);
 
 // different units
-static_assert(compare<decltype(1_q_m + 1_q_km), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1._q_m + 1_q_km), length<metre, long double>>);
-static_assert(compare<decltype(1_q_m + 1._q_km), length<metre, long double>>);
-static_assert(compare<decltype(1._q_m + 1._q_km), length<metre, long double>>);
+static_assert(is_of_type<1 * m + 1 * km, quantity<si::metre, int>>);
+static_assert(is_of_type<1. * m + 1 * km, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m + 1. * km, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * m + 1. * km, quantity<si::metre, double>>);
 
-static_assert(compare<decltype(1_q_km + 1_q_m), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1._q_km + 1_q_m), length<metre, long double>>);
-static_assert(compare<decltype(1_q_km + 1._q_m), length<metre, long double>>);
-static_assert(compare<decltype(1._q_km + 1._q_m), length<metre, long double>>);
+static_assert(is_of_type<1 * km + 1 * m, quantity<si::metre, int>>);
+static_assert(is_of_type<1. * km + 1 * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * km + 1. * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * km + 1. * m, quantity<si::metre, double>>);
 
-static_assert(compare<decltype(1_q_m - 1_q_km), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1._q_m - 1_q_km), length<metre, long double>>);
-static_assert(compare<decltype(1_q_m - 1._q_km), length<metre, long double>>);
-static_assert(compare<decltype(1._q_m - 1._q_km), length<metre, long double>>);
+static_assert(is_of_type<1 * m - 1 * km, quantity<si::metre, int>>);
+static_assert(is_of_type<1. * m - 1 * km, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * m - 1. * km, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * m - 1. * km, quantity<si::metre, double>>);
 
-static_assert(compare<decltype(1_q_km - 1_q_m), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1._q_km - 1_q_m), length<metre, long double>>);
-static_assert(compare<decltype(1_q_km - 1._q_m), length<metre, long double>>);
-static_assert(compare<decltype(1._q_km - 1._q_m), length<metre, long double>>);
+static_assert(is_of_type<1 * km - 1 * m, quantity<si::metre, int>>);
+static_assert(is_of_type<1. * km - 1 * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1 * km - 1. * m, quantity<si::metre, double>>);
+static_assert(is_of_type<1. * km - 1. * m, quantity<si::metre, double>>);
 
-static_assert(is_same_v<decltype(1_q_m % 1_q_km), length<metre, std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_km % 1_q_m), length<kilometre, std::int64_t>>);
+static_assert(is_of_type<1 * m % (1 * km), quantity<si::metre, int>>);
 
 // different dimensions
-static_assert(compare<decltype(1_q_m_per_s * 1_q_s), length<metre, std::int64_t>>);
-static_assert(compare<decltype(1_q_m_per_s * 1_q_h), length<scaled_unit<mag<3600>(), metre>, std::int64_t>>);
-static_assert(
-  compare<decltype(1_q_m * 1_q_min),
-          quantity<unknown_dimension<exponent<dim_length, 1>, exponent<dim_time, 1>>,
-                   scaled_unit<mag<60>(), unknown_coherent_unit<exponent<dim_length, 1>, exponent<dim_time, 1>>>,
-                   std::int64_t>>);
-static_assert(compare<decltype(1_q_s * 1_q_Hz), dimensionless<one, std::int64_t>>);
-static_assert(compare<decltype(1 / 1_q_min), frequency<scaled_unit<mag<ratio(1, 60)>(), hertz>, std::int64_t>>);
-static_assert(compare<decltype(1 / 1_q_Hz), isq::si::time<second, std::int64_t>>);
-static_assert(
-  compare<decltype(1 / 1_q_km),
-          quantity<unknown_dimension<exponent<dim_length, -1>>,
-                   scaled_unit<mag<ratio(1, 1000)>(), unknown_coherent_unit<exponent<dim_length, -1>>>, std::int64_t>>);
-static_assert(compare<decltype(1_q_km / 1_q_m), dimensionless<scaled_unit<mag<1000>(), one>, std::int64_t>>);
-static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int64_t>>);
-static_assert(
-  compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<mag<ratio(1, 60)>(), metre_per_second>, std::int64_t>>);
-static_assert(
-  compare<decltype(1_q_min / 1_q_m),
-          quantity<unknown_dimension<exponent<dim_length, -1>, exponent<dim_time, 1>>,
-                   scaled_unit<mag<60>(), unknown_coherent_unit<exponent<dim_length, -1>, exponent<dim_time, 1>>>,
-                   std::int64_t>>);
+static_assert(is_of_type<1 * (m / s) * (1 * s), quantity<si::metre, int>>);
+static_assert(is_of_type<1 * (m / s) * (1 * h),
+                         quantity<derived_unit<struct si::hour, struct si::metre, per<struct si::second>>{}, int>>);
+static_assert(is_of_type<1 * m * (1 * min), quantity<derived_unit<struct si::metre, struct si::minute>{}, int>>);
+static_assert(is_of_type<1 * s * (1 * Hz), quantity<derived_unit<struct si::hertz, struct si::second>{}, int>>);
+static_assert(is_of_type<1 / (1 * min), quantity<derived_unit<struct one, per<struct si::minute>>{}, int>>);
+static_assert(is_of_type<1 / (1 * Hz), quantity<derived_unit<struct one, per<struct si::hertz>>{}, int>>);
+static_assert(is_of_type<1 / (1 * km), quantity<derived_unit<struct one, per<si::kilo_<si::metre>>>{}, int>>);
+static_assert(is_of_type<1 * km / (1 * m), quantity<derived_unit<si::kilo_<si::metre>, per<struct si::metre>>{}, int>>);
+static_assert(is_of_type<1 * m / (1 * s), quantity<derived_unit<struct si::metre, per<struct si::second>>{}, int>>);
+static_assert(is_of_type<1 * m / (1 * min), quantity<derived_unit<struct si::metre, per<struct si::minute>>{}, int>>);
+static_assert(is_of_type<1 * min / (1 * m), quantity<derived_unit<struct si::minute, per<struct si::metre>>{}, int>>);
 
-static_assert((1_q_m + 1_q_m).number() == 2);
-static_assert((1_q_m + 1_q_km).number() == 1001);
-static_assert((1_q_km + 1_q_m).number() == 1001);
-static_assert((2_q_m - 1_q_m).number() == 1);
-static_assert((1_q_km - 1_q_m).number() == 999);
-static_assert((2_q_m * 2).number() == 4);
-static_assert((2_q_m * quantity{2}).number() == 4);
-static_assert((2_q_m * dimensionless<percent, int>(2)).number() == 4);
-static_assert((3 * 3_q_m).number() == 9);
-static_assert((quantity{3} * 3_q_m).number() == 9);
-static_assert((dimensionless<percent, int>(3) * 3_q_m).number() == 9);
-static_assert((4_q_m / 2).number() == 2);
-static_assert((4_q_m / quantity{2}).number() == 2);
-static_assert((4_q_m / dimensionless<percent, int>(2)).number() == 2);
-static_assert((4_q_km / 2_q_m).number() == 2);
-static_assert((4000_q_m / 2_q_m).number() == 2000);
+static_assert((1 * m + 1 * m).number() == 2);
+static_assert((1 * m + 1 * km).number() == 1001);
+static_assert((1 * km + 1 * m).number() == 1001);
+static_assert((2 * m - 1 * m).number() == 1);
+static_assert((1 * km - 1 * m).number() == 999);
+static_assert((2 * m * 2).number() == 4);
+static_assert((2 * m * (2 * one)).number() == 4);
+static_assert((2 * m * (2 * percent)).number() == 4);
+static_assert((3 * 3 * m).number() == 9);
+static_assert(((3 * one) * (3 * m)).number() == 9);
+static_assert(((3 * percent) * (3 * m)).number() == 9);
+static_assert((4 * m / 2).number() == 2);
+static_assert((4 * m / (2 * one)).number() == 2);
+static_assert((4 * m / (2 * percent)).number() == 2);
+static_assert((4 * km / (2 * m)).number() == 2);
+static_assert((4000 * m / (2 * m)).number() == 2000);
 
-static_assert((1.5_q_m + 1_q_m).number() == 2.5);
-static_assert((1.5_q_m + 1_q_km).number() == 1001.5);
-static_assert((1.5_q_km + 1_q_m).number() == 1501);
-static_assert((2.5_q_m - 1_q_m).number() == 1.5);
-static_assert((1.5_q_km - 1_q_m).number() == 1499);
-static_assert((2.5_q_m * 2).number() == 5);
-static_assert((2.5_q_m * quantity{2}).number() == 5);
-static_assert((2.5_q_m * dimensionless<percent, int>(2)).number() == 5);
-static_assert((2.5L * 2_q_m).number() == 5);
-static_assert((quantity{2.5L} * 2_q_m).number() == 5);
-static_assert((dimensionless<percent, long double>(2.5L) * 2_q_m).number() == 5);
-static_assert((5._q_m / 2).number() == 2.5);
-static_assert((5._q_m / quantity{2}).number() == 2.5);
-static_assert((5._q_m / dimensionless<percent, int>(2)).number() == 2.5);
-static_assert((5._q_km / 2_q_m).number() == 2.5);
-static_assert((5000._q_m / 2_q_m).number() == 2500);
+static_assert((1.5 * m + 1 * m).number() == 2.5);
+static_assert((1.5 * m + 1 * km).number() == 1001.5);
+static_assert((1.5 * km + 1 * m).number() == 1501);
+static_assert((2.5 * m - 1 * m).number() == 1.5);
+static_assert((1.5 * km - 1 * m).number() == 1499);
+static_assert((2.5 * m * 2).number() == 5);
+static_assert((2.5 * m * (2 * one)).number() == 5);
+static_assert((2.5 * m * (2 * percent)).number() == 5);
+static_assert((2.5L * (2 * m)).number() == 5);
+static_assert((2.5L * one * (2 * m)).number() == 5);
+static_assert((2.5L * percent * (2 * m)).number() == 5);
+static_assert((5. * m / 2).number() == 2.5);
+static_assert((5. * m / (2 * one)).number() == 2.5);
+static_assert((5. * m / (2 * percent)).number() == 2.5);
+static_assert((5. * km / (2 * m)).number() == 2.5);
+static_assert((5000. * m / (2 * m)).number() == 2500);
 
-static_assert((1_q_m + 1.5_q_m).number() == 2.5);
-static_assert((1_q_m + 1.5_q_km).number() == 1501);
-static_assert((1_q_km + 1.5_q_m).number() == 1001.5);
-static_assert((2_q_m - 1.5_q_m).number() == 0.5);
-static_assert((1_q_km - 1.5_q_m).number() == 998.5);
-static_assert((2_q_m * 2.5L).number() == 5);
-static_assert((2_q_m * quantity{2.5L}).number() == 5);
-static_assert((2_q_m * dimensionless<percent, long double>(2.5L)).number() == 5);
-static_assert((2 * 2.5_q_m).number() == 5);
-static_assert((quantity{2} * 2.5_q_m).number() == 5);
-static_assert((dimensionless<percent, int>(2) * 2.5_q_m).number() == 5);
-static_assert((5_q_m / 2.5L).number() == 2);
-static_assert((5_q_m / quantity{2.5L}).number() == 2);
-static_assert((5_q_m / dimensionless<percent, long double>(2.5L)).number() == 2);
-static_assert((5_q_km / 2.5_q_m).number() == 2);
-static_assert((5000_q_m / 2.5_q_m).number() == 2000);
+static_assert((1 * m + 1.5 * m).number() == 2.5);
+static_assert((1 * m + 1.5 * km).number() == 1501);
+static_assert((1 * km + 1.5 * m).number() == 1001.5);
+static_assert((2 * m - 1.5 * m).number() == 0.5);
+static_assert((1 * km - 1.5 * m).number() == 998.5);
+static_assert((2 * m * 2.5L).number() == 5);
+static_assert((2 * m * (2.5L * one)).number() == 5);
+static_assert((2 * m * (2.5L * percent)).number() == 5);
+static_assert((2 * 2.5 * m).number() == 5);
+static_assert((2 * one * (2.5 * m)).number() == 5);
+static_assert((2 * percent * (2.5 * m)).number() == 5);
+static_assert((5 * m / 2.5L).number() == 2);
+static_assert((5 * m / (2.5L * one)).number() == 2);
+static_assert((5 * m / (2.5L * percent)).number() == 2);
+static_assert((5 * km / (2.5 * m)).number() == 2);
+static_assert((5000 * m / (2.5 * m)).number() == 2000);
 
-static_assert((7_q_m % 2).number() == 1);
-static_assert((7_q_m % quantity{2}).number() == 1);
-static_assert((7_q_m % dimensionless<percent, int>(2)).number() == 1);
-static_assert((7_q_m % 2_q_m).number() == 1);
-static_assert((7_q_km % 2000_q_m).number() == 7);
+static_assert((7 * m % (2 * m)).number() == 1);
+static_assert((7 * km % (2000 * m)).number() == 1000);
+static_assert((1300 * m % (1 * km)).number() == 300);
+static_assert((7 * one % (2 * one)).number() == 1);
+static_assert((7 * one % 2).number() == 1);
 
-static_assert((10_q_km2 * 10_q_km2) / 50_q_km2 == 2_q_km2);
-
-static_assert((10_q_km / 5_q_m).number() == 2);
-static_assert(dimensionless<one>(10_q_km / 5_q_m).number() == 2000);
-
-#if UNITS_DOWNCAST_MODE == 0
-static_assert(quantity_cast<dim_one, one>(10_q_km / 5_q_m).number() == 2000);
-#else
-static_assert(quantity_cast<one>(10_q_km / 5_q_m).number() == 2000);
-#endif
-
-static_assert((10_q_s * 2_q_kHz).number() == 20);
-
-// quantity references
-static_assert(2_q_m * (1 * m) == (2_q_m2));
-static_assert(2_q_m2 / (1 * m) == (2_q_m));
+static_assert((10 * m2 * (10 * m2)) / (50 * m2) == 2 * m2);
 
+static_assert((10 * km / (5 * m)).number() == 2);
+static_assert((10 * km / (5 * m))[one].number() == 2000);
+static_assert((10 * s * (2 * kHz)).number() == 20);
 
 // dimensionless
 
-static_assert((quantity{3} *= quantity{2}) == 6);
-static_assert((quantity{6} /= quantity{2}) == 3);
-static_assert(quantity{1} + quantity{1} == 2);
-static_assert(1 + quantity{1} == 2);
-static_assert(quantity{1} + 1 == 2);
-static_assert(quantity{2} - quantity{1} == 1);
-static_assert(2 - quantity{1} == 1);
-static_assert(quantity{2} - 1 == 1);
-static_assert(quantity{2} * quantity{2} == 4);
-static_assert(2 * quantity{2} == 4);
-static_assert(quantity{2} * 2 == 4);
-static_assert(quantity{4} / quantity{2} == 2);
-static_assert(4 / quantity{2} == 2);
-static_assert(quantity{4} / 2 == 2);
-static_assert(quantity{4} % quantity{2} == 0);
-static_assert(4 % quantity{2} == 0);
-static_assert(quantity{4} % 2 == 0);
-
-static_assert(is_same_v<decltype(quantity(0) + 0.0), decltype(quantity(0.0))>);
-static_assert(is_same_v<decltype(quantity(0) - 0.0), decltype(quantity(0.0))>);
-static_assert(is_same_v<decltype(0.0 + quantity(0)), decltype(quantity(0.0))>);
-static_assert(is_same_v<decltype(0.0 + quantity(0)), decltype(quantity(0.0))>);
-static_assert(quantity(1) + 2.3 == quantity(1 + 2.3));
-static_assert(quantity(1) - 2.3 == quantity(1 - 2.3));
-static_assert(1.2 + quantity(3) == quantity(1.2 + 3));
-static_assert(1.2 - quantity(3) == quantity(1.2 - 3));
-
-static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} + quantity{std::uint8_t(0)}).number()), int&&>);
-static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} - quantity{std::uint8_t(0)}).number()), int&&>);
-static_assert((quantity{std::uint8_t(128)} + quantity{std::uint8_t(128)}).number() ==
-              std::uint8_t(128) + std::uint8_t(128));
-static_assert((quantity{std::uint8_t(0)} - quantity{std::uint8_t(1)}).number() == std::uint8_t(0) - std::uint8_t(1));
-
-static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} % quantity{std::uint8_t(0)}).number()),
-                        decltype(std::uint8_t(0) % std::uint8_t(0))&&>);
-
-static_assert(quantity{2} * (1 * m) == 2_q_m);
-static_assert(quantity{2} / (1 * m) == 2 / 1_q_m);
-
-
-///////////////////////
-// equality operators
-///////////////////////
-
-template<typename Metre>
-concept no_crossdimensional_equality = requires {
-                                         requires !requires { 1_q_s == length<Metre, int>(1); };
-                                         requires !requires { 1_q_s != length<Metre, int>(1); };
-                                       };
-static_assert(no_crossdimensional_equality<metre>);
-
-// same type
-static_assert(length<metre, int>(123) == length<metre, int>(123));
-static_assert(length<metre, int>(321) != length<metre, int>(123));
-static_assert(!(length<metre, int>(123) == length<metre, int>(321)));
-static_assert(!(length<metre, int>(123) != length<metre, int>(123)));
-
-// different types
-static_assert(length<metre, double>(123) == length<metre, int>(123));
-static_assert(length<metre, double>(321) != length<metre, int>(123));
-static_assert(!(length<metre, double>(123) == length<metre, int>(321)));
-static_assert(!(length<metre, double>(123) != length<metre, int>(123)));
-
-static_assert(length<kilometre, int>(123) == length<metre, int>(123000));
-static_assert(length<kilometre, int>(321) != length<metre, int>(123000));
-static_assert(!(length<kilometre, int>(123) == length<metre, int>(321000)));
-static_assert(!(length<kilometre, int>(123) != length<metre, int>(123000)));
-
-// dimensionless
-
-static_assert(quantity{123} == 123);
-static_assert(quantity{321} != 123);
-static_assert(123 == quantity{123});
-static_assert(123 != quantity{321});
-
-
-///////////////////////
-// ordering operators
-///////////////////////
-
-template<typename Metre>
-concept no_crossdimensional_ordering = requires {
-                                         requires !requires { 1_q_s < length<Metre, int>(1); };
-                                         requires !requires { 1_q_s > length<Metre, int>(1); };
-                                         requires !requires { 1_q_s <= length<Metre, int>(1); };
-                                         requires !requires { 1_q_s >= length<Metre, int>(1); };
-                                       };
-static_assert(no_crossdimensional_ordering<metre>);
-
-// same type
-static_assert(length<metre, int>(123) < length<metre, int>(321));
-static_assert(length<metre, int>(123) <= length<metre, int>(123));
-static_assert(length<metre, int>(123) <= length<metre, int>(321));
-static_assert(length<metre, int>(321) > length<metre, int>(123));
-static_assert(length<metre, int>(123) >= length<metre, int>(123));
-static_assert(length<metre, int>(321) >= length<metre, int>(123));
-static_assert(!(length<metre, int>(321) < length<metre, int>(123)));
-static_assert(!(length<metre, int>(123) < length<metre, int>(123)));
-static_assert(!(length<metre, int>(321) <= length<metre, int>(123)));
-static_assert(!(length<metre, int>(123) > length<metre, int>(321)));
-static_assert(!(length<metre, int>(123) > length<metre, int>(123)));
-static_assert(!(length<metre, int>(123) >= length<metre, int>(321)));
-
-// different types
-static_assert(length<metre, double>(123) < length<metre, int>(321));
-static_assert(length<metre, double>(123) <= length<metre, int>(123));
-static_assert(length<metre, double>(123) <= length<metre, int>(321));
-static_assert(length<metre, double>(321) > length<metre, int>(123));
-static_assert(length<metre, double>(123) >= length<metre, int>(123));
-static_assert(length<metre, double>(321) >= length<metre, int>(123));
-static_assert(!(length<metre, double>(321) < length<metre, int>(123)));
-static_assert(!(length<metre, double>(123) < length<metre, int>(123)));
-static_assert(!(length<metre, double>(321) <= length<metre, int>(123)));
-static_assert(!(length<metre, double>(123) > length<metre, int>(321)));
-static_assert(!(length<metre, double>(123) > length<metre, int>(123)));
-static_assert(!(length<metre, double>(123) >= length<metre, int>(321)));
-
-static_assert(length<kilometre, int>(123) < length<metre, int>(321000));
-static_assert(length<kilometre, int>(123) <= length<metre, int>(123000));
-static_assert(length<kilometre, int>(123) <= length<metre, int>(321000));
-static_assert(length<kilometre, int>(321) > length<metre, int>(123000));
-static_assert(length<kilometre, int>(123) >= length<metre, int>(123000));
-static_assert(length<kilometre, int>(321) >= length<metre, int>(123000));
-static_assert(!(length<kilometre, int>(321) < length<metre, int>(123000)));
-static_assert(!(length<kilometre, int>(123) < length<metre, int>(123000)));
-static_assert(!(length<kilometre, int>(321) <= length<metre, int>(123000)));
-static_assert(!(length<kilometre, int>(123) > length<metre, int>(321000)));
-static_assert(!(length<kilometre, int>(123) > length<metre, int>(123000)));
-static_assert(!(length<kilometre, int>(123) >= length<metre, int>(321000)));
-
-// dimensionless
-
-static_assert(quantity{123} < 321);
-static_assert(quantity{123} <= 123);
-static_assert(quantity{123} <= 321);
-static_assert(quantity{321} > 123);
-static_assert(quantity{123} >= 123);
-static_assert(quantity{321} >= 123);
-
-static_assert(123 < quantity{321});
-static_assert(123 <= quantity{123});
-static_assert(123 <= quantity{321});
-static_assert(321 > quantity{123});
-static_assert(123 >= quantity{123});
-static_assert(321 >= quantity{123});
-
-
-//////////////////
-// dimensionless
-//////////////////
-
-static_assert(std::equality_comparable_with<dimensionless<one>, int>);
-static_assert(std::equality_comparable_with<dimensionless<one>, double>);
-static_assert(std::equality_comparable_with<dimensionless<one, int>, int>);
-static_assert(!std::equality_comparable_with<dimensionless<one, int>, double>);
-
-template<typename Int>
-concept invalid_dimensionless_operations = requires {
-                                             requires !requires(dimensionless<percent, Int> d) { 1 + d; };
-                                             requires !requires(dimensionless<percent, Int> d) { d + 1; };
-                                           };
-static_assert(invalid_dimensionless_operations<int>);
-
-static_assert(compare<decltype(10_q_km / 5_q_km), quantity<dim_one, one, std::int64_t>>);
-
-#if UNITS_DOWNCAST_MODE == 0
-static_assert(quantity_cast<dim_one, percent>(50._q_m / 100._q_m).number() == 50);
-#else
-static_assert(quantity_cast<percent>(50._q_m / 100._q_m).number() == 50);
-#endif
-static_assert(50._q_m / 100._q_m == dimensionless<percent>(50));
-
-static_assert(dimensionless<one>(dimensionless<percent>(50)).number() == 0.5);
-
-
-////////////////
-// alias units
-////////////////
-
-static_assert(compare<decltype(2_q_l + 2_q_ml), volume<cubic_centimetre, std::int64_t>>);
-static_assert(2_q_l + 2_q_ml == 2002_q_cm3);
-static_assert(2_q_l + 2_q_ml == 2002_q_ml);
-static_assert(2_q_l + 2_q_cm3 == 2002_q_ml);
-static_assert(2_q_dm3 + 2_q_cm3 == 2002_q_ml);
-
-
-//////////////////
-// quantity_cast
-//////////////////
-
-static_assert(quantity_cast<length<metre, int>>(2_q_km).number() == 2000);
-static_assert(quantity_cast<length<kilometre, int>>(2000_q_m).number() == 2);
-static_assert(quantity_cast<length<metre, int>>(1.23_q_m).number() == 1);
-static_assert(quantity_cast<metre>(2_q_km).number() == 2000);
-static_assert(quantity_cast<kilometre>(2000_q_m).number() == 2);
-static_assert(quantity_cast<int>(1.23_q_m).number() == 1);
-static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q_s).number() == 2);
-
-static_assert(quantity_cast<dim_length>(1 * cgs_cm) == 1 * cm);
-
-static_assert(is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<litre, std::int64_t>>);
-static_assert(!is_same_v<decltype(quantity_cast<litre>(2_q_dm3)), volume<cubic_decimetre, std::int64_t>>);
-
-////////////////
-// downcasting
-////////////////
-
-#if UNITS_DOWNCAST_MODE == 0
-
-static_assert(
-  is_same_v<decltype(10_q_m / 5_q_s),
-            quantity<unknown_dimension<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>,
-                     scaled_unit<mag<1>(),
-                                 unknown_coherent_unit<units::exponent<dim_length, 1>, units::exponent<dim_time, -1>>>,
-                     std::int64_t>>);
-static_assert(is_same_v<decltype(1_q_mm + 1_q_km), length<scaled_unit<mag<ratio(1, 1000)>(), metre>, std::int64_t>>);
-
-#else
-
-static_assert(compare<decltype(10_q_m / 5_q_s), speed<metre_per_second, std::int64_t>>);
-static_assert(compare<decltype(1_q_mm + 1_q_km), length<millimetre, std::int64_t>>);
-
-#endif
+static_assert((3 * one *= 2 * one) == 6);
+static_assert((6 * one /= 2 * one) == 3);
+static_assert(1 * one + 1 * one == 2);
+static_assert(1 + 1 * one == 2);
+static_assert(1 * one + 1 == 2);
+static_assert(2 * one - 1 * one == 1);
+static_assert(2 - 1 * one == 1);
+static_assert(2 * one - 1 == 1);
+static_assert(2 * one * (2 * one) == 4);
+static_assert(2 * (2 * one) == 4);
+static_assert(2 * one * 2 == 4);
+static_assert(4 * one / (2 * one) == 2);
+static_assert(4 / (2 * one) == 2);
+static_assert(4 * one / 2 == 2);
+static_assert(4 * one % (2 * one) == 0);
+static_assert(4 % (2 * one) == 0);
+static_assert(4 % (2 * one) == 0);
 
 // modulo arithmetics
 
@@ -913,18 +707,195 @@ constexpr auto quotient_remainder_theorem(auto q1, auto q2)
   return q;
 }
 
-static_assert(comp(quotient_remainder_theorem(3'000 * m, 400 * m), 3'000 * m));
-static_assert(comp(quotient_remainder_theorem(3 * km, 400 * m), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, 2 * m), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, 400'000 * mm), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, 2'000 * mm), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, 400 * mm), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, 2 * mm), 3 * km));
-static_assert(same(quotient_remainder_theorem(3'000 * m, 400), 3'000 * m));
-static_assert(comp(quotient_remainder_theorem(3'000 * m, quantity(400)), 3'000 * m));
-static_assert(comp(quotient_remainder_theorem(3 * km, quantity(400)), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, quantity(2)), 3 * km));
-static_assert(comp(quotient_remainder_theorem(3 * km, dimensionless<scaled_unit<mag<ratio(1, 1000)>(), one>, int>(400)),
-                   3 * km));
+static_assert(quotient_remainder_theorem(3'000 * m, 400 * m) == 3'000 * m);
+// static_assert(quotient_remainder_theorem(3 * km, 400 * m) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 2 * m) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 400'000 * mm) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 2'000 * mm) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 400 * mm) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 2 * mm) == 3 * km);
+// static_assert(quotient_remainder_theorem(3'000 * m, 400) == 3'000 * m);
+// static_assert(quotient_remainder_theorem(3'000 * m, 400 * one) == 3'000 * m);
+// static_assert(quotient_remainder_theorem(3 * km, 400 * one) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 2 * one) == 3 * km);
+// static_assert(quotient_remainder_theorem(3 * km, 400 * (mag<ratio{1, 1000}> * one)) == 3 * km);
+
+static_assert((7 * m / (3 * m)) * (3 * m) + (7 * m) % (3 * m) == 7 * m);
+static_assert((7 * m / 3) * 3 + (7 * m) % 3 == 7 * m);
+static_assert((7 * m / (3 * one)) * (3 * one) + (7 * m) % (3 * one) == 7 * m);
+static_assert((7 / (3 * one)) * (3 * one) + 7 % (3 * one) == 7);
+
+// static_assert((7 * km / (2500 * m)) * (2500 * m) + (7 * km) % (2500 * m) == 7 * km);
+// static_assert((7500 * m / (3 * km)) * (3 * km) + (75000 * m) % (3 * km) == 7500 * m);
+
+static_assert(is_same_v<decltype(0 * one + 0.0), decltype(0.0 * one)>);
+static_assert(is_same_v<decltype(0 * one - 0.0), decltype(0.0 * one)>);
+static_assert(is_same_v<decltype(0.0 + 0 * one), decltype(0.0 * one)>);
+static_assert(is_same_v<decltype(0.0 + 0 * one), decltype(0.0 * one)>);
+static_assert(1 * one + 2.3 == (1 + 2.3) * one);
+static_assert(1 * one - 2.3 == (1 - 2.3) * one);
+static_assert(1.2 + 3 * one == (1.2 + 3) * one);
+static_assert(1.2 - 3 * one == (1.2 - 3) * one);
+
+static_assert(1 - 30 * percent == (100 - 30) * percent);
+static_assert(1 + 30 * percent == (100 + 30) * percent);
+
+static_assert(is_same_v<decltype((std::uint8_t(0) * one + std::uint8_t(0) * one).number()), int&&>);
+static_assert(is_same_v<decltype((std::uint8_t(0) * one - std::uint8_t(0) * one).number()), int&&>);
+static_assert((std::uint8_t(128) * one + std::uint8_t(128) * one).number() == std::uint8_t(128) + std::uint8_t(128));
+static_assert((std::uint8_t(0) * one - std::uint8_t(1) * one).number() == std::uint8_t(0) - std::uint8_t(1));
+
+static_assert(is_same_v<decltype((std::uint8_t(0) * one % (std::uint8_t(0) * one)).number()),
+                        decltype(std::uint8_t(0) % std::uint8_t(0))&&>);
+
+static_assert(2 * one * (1 * m) == 2 * m);
+static_assert(2 * one / (1 * m) == 2 / (1 * m));
+
+
+///////////////////////
+// equality operators
+///////////////////////
+
+static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre>>);
+static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::metre, int>>);
+static_assert(std::equality_comparable_with<quantity<si::metre>, quantity<si::kilo<si::metre>, int>>);
+static_assert(std::equality_comparable_with<quantity<si::metre, int>, quantity<si::kilo<si::metre>, int>>);
+static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre>>);
+static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::metre, int>>);
+static_assert(std::equality_comparable_with<quantity<isq::length[si::metre]>, quantity<si::kilo<si::metre>, int>>);
+static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre>>);
+static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::metre, int>>);
+static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<si::kilo<si::metre>, int>>);
+static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre]>>);
+static_assert(std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::metre], int>>);
+static_assert(
+  std::equality_comparable_with<quantity<isq::width[si::metre]>, quantity<isq::height[si::kilo<si::metre>], int>>);
+
+template<auto M>
+concept no_crossdimensional_equality = requires {
+  requires !requires { 1 * s == 1 * M; };
+  requires !requires { 1 * s != 1 * M; };
+};
+static_assert(no_crossdimensional_equality<si::metre>);
+
+// same type
+static_assert(123 * m == 123 * m);
+static_assert(321 * m != 123 * m);
+static_assert(!(123 * m == 321 * m));
+static_assert(!(123 * m != 123 * m));
+
+// different types
+static_assert(123. * m == 123 * m);
+static_assert(321. * m != 123 * m);
+static_assert(!(123. * m == 321 * m));
+static_assert(!(123. * m != 123 * m));
+
+static_assert(123 * km == 123000 * m);
+static_assert(321 * km != 123000 * m);
+static_assert(!(123 * km == 321000 * m));
+static_assert(!(123 * km != 123000 * m));
+
+// dimensionless
+static_assert(std::equality_comparable_with<quantity<dimensionless[one]>, double>);
+static_assert(std::equality_comparable_with<quantity<dimensionless[one]>, int>);
+static_assert(std::equality_comparable_with<quantity<dimensionless[one], int>, int>);
+static_assert(std::equality_comparable_with<quantity<dimensionless[one], int>, double>);
+
+static_assert(123 * one == 123);
+static_assert(321 * one != 123);
+static_assert(123 == 123 * one);
+static_assert(123 != 321 * one);
+
+
+///////////////////////
+// ordering operators
+///////////////////////
+
+template<auto M>
+concept no_crossdimensional_ordering = requires {
+  requires !requires { 1 * s < 1 * M; };
+  requires !requires { 1 * s > 1 * M; };
+  requires !requires { 1 * s <= 1 * M; };
+  requires !requires { 1 * s >= 1 * M; };
+};
+static_assert(no_crossdimensional_ordering<si::metre>);
+
+// same type
+static_assert(123 * m < 321 * m);
+static_assert(123 * m <= 123 * m);
+static_assert(123 * m <= 321 * m);
+static_assert(321 * m > 123 * m);
+static_assert(123 * m >= 123 * m);
+static_assert(321 * m >= 123 * m);
+static_assert(!(321 * m < 123 * m));
+static_assert(!(123 * m < 123 * m));
+static_assert(!(321 * m <= 123 * m));
+static_assert(!(123 * m > 321 * m));
+static_assert(!(123 * m > 123 * m));
+static_assert(!(123 * m >= 321 * m));
+
+// different types
+static_assert(123. * m < 321 * m);
+static_assert(123. * m <= 123 * m);
+static_assert(123. * m <= 321 * m);
+static_assert(321. * m > 123 * m);
+static_assert(123. * m >= 123 * m);
+static_assert(321. * m >= 123 * m);
+static_assert(!(321. * m < 123 * m));
+static_assert(!(123. * m < 123 * m));
+static_assert(!(321. * m <= 123 * m));
+static_assert(!(123. * m > 321 * m));
+static_assert(!(123. * m > 123 * m));
+static_assert(!(123. * m >= 321 * m));
+
+static_assert(123 * km < 321000 * m);
+static_assert(123 * km <= 123000 * m);
+static_assert(123 * km <= 321000 * m);
+static_assert(321 * km > 123000 * m);
+static_assert(123 * km >= 123000 * m);
+static_assert(321 * km >= 123000 * m);
+static_assert(!(321 * km < 123000 * m));
+static_assert(!(123 * km < 123000 * m));
+static_assert(!(321 * km <= 123000 * m));
+static_assert(!(123 * km > 321000 * m));
+static_assert(!(123 * km > 123000 * m));
+static_assert(!(123 * km >= 321000 * m));
+
+// dimensionless
+static_assert(123 * one < 321);
+static_assert(123 * one <= 123);
+static_assert(123 * one <= 321);
+static_assert(321 * one > 123);
+static_assert(123 * one >= 123);
+static_assert(321 * one >= 123);
+
+static_assert(123 < 321 * one);
+static_assert(123 <= 123 * one);
+static_assert(123 <= 321 * one);
+static_assert(321 > 123 * one);
+static_assert(123 >= 123 * one);
+static_assert(321 >= 123 * one);
+
+
+//////////////////
+// dimensionless
+//////////////////
+
+static_assert(is_of_type<10 * km / (5 * km), quantity<one, int>>);
+
+static_assert((50. * m / (100. * m))[percent].number() == 50);
+static_assert(50. * m / (100. * m) == 50 * percent);
+
+static_assert(((50. * percent)[one]).number() == 0.5);
+
+
+//////////////////
+// value_cast
+//////////////////
+
+static_assert(value_cast<m>(2 * km).number() == 2000);
+static_assert(value_cast<km>(2000 * m).number() == 2);
+static_assert(value_cast<int>(1.23 * m).number() == 1);
+static_assert(value_cast<km / h>(2000.0 * m / (3600.0 * s)).number() == 2);
 
 }  // namespace