diff --git a/src/include/units/bits/base_units_ratio.h b/src/include/units/bits/base_units_ratio.h
index 06ef2a5c..50d505c5 100644
--- a/src/include/units/bits/base_units_ratio.h
+++ b/src/include/units/bits/base_units_ratio.h
@@ -32,7 +32,7 @@ template<Exponent E>
   requires (E::den == 1 || E::den == 2) // TODO provide support for any den
 struct exp_ratio {
   using base_ratio = E::dimension::base_unit::ratio;
-  using positive_ratio = conditional<E::num * E::den < 0, ratio<base_ratio::den, base_ratio::num>, base_ratio>;
+  using positive_ratio = conditional<E::num * E::den < 0, ratio<base_ratio::den, base_ratio::num, -base_ratio::exp>, base_ratio>;
   static constexpr std::int64_t N = E::num * E::den < 0 ? -E::num : E::num;
   using pow = ratio_pow<positive_ratio, N>;
   using type = conditional<E::den == 2, ratio_sqrt<pow>, pow>;
diff --git a/src/include/units/bits/unit_text.h b/src/include/units/bits/unit_text.h
index bed0f58d..850e7f57 100644
--- a/src/include/units/bits/unit_text.h
+++ b/src/include/units/bits/unit_text.h
@@ -29,13 +29,19 @@ namespace units::detail {
 template<typename Ratio>
 constexpr auto ratio_text()
 {
-  if constexpr(Ratio::num != 1 || Ratio::den != 1) {
+  if constexpr(Ratio::num != 1 || Ratio::den != 1 || Ratio::exp != 0) {
     auto txt = basic_fixed_string("[") + regular<Ratio::num>();
-    if constexpr(Ratio::den == 1) {
+    if constexpr(Ratio::den == 1 && Ratio::exp == 0) {
       return txt + basic_fixed_string("]");
     }
+    else if constexpr (Ratio::den == 1) {
+      return txt + basic_fixed_string(" x 10") + superscript<Ratio::exp>() +
+          basic_fixed_string("]");
+    }
     else {
-      return txt + basic_fixed_string("/") + regular<Ratio::den>() + basic_fixed_string("]");
+      return txt + basic_fixed_string("/") + regular<Ratio::den>() +
+          basic_fixed_string(" x 10") + superscript<Ratio::exp>() +
+          basic_fixed_string("]");
     }
   }
   else {
@@ -46,7 +52,7 @@ constexpr auto ratio_text()
 template<typename Ratio, typename PrefixType>
 constexpr auto prefix_or_ratio_text()
 {
-  if constexpr(Ratio::num == 1 && Ratio::den == 1) {
+  if constexpr(Ratio::num == 1 && Ratio::den == 1 && Ratio::exp == 0) {
     // no ratio/prefix
     return basic_fixed_string("");
   }
diff --git a/src/include/units/physical/si/prefixes.h b/src/include/units/physical/si/prefixes.h
index 6c09b90a..541ce36d 100644
--- a/src/include/units/physical/si/prefixes.h
+++ b/src/include/units/physical/si/prefixes.h
@@ -31,21 +31,23 @@ struct prefix : prefix_type {};
 
 // TODO Remove dependency on std::ratio
 
-struct atto : units::prefix<atto, prefix, "a", ratio<1, std::atto::den>> {};
-struct femto : units::prefix<femto, prefix, "f", ratio<1, std::femto::den>> {};
-struct pico : units::prefix<pico, prefix, "p", ratio<1, std::pico::den>> {};
-struct nano : units::prefix<nano, prefix, "n", ratio<1, std::nano::den>> {};
-struct micro : units::prefix<micro, prefix, "\u00b5", ratio<1, std::micro::den>> {};
-struct milli : units::prefix<milli, prefix, "m", ratio<1, std::milli::den>> {};
-struct centi : units::prefix<centi, prefix, "c", ratio<1, std::centi::den>> {};
-struct deci : units::prefix<deci, prefix, "d", ratio<1, std::deci::den>> {};
-struct deca : units::prefix<deca, prefix, "da", ratio<std::deca::num>> {};
-struct hecto : units::prefix<hecto, prefix, "h", ratio<std::hecto::num>> {};
-struct kilo : units::prefix<kilo, prefix, "k", ratio<std::kilo::num>> {};
-struct mega : units::prefix<mega, prefix, "M", ratio<std::mega::num>> {};
-struct giga : units::prefix<giga, prefix, "G", ratio<std::giga::num>> {};
-struct tera : units::prefix<tera, prefix, "T", ratio<std::tera::num>> {};
-struct peta : units::prefix<peta, prefix, "P", ratio<std::peta::num>> {};
-struct exa : units::prefix<exa, prefix, "E", ratio<std::exa::num>> {};
+// clang-format off
+struct atto   : units::prefix<atto,   prefix, "a",      ratio<1, 1, -18>> {}; // std::atto::den>> {};
+struct femto  : units::prefix<femto,  prefix, "f",      ratio<1, 1, -15>> {}; // std::femto::den>> {};
+struct pico   : units::prefix<pico,   prefix, "p",      ratio<1, 1, -12>> {}; // std::pico::den>> {};
+struct nano   : units::prefix<nano,   prefix, "n",      ratio<1, 1,  -9>> {}; // std::nano::den>> {};
+struct micro  : units::prefix<micro,  prefix, "\u00b5", ratio<1, 1,  -6>> {}; // std::micro::den>> {};
+struct milli  : units::prefix<milli,  prefix, "m",      ratio<1, 1,  -3>> {}; // std::milli::den>> {};
+struct centi  : units::prefix<centi,  prefix, "c",      ratio<1, 1,  -2>> {}; // std::centi::den>> {};
+struct deci   : units::prefix<deci,   prefix, "d",      ratio<1, 1,  -1>> {}; // std::deci::den>> {};
+struct deca   : units::prefix<deca,   prefix, "da",     ratio<1, 1,   1>> {}; // std::deca::num>> {};
+struct hecto  : units::prefix<hecto,  prefix, "h",      ratio<1, 1,   2>> {}; // std::hecto::num>> {};
+struct kilo   : units::prefix<kilo,   prefix, "k",      ratio<1, 1,   3>> {}; // std::kilo::num>> {};
+struct mega   : units::prefix<mega,   prefix, "M",      ratio<1, 1,   6>> {}; // std::mega::num>> {};
+struct giga   : units::prefix<giga,   prefix, "G",      ratio<1, 1,   9>> {}; // std::giga::num>> {};
+struct tera   : units::prefix<tera,   prefix, "T",      ratio<1, 1,  12>> {}; // std::tera::num>> {};
+struct peta   : units::prefix<peta,   prefix, "P",      ratio<1, 1,  15>> {}; // std::peta::num>> {};
+struct exa    : units::prefix<exa,    prefix, "E",      ratio<1, 1,  18>> {}; // std::exa::num>> {};
+// clang-format off
 
 }  // namespace units::si
diff --git a/src/include/units/prefix.h b/src/include/units/prefix.h
index eaded432..fb923521 100644
--- a/src/include/units/prefix.h
+++ b/src/include/units/prefix.h
@@ -30,14 +30,14 @@ namespace units {
 
 /**
  * @brief The base for all prefix types
- * 
+ *
  * Every prefix type should inherit from this type to satisfy PrefixType concept.
  */
 struct prefix_type {};
 
 /**
  * @brief No prefix possible for the unit
- * 
+ *
  * This is a special prefix type tag specifying that the unit can not be scaled with any kind
  * of the prefix.
  */
@@ -55,14 +55,14 @@ struct prefix_base : downcast_base<prefix_base<PT, R>> {
 
 /**
  * @brief A prefix used to scale units
- * 
+ *
  * Data from a prefix class is used in two cases:
  * - when defining a prefixed_unit its ratio is used to scale the reference unit and its
  *   symbol is used to prepend to the symbol of referenced unit
  * - when printing the symbol of a scaled unit that was not predefined by the user but its
  *   factor matches ratio of a prefix from the specified prefix family, its symbol will be
  *   prepended to the symbol of the unit
- * 
+ *
  * @tparam Child inherited class type used by the downcasting facility (CRTP Idiom)
  * @tparam PT a type of prefix family
  * @tparam Symbol a text representation of the prefix
@@ -70,7 +70,7 @@ struct prefix_base : downcast_base<prefix_base<PT, R>> {
  */
 template<typename Child, PrefixType PT, basic_fixed_string Symbol, Ratio R>
   requires (!std::same_as<PT, no_prefix>)
-struct prefix : downcast_child<Child, detail::prefix_base<PT, ratio<R::num, R::den>>> {
+struct prefix : downcast_child<Child, detail::prefix_base<PT, ratio<R::num, R::den, R::exp>>> {
   static constexpr auto symbol = Symbol;
 };
 
diff --git a/src/include/units/quantity.h b/src/include/units/quantity.h
index c8789c4e..ebcfe6ba 100644
--- a/src/include/units/quantity.h
+++ b/src/include/units/quantity.h
@@ -32,6 +32,7 @@
 #endif
 
 #include <ostream>
+#include <iostream>
 
 namespace units {
 
@@ -51,10 +52,10 @@ concept safe_divisible = // exposition only
 
 /**
  * @brief A quantity
- * 
+ *
  * Property of a phenomenon, body, or substance, where the property has a magnitude that can be
  * expressed by means of a number and a measurement unit.
- * 
+ *
  * @tparam D a dimension of the quantity (can be either a BaseDimension or a DerivedDimension)
  * @tparam U a measurement unit of the quantity
  * @tparam Rep a type to be used to represent values of a quantity
@@ -352,7 +353,7 @@ template<typename D1, typename U1, typename Rep1, typename D2, typename U2, type
 {
   using common_rep = decltype(lhs.count() * rhs.count());
   using ratio = ratio_multiply<typename U1::ratio, typename U2::ratio>;
-  return common_rep(lhs.count()) * common_rep(rhs.count()) * common_rep(ratio::num) / common_rep(ratio::den);
+  return common_rep(lhs.count()) * common_rep(rhs.count()) * common_rep(ratio::num) * std::pow(10, common_rep(ratio::exp)) / common_rep(ratio::den);
 }
 
 template<typename D1, typename U1, typename Rep1, typename D2, typename U2, typename Rep2>
@@ -376,7 +377,7 @@ template<Scalar Value, typename D, typename U, typename Rep>
   Expects(q.count() != 0);
 
   using dim = dim_invert<D>;
-  using ratio = ratio<U::ratio::den, U::ratio::num>;
+  using ratio = ratio<U::ratio::den, U::ratio::num, -U::ratio::exp>;
   using unit = downcast_unit<dim, ratio>;
   using common_rep = decltype(v / q.count());
   using ret = quantity<dim, unit, common_rep>;
diff --git a/src/include/units/quantity_cast.h b/src/include/units/quantity_cast.h
index 4906995b..ac019d82 100644
--- a/src/include/units/quantity_cast.h
+++ b/src/include/units/quantity_cast.h
@@ -24,6 +24,7 @@
 
 #include <units/concepts.h>
 #include <units/bits/dimension_op.h>
+#include <cmath>
 
 namespace units {
 
@@ -41,10 +42,15 @@ struct quantity_cast_impl {
   {
     if constexpr (treat_as_floating_point<CRep>) {
       return To(static_cast<To::rep>(static_cast<CRep>(q.count()) *
-                                     (static_cast<CRep>(CRatio::num) / static_cast<CRep>(CRatio::den))));
+                                     static_cast<CRep>(std::pow(10, CRatio::exp)) *
+                                     (static_cast<CRep>(CRatio::num) /
+                                      static_cast<CRep>(CRatio::den))));
     } else {
-      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(CRatio::num) /
-                                     static_cast<CRep>(CRatio::den)));
+      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) *
+                                     static_cast<CRep>(CRatio::num) *
+                                     static_cast<CRep>(CRatio::exp > 0 ? std::pow(10, CRatio::exp) : 1) /
+                                     (static_cast<CRep>(CRatio::den) *
+                                      static_cast<CRep>(CRatio::exp < 0 ? std::pow(10, -CRatio::exp) : 1))));
     }
   }
 };
@@ -54,7 +60,7 @@ struct quantity_cast_impl<To, CRatio, CRep, true, true> {
   template<Quantity Q>
   static constexpr To cast(const Q& q)
   {
-    return To(static_cast<To::rep>(q.count()));
+    return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(std::pow(10, CRatio::exp))));
   }
 };
 
@@ -64,9 +70,9 @@ struct quantity_cast_impl<To, CRatio, CRep, true, false> {
   static constexpr To cast(const Q& q)
   {
     if constexpr (treat_as_floating_point<CRep>) {
-      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * (CRep{1} / static_cast<CRep>(CRatio::den))));
+      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(std::pow(10, CRatio::exp)) * (CRep{1} / static_cast<CRep>(CRatio::den))));
     } else {
-      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) / static_cast<CRep>(CRatio::den)));
+      return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(std::pow(10, CRatio::exp)) / static_cast<CRep>(CRatio::den)));
     }
   }
 };
@@ -76,7 +82,7 @@ struct quantity_cast_impl<To, CRatio, CRep, false, true> {
   template<Quantity Q>
   static constexpr To cast(const Q& q)
   {
-    return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(CRatio::num)));
+    return To(static_cast<To::rep>(static_cast<CRep>(q.count()) * static_cast<CRep>(CRatio::num) * static_cast<CRep>(std::pow(10, CRatio::exp))));
   }
 };
 
@@ -105,14 +111,14 @@ struct cast_ratio<FromD, FromU, ToD, ToU> {
 
 /**
  * @brief Explcit cast of a quantity
- * 
+ *
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (i.e. non-truncating) conversion. In such cases an explicit cast have to be used.
- * 
+ *
  * This cast gets the target quantity type to cast to. For example:
- * 
+ *
  * auto q1 = units::quantity_cast<units::si::time<units::si::second>>(1ms);
- * 
+ *
  * @tparam To a target quantity type to cast to
  */
 template<Quantity To, typename D, typename U, typename Rep>
@@ -124,20 +130,20 @@ template<Quantity To, typename D, typename U, typename Rep>
   using c_rep = std::common_type_t<typename To::rep, Rep, intmax_t>;
   using ret_unit = downcast_unit<typename To::dimension, typename To::unit::ratio>;
   using ret = quantity<typename To::dimension, ret_unit, typename To::rep>;
-  using cast = detail::quantity_cast_impl<ret, c_ratio, c_rep, c_ratio::num == 1, c_ratio::den == 1>;
+  using cast = detail::quantity_cast_impl<ret, c_ratio, c_rep, c_ratio::num == 1 && c_ratio::exp == 0, c_ratio::den == 1 && c_ratio::exp == 0>;
   return cast::cast(q);
 }
 
 /**
  * @brief Explcit cast of a quantity
- * 
+ *
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (i.e. non-truncating) conversion. In such cases an explicit cast have to be used.
- * 
+ *
  * This cast gets only the target dimension to cast to. For example:
- * 
+ *
  * auto q1 = units::quantity_cast<units::si::acceleration>(200Gal);
- * 
+ *
  * @tparam ToD a dimension type to use for a target quantity
  */
 template<Dimension ToD, typename D, typename U, typename Rep>
@@ -149,14 +155,14 @@ template<Dimension ToD, typename D, typename U, typename Rep>
 
 /**
  * @brief Explcit cast of a quantity
- * 
+ *
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (i.e. non-truncating) conversion. In such cases an explicit cast have to be used.
- * 
+ *
  * This cast gets only the target unit to cast to. For example:
- * 
+ *
  * auto q1 = units::quantity_cast<units::si::second>(1ms);
- * 
+ *
  * @tparam ToU a unit type to use for a target quantity
  */
 template<Unit ToU, typename D, typename U, typename Rep>
@@ -168,14 +174,14 @@ template<Unit ToU, typename D, typename U, typename Rep>
 
 /**
  * @brief Explcit cast of a quantity
- * 
+ *
  * Implicit conversions between quantities of different types are allowed only for "safe"
  * (i.e. non-truncating) conversion. In such cases an explicit cast have to be used.
- * 
+ *
  * This cast gets only representation to cast to. For example:
- * 
+ *
  * auto q1 = units::quantity_cast<int>(1ms);
- * 
+ *
  * @tparam ToRep a representation type to use for a target quantity
  */
 template<Scalar ToRep, typename D, typename U, typename Rep>
diff --git a/src/include/units/ratio.h b/src/include/units/ratio.h
index 6ad15cef..f7dc4da6 100644
--- a/src/include/units/ratio.h
+++ b/src/include/units/ratio.h
@@ -27,6 +27,8 @@
 #include <cstdint>
 #include <numeric>
 #include <type_traits>
+#include <tuple>
+#include <algorithm>
 
 namespace units {
 
@@ -38,24 +40,45 @@ template<typename T>
   return v < 0 ? -v : v;
 }
 
+constexpr std::tuple<std::intmax_t, std::intmax_t, std::intmax_t>  normalize(std::intmax_t num, std::intmax_t den, std::intmax_t exp) {
+  std::intmax_t gcd = std::gcd(num, den);
+  num = num * (den < 0 ? -1 : 1) / gcd;
+  den = detail::abs(den) / gcd;
+
+  while (num % 10 == 0) {
+    num /= 10;
+    ++exp;
+  }
+  while (den % 10 == 0) {
+    den /= 10;
+    --exp;
+  }
+  return std::make_tuple(num, den, exp);
+}
+
 }  // namespace detail
 
-template<std::intmax_t Num, std::intmax_t Den = 1>
+template<std::intmax_t Num, std::intmax_t Den = 1, std::intmax_t Exp = 0>
   requires(Den != 0)
 struct ratio {
   static_assert(-INTMAX_MAX <= Num, "numerator too negative");
   static_assert(-INTMAX_MAX <= Den, "denominator too negative");
 
-  static constexpr std::intmax_t num = Num * (Den < 0 ? -1 : 1) / std::gcd(Num, Den);
-  static constexpr std::intmax_t den = detail::abs(Den) / std::gcd(Num, Den);
+ private:
+  static constexpr auto norm = detail::normalize(Num, Den, Exp);
 
-  using type = ratio<num, den>;
+ public:
+  static constexpr std::intmax_t num = std::get<0>(norm);
+  static constexpr std::intmax_t den = std::get<1>(norm);
+  static constexpr std::intmax_t exp = std::get<2>(norm);
+
+  using type = ratio<num, den, exp>;
 };
 
 namespace detail {
 
-template<intmax_t Num, intmax_t Den>
-inline constexpr bool is_ratio<ratio<Num, Den>> = true;
+template<intmax_t Num, intmax_t Den, intmax_t Exp>
+inline constexpr bool is_ratio<ratio<Num, Den, Exp>> = true;
 
 }  // namespace detail
 
@@ -97,10 +120,19 @@ private:
   static constexpr std::intmax_t gcd1 = std::gcd(R1::num, R2::den);
   static constexpr std::intmax_t gcd2 = std::gcd(R2::num, R1::den);
 
+  static constexpr auto norm = detail::normalize(safe_multiply(R1::num / gcd1, R2::num / gcd2),
+                                                 safe_multiply(R1::den / gcd2, R2::den / gcd1),
+                                                 R1::exp + R2::exp);
+
+  static constexpr std::intmax_t norm_num = std::get<0>(norm);
+  static constexpr std::intmax_t norm_den = std::get<1>(norm);
+  static constexpr std::intmax_t norm_exp = std::get<2>(norm);
+
 public:
-  using type = ratio<safe_multiply(R1::num / gcd1, R2::num / gcd2), safe_multiply(R1::den / gcd2, R2::den / gcd1)>;
+  using type = ratio<norm_num, norm_den, norm_exp>;
   static constexpr std::intmax_t num = type::num;
   static constexpr std::intmax_t den = type::den;
+  static constexpr std::intmax_t exp = type::exp;
 };
 
 }  // namespace detail
@@ -115,9 +147,10 @@ namespace detail {
 template<typename R1, typename R2>
 struct ratio_divide_impl {
   static_assert(R2::num != 0, "division by 0");
-  using type = ratio_multiply<R1, ratio<R2::den, R2::num>>;
+  using type = ratio_multiply<R1, ratio<R2::den, R2::num, -R2::exp>>;
   static constexpr std::intmax_t num = type::num;
   static constexpr std::intmax_t den = type::den;
+  static constexpr std::intmax_t exp = type::exp;
 };
 
 }  // namespace detail
@@ -168,6 +201,7 @@ static constexpr std::intmax_t sqrt_impl(std::intmax_t v) { return sqrt_impl(v,
 
 template<typename R>
 struct ratio_sqrt_impl {
+  // TODO  this is broken..need /2 logic on EXP
   using type = ratio<detail::sqrt_impl(R::num), detail::sqrt_impl(R::den)>;
 };
 
@@ -190,7 +224,7 @@ template<typename R1, typename R2>
 struct common_ratio_impl {
   static constexpr std::intmax_t gcd_num = std::gcd(R1::num, R2::num);
   static constexpr std::intmax_t gcd_den = std::gcd(R1::den, R2::den);
-  using type = ratio<gcd_num, (R1::den / gcd_den) * R2::den>;
+  using type = ratio<gcd_num, (R1::den / gcd_den) * R2::den, std::min(R1::exp, R2::exp)>;
 };
 
 }  // namespace detail
diff --git a/test/unit_test/runtime/fmt_test.cpp b/test/unit_test/runtime/fmt_test.cpp
index 8214bdd1..13ca5176 100644
--- a/test/unit_test/runtime/fmt_test.cpp
+++ b/test/unit_test/runtime/fmt_test.cpp
@@ -110,7 +110,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
   {
     SECTION("in terms of base units")
     {
-      const length<scaled_unit<ratio<1'000'000>, metre>> q(123);
+      const length<scaled_unit<ratio<1, 1, 6>, metre>> q(123);
       stream << q;
 
       SECTION("iostream")
@@ -131,7 +131,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
     SECTION("in terms of derived units")
     {
-      const energy<scaled_unit<ratio<1, 100>, joule>> q(60);
+      const energy<scaled_unit<ratio<1, 1, -2>, joule>> q(60);
       stream << q;
 
       SECTION("iostream")
@@ -296,7 +296,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "8 [1/100]m³");
+        CHECK(stream.str() == "8 [1 x 10⁻²]m³");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -317,7 +317,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "2 [60]Hz");
+        CHECK(stream.str() == "2 [6 x 10¹]Hz");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -338,7 +338,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "10 [1/60]W");
+        CHECK(stream.str() == "10 [1/6 x 10⁻¹]W");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -359,7 +359,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "30 [50/3]W");
+        CHECK(stream.str() == "30 [1/6 x 10²]W");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -404,7 +404,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "8 [1000]m⋅s");
+        CHECK(stream.str() == "8 [1 x 10³]m⋅s");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -425,7 +425,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "2 [60]kg/s");
+        CHECK(stream.str() == "2 [6 x 10¹]kg/s");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -446,7 +446,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "10 [1/60]kg/s");
+        CHECK(stream.str() == "10 [1/6 x 10⁻¹]kg/s");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -467,7 +467,7 @@ TEST_CASE("operator<< on a quantity", "[text][ostream][fmt]")
 
       SECTION("iostream")
       {
-        CHECK(stream.str() == "30 [3/50]1/m⋅s");
+        CHECK(stream.str() == "30 [6 x 10⁻²]1/m⋅s");
       }
 
       SECTION("fmt with default format {} on a quantity")
@@ -693,7 +693,7 @@ TEST_CASE("%q an %Q can be put anywhere in a format string", "[text][fmt]")
 
 TEST_CASE("fill and align specification", "[text][fmt]")
 {
-  SECTION("default format {} on a quantity") 
+  SECTION("default format {} on a quantity")
   {
     CHECK(fmt::format("|{:0}|", 123m) == "|123 m|");
     CHECK(fmt::format("|{:10}|", 123m) == "|     123 m|");
@@ -716,8 +716,8 @@ TEST_CASE("fill and align specification", "[text][fmt]")
     CHECK(fmt::format("|{:*>10%Q%q}|", 123m) == "|******123m|");
     CHECK(fmt::format("|{:*^10%Q%q}|", 123m) == "|***123m***|");
   }
-  
-  SECTION("value only format {:%Q} on a quantity") 
+
+  SECTION("value only format {:%Q} on a quantity")
   {
     CHECK(fmt::format("|{:0%Q}|", 123m) == "|123|");
     CHECK(fmt::format("|{:10%Q}|", 123m) == "|       123|");
@@ -729,7 +729,7 @@ TEST_CASE("fill and align specification", "[text][fmt]")
     CHECK(fmt::format("|{:*^10%Q}|", 123m) == "|***123****|");
   }
 
-  SECTION("symbol only format {:%q} on a quantity") 
+  SECTION("symbol only format {:%q} on a quantity")
   {
     CHECK(fmt::format("|{:0%q}|", 123m) == "|m|");
     CHECK(fmt::format("|{:10%q}|", 123m) == "|m         |");
@@ -747,7 +747,7 @@ TEST_CASE("sign specification", "[text][fmt]")
   length<metre> inf(std::numeric_limits<double>::infinity());
   length<metre> nan(std::numeric_limits<double>::quiet_NaN());
 
-  SECTION("default format {} on a quantity") 
+  SECTION("default format {} on a quantity")
   {
     CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", 1m) == "1 m,+1 m,1 m, 1 m");
     CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", -1m) == "-1 m,-1 m,-1 m,-1 m");
@@ -755,7 +755,7 @@ TEST_CASE("sign specification", "[text][fmt]")
     CHECK(fmt::format("{0:},{0:+},{0:-},{0: }", nan) == "nan m,+nan m,nan m, nan m");
   }
 
-  SECTION("full format {:%Q %q} on a quantity") 
+  SECTION("full format {:%Q %q} on a quantity")
   {
     CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", 1m) == "1m,+1m,1m, 1m");
     CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", -1m) == "-1m,-1m,-1m,-1m");
@@ -763,7 +763,7 @@ TEST_CASE("sign specification", "[text][fmt]")
     CHECK(fmt::format("{0:%Q%q},{0:+%Q%q},{0:-%Q%q},{0: %Q%q}", nan) == "nanm,+nanm,nanm, nanm");
   }
 
-  SECTION("value only format {:%Q} on a quantity") 
+  SECTION("value only format {:%Q} on a quantity")
   {
     CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", 1m) == "1,+1,1, 1");
     CHECK(fmt::format("{0:%Q},{0:+%Q},{0:-%Q},{0: %Q}", -1m) == "-1,-1,-1,-1");
@@ -781,7 +781,7 @@ TEST_CASE("sign specification for unit only", "[text][fmt][exception]")
 
 TEST_CASE("precision specification", "[text][fmt]")
 {
-  SECTION("default format {} on a quantity") 
+  SECTION("default format {} on a quantity")
   {
     CHECK(fmt::format("{:.1}", 1.2345m) == "1.2 m");
     CHECK(fmt::format("{:.0}", 1.2345m) == "1 m");
@@ -792,7 +792,7 @@ TEST_CASE("precision specification", "[text][fmt]")
     CHECK(fmt::format("{:.10}", 1.2345m) == "1.2345000000 m");
   }
 
-  SECTION("full format {:%Q %q} on a quantity") 
+  SECTION("full format {:%Q %q} on a quantity")
   {
     CHECK(fmt::format("{:.0%Q %q}", 1.2345m) == "1 m");
     CHECK(fmt::format("{:.1%Q %q}", 1.2345m) == "1.2 m");
@@ -803,7 +803,7 @@ TEST_CASE("precision specification", "[text][fmt]")
     CHECK(fmt::format("{:.10%Q %q}", 1.2345m) == "1.2345000000 m");
   }
 
-  SECTION("value only format {:%Q} on a quantity") 
+  SECTION("value only format {:%Q} on a quantity")
   {
     CHECK(fmt::format("{:.0%Q}", 1.2345m) == "1");
     CHECK(fmt::format("{:.1%Q}", 1.2345m) == "1.2");
@@ -817,17 +817,17 @@ TEST_CASE("precision specification", "[text][fmt]")
 
 TEST_CASE("precision specification for integral representation should throw", "[text][fmt][exception]")
 {
-  SECTION("default format {} on a quantity") 
+  SECTION("default format {} on a quantity")
   {
     REQUIRE_THROWS_MATCHES(fmt::format("{:.1}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
   }
 
-  SECTION("full format {:%Q %q} on a quantity") 
+  SECTION("full format {:%Q %q} on a quantity")
   {
     REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q %q}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
   }
 
-  SECTION("value only format {:%Q} on a quantity") 
+  SECTION("value only format {:%Q} on a quantity")
   {
     REQUIRE_THROWS_MATCHES(fmt::format("{:.1%Q}", 1m), fmt::format_error, Message("precision not allowed for integral quantity representation"));
   }
diff --git a/test/unit_test/static/quantity_test.cpp b/test/unit_test/static/quantity_test.cpp
index 7dd965f3..12a2706a 100644
--- a/test/unit_test/static/quantity_test.cpp
+++ b/test/unit_test/static/quantity_test.cpp
@@ -160,6 +160,7 @@ static_assert(length<metre, int>(1km).count() == 1000);
 // static_assert(length<metre, int>(1s).count() == 1);   // should not compile (different dimensions)
 //static_assert(length<kilometre, int>(1010m).count() == 1);   // should not compile (truncating conversion)
 static_assert(length<kilometre, int>(quantity_cast<length<kilometre, my_int>>(1010m)).count() == 1);
+static_assert(length<metre, int>(quantity_cast<length<kilometre, my_int>>(1010m)).count() == 1000);
 
 // assignment operator
 
@@ -236,23 +237,23 @@ static_assert(std::is_same_v<decltype(1.0 * length<metre, int>()), length<metre,
 static_assert(
     std::is_same_v<decltype(velocity<metre_per_second, int>() * si::time<second, int>()), length<metre, int>>);
 static_assert(
-    std::is_same_v<decltype(velocity<metre_per_second, int>() * si::time<hour, int>()), length<scaled_unit<ratio<3600>, metre>, int>>);
+    std::is_same_v<decltype(velocity<metre_per_second, int>() * si::time<hour, int>()), length<scaled_unit<ratio<36, 1, 2>, metre>, int>>);
 static_assert(std::is_same_v<decltype(length<metre>() * si::time<minute>()),
-                             quantity<unknown_dimension<units::exp<dim_length, 1>, units::exp<dim_time, 1>>, scaled_unit<ratio<60>, unknown_unit>>>);
+              quantity<unknown_dimension<units::exp<dim_length, 1>, units::exp<dim_time, 1>>, scaled_unit<ratio<6, 1, 1>, unknown_unit>>>);
 static_assert(std::is_same_v<decltype(1 / si::time<second, int>()), frequency<hertz, int>>);
-static_assert(std::is_same_v<decltype(1 / si::time<minute, int>()), frequency<scaled_unit<ratio<1, 60>, hertz>, int>>);
+static_assert(std::is_same_v<decltype(1 / si::time<minute, int>()), frequency<scaled_unit<ratio<1, 6, -1>, hertz>, int>>);
 static_assert(std::is_same_v<decltype(1 / frequency<hertz, int>()), si::time<second, int>>);
 static_assert(std::is_same_v<decltype(1 / length<kilometre>()),
-                             quantity<unknown_dimension<units::exp<dim_length, -1>>, scaled_unit<ratio<1, 1000>, unknown_unit>>>);
+              quantity<unknown_dimension<units::exp<dim_length, -1>>, scaled_unit<ratio<1, 1, -3>, unknown_unit>>>);
 static_assert(std::is_same_v<decltype(length<metre, int>() / 1.0), length<metre, double>>);
 static_assert(std::is_same_v<decltype(length<metre, int>() / length<metre, double>()), double>);
 static_assert(std::is_same_v<decltype(length<kilometre, int>() / length<metre, double>()), double>);
 static_assert(
     std::is_same_v<decltype(length<metre, int>() / si::time<second, int>()), velocity<metre_per_second, int>>);
 static_assert(
-    std::is_same_v<decltype(length<metre>() / si::time<minute>()), velocity<scaled_unit<ratio<1, 60>, metre_per_second>>>);
+    std::is_same_v<decltype(length<metre>() / si::time<minute>()), velocity<scaled_unit<ratio<1, 6, -1>, metre_per_second>>>);
 static_assert(std::is_same_v<decltype(si::time<minute>() / length<metre>()),
-                             quantity<unknown_dimension<units::exp<dim_length, -1>, units::exp<dim_time, 1>>, scaled_unit<ratio<60>, unknown_unit>>>);
+              quantity<unknown_dimension<units::exp<dim_length, -1>, units::exp<dim_time, 1>>, scaled_unit<ratio<6 ,1 , 1>, unknown_unit>>>);
 static_assert(std::is_same_v<decltype(length<metre, int>() % short(1)), length<metre, int>>);
 static_assert(std::is_same_v<decltype(length<metre, int>() % length<metre, short>(1)), length<metre, int>>);
 
diff --git a/test/unit_test/static/ratio_test.cpp b/test/unit_test/static/ratio_test.cpp
index ec1eae7a..7164a32b 100644
--- a/test/unit_test/static/ratio_test.cpp
+++ b/test/unit_test/static/ratio_test.cpp
@@ -27,10 +27,16 @@
   using namespace units;
 
   template<Ratio R1, Ratio R2>
-  inline constexpr bool same = R1::num == R2::num && R1::den == R2::den;
+  inline constexpr bool same = R1::num == R2::num && R1::den == R2::den && R1::exp == R2::exp;
 
   static_assert(same<ratio<2, 4>, ratio<1, 2>>);
 
+  // basic exponents tests
+  // note use of ::type is required because template params are changed while stamping out template
+  static_assert(std::is_same_v<ratio<2, 40, 1>::type, ratio<1, 20, 1>::type>);
+  static_assert(std::is_same_v<ratio<20, 4, -1>::type, ratio<10, 2, -1>::type>);
+  static_assert(std::is_same_v<ratio<200, 5>::type, ratio<20'000, 50, -1>::type>);
+
   static_assert(std::is_same_v<ratio_multiply<ratio<1>, ratio<3, 8>>, ratio<3, 8>>);
   static_assert(std::is_same_v<ratio_multiply<ratio<3, 8>, ratio<1>>, ratio<3, 8>>);
   static_assert(std::is_same_v<ratio_multiply<ratio<4>, ratio<1, 8>>, ratio<1, 2>>);
@@ -38,11 +44,19 @@
   static_assert(std::is_same_v<ratio_multiply<ratio<1, 8>, ratio<2>>, ratio<1, 4>>);
   static_assert(std::is_same_v<ratio_multiply<ratio<1, 2>, ratio<8>>, ratio<4>>);
 
+  // multiply with exponents
+  static_assert(std::is_same_v<ratio_multiply<ratio<1, 8, 2>, ratio<2, 1, 4>>, ratio<1, 4, 6>>);
+  static_assert(std::is_same_v<ratio_multiply<ratio<1, 2, -4>, ratio<8, 1, 3>>, ratio<4, 1, -1>>);
+
   static_assert(std::is_same_v<ratio_divide<ratio<4>, ratio<2>>, ratio<2>>);
   static_assert(std::is_same_v<ratio_divide<ratio<2>, ratio<8>>, ratio<1, 4>>);
   static_assert(std::is_same_v<ratio_divide<ratio<1, 8>, ratio<2>>, ratio<1, 16>>);
   static_assert(std::is_same_v<ratio_divide<ratio<6>, ratio<3>>, ratio<2>>);
 
+  // divide with exponents
+  static_assert(std::is_same_v<ratio_divide<ratio<1, 8, -6>, ratio<2, 1, -8>>, ratio<1, 16, 2>>);
+  static_assert(std::is_same_v<ratio_divide<ratio<6, 1, 4>, ratio<3>>, ratio<2, 1, 4>>);
+
   static_assert(std::is_same_v<ratio_pow<ratio<2>, 0>, ratio<1>>);
   static_assert(std::is_same_v<ratio_pow<ratio<2>, 1>, ratio<2>>);
   static_assert(std::is_same_v<ratio_pow<ratio<2>, 2>, ratio<4>>);
@@ -52,17 +66,33 @@
   static_assert(std::is_same_v<ratio_pow<ratio<1, 2>, 2>, ratio<1, 4>>);
   static_assert(std::is_same_v<ratio_pow<ratio<1, 2>, 3>, ratio<1, 8>>);
 
+  // pow with exponents
+  static_assert(std::is_same_v<ratio_pow<ratio<1, 2, 3>, 2>, ratio<1, 4, 6>>);
+  static_assert(std::is_same_v<ratio_pow<ratio<1, 2, -6>, 3>, ratio<1, 8, -18>>);
+
   static_assert(std::is_same_v<ratio_sqrt<ratio<9>>, ratio<3>>);
   static_assert(std::is_same_v<ratio_sqrt<ratio<4>>, ratio<2>>);
   static_assert(std::is_same_v<ratio_sqrt<ratio<1>>, ratio<1>>);
   static_assert(std::is_same_v<ratio_sqrt<ratio<0>>, ratio<0>>);
   static_assert(std::is_same_v<ratio_sqrt<ratio<1, 4>>, ratio<1, 2>>);
 
+  // // sqrt with exponents: TODO not working yet. Also not sure the non exponent version is accurate.
+  // static_assert(std::is_same_v<ratio_sqrt<ratio<9, 1, 2>>, ratio<3, 1, 1>>);
+  // static_assert(std::is_same_v<ratio_sqrt<ratio<4>>, ratio<2>>);
+
   // common_ratio
+  // note use of ::type is required because template params are changed while stamping out template
+  static_assert(std::is_same_v<common_ratio<ratio<1>::type, ratio<1000>>, ratio<1>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<1000>, ratio<1>>::type, ratio<1>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<1>, ratio<1, 1000>>::type, ratio<1, 1000>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<1, 1000>, ratio<1>>::type, ratio<1, 1000>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<100, 1>, ratio<10, 1>>::type, ratio<10, 1>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<100, 1>, ratio<1, 10>>::type, ratio<1, 10>::type>);
 
-  static_assert(std::is_same_v<common_ratio<ratio<1>, ratio<1000>>, ratio<1>>);
-  static_assert(std::is_same_v<common_ratio<ratio<1000>, ratio<1>>, ratio<1>>);
-  static_assert(std::is_same_v<common_ratio<ratio<1>, ratio<1, 1000>>, ratio<1, 1000>>);
-  static_assert(std::is_same_v<common_ratio<ratio<1, 1000>, ratio<1>>, ratio<1, 1000>>);
+  // common ratio with exponents
+  static_assert(std::is_same_v<common_ratio<ratio<1>, ratio<1, 1, 3>>::type, ratio<1>::type>);
+  static_assert(std::is_same_v<common_ratio<ratio<10, 1, -1>, ratio<1, 1, -3>>::type, ratio<1, 1, -3>::type>);
 
-  }  // namespace
\ No newline at end of file
+
+
+  }  // namespace
diff --git a/test/unit_test/static/si_test.cpp b/test/unit_test/static/si_test.cpp
index a6a54fc2..62d7ab3d 100644
--- a/test/unit_test/static/si_test.cpp
+++ b/test/unit_test/static/si_test.cpp
@@ -192,7 +192,7 @@ static_assert(10V * 1F == 10C);
 
 // velocity
 
-static_assert(std::is_same_v<decltype(1km / 1s), velocity<scaled_unit<ratio<1000>, metre_per_second>, std::int64_t>>);
+static_assert(std::is_same_v<decltype(1km / 1s), velocity<scaled_unit<ratio<1, 1, 3>, metre_per_second>, std::int64_t>>);
 
 static_assert(10m / 5s == 2mps);
 static_assert(10 / 5s * 1m == 2mps);
diff --git a/test/unit_test/static/unit_test.cpp b/test/unit_test/static/unit_test.cpp
index f7b7aa42..3be1ee5d 100644
--- a/test/unit_test/static/unit_test.cpp
+++ b/test/unit_test/static/unit_test.cpp
@@ -30,12 +30,12 @@ using namespace units;
 struct metre : named_unit<metre, "m", si::prefix> {};
 struct centimetre : prefixed_unit<centimetre, si::centi, metre> {};
 struct kilometre : prefixed_unit<kilometre, si::kilo, metre> {};
-struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio<9'144, 10'000>, metre> {};
+struct yard : named_scaled_unit<yard, "yd", no_prefix, ratio<9'144, 1, -4>, metre> {};
 struct foot : named_scaled_unit<foot, "ft", no_prefix, ratio<1, 3>, yard> {};
 struct dim_length : base_dimension<"length", metre> {};
 
 struct second : named_unit<second, "s", si::prefix> {};
-struct hour : named_scaled_unit<hour, "h", no_prefix, ratio<3600>, second> {};
+struct hour : named_scaled_unit<hour, "h", no_prefix, ratio<36, 1, 2>, second> {};
 struct dim_time : base_dimension<"time", second> {};
 
 struct kelvin : named_unit<kelvin, "K", no_prefix> {};
@@ -46,8 +46,8 @@ struct dim_velocity : derived_dimension<dim_velocity, metre_per_second, exp<dim_
 struct kilometre_per_hour : deduced_unit<kilometre_per_hour, dim_velocity, kilometre, hour> {};
 
 static_assert(std::is_same_v<downcast<scaled_unit<ratio<1>, metre>>, metre>);
-static_assert(std::is_same_v<downcast<scaled_unit<ratio<1, 100>, metre>>, centimetre>);
-static_assert(std::is_same_v<downcast<scaled_unit<ratio<yard::ratio::num, yard::ratio::den>, metre>>, yard>);
+static_assert(std::is_same_v<downcast<scaled_unit<ratio<1, 1, -2>, metre>>, centimetre>);
+static_assert(std::is_same_v<downcast<scaled_unit<ratio<yard::ratio::num, yard::ratio::den, yard::ratio::exp>, metre>>, yard>);
 static_assert(std::is_same_v<downcast<scaled_unit<ratio_multiply<typename yard::ratio, ratio<1, 3>>, metre>>, foot>);
 static_assert(std::is_same_v<downcast<scaled_unit<ratio_divide<typename kilometre::ratio, typename hour::ratio>, metre_per_second>>, kilometre_per_hour>);