diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 34c955aa..340caf7c 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -4,6 +4,7 @@
   - (!) refactor: `ScalableNumber` renamed to `QuantityValue`
   - (!) refactor: output stream operators moved to the `units/quantity_io.h` header file
   - (!) refactor: Refactored the library file tree
+  - (!) refactor: `quantity::count()` renamed to `quantity::number()`
   - refactor: quantity (kind) point updated to reflect latest changes to `quantity`
   - refactor: basic concepts, `quantity` and `quantity_cast` refactored
   - refactor: `abs()` definition refactored to be more explicit about the return type
diff --git a/docs/framework/conversions_and_casting.rst b/docs/framework/conversions_and_casting.rst
index 6ce8346a..6114a161 100644
--- a/docs/framework/conversions_and_casting.rst
+++ b/docs/framework/conversions_and_casting.rst
@@ -179,7 +179,7 @@ code will not compile::
 
 To make it compile fine we have to either explicitly get the value stored in the quantity::
 
-    auto v = std::exp(quantity_cast<one>(10_q_m / 5_q_m).count());
+    auto v = std::exp(quantity_cast<one>(10_q_m / 5_q_m).number());
 
 or use a mathematical wrapper function from `units` namespace::
 
@@ -188,4 +188,4 @@ or use a mathematical wrapper function from `units` namespace::
 .. important::
 
     Always remember to explicitly cast the quantity to the destination unit with `quantity_cast` before
-    calling `quantity::count()`!
+    calling `quantity::number()`!
diff --git a/docs/framework/quantities.rst b/docs/framework/quantities.rst
index 0367bd77..d5daf5f1 100644
--- a/docs/framework/quantities.rst
+++ b/docs/framework/quantities.rst
@@ -336,7 +336,7 @@ will print ``50 %`` to the console output.
 
 Again, according to the ISO definition "such quantities convey more information than a
 number". This is exactly what we observe in the above example. The value stored inside
-the quantity, the text output, and the value returned by the `quantity::count()` member
+the quantity, the text output, and the value returned by the `quantity::number()` member
 function is ``50`` rather than ``0.5``. It means that dimensionless quantities behave
 like all other quantities and store the value in terms of a ratio of a coherent unit.
 This allows us to not loose precision when we divide quantities of the same dimensions
diff --git a/docs/use_cases/interoperability.rst b/docs/use_cases/interoperability.rst
index 764f3c14..c2877f96 100644
--- a/docs/use_cases/interoperability.rst
+++ b/docs/use_cases/interoperability.rst
@@ -11,7 +11,7 @@ provide the following:
     - ``dimension`` mapping the source with target dimension type
     - ``unit`` mapping the source with target unit type
     - ``rep`` mapping the source with target representation type
-- a static member function ``count(T)`` that returns the raw value/magnitude of the quantity.
+- a static member function ``number(T)`` that returns the raw value/magnitude of the quantity.
 
 For example, to provide support for the ``std::chrono::duration`` it is enough to define::
 
@@ -26,7 +26,7 @@ For example, to provide support for the ``std::chrono::duration`` it is enough t
       using dimension = isq::si::dim_time;
       using unit = downcast_unit<dimension, ratio(Period::num, Period::den)>;
       using rep = Rep;
-      [[nodiscard]] static constexpr rep count(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
+      [[nodiscard]] static constexpr rep number(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
     };
 
     } // namespace units
@@ -56,7 +56,7 @@ such an explicit conversion::
 
 For external quantity point-like types, `quantity_point_like_traits` is also provided.
 It works just like `quantity_like_traits`, except that
-``count(T)`` is replaced with ``relative(T)`` that returns the `QuantityLike` value.
+``number(T)`` is replaced with ``relative(T)`` that returns the `QuantityLike` value.
 
 Similar to `quantity` and `quantity_kind`, `quantity_point` and `quantity_kind_point`
 provide a deduction guide from `QuantityPointLike`::
diff --git a/docs/use_cases/legacy_interfaces.rst b/docs/use_cases/legacy_interfaces.rst
index 70e51b8c..b9db03f9 100644
--- a/docs/use_cases/legacy_interfaces.rst
+++ b/docs/use_cases/legacy_interfaces.rst
@@ -4,7 +4,7 @@ Working with Legacy Interfaces
 ==============================
 
 In case we are working with a legacy/unsafe interface we may be forced to
-extract the :term:`value of a quantity` with :func:`quantity::count()`
+extract the :term:`value of a quantity` with :func:`quantity::number()`
 (in addition
 to the quantity of a `quantity_point` with :func:`quantity_point::relative()`,
 or the quantity of a `quantity_kind` with :func:`quantity_kind::common()`,
@@ -38,18 +38,18 @@ and pass it to the library's output:
     void print_eta(Length auto d, Time auto t)
     {
       Speed auto v = avg_speed(d, t);
-      legacy::print_eta(quantity_cast<si::metre_per_second>(v).count());
+      legacy::print_eta(quantity_cast<si::metre_per_second>(v).number());
     }
 
     template<QuantityPoint QP>
       requires Length<typename QP::quantity_type>
     void set_path_position(QP p)
     {
-      legacy::set_path_position(quantity_point_cast<si::metre>(p).relative().count());
+      legacy::set_path_position(quantity_point_cast<si::metre>(p).relative().number());
     }
 
 .. important::
 
     When dealing with a quantity of an unknown ``auto`` type please remember
     to always use `quantity_cast` to cast it to a desired unit before calling
-    `quantity::count()` and passing the raw value to the legacy/unsafe interface.
+    `quantity::number()` and passing the raw value to the legacy/unsafe interface.
diff --git a/docs/use_cases/unknown_dimensions.rst b/docs/use_cases/unknown_dimensions.rst
index 705b34d5..da602306 100644
--- a/docs/use_cases/unknown_dimensions.rst
+++ b/docs/use_cases/unknown_dimensions.rst
@@ -64,7 +64,7 @@ Operations On Unknown Dimensions And Their Units
 For some cases we can eliminate the need to predefine a specific dimension and just use
 the `unknown_dimension` instead. Let's play with the previous example a bit::
 
-    static_assert(result.count() == 72);
+    static_assert(result.number() == 72);
 
 As we can see the value stored in this quantity can be easily obtained and contains a
 correct result. However, if we try to print its value to the text output we will get::
diff --git a/example/alternative_namespaces/conversion_factor.cpp b/example/alternative_namespaces/conversion_factor.cpp
index c08eb4a2..feec2aab 100644
--- a/example/alternative_namespaces/conversion_factor.cpp
+++ b/example/alternative_namespaces/conversion_factor.cpp
@@ -36,7 +36,7 @@ inline constexpr std::common_type_t<typename Target::rep, typename Source::rep>
   typedef std::common_type_t<typename Target::rep, typename Source::rep> rep;
   typedef units::quantity<typename Source::dimension, typename Source::unit, rep> source;
   typedef units::quantity<typename Target::dimension, typename Target::unit, rep> target;
-  return target{source{1}}.count();
+  return target{source{1}}.number();
 }
 
 }  // namespace
@@ -58,6 +58,6 @@ int main()
 
   std::cout << "conversion factor from lengthA::unit of "
             << units_str(lengthA).standard() << " to lengthB::unit of " << units_str(lengthB).standard() << " :\n\n"
-            << "lengthB.count( " << lengthB.count() << " ) == lengthA.count( " << lengthA.count()
+            << "lengthB.number( " << lengthB.number() << " ) == lengthA.number( " << lengthA.number()
             << " ) * conversion_factor( " << conversion_factor(lengthB, lengthA) << " )\n";
 }
diff --git a/example/conversion_factor.cpp b/example/conversion_factor.cpp
index c2d1bb00..2e70c1bf 100644
--- a/example/conversion_factor.cpp
+++ b/example/conversion_factor.cpp
@@ -35,7 +35,7 @@ inline constexpr std::common_type_t<typename Target::rep, typename Source::rep>
   typedef std::common_type_t<typename Target::rep, typename Source::rep> rep;
   typedef units::quantity<typename Source::dimension, typename Source::unit, rep> source;
   typedef units::quantity<typename Target::dimension, typename Target::unit, rep> target;
-  return target{source{1}}.count();
+  return target{source{1}}.number();
 }
 
 }  // namespace
@@ -55,6 +55,6 @@ int main()
   std::cout << fmt::format("therefore ratio lengthA / lengthB == {}\n\n", lengthA / lengthB);
 
   std::cout << fmt::format("conversion factor from lengthA::unit of {:%q} to lengthB::unit of {:%q}:\n\n", lengthA, lengthB)
-            << fmt::format("lengthB.count( {} ) == lengthA.count( {} ) * conversion_factor( {} )\n",
-                           lengthB.count(), lengthA.count(), conversion_factor(lengthB, lengthA));
+            << fmt::format("lengthB.number( {} ) == lengthA.number( {} ) * conversion_factor( {} )\n",
+                           lengthB.number(), lengthA.number(), conversion_factor(lengthB, lengthA));
 }
diff --git a/src/core-fmt/include/units/format.h b/src/core-fmt/include/units/format.h
index c8f432cc..86f504ee 100644
--- a/src/core-fmt/include/units/format.h
+++ b/src/core-fmt/include/units/format.h
@@ -272,7 +272,7 @@ namespace units {
         rep_format_specs const & rspecs, unit_format_specs const & uspecs,
         LocaleRef lc
       ):
-        out(o), val(q.count()), global_specs(gspecs), rep_specs(rspecs), unit_specs(uspecs), loc(lc)
+        out(o), val(q.number()), global_specs(gspecs), rep_specs(rspecs), unit_specs(uspecs), loc(lc)
       {
       }
 
@@ -491,7 +491,7 @@ public:
     // deal with quantity content
     if(begin == end || *begin == '}') {
       // default format should print value followed by the unit separated with 1 space
-      to_quantity_buffer = units::detail::format_units_quantity_value<CharT>(to_quantity_buffer, q.count(), rep_specs, ctx.locale());
+      to_quantity_buffer = units::detail::format_units_quantity_value<CharT>(to_quantity_buffer, q.number(), rep_specs, ctx.locale());
       constexpr auto symbol = units::detail::unit_text<Dimension, Unit>();
       if(symbol.standard().size()) {
         *to_quantity_buffer++ = CharT(' ');
diff --git a/src/core-io/include/units/quantity_io.h b/src/core-io/include/units/quantity_io.h
index 8c47af26..4be8f3ab 100644
--- a/src/core-io/include/units/quantity_io.h
+++ b/src/core-io/include/units/quantity_io.h
@@ -34,7 +34,7 @@ namespace detail {
 template<typename CharT, class Traits, typename D, typename U, typename Rep>
 void to_stream(std::basic_ostream<CharT, Traits>& os, const quantity<D, U, Rep>& q)
 {
-  os << q.count();
+  os << q.number();
   constexpr auto symbol = detail::unit_text<D, U>();
   if constexpr (!symbol.standard().empty()) {
     os << " " << symbol.standard();
@@ -45,7 +45,7 @@ void to_stream(std::basic_ostream<CharT, Traits>& os, const quantity<D, U, Rep>&
 
 template<typename CharT, typename Traits, typename D, typename U, typename Rep>
 std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, const quantity<D, U, Rep>& q)
-  requires requires { os << q.count(); }
+  requires requires { os << q.number(); }
 {
   if(os.width()) {
     // std::setw() applies to the whole quantity output so it has to be first put into std::string
diff --git a/src/core/include/units/bits/basic_concepts.h b/src/core/include/units/bits/basic_concepts.h
index 6e9bada5..4f7f2410 100644
--- a/src/core/include/units/bits/basic_concepts.h
+++ b/src/core/include/units/bits/basic_concepts.h
@@ -414,7 +414,7 @@ template<typename T>
     requires Dimension<typename quantity_like_traits<T>::dimension>;
     requires Unit<typename quantity_like_traits<T>::unit>;
     requires QuantityValue<typename quantity_like_traits<T>::rep>;
-    { quantity_like_traits<T>::count(q) } -> std::convertible_to<typename quantity_like_traits<T>::rep>;
+    { quantity_like_traits<T>::number(q) } -> std::convertible_to<typename quantity_like_traits<T>::rep>;
   }
 inline constexpr bool is_quantity_like<T> = true;
 
diff --git a/src/core/include/units/chrono.h b/src/core/include/units/chrono.h
index b8400b99..3f5506de 100644
--- a/src/core/include/units/chrono.h
+++ b/src/core/include/units/chrono.h
@@ -33,7 +33,7 @@ struct quantity_like_traits<std::chrono::duration<Rep, Period>> {
   using dimension = isq::si::dim_time;
   using unit = downcast_unit<dimension, ratio(Period::num, Period::den)>;
   using rep = Rep;
-  [[nodiscard]] static constexpr rep count(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
+  [[nodiscard]] static constexpr rep number(const std::chrono::duration<Rep, Period>& q) { return q.count(); }
 };
 
 template<typename C, typename Rep, typename Period>
diff --git a/src/core/include/units/customization_points.h b/src/core/include/units/customization_points.h
index 1cb1bb64..5b3a3d56 100644
--- a/src/core/include/units/customization_points.h
+++ b/src/core/include/units/customization_points.h
@@ -76,7 +76,7 @@ struct quantity_values {
  * @brief Provides support for external quantity-like types
  * 
  * The type trait should provide the following nested type aliases: @c dimension, @c unit, @c rep,
- * and a static member function @c count(T) that will return the raw value of the quantity.
+ * and a static member function @c number(T) that will return the raw value of the quantity.
  * 
  * Usage example can be found in @c units/chrono.h header file.
  * 
diff --git a/src/core/include/units/math.h b/src/core/include/units/math.h
index 2c40e8c2..a2ce3493 100644
--- a/src/core/include/units/math.h
+++ b/src/core/include/units/math.h
@@ -41,7 +41,7 @@ namespace units {
  */
 template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q>
   requires detail::non_zero<Den>
-[[nodiscard]] inline auto pow(const Q& q) noexcept requires requires { std::pow(q.count(), 1.0); }
+[[nodiscard]] inline auto pow(const Q& q) noexcept requires requires { std::pow(q.number(), 1.0); }
 {
   using rep = TYPENAME Q::rep;
   if constexpr (Num == 0) {
@@ -50,7 +50,7 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q>
     using dim = dimension_pow<typename Q::dimension, Num, Den>;
     using unit = downcast_unit<dim, pow<Num, Den>(Q::unit::ratio)>;
     return quantity<dim, unit, rep>(
-        static_cast<rep>(std::pow(q.count(), static_cast<double>(Num) / static_cast<double>(Den))));
+        static_cast<rep>(std::pow(q.number(), static_cast<double>(Num) / static_cast<double>(Den))));
   }
 }
 
@@ -64,12 +64,12 @@ template<std::intmax_t Num, std::intmax_t Den = 1, Quantity Q>
  */
 template<Quantity Q>
 [[nodiscard]] inline Quantity auto sqrt(const Q& q) noexcept
-  requires requires { std::sqrt(q.count()); }
+  requires requires { std::sqrt(q.number()); }
 {
   using dim = dimension_pow<typename Q::dimension, 1, 2>;
   using unit = downcast_unit<dim, sqrt(Q::unit::ratio)>;
   using rep = TYPENAME Q::rep;
-  return quantity<dim, unit, rep>(static_cast<rep>(std::sqrt(q.count())));
+  return quantity<dim, unit, rep>(static_cast<rep>(std::sqrt(q.number())));
 }
 
 /**
@@ -82,12 +82,12 @@ template<Quantity Q>
  */
 template<Quantity Q>
 [[nodiscard]] inline Quantity auto cbrt(const Q& q) noexcept
-  requires requires { std::cbrt(q.count()); }
+  requires requires { std::cbrt(q.number()); }
 {
   using dim = dimension_pow<typename Q::dimension, 1, 3>;
   using unit = downcast_unit<dim, cbrt(Q::unit::ratio)>;
   using rep = TYPENAME Q::rep;
-  return quantity<dim, unit, rep>(static_cast<rep>(std::cbrt(q.count())));
+  return quantity<dim, unit, rep>(static_cast<rep>(std::cbrt(q.number())));
 }
 
 /**
@@ -101,7 +101,7 @@ template<Quantity Q>
 template<typename U, typename Rep>
 [[nodiscard]] inline dimensionless<U, Rep> exp(const dimensionless<U, Rep>& q)
 {
-  return quantity_cast<U>(dimensionless<one, Rep>(std::exp(quantity_cast<one>(q).count())));
+  return quantity_cast<U>(dimensionless<one, Rep>(std::exp(quantity_cast<one>(q).number())));
 }
 
 /**
@@ -112,9 +112,9 @@ template<typename U, typename Rep>
  */
 template<typename D, typename U, typename Rep>
 [[nodiscard]] inline quantity<D, U, Rep> abs(const quantity<D, U, Rep>& q) noexcept
-  requires requires { std::abs(q.count()); }
+  requires requires { std::abs(q.number()); }
 {
-  return quantity<D, U, Rep>(std::abs(q.count()));
+  return quantity<D, U, Rep>(std::abs(q.number()));
 }
 
 /**
diff --git a/src/core/include/units/quantity.h b/src/core/include/units/quantity.h
index c734cd7e..1eeff3e3 100644
--- a/src/core/include/units/quantity.h
+++ b/src/core/include/units/quantity.h
@@ -149,31 +149,31 @@ public:
   quantity(const Value& v) : value_(v) {}
 
   template<safe_castable_to_<quantity> Q>
-  constexpr explicit(false) quantity(const Q& q) : value_(quantity_cast<quantity>(q).count()) {}
+  constexpr explicit(false) quantity(const Q& q) : value_(quantity_cast<quantity>(q).number()) {}
 
   template<QuantityLike Q>
     requires safe_castable_to_<quantity_like_type<Q>, quantity>
-  constexpr explicit quantity(const Q& q) : quantity(quantity_like_type<Q>(quantity_like_traits<Q>::count(q))) {}
+  constexpr explicit quantity(const Q& q) : quantity(quantity_like_type<Q>(quantity_like_traits<Q>::number(q))) {}
 
   quantity& operator=(const quantity&) = default;
   quantity& operator=(quantity&&) = default;
 
   // data access
-  [[nodiscard]] constexpr rep count() const noexcept { return value_; }
+  [[nodiscard]] constexpr rep number() const noexcept { return value_; }
 
   // member unary operators
   [[nodiscard]] constexpr Quantity auto operator+() const
     requires requires(rep v) { { +v } -> std::common_with<rep>; }
   {
-    using ret = quantity<D, U, decltype(+count())>;
-    return ret(+count());
+    using ret = quantity<D, U, decltype(+number())>;
+    return ret(+number());
   }
 
   [[nodiscard]] constexpr Quantity auto operator-() const
     requires std::regular_invocable<std::negate<>, rep>
   {
-    using ret = quantity<D, U, decltype(-count())>;
-    return ret(-count());
+    using ret = quantity<D, U, decltype(-number())>;
+    return ret(-number());
   }
 
   constexpr quantity& operator++()
@@ -205,14 +205,14 @@ public:
   constexpr quantity& operator+=(const quantity& q)
     requires requires(rep a, rep b) { { a += b } -> std::same_as<rep&>; }
   {
-    value_ += q.count();
+    value_ += q.number();
     return *this;
   }
 
   constexpr quantity& operator-=(const quantity& q)
     requires requires(rep a, rep b) { { a -= b } -> std::same_as<rep&>; }
   {
-    value_ -= q.count();
+    value_ -= q.number();
     return *this;
   }
 
@@ -227,7 +227,7 @@ public:
   constexpr quantity& operator*=(const dimensionless<units::one, Rep2>& rhs)
     requires requires(rep a, const Rep2 b) { { a *= b } -> std::same_as<rep&>; }
   {
-    value_ *= rhs.count();
+    value_ *= rhs.number();
     return *this;
   }
 
@@ -243,8 +243,8 @@ public:
   constexpr quantity& operator/=(const dimensionless<units::one, Rep2>& rhs)
     requires requires(rep a, const Rep2 b) { { a /= b } -> std::same_as<rep&>; }
   {
-    gsl_ExpectsAudit(rhs.count() != quantity_values<Rep2>::zero());
-    value_ /= rhs.count();
+    gsl_ExpectsAudit(rhs.number() != quantity_values<Rep2>::zero());
+    value_ /= rhs.number();
     return *this;
   }
 
@@ -263,8 +263,8 @@ public:
     requires (!floating_point_<rep>) && (!floating_point_<Rep2>) &&
              requires(rep a, const Rep2 b) { { a %= b } -> std::same_as<rep&>; }
   {
-    gsl_ExpectsAudit(rhs.count() != quantity_values<Rep2>::zero());
-    value_ %= rhs.count();
+    gsl_ExpectsAudit(rhs.number() != quantity_values<Rep2>::zero());
+    value_ %= rhs.number();
     return *this;
   }
 
@@ -272,8 +272,8 @@ public:
     requires (!floating_point_<rep>) &&
              requires(rep a, rep b) { { a %= b } -> std::same_as<rep&>; }
   {
-    gsl_ExpectsAudit(q.count() != quantity_values<rep>::zero());
-    value_ %= q.count();
+    gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
+    value_ %= q.number();
     return *this;
   }
 
@@ -284,14 +284,14 @@ public:
     requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;  // TODO: Simplify
           requires invoke_result_convertible_to_<rep, std::plus<>, rep, Value>; }         // when Clang catches up.
   {
-    return units::quantity(lhs.count() + rhs);
+    return units::quantity(lhs.number() + rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator+(const Value& lhs, const quantity& rhs)
     requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;  // TODO: Simplify
           requires invoke_result_convertible_to_<rep, std::plus<>, Value, rep>; }         // when Clang catches up.
   {
-    return units::quantity(lhs + rhs.count());
+    return units::quantity(lhs + rhs.number());
   }
 
   template<typename Value>
@@ -299,14 +299,14 @@ public:
     requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;  // TODO: Simplify
           requires invoke_result_convertible_to_<rep, std::minus<>, rep, Value>; }        // when Clang catches up.
   {
-    return units::quantity(lhs.count() - rhs);
+    return units::quantity(lhs.number() - rhs);
   }
   template<typename Value>
   [[nodiscard]] friend constexpr Quantity auto operator-(const Value& lhs, const quantity& rhs)
     requires requires { requires !Quantity<Value>; requires is_same_v<unit, units::one>;  // TODO: Simplify
           requires invoke_result_convertible_to_<rep, std::minus<>, Value, rep>; }        // when Clang catches up.
   {
-    return units::quantity(lhs - rhs.count());
+    return units::quantity(lhs - rhs.number());
   }
 
   template<typename Value>
@@ -315,7 +315,7 @@ public:
   [[nodiscard]] friend constexpr Quantity auto operator*(const quantity& q, const Value& v)
   {
     using ret = quantity<D, U, std::invoke_result_t<std::multiplies<>, rep, Value>>;
-    return ret(q.count() * v);
+    return ret(q.number() * v);
   }
 
   template<typename Value>
@@ -324,7 +324,7 @@ public:
   [[nodiscard]] friend constexpr Quantity auto operator*(const Value& v, const quantity& q)
   {
     using ret = quantity<D, U, std::invoke_result_t<std::multiplies<>, Value, rep>>;
-    return ret(v * q.count());
+    return ret(v * q.number());
   }
 
   template<typename Value>
@@ -334,7 +334,7 @@ public:
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
     using ret = quantity<D, U, std::invoke_result_t<std::divides<>, rep, Value>>;
-    return ret(q.count() / v);
+    return ret(q.number() / v);
   }
 
   template<typename Value>
@@ -342,11 +342,11 @@ public:
           invoke_result_convertible_to_<rep, std::divides<>, const Value&, rep>
   [[nodiscard]] friend constexpr Quantity auto operator/(const Value& v, const quantity& q)
   {
-    gsl_ExpectsAudit(q.count() != quantity_values<rep>::zero());
+    gsl_ExpectsAudit(q.number() != quantity_values<rep>::zero());
     using dim = dim_invert<D>;
     using ret_unit = downcast_unit<dim, inverse(U::ratio)>;
     using ret = quantity<dim, ret_unit, std::invoke_result_t<std::divides<>, Value, rep>>;
-    return ret(v / q.count());
+    return ret(v / q.number());
   }
 
   template<typename Value>
@@ -356,15 +356,15 @@ public:
   {
     gsl_ExpectsAudit(v != quantity_values<Value>::zero());
     using ret = quantity<D, U, std::invoke_result_t<std::modulus<>, rep, Value>>;
-    return ret(q.count() % v);
+    return ret(q.number() % v);
   }
 
   [[nodiscard]] friend constexpr Quantity auto operator%(const quantity& lhs, const quantity& rhs)
     requires (!floating_point_<rep>) && is_same_v<unit, units::one> &&
             invoke_result_convertible_to_<rep, std::modulus<>, rep, rep>
   {
-    gsl_ExpectsAudit(rhs.count() != quantity_values<rep>::zero());
-    return units::quantity(lhs.count() % rhs.count());
+    gsl_ExpectsAudit(rhs.number() != quantity_values<rep>::zero());
+    return units::quantity(lhs.number() % rhs.number());
   }
 
   [[nodiscard]] friend constexpr auto operator<=>(const quantity& lhs, const quantity& rhs)
@@ -373,7 +373,7 @@ public:
   = default;
 #else
   {
-    return lhs.count() <=> rhs.count();
+    return lhs.number() <=> rhs.number();
   }
 #endif
 
@@ -393,7 +393,7 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
 [[nodiscard]] constexpr Quantity auto operator+(const Q1& lhs, const Q2& rhs)
 {
   using ret = common_quantity_for<std::plus<>, Q1, Q2>;
-  return ret(ret(lhs).count() + ret(rhs).count());
+  return ret(ret(lhs).number() + ret(rhs).number());
 }
 
 template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
@@ -401,22 +401,22 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
 [[nodiscard]] constexpr Quantity auto operator-(const Q1& lhs, const Q2& rhs)
 {
   using ret = common_quantity_for<std::minus<>, Q1, Q2>;
-  return ret(ret(lhs).count() - ret(rhs).count());
+  return ret(ret(lhs).number() - ret(rhs).number());
 }
 
 template<Quantity Q1, Quantity Q2>
   requires quantity_value_for_<std::multiplies<>, typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr Quantity auto operator*(const Q1& lhs, const Q2& rhs)
 {
-  return detail::make_quantity<Q1::reference * Q2::reference>(lhs.count() * rhs.count());
+  return detail::make_quantity<Q1::reference * Q2::reference>(lhs.number() * rhs.number());
 }
 
 template<Quantity Q1, Quantity Q2>
   requires quantity_value_for_<std::divides<>, typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr Quantity auto operator/(const Q1& lhs, const Q2& rhs)
 {
-  gsl_ExpectsAudit(rhs.count() != quantity_values<typename Q2::rep>::zero());
-  return detail::make_quantity<Q1::reference / Q2::reference>(lhs.count() / rhs.count());
+  gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q2::rep>::zero());
+  return detail::make_quantity<Q1::reference / Q2::reference>(lhs.number() / rhs.number());
 }
 
 template<typename D1, typename U1, typename Rep1, typename U2, typename Rep2>
@@ -424,10 +424,10 @@ template<typename D1, typename U1, typename Rep1, typename U2, typename Rep2>
           quantity_value_for_<std::modulus<>, Rep1, Rep2>
 [[nodiscard]] constexpr Quantity auto operator%(const quantity<D1, U1, Rep1>& lhs, const quantity<dim_one, U2, Rep2>& rhs)
 {
-  gsl_ExpectsAudit(rhs.count() != quantity_values<Rep2>::zero());
+  gsl_ExpectsAudit(rhs.number() != quantity_values<Rep2>::zero());
   using unit = downcast_unit<D1, U1::ratio * U2::ratio>;
   using ret = quantity<D1, unit, std::invoke_result_t<std::modulus<>, Rep1, Rep2>>;
-  return ret(lhs.count() % rhs.count());
+  return ret(lhs.number() % rhs.number());
 }
 
 template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
@@ -435,9 +435,9 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
           quantity_value_for_<std::modulus<>, typename Q1::rep, typename Q2::rep>
 [[nodiscard]] constexpr Quantity auto operator%(const Q1& lhs, const Q2& rhs)
 {
-  gsl_ExpectsAudit(rhs.count() != quantity_values<typename Q2::rep>::zero());
+  gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q2::rep>::zero());
   using ret = common_quantity_for<std::modulus<>, Q1, Q2>;
-  return ret(ret(lhs).count() % ret(rhs).count());
+  return ret(ret(lhs).number() % ret(rhs).number());
 }
 
 template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
@@ -445,7 +445,7 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
 [[nodiscard]] constexpr auto operator<=>(const Q1& lhs, const Q2& rhs)
 {
   using cq = common_quantity<Q1, Q2>;
-  return cq(lhs).count() <=> cq(rhs).count();
+  return cq(lhs).number() <=> cq(rhs).number();
 }
 
 template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
@@ -453,7 +453,7 @@ template<Quantity Q1, QuantityEquivalentTo<Q1> Q2>
 [[nodiscard]] constexpr bool operator==(const Q1& lhs, const Q2& rhs)
 {
   using cq = common_quantity<Q1, Q2>;
-  return cq(lhs).count() == cq(rhs).count();
+  return cq(lhs).number() == cq(rhs).number();
 }
 
 // type traits
diff --git a/src/core/include/units/quantity_cast.h b/src/core/include/units/quantity_cast.h
index d0c48879..6009dcd8 100644
--- a/src/core/include/units/quantity_cast.h
+++ b/src/core/include/units/quantity_cast.h
@@ -121,17 +121,17 @@ template<Quantity To, typename D, typename U, scalable_with_<typename To::rep> R
   constexpr auto c_ratio = detail::cast_ratio<quantity<D, U, Rep>, To>;
 
   if constexpr (treat_as_floating_point<rep_type>) {
-    return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.count()) *
+    return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) *
                               (static_cast<ratio_type>(c_ratio.num) * detail::fpow10<ratio_type>(c_ratio.exp) / static_cast<ratio_type>(c_ratio.den))));
   }
   else {
     if constexpr (c_ratio.exp > 0) {
-      return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.count()) *
+      return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) *
                               (static_cast<ratio_type>(c_ratio.num) * static_cast<ratio_type>(detail::ipow10(c_ratio.exp))) /
                               static_cast<ratio_type>(c_ratio.den)));
     }
     else {
-      return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.count()) *
+      return To(static_cast<TYPENAME To::rep>(static_cast<rep_type>(q.number()) *
                               static_cast<ratio_type>(c_ratio.num) /
                               (static_cast<ratio_type>(c_ratio.den) * static_cast<ratio_type>(detail::ipow10(-c_ratio.exp)))));
     }
diff --git a/src/core/include/units/quantity_kind.h b/src/core/include/units/quantity_kind.h
index d378a3a8..79cc4177 100644
--- a/src/core/include/units/quantity_kind.h
+++ b/src/core/include/units/quantity_kind.h
@@ -232,7 +232,7 @@ public:
   constexpr quantity_kind& operator%=(const quantity_kind& qk)
     requires requires(quantity_type q) { q %= qk.common(); }
   {
-    gsl_ExpectsAudit(qk.common().count() != quantity_values<rep>::zero());
+    gsl_ExpectsAudit(qk.common().number() != quantity_values<rep>::zero());
     q_ %= qk.common();
     return *this;
   }
@@ -265,7 +265,7 @@ public:
   [[nodiscard]] friend constexpr QuantityKind auto operator/(const Value& v, const quantity_kind& qk)
     requires requires(quantity_type q) { { v / q } -> Quantity; }
   {
-    gsl_ExpectsAudit(qk.common().count() != quantity_values<rep>::zero());
+    gsl_ExpectsAudit(qk.common().number() != quantity_values<rep>::zero());
     return detail::downcasted_kind<quantity_kind>(v / qk.common());
   }
 
@@ -325,7 +325,7 @@ template<QuantityKind QK, Quantity Q>
 [[nodiscard]] constexpr QuantityKind auto operator/(const QK& lhs, const Q& rhs)
   requires requires { lhs.common() / rhs; }
 {
-  gsl_ExpectsAudit(rhs.count() != quantity_values<typename Q::rep>::zero());
+  gsl_ExpectsAudit(rhs.number() != quantity_values<typename Q::rep>::zero());
   return detail::downcasted_kind<QK>(lhs.common() / rhs);
 }
 
@@ -333,7 +333,7 @@ template<Quantity Q, QuantityKind QK>
 [[nodiscard]] constexpr QuantityKind auto operator/(const Q& lhs, const QK& rhs)
   requires requires { lhs / rhs.common(); }
 {
-  gsl_ExpectsAudit(rhs.common().count() != quantity_values<typename QK::rep>::zero());
+  gsl_ExpectsAudit(rhs.common().number() != quantity_values<typename QK::rep>::zero());
   return detail::downcasted_kind<QK>(lhs / rhs.common());
 }
 
@@ -348,7 +348,7 @@ template<QuantityKind QK, Dimensionless D>
 [[nodiscard]] constexpr QuantityKind auto operator%(const QK& lhs, const D& rhs)
   requires requires { lhs.common() % rhs; }
 {
-  gsl_ExpectsAudit(rhs.count() != quantity_values<typename D::rep>::zero());
+  gsl_ExpectsAudit(rhs.number() != quantity_values<typename D::rep>::zero());
   return detail::make_quantity_kind<QK>(lhs.common() % rhs);
 }
 
@@ -356,7 +356,7 @@ template<QuantityKind QK1, QuantityKindEquivalentTo<QK1> QK2>
 [[nodiscard]] constexpr QuantityKind auto operator%(const QK1& lhs, const QK2& rhs)
   requires requires { lhs.common() % rhs.common(); }
 {
-  gsl_ExpectsAudit(rhs.common().count() != quantity_values<typename QK2::rep>::zero());
+  gsl_ExpectsAudit(rhs.common().number() != quantity_values<typename QK2::rep>::zero());
   return detail::make_quantity_kind<QK1>(lhs.common() % rhs.common());
 }
 
diff --git a/src/core/include/units/random.h b/src/core/include/units/random.h
index 0ef305f6..542aaca0 100644
--- a/src/core/include/units/random.h
+++ b/src/core/include/units/random.h
@@ -34,7 +34,7 @@ namespace detail {
     {
         std::vector<typename Q::rep> intervals_rep;
         intervals_rep.reserve(static_cast<size_t>(std::distance(first, last)));
-        for (auto itr = first; itr != last; ++itr) { intervals_rep.push_back(itr->count()); }
+        for (auto itr = first; itr != last; ++itr) { intervals_rep.push_back(itr->number()); }
         return intervals_rep;
     }
     
@@ -43,7 +43,7 @@ namespace detail {
     {
         std::vector<typename Q::rep> bl_rep;
         bl_rep.reserve(bl.size());
-        for (const Q& qty : bl) { bl_rep.push_back(qty.count()); }
+        for (const Q& qty : bl) { bl_rep.push_back(qty.number()); }
         return bl_rep;
     }
 
@@ -79,7 +79,7 @@ struct uniform_int_distribution : public std::uniform_int_distribution<typename
     using base = TYPENAME std::uniform_int_distribution<rep>;
     
     uniform_int_distribution() : base() {}
-    uniform_int_distribution(const Q& a, const Q& b) : base(a.count(), b.count()) {}
+    uniform_int_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -99,7 +99,7 @@ struct uniform_real_distribution : public std::uniform_real_distribution<typenam
     using base = TYPENAME std::uniform_real_distribution<rep>;
     
     uniform_real_distribution() : base() {}
-    uniform_real_distribution(const Q& a, const Q& b) : base(a.count(), b.count()) {}
+    uniform_real_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -119,7 +119,7 @@ struct binomial_distribution : public std::binomial_distribution<typename Q::rep
     using base = TYPENAME std::binomial_distribution<rep>;
     
     binomial_distribution() : base() {}
-    binomial_distribution(const Q& t, double p) : base(t.count(), p) {}
+    binomial_distribution(const Q& t, double p) : base(t.number(), p) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -138,7 +138,7 @@ struct negative_binomial_distribution : public std::negative_binomial_distributi
     using base = TYPENAME std::negative_binomial_distribution<rep>;
     
     negative_binomial_distribution() : base() {}
-    negative_binomial_distribution(const Q& k, double p) : base(k.count(), p) {}
+    negative_binomial_distribution(const Q& k, double p) : base(k.number(), p) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -242,7 +242,7 @@ struct extreme_value_distribution : public std::extreme_value_distribution<typen
     using base = TYPENAME std::extreme_value_distribution<rep>;
     
     extreme_value_distribution() : base() {}
-    extreme_value_distribution(const Q& a, const rep& b) : base(a.count(), b) {}
+    extreme_value_distribution(const Q& a, const rep& b) : base(a.number(), b) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -261,7 +261,7 @@ struct normal_distribution : public std::normal_distribution<typename Q::rep>
     using base = TYPENAME std::normal_distribution<rep>;
     
     normal_distribution() : base() {}
-    normal_distribution(const Q& mean, const Q& stddev) : base(mean.count(), stddev.count()) {}
+    normal_distribution(const Q& mean, const Q& stddev) : base(mean.number(), stddev.number()) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -281,7 +281,7 @@ struct lognormal_distribution : public std::lognormal_distribution<typename Q::r
     using base = TYPENAME std::lognormal_distribution<rep>;
     
     lognormal_distribution() : base() {}
-    lognormal_distribution(const Q& m, const Q& s) : base(m.count(), s.count()) {}
+    lognormal_distribution(const Q& m, const Q& s) : base(m.number(), s.number()) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -318,7 +318,7 @@ struct cauchy_distribution : public std::cauchy_distribution<typename Q::rep>
     using base = TYPENAME std::cauchy_distribution<rep>;
     
     cauchy_distribution() : base() {}
-    cauchy_distribution(const Q& a, const Q& b) : base(a.count(), b.count()) {}
+    cauchy_distribution(const Q& a, const Q& b) : base(a.number(), b.number()) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -416,7 +416,7 @@ public:
 
     template <typename UnaryOperation>
     piecewise_constant_distribution(std::size_t nw, const Q& xmin, const Q& xmax, UnaryOperation fw) :
-        base(nw, xmin.count(), xmax.count(), [fw](rep val) { return fw(Q(val)); }) {}
+        base(nw, xmin.number(), xmax.number(), [fw](rep val) { return fw(Q(val)); }) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
@@ -461,7 +461,7 @@ public:
 
     template <typename UnaryOperation>
     piecewise_linear_distribution(std::size_t nw, const Q& xmin, const Q& xmax, UnaryOperation fw) :
-        base(nw, xmin.count(), xmax.count(), [fw](rep val) { return fw(Q(val)); }) {}
+        base(nw, xmin.number(), xmax.number(), [fw](rep val) { return fw(Q(val)); }) {}
     
     template<typename Generator>
     Q operator()(Generator& g) { return Q(base::operator()(g)); }
diff --git a/test/unit_test/runtime/distribution_test.cpp b/test/unit_test/runtime/distribution_test.cpp
index 264183ae..c912d40a 100644
--- a/test/unit_test/runtime/distribution_test.cpp
+++ b/test/unit_test/runtime/distribution_test.cpp
@@ -531,7 +531,7 @@ TEST_CASE("piecewise_constant_distribution")
     std::initializer_list<q> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
     
     auto stl_dist = std::piecewise_constant_distribution<rep>(intervals_rep, [](rep val) { return val; });
-    auto units_dist = units::piecewise_constant_distribution<q>(intervals_qty, [](q qty) { return qty.count(); });
+    auto units_dist = units::piecewise_constant_distribution<q>(intervals_qty, [](q qty) { return qty.number(); });
 
     CHECK(units_dist.intervals() == intervals_qty_vec);
     CHECK(units_dist.densities() == stl_dist.densities());
@@ -543,7 +543,7 @@ TEST_CASE("piecewise_constant_distribution")
     constexpr q xmin_qty = 1.0_q_m, xmax_qty = 3.0_q_m;
     
     auto stl_dist = std::piecewise_constant_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
-    auto units_dist = units::piecewise_constant_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.count(); });
+    auto units_dist = units::piecewise_constant_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.number(); });
 
     CHECK(units_dist.intervals() == intervals_qty_vec);
     CHECK(units_dist.densities() == stl_dist.densities());
@@ -589,7 +589,7 @@ TEST_CASE("piecewise_linear_distribution")
     std::initializer_list<q> intervals_qty = {1.0_q_m, 2.0_q_m, 3.0_q_m};
     
     auto stl_dist = std::piecewise_linear_distribution<rep>(intervals_rep, [](rep val) { return val; });
-    auto units_dist = units::piecewise_linear_distribution<q>(intervals_qty, [](q qty) { return qty.count(); });
+    auto units_dist = units::piecewise_linear_distribution<q>(intervals_qty, [](q qty) { return qty.number(); });
 
     CHECK(units_dist.intervals() == intervals_qty_vec);
     CHECK(units_dist.densities() == stl_dist.densities());
@@ -601,7 +601,7 @@ TEST_CASE("piecewise_linear_distribution")
     constexpr q xmin_qty = 1.0_q_m, xmax_qty = 3.0_q_m;
     
     auto stl_dist = std::piecewise_linear_distribution<rep>(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
-    auto units_dist = units::piecewise_linear_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.count(); });
+    auto units_dist = units::piecewise_linear_distribution<q>(nw, xmin_qty, xmax_qty, [](q qty) { return qty.number(); });
 
     CHECK(units_dist.intervals() == intervals_qty_vec);
     CHECK(units_dist.densities() == stl_dist.densities());
diff --git a/test/unit_test/runtime/math_test.cpp b/test/unit_test/runtime/math_test.cpp
index 3ac46f2a..a64c09f9 100644
--- a/test/unit_test/runtime/math_test.cpp
+++ b/test/unit_test/runtime/math_test.cpp
@@ -100,13 +100,13 @@ TEST_CASE("absolute functions on quantity returns the absolute value", "[math][a
 TEST_CASE("numeric_limits functions", "[limits]")
 {
   SECTION ("'epsilon' works as expected using default floating type") {
-    REQUIRE(epsilon<decltype(1._q_m)>().count() == std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
+    REQUIRE(epsilon<decltype(1._q_m)>().number() == std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
   }
   SECTION ("'epsilon' works as expected using integers") {
-    REQUIRE(epsilon<decltype(1_q_m)>().count() == std::numeric_limits<decltype(1_q_m)::rep>::epsilon());
+    REQUIRE(epsilon<decltype(1_q_m)>().number() == std::numeric_limits<decltype(1_q_m)::rep>::epsilon());
   }
   SECTION ("'epsilon' works as expected using mixed Rep types") {
-    REQUIRE(epsilon<decltype(1_q_m)>().count() != std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
+    REQUIRE(epsilon<decltype(1_q_m)>().number() != std::numeric_limits<decltype(1._q_m)::rep>::epsilon());
   }
 }
 
diff --git a/test/unit_test/static/cgs_test.cpp b/test/unit_test/static/cgs_test.cpp
index bdb72c28..1d25c965 100644
--- a/test/unit_test/static/cgs_test.cpp
+++ b/test/unit_test/static/cgs_test.cpp
@@ -51,8 +51,8 @@ static_assert(centimetre::symbol == "cm");
 
 // speed
 
-static_assert((10_q_cm / 5_q_s).count() == 2);
-static_assert((2_q_cm_per_s).count() == 2);
+static_assert((10_q_cm / 5_q_s).number() == 2);
+static_assert((2_q_cm_per_s).number() == 2);
 static_assert(10_q_cm / 5_q_s == 2_q_cm_per_s);
 static_assert(10_q_cm / 2_q_cm_per_s == 5_q_s);
 static_assert(10_q_cm == 2_q_cm_per_s * 5_q_s);
@@ -62,8 +62,8 @@ static_assert(detail::unit_text<dim_speed, centimetre_per_second>() == "cm/s");
 // area
 static_assert(centimetre::ratio / dimension_unit<dim_length>::ratio == ratio(1));
 
-static_assert((1_q_cm * 1_q_cm).count() == 1);
-static_assert((1_q_cm2).count() == 1);
+static_assert((1_q_cm * 1_q_cm).number() == 1);
+static_assert((1_q_cm2).number() == 1);
 static_assert(1_q_cm * 1_q_cm == 1_q_cm2);
 static_assert(100_q_cm * 100_q_cm == area<isq::si::square_metre>(1));
 static_assert(100_q_cm * 100_q_cm == length<isq::si::metre>(1) * length<isq::si::metre>(1));
diff --git a/test/unit_test/static/quantity_kind_test.cpp b/test/unit_test/static/quantity_kind_test.cpp
index 521b2bea..6c73ed79 100644
--- a/test/unit_test/static/quantity_kind_test.cpp
+++ b/test/unit_test/static/quantity_kind_test.cpp
@@ -167,8 +167,8 @@ static_assert(width<metre, double>::zero().common() == 0 * m);
 static_assert(width<metre, double>::one().common() == 1 * m);
 static_assert(width<metre, unsigned>::min().common() == 0 * m);
 static_assert(width<metre, unsigned>::max().common() == std::numeric_limits<unsigned>::max() * m);
-static_assert(width<metre, double>::min().common().count() == std::numeric_limits<double>::lowest());
-static_assert(width<metre, double>::max().common().count() == std::numeric_limits<double>::max());
+static_assert(width<metre, double>::min().common().number() == std::numeric_limits<double>::lowest());
+static_assert(width<metre, double>::max().common().number() == std::numeric_limits<double>::max());
 
 
 ////////////////////////
@@ -204,8 +204,8 @@ static_assert(same(quantity_kind(rate_of_climb<kilometre_per_hour, double>(0.01
 
 static_assert(construct_from_only<apples<one, int>>(1).common() == 1);
 static_assert(construct_from_only<apples<one, double>>(1.0).common() == 1);
-static_assert(construct_from_only<apples<percent, int>>(1ULL).common().count() == 1);
-static_assert(construct_from_only<apples<percent, double>>(1.0L).common().count() == 1);
+static_assert(construct_from_only<apples<percent, int>>(1ULL).common().number() == 1);
+static_assert(construct_from_only<apples<percent, double>>(1.0L).common().number() == 1);
 static_assert(!constructible_or_convertible_from<apples<one, int>>(1.0));
 static_assert(!constructible_or_convertible_from<apples<percent, int>>(1.0));
 static_assert(!constructible_or_convertible_from<width<metre, double>>(1.0));
@@ -248,20 +248,20 @@ static_assert(construct_from_only<width<metre, short>>(1 * m).common() == 1 * m)
 
 static_assert(construct_from_only<apples<one, int>>(quantity(1)).common() == 1);
 static_assert(construct_from_only<apples<one, double>>(dimensionless<percent>(1)).common() == 0.01);
-static_assert(construct_from_only<apples<percent, double>>(quantity(1.0)).common().count() == 100);
-static_assert(construct_from_only<apples<percent, double>>(dimensionless<percent>(1)).common().count() == 1);
+static_assert(construct_from_only<apples<percent, double>>(quantity(1.0)).common().number() == 100);
+static_assert(construct_from_only<apples<percent, double>>(dimensionless<percent>(1)).common().number() == 1);
 static_assert(construct_from_only<apples<one, double>>(quantity(1.0)).common() == 1);
 static_assert(construct_from_only<apples<one, double>>(quantity(1.0f)).common() == 1);
 static_assert(construct_from_only<apples<one, float>>(quantity(1.0)).common() == 1);
 static_assert(construct_from_only<apples<one, double>>(quantity(1)).common() == 1);
 static_assert(construct_from_only<apples<one, double>>(quantity(short{1})).common() == 1);
 static_assert(construct_from_only<apples<one, short>>(quantity(1)).common() == 1);
-static_assert(construct_from_only<apples<percent, double>>(quantity(1.0)).common().count() == 1e2);
-static_assert(construct_from_only<apples<percent, double>>(quantity(1.0f)).common().count() == 1e2);
-static_assert(construct_from_only<apples<percent, float>>(quantity(1.0)).common().count() == 1e2f);
-static_assert(construct_from_only<apples<percent, double>>(quantity(1)).common().count() == 1e2);
-static_assert(construct_from_only<apples<percent, double>>(quantity(short{1})).common().count() == 1e2);
-static_assert(construct_from_only<apples<percent, short>>(quantity(1)).common().count() == 1e2);
+static_assert(construct_from_only<apples<percent, double>>(quantity(1.0)).common().number() == 1e2);
+static_assert(construct_from_only<apples<percent, double>>(quantity(1.0f)).common().number() == 1e2);
+static_assert(construct_from_only<apples<percent, float>>(quantity(1.0)).common().number() == 1e2f);
+static_assert(construct_from_only<apples<percent, double>>(quantity(1)).common().number() == 1e2);
+static_assert(construct_from_only<apples<percent, double>>(quantity(short{1})).common().number() == 1e2);
+static_assert(construct_from_only<apples<percent, short>>(quantity(1)).common().number() == 1e2);
 
 static_assert(!constructible_or_convertible_from<dimensionless<one, double>>(apples<one, double>{}));
 static_assert(!constructible_or_convertible_from<dimensionless<one, double>>(apples<one, float>{}));
@@ -471,12 +471,12 @@ static_assert(same(width<metre, double>(2. * m) - width<metre, int>(3 * m), widt
 static_assert(same(width<metre, double>(2e3 * m) - width<kilometre, int>(3 * km), width<metre, double>(-1e3 * m)));
 
 static_assert(is_same_v<
-  decltype((width<metre, std::uint8_t>(0 * m) + width<metre, std::uint8_t>(0 * m)).common().count()), int>);
+  decltype((width<metre, std::uint8_t>(0 * m) + width<metre, std::uint8_t>(0 * m)).common().number()), int>);
 static_assert(is_same_v<
-  decltype((width<metre, std::uint8_t>(0 * m) - width<metre, std::uint8_t>(0 * m)).common().count()), int>);
-static_assert((width<metre, std::uint8_t>(128 * m) + width<metre, std::uint8_t>(128 * m)).common().count() ==
+  decltype((width<metre, std::uint8_t>(0 * m) - width<metre, std::uint8_t>(0 * m)).common().number()), int>);
+static_assert((width<metre, std::uint8_t>(128 * m) + width<metre, std::uint8_t>(128 * m)).common().number() ==
   std::uint8_t(128) + std::uint8_t(128));
-static_assert((width<metre, std::uint8_t>(0 * m) - width<metre, std::uint8_t>(1 * m)).common().count() ==
+static_assert((width<metre, std::uint8_t>(0 * m) - width<metre, std::uint8_t>(1 * m)).common().number() ==
   std::uint8_t(0) - std::uint8_t(1));
 
 static_assert(!std::is_invocable_v<std::plus<>, width<metre>, double>);
@@ -641,7 +641,7 @@ static_assert(same(width<metre, int>(2 * m) % 3, width<metre, int>(2 * m)));
 static_assert(same(width<metre, int>(3 * m) % width<metre, int>(2 * m), width<metre, int>(1 * m)));
 
 static_assert(is_same_v<
-  decltype((width<metre, std::uint8_t>(0 * m) % width<metre, std::uint8_t>(0 * m)).common().count()),
+  decltype((width<metre, std::uint8_t>(0 * m) % width<metre, std::uint8_t>(0 * m)).common().number()),
   decltype(std::uint8_t(0) % std::uint8_t(0))>);
 
 static_assert(!std::is_invocable_v<std::multiplies<>, reference<dim_length, metre>, width<metre>>);
diff --git a/test/unit_test/static/quantity_point_kind_test.cpp b/test/unit_test/static/quantity_point_kind_test.cpp
index 50717cfe..0eba1ae1 100644
--- a/test/unit_test/static/quantity_point_kind_test.cpp
+++ b/test/unit_test/static/quantity_point_kind_test.cpp
@@ -179,8 +179,8 @@ static_assert(same(abscissa<metre>{}.relative(), width<metre>{}));
 
 static_assert(abscissa<metre, unsigned>::min().relative().common() == 0 * m);
 static_assert(abscissa<metre, unsigned>::max().relative().common() == std::numeric_limits<unsigned>::max() * m);
-static_assert(abscissa<metre, double>::min().relative().common().count() == std::numeric_limits<double>::lowest());
-static_assert(abscissa<metre, double>::max().relative().common().count() == std::numeric_limits<double>::max());
+static_assert(abscissa<metre, double>::min().relative().common().number() == std::numeric_limits<double>::lowest());
+static_assert(abscissa<metre, double>::max().relative().common().number() == std::numeric_limits<double>::max());
 
 
 ////////////////////////
@@ -220,8 +220,8 @@ static_assert(construct_from_only<nth_apple<one, double>>(1).relative().common()
 static_assert(construct_from_only<nth_apple<one, double>>(short{1}).relative().common() == 1);
 static_assert(construct_from_only<nth_apple<one, short>>(1).relative().common() == 1);
 static_assert(construct_from_only<nth_apple<one, int>>(1).relative().common() == 1);
-static_assert(construct_from_only<nth_apple<percent, int>>(1ULL).relative().common().count() == 1);
-static_assert(construct_from_only<nth_apple<percent, double>>(1).relative().common().count() == 1);
+static_assert(construct_from_only<nth_apple<percent, int>>(1ULL).relative().common().number() == 1);
+static_assert(construct_from_only<nth_apple<percent, double>>(1).relative().common().number() == 1);
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(1.0));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(1.0));
 static_assert(!constructible_or_convertible_from<abscissa<metre, double>>(1.0));
@@ -256,8 +256,8 @@ static_assert(!constructible_or_convertible_from<abscissa<metre, int>>(1s));
 static_assert(construct_from_only<nth_apple<one, int>>(quantity(1)).relative().common() == 1);
 static_assert(construct_from_only<nth_apple<one, double>>(dimensionless<percent>(1)).relative().common() == 0.01);
 static_assert(construct_from_only<nth_apple<one, double>>(dimensionless<percent>(1)).relative().common() == 0.01);
-static_assert(construct_from_only<nth_apple<percent, double>>(dimensionless<percent>(1)).relative().common().count() == 1);
-static_assert(construct_from_only<nth_apple<percent, double>>(quantity(1)).relative().common().count() == 100);
+static_assert(construct_from_only<nth_apple<percent, double>>(dimensionless<percent>(1)).relative().common().number() == 1);
+static_assert(construct_from_only<nth_apple<percent, double>>(quantity(1)).relative().common().number() == 100);
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(quantity(1.0)));
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(dimensionless<percent>(1)));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(quantity(1.0)));
@@ -293,8 +293,8 @@ static_assert(construct_from_only<nth_apple<one, double>>(quantity_point(1)).rel
 static_assert(construct_from_only<nth_apple<one, double>>(quantity_point(dimensionless<percent, int>(1))).relative().common() == 0.01);
 static_assert(construct_from_only<nth_apple<one, double>>(quantity_point(1.0)).relative().common() == 1);
 static_assert(construct_from_only<nth_apple<one, double>>(quantity_point(dimensionless<percent, double>(1.0))).relative().common() == 0.01);
-static_assert(construct_from_only<nth_apple<percent, int>>(quantity_point(1)).relative().common().count() == 100);
-static_assert(construct_from_only<nth_apple<percent, double>>(quantity_point(dimensionless<percent>(1))).relative().common().count() == 1);
+static_assert(construct_from_only<nth_apple<percent, int>>(quantity_point(1)).relative().common().number() == 100);
+static_assert(construct_from_only<nth_apple<percent, double>>(quantity_point(dimensionless<percent>(1))).relative().common().number() == 1);
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(quantity_point(1.0)));
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(quantity_point(dimensionless<percent>(1))));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(quantity_point(1.0)));
@@ -327,8 +327,8 @@ static_assert(!constructible_or_convertible_from<abscissa<metre, int>>(abscissa_
 
 static_assert(construct_from_only<nth_apple<one, int>>(apples<one, int>(1)).relative().common() == 1);
 static_assert(construct_from_only<nth_apple<one, double>>(apples<percent, double>(dimensionless<percent>(1))).relative().common() == 0.01);
-static_assert(construct_from_only<nth_apple<percent, int>>(apples<one, int>(1)).relative().common().count() == 100);
-static_assert(construct_from_only<nth_apple<percent, double>>(apples<percent, double>(dimensionless<percent>(1))).relative().common().count() == 1);
+static_assert(construct_from_only<nth_apple<percent, int>>(apples<one, int>(1)).relative().common().number() == 100);
+static_assert(construct_from_only<nth_apple<percent, double>>(apples<percent, double>(dimensionless<percent>(1))).relative().common().number() == 1);
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(apples<one, double>(1.0)));
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(apples<percent, double>(dimensionless<percent>(1))));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(apples<one, double>(1.0)));
@@ -354,8 +354,8 @@ static_assert(!constructible_or_convertible_from<abscissa<metre, int>>(quantity_
 
 static_assert(construct_and_convert_from<nth_apple<one, int>>(nth_apple<one, int>(1)).relative().common() == 1);
 static_assert(construct_and_convert_from<nth_apple<one, double>>(nth_apple<percent, double>(dimensionless<percent>(1))).relative().common() == 0.01);
-static_assert(construct_and_convert_from<nth_apple<percent, int>>(nth_apple<one, int>(1)).relative().common().count() == 100);
-static_assert(construct_and_convert_from<nth_apple<percent, double>>(nth_apple<percent, double>(dimensionless<percent>(1))).relative().common().count() == 1);
+static_assert(construct_and_convert_from<nth_apple<percent, int>>(nth_apple<one, int>(1)).relative().common().number() == 100);
+static_assert(construct_and_convert_from<nth_apple<percent, double>>(nth_apple<percent, double>(dimensionless<percent>(1))).relative().common().number() == 1);
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(nth_apple<one, double>(1.0)));
 static_assert(!constructible_or_convertible_from<nth_apple<percent, int>>(nth_apple<percent, double>(dimensionless<percent>(1))));
 static_assert(!constructible_or_convertible_from<nth_apple<one, int>>(nth_apple<one, double>(1.0)));
diff --git a/test/unit_test/static/quantity_point_test.cpp b/test/unit_test/static/quantity_point_test.cpp
index 4034d998..12f2a66f 100644
--- a/test/unit_test/static/quantity_point_test.cpp
+++ b/test/unit_test/static/quantity_point_test.cpp
@@ -99,11 +99,11 @@ static_assert([]() { quantity_point<dim_length, metre, int> l1(1_q_m), l2{}; ret
 
 // static member functions
 
-static_assert(quantity_point<dim_length, metre, int>::min().relative().count() == std::numeric_limits<int>::lowest());
-static_assert(quantity_point<dim_length, metre, int>::max().relative().count() == std::numeric_limits<int>::max());
-static_assert(quantity_point<dim_length, metre, double>::min().relative().count() ==
+static_assert(quantity_point<dim_length, metre, int>::min().relative().number() == std::numeric_limits<int>::lowest());
+static_assert(quantity_point<dim_length, metre, int>::max().relative().number() == std::numeric_limits<int>::max());
+static_assert(quantity_point<dim_length, metre, double>::min().relative().number() ==
               std::numeric_limits<double>::lowest());
-static_assert(quantity_point<dim_length, metre, double>::max().relative().count() ==
+static_assert(quantity_point<dim_length, metre, double>::max().relative().number() ==
               std::numeric_limits<double>::max());
 
 // unary member operators
@@ -127,8 +127,8 @@ static_assert([](auto v) {
 
 // compound assignment
 
-static_assert((quantity_point(1_q_m) += 1_q_m).relative().count() == 2);
-static_assert((quantity_point(2_q_m) -= 1_q_m).relative().count() == 1);
+static_assert((quantity_point(1_q_m) += 1_q_m).relative().number() == 2);
+static_assert((quantity_point(2_q_m) -= 1_q_m).relative().number() == 1);
 
 // non-member arithmetic operators
 
@@ -151,10 +151,10 @@ static_assert(
     compare<decltype(quantity_point<dim_length, kilometre, double>() - quantity_point<dim_length, metre, int>()),
                    length<metre, double>>);
 
-static_assert((1_q_m + km).relative().count() == 1001);
-static_assert((quantity_point(1_q_m) + 1_q_km).relative().count() == 1001);
-static_assert((km - 1_q_m).relative().count() == 999);
-static_assert((quantity_point(1_q_km) - quantity_point(1_q_m)).count() == 999);
+static_assert((1_q_m + km).relative().number() == 1001);
+static_assert((quantity_point(1_q_m) + 1_q_km).relative().number() == 1001);
+static_assert((km - 1_q_m).relative().number() == 999);
+static_assert((quantity_point(1_q_km) - quantity_point(1_q_m)).number() == 999);
 
 // comparators
 
@@ -221,19 +221,19 @@ static_assert(std::equality_comparable_with<decltype(quantity_point(1_q_m)), dec
 
 // quantity_cast
 
-static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(2_q_km)).relative().count() ==
+static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(2_q_km)).relative().number() ==
               2000);
 static_assert(
-    quantity_point_cast<quantity_point<dim_length, kilometre, int>>(quantity_point(2000_q_m)).relative().count() == 2);
-static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(1.23_q_m)).relative().count() ==
+    quantity_point_cast<quantity_point<dim_length, kilometre, int>>(quantity_point(2000_q_m)).relative().number() == 2);
+static_assert(quantity_point_cast<quantity_point<dim_length, metre, int>>(quantity_point(1.23_q_m)).relative().number() ==
               1);
-static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2_q_km)).relative().count() == 2000);
-static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000_q_m)).relative().count() == 2);
-static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23_q_m)).relative().count() == 1);
-static_assert(quantity_point_cast<metre>(quantity_point(2_q_km)).relative().count() == 2000);
-static_assert(quantity_point_cast<kilometre>(quantity_point(2000_q_m)).relative().count() == 2);
-static_assert(quantity_point_cast<int>(quantity_point(1.23_q_m)).relative().count() == 1);
-static_assert(quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().count() == 2);
+static_assert(quantity_point_cast<length<metre, int>>(quantity_point(2_q_km)).relative().number() == 2000);
+static_assert(quantity_point_cast<length<kilometre, int>>(quantity_point(2000_q_m)).relative().number() == 2);
+static_assert(quantity_point_cast<length<metre, int>>(quantity_point(1.23_q_m)).relative().number() == 1);
+static_assert(quantity_point_cast<metre>(quantity_point(2_q_km)).relative().number() == 2000);
+static_assert(quantity_point_cast<kilometre>(quantity_point(2000_q_m)).relative().number() == 2);
+static_assert(quantity_point_cast<int>(quantity_point(1.23_q_m)).relative().number() == 1);
+static_assert(quantity_point_cast<dim_speed, kilometre_per_hour>(quantity_point(2000.0_q_m / 3600.0_q_s)).relative().number() == 2);
 
 // time
 
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index 8f0960e1..09f1ae38 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -106,12 +106,12 @@ static_assert(is_same_v<fps::length<fps::mile>::rep, double>);
 // static member functions
 ////////////////////////////
 
-static_assert(length<metre, int>::zero().count() == 0);
-static_assert(length<metre, int>::min().count() == std::numeric_limits<int>::lowest());
-static_assert(length<metre, int>::max().count() == std::numeric_limits<int>::max());
-static_assert(length<metre, double>::zero().count() == 0.0);
-static_assert(length<metre, double>::min().count() == std::numeric_limits<double>::lowest());
-static_assert(length<metre, double>::max().count() == std::numeric_limits<double>::max());
+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());
 
 
 //////////////////////////////
@@ -182,11 +182,11 @@ 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>().count() == 0); // value initialization
-static_assert(length<metre, int>(1).count() == 1);
-static_assert(length<metre, double>(1.0).count() == 1.0);
-static_assert(length<metre, double>(1).count() == 1.0);
-static_assert(length<metre, double>(3.14).count() == 3.14);
+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);
 
 
 ///////////////////////////////////////
@@ -226,10 +226,10 @@ 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(length<metre, int>(123_q_m).count() == 123);
-static_assert(length<kilometre, int>(2_q_km).count() == 2);
-static_assert(length<metre, int>(2_q_km).count() == 2000);
-static_assert(length<kilometre>(1500_q_m).count() == 1.5);
+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);
 
 
 /////////
@@ -248,25 +248,25 @@ static_assert(is_same_v<decltype(quantity{1.23}), dimensionless<one, double>>);
 // assignment operator
 ////////////////////////
 
-static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = l1; }().count() == 1);
-static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = std::move(l1); }().count() == 1);
+static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = l1; }().number() == 1);
+static_assert([]() { length<metre, int> l1(1), l2(2); return l2 = std::move(l1); }().number() == 1);
 
 
 ////////////////////
 // unary operators
 ////////////////////
 
-static_assert((+123_q_m).count() == 123);
-static_assert((-123_q_m).count() == -123);
-static_assert((+(-123_q_m)).count() == -123);
-static_assert((-(-123_q_m)).count() == 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_q_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));
 static_assert([](auto v) { auto vv = ++v; return std::pair(v, vv); }(123_q_m) == std::pair(124_q_m, 124_q_m));
 static_assert([](auto v) { auto vv = v--; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 123_q_m));
 static_assert([](auto v) { auto vv = --v; return std::pair(v, vv); }(123_q_m) == std::pair(122_q_m, 122_q_m));
 
-static_assert(is_same_v<decltype((+(short{0} * m)).count()), int>);
+static_assert(is_same_v<decltype((+(short{0} * m)).number()), int>);
 
 
 ////////////////////////
@@ -274,42 +274,42 @@ static_assert(is_same_v<decltype((+(short{0} * m)).count()), int>);
 ////////////////////////
 
 // same type
-static_assert((1_q_m += 1_q_m).count() == 2);
-static_assert((2_q_m -= 1_q_m).count() == 1);
-static_assert((1_q_m *= 2).count() == 2);
-static_assert((2_q_m /= 2).count() == 1);
-static_assert((7_q_m %= 2).count() == 1);
-static_assert((1_q_m *= quantity(2)).count() == 2);
-static_assert((2_q_m /= quantity(2)).count() == 1);
-static_assert((7_q_m %= quantity(2)).count() == 1);
-static_assert((7_q_m %= 2_q_m).count() == 1);
+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);
 
 // different types
-static_assert((2.5_q_m += 3_q_m).count() == 5.5);
-static_assert((123_q_m += 1_q_km).count() == 1123);
-static_assert((5.5_q_m -= 3_q_m).count() == 2.5);
-static_assert((1123_q_m -= 1_q_km).count() == 123);
-static_assert((2.5_q_m *= 3).count() == 7.5);
-static_assert((7.5_q_m /= 3).count() == 2.5);
-static_assert((2.5_q_m *= quantity(3)).count() == 7.5);
-static_assert((7.5_q_m /= quantity(3)).count() == 2.5);
-static_assert((3500_q_m %= 1_q_km).count() == 500);
+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((std::uint8_t(255) * m %= 256).count() == [] { std::uint8_t ui(255); return ui %= 256; }());
-static_assert((std::uint8_t(255) * m %= quantity(256)).count() == [] { std::uint8_t ui(255); return ui %= 256; }());
-// static_assert((std::uint8_t(255) * m %= 256 * m).count() != [] { std::uint8_t ui(255); return ui %= 256; }());  // UB
-static_assert((std::uint8_t(255) * m %= 257).count() == [] { std::uint8_t ui(255); return ui %= 257; }());
-static_assert((std::uint8_t(255) * m %= quantity(257)).count() == [] { std::uint8_t ui(255); return ui %= 257; }());
+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() == [] { std::uint8_t ui(255); return ui %= 256; }());
+// static_assert((std::uint8_t(255) * m %= 256 * m).number() != [] { std::uint8_t ui(255); return ui %= 256; }());  // UB
+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() == [] { std::uint8_t ui(255); return ui %= 257; }());
 // TODO: Fix
-static_assert((std::uint8_t(255) * m %= 257 * m).count() != [] { std::uint8_t ui(255); return ui %= 257; }());
+static_assert((std::uint8_t(255) * m %= 257 * m).number() != [] { std::uint8_t ui(255); return ui %= 257; }());
 
 #ifndef UNITS_COMP_MSVC  // TODO ICE (https://developercommunity2.visualstudio.com/t/ICE-on-a-constexpr-operator-in-mp-unit/1302907)
 // next two lines trigger conversions warnings
 // (warning disabled in CMake for this file)
-static_assert((22_q_m *= 33.33).count() == 733);
-static_assert((22_q_m /= 3.33).count() == 6);
-static_assert((22_q_m *= quantity(33.33)).count() == 733);
-static_assert((22_q_m /= quantity(3.33)).count() == 6);
+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);
 #endif
 
 template<typename Metre, typename Kilometre>
@@ -403,12 +403,12 @@ 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<ratio(1, 100), hertz>, std::int64_t>>);
 
-static_assert(is_same_v<decltype((std::uint8_t(0) * m + std::uint8_t(0) * m).count()), int>);
-static_assert(is_same_v<decltype((std::uint8_t(0) * m - std::uint8_t(0) * m).count()), int>);
-static_assert((std::uint8_t(128) * m + std::uint8_t(128) * m).count() == std::uint8_t(128) + std::uint8_t(128));
-static_assert((std::uint8_t(0) * m - std::uint8_t(1) * m).count() == std::uint8_t(0) - std::uint8_t(1));
+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));
+static_assert((std::uint8_t(0) * m - std::uint8_t(1) * m).number() == std::uint8_t(0) - std::uint8_t(1));
 
-static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m)).count()),
+static_assert(is_same_v<decltype(((std::uint8_t(0) * m) % (std::uint8_t(0) * m)).number()),
                         decltype(std::uint8_t(0) % std::uint8_t(0))>);
 
 // different representation types
@@ -487,75 +487,75 @@ static_assert(compare<decltype(1_q_m / 1_q_s), speed<metre_per_second, std::int6
 static_assert(compare<decltype(1_q_m / 1_q_min), speed<scaled_unit<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<ratio(60), unknown_coherent_unit>, std::int64_t>>);
 
-static_assert((1_q_m + 1_q_m).count() == 2);
-static_assert((1_q_m + 1_q_km).count() == 1001);
-static_assert((1_q_km + 1_q_m).count() == 1001);
-static_assert((2_q_m - 1_q_m).count() == 1);
-static_assert((1_q_km - 1_q_m).count() == 999);
-static_assert((2_q_m * 2).count() == 4);
-static_assert((2_q_m * quantity{2}).count() == 4);
-static_assert((2_q_m * dimensionless<percent, int>(2)).count() == 4);
-static_assert((3 * 3_q_m).count() == 9);
-static_assert((quantity{3} * 3_q_m).count() == 9);
-static_assert((dimensionless<percent, int>(3) * 3_q_m).count() == 9);
-static_assert((4_q_m / 2).count() == 2);
-static_assert((4_q_m / quantity{2}).count() == 2);
-static_assert((4_q_m / dimensionless<percent, int>(2)).count() == 2);
-static_assert((4_q_km / 2_q_m).count() == 2);
-static_assert((4000_q_m / 2_q_m).count() == 2000);
+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.5_q_m + 1_q_m).count() == 2.5);
-static_assert((1.5_q_m + 1_q_km).count() == 1001.5);
-static_assert((1.5_q_km + 1_q_m).count() == 1501);
-static_assert((2.5_q_m - 1_q_m).count() == 1.5);
-static_assert((1.5_q_km - 1_q_m).count() == 1499);
-static_assert((2.5_q_m * 2).count() == 5);
-static_assert((2.5_q_m * quantity{2}).count() == 5);
-static_assert((2.5_q_m * dimensionless<percent, int>(2)).count() == 5);
-static_assert((2.5L * 2_q_m).count() == 5);
-static_assert((quantity{2.5L} * 2_q_m).count() == 5);
-static_assert((dimensionless<percent, long double>(2.5L) * 2_q_m).count() == 5);
-static_assert((5._q_m / 2).count() == 2.5);
-static_assert((5._q_m / quantity{2}).count() == 2.5);
-static_assert((5._q_m / dimensionless<percent, int>(2)).count() == 2.5);
-static_assert((5._q_km / 2_q_m).count() == 2.5);
-static_assert((5000._q_m / 2_q_m).count() == 2500);
+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_q_m + 1.5_q_m).count() == 2.5);
-static_assert((1_q_m + 1.5_q_km).count() == 1501);
-static_assert((1_q_km + 1.5_q_m).count() == 1001.5);
-static_assert((2_q_m - 1.5_q_m).count() == 0.5);
-static_assert((1_q_km - 1.5_q_m).count() == 998.5);
-static_assert((2_q_m * 2.5L).count() == 5);
-static_assert((2_q_m * quantity{2.5L}).count() == 5);
-static_assert((2_q_m * dimensionless<percent, long double>(2.5L)).count() == 5);
-static_assert((2 * 2.5_q_m).count() == 5);
-static_assert((quantity{2} * 2.5_q_m).count() == 5);
-static_assert((dimensionless<percent, int>(2) * 2.5_q_m).count() == 5);
-static_assert((5_q_m / 2.5L).count() == 2);
-static_assert((5_q_m / quantity{2.5L}).count() == 2);
-static_assert((5_q_m / dimensionless<percent, long double>(2.5L)).count() == 2);
-static_assert((5_q_km / 2.5_q_m).count() == 2);
-static_assert((5000_q_m / 2.5_q_m).count() == 2000);
+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((7_q_m % 2).count() == 1);
-static_assert((7_q_m % quantity{2}).count() == 1);
-static_assert((7_q_m % dimensionless<percent, int>(2)).count() == 1);
-static_assert((7_q_m % 2_q_m).count() == 1);
-static_assert((7_q_km % 2000_q_m).count() == 1000);
+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() == 1000);
 
 static_assert((10_q_km2 * 10_q_km2) / 50_q_km2 == 2_q_km2);
 
-static_assert((10_q_km / 5_q_m).count() == 2);
-static_assert(dimensionless<one>(10_q_km / 5_q_m).count() == 2000);
+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).count() == 2000);
+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).count() == 2000);
+static_assert(quantity_cast<one>(10_q_km / 5_q_m).number() == 2000);
 #endif
 
-static_assert((10_q_s * 2_q_kHz).count() == 20);
+static_assert((10_q_s * 2_q_kHz).number() == 20);
 
 // unit constants
 
@@ -592,13 +592,13 @@ 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)}).count()), int>);
-static_assert(is_same_v<decltype((quantity{std::uint8_t(0)} - quantity{std::uint8_t(0)}).count()), int>);
-static_assert((quantity{std::uint8_t(128)} + quantity{std::uint8_t(128)}).count() ==
+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)}).count() == std::uint8_t(0) - std::uint8_t(1));
+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)}).count()),
+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);
@@ -731,13 +731,13 @@ 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).count() == 50);
+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).count() == 50);
+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)).count() == 0.5);
+static_assert(dimensionless<one>(dimensionless<percent>(50)).number() == 0.5);
 
 
 ////////////////
@@ -755,13 +755,13 @@ static_assert(2_q_dm3 + 2_q_cm3 == 2002_q_ml);
 // quantity_cast
 //////////////////
 
-static_assert(quantity_cast<length<metre, int>>(2_q_km).count() == 2000);
-static_assert(quantity_cast<length<kilometre, int>>(2000_q_m).count() == 2);
-static_assert(quantity_cast<length<metre, int>>(1.23_q_m).count() == 1);
-static_assert(quantity_cast<metre>(2_q_km).count() == 2000);
-static_assert(quantity_cast<kilometre>(2000_q_m).count() == 2);
-static_assert(quantity_cast<int>(1.23_q_m).count() == 1);
-static_assert(quantity_cast<dim_speed, kilometre_per_hour>(2000.0_q_m / 3600.0_q_s).count() == 2);
+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);
 
diff --git a/test/unit_test/static/si_test.cpp b/test/unit_test/static/si_test.cpp
index 6f313992..1afe224e 100644
--- a/test/unit_test/static/si_test.cpp
+++ b/test/unit_test/static/si_test.cpp
@@ -105,7 +105,7 @@ static_assert(120 / 1_q_min == 2_q_Hz);
 static_assert(1000 / 1_q_s == 1_q_kHz);
 static_assert(1 / 1_q_ms == 1_q_kHz);
 static_assert(3.2_q_GHz == 3'200'000'000_q_Hz);
-static_assert((10_q_Hz * 1_q_min).count() == 10);
+static_assert((10_q_Hz * 1_q_min).number() == 10);
 static_assert(10_q_Hz * 1_q_min == dimensionless<scaled_unit<ratio(60), one>>(10));
 static_assert(10_q_Hz * 1_q_min == dimensionless<one>(600));
 static_assert(2 / 1_q_Hz == 2_q_s);