feat: 💥 pi and π is now a unit constant (pi magnitude constant renamed to pi_c)

mpusz · mpusz · commit 6d10a154fae7 · 2025-12-28T13:35:54.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,11 @@ This page documents the version history and changes for the **mp-units** library
 
 ## mp-units
 
+### 2.6.0 <small>TBD</small> { id="2.6.0" }
+
+- (!) feat: `pi` and `π` is now a unit constant
+- (!) refactor: `pi` magnitude constant renamed to `pi_c`
+
 ### 2.5.0 <small>December 24, 2025</small> { id="2.5.0" }
 
 - (!) feat: representation concepts improved
diff --git a/docs/examples/measurement.md b/docs/examples/measurement.md
@@ -78,7 +78,7 @@ This showcases:
 2. **Kinematic calculations** - Multiplying _acceleration_ by _time_ with automatic unit
    conversions
 3. **Scalar multiplication** - Exact scaling preserves relative uncertainty
-4. **Faster-than-lightspeed constants** - Using `mag<π>` keeps π as an exact symbolic value,
+4. **Faster-than-lightspeed constants** - Using `π` keeps pi as an exact symbolic value,
    not a numeric approximation
 5. **Geometric calculations** - Computing _circumference_ and _area_ where π contributes
    zero uncertainty
@@ -93,8 +93,8 @@ Velocity calculation:   V = 9.8 ± 0.1 m/s² * 1.2 ± 0.1 s = 11.76 ± 0.98732 m
 Scalar multiplication:  d = 10 * 123 ± 1 m = 1230 ± 10 m
 Radius:                 r = 5 ± 0.1 m
 Circular circumference: 2πr = 5 ± 0.1 (2 π) m = 31.4159 ± 0.628319 m
-Circular area:          πr² = 25 ± 1 (π) m² = 78.5398 ± 3.14159 m²
-Radius from area:       A = 25 ± 1 (π m²) -> r = √(A/π) = 5 ± 0.1 m
+Circular area:          πr² = 25 ± 1 π m² = 78.5398 ± 3.14159 m²
+Radius from area:       A = 25 ± 1 π m² -> r = √(A/π) = 5 ± 0.1 m
 ```
 
 ### Uncertainty Propagation Analysis
diff --git a/docs/getting_started/cheat_sheet.md b/docs/getting_started/cheat_sheet.md
@@ -286,7 +286,7 @@ constexpr Unit auto m3 = cubic(si::metre);
 constexpr Unit auto mps = m / s;
 
 // Constants as a unit
-constexpr Unit auto two_pi = mag<2> * mag<pi> * one;
+constexpr Unit auto two_pi = mag<2> * π;
 ```
 
 1. Non-SI unit accepted for use with SI
diff --git a/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md b/docs/users_guide/framework_basics/faster_than_lightspeed_constants.md
@@ -45,7 +45,7 @@ inline constexpr struct speed_of_light_in_vacuum final :
 }  // namespace si2019
 
 inline constexpr struct magnetic_constant final :
-  named_unit<{u8"μ₀", "u_0"}, mag<4> * mag<π> * mag_power<10, -7> * henry / metre> {} magnetic_constant;
+  named_unit<{u8"μ₀", "u_0"}, mag<4> * mag_power<10, -7> * π * henry / metre> {} magnetic_constant;
 
 }  // namespace mp_units::si
 ```
diff --git a/docs/users_guide/framework_basics/simple_and_typed_quantities.md b/docs/users_guide/framework_basics/simple_and_typed_quantities.md
@@ -284,7 +284,7 @@ Let's see another example:
         public:
           constexpr CylindricalStorageTank(const quantity<si::metre>& radius,
                                            const quantity<si::metre>& height) :
-            StorageTank(std::numbers::pi * pow<2>(radius), height)
+            StorageTank(pow<2>(radius) * π, height)
           {
           }
         };
@@ -341,8 +341,7 @@ Let's see another example:
         public:
           constexpr CylindricalStorageTank(const quantity<isq::radius[si::metre]>& radius,
                                            const quantity<isq::height[si::metre]>& height) :
-            StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),
-                        height)
+            StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)
           {
           }
         };
@@ -395,7 +394,7 @@ Let's see another example:
         public:
           constexpr CylindricalStorageTank(const quantity<si::metre>& radius,
                                            const quantity<si::metre>& height) :
-            StorageTank(std::numbers::pi * pow<2>(radius), height)
+            StorageTank(pow<2>(radius) * π, height)
           {
           }
         };
@@ -454,8 +453,7 @@ Let's see another example:
         public:
           constexpr CylindricalStorageTank(const quantity<isq::radius[si::metre]>& radius,
                                            const quantity<isq::height[si::metre]>& height) :
-            StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),
-                        height)
+            StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)
           {
           }
         };
@@ -565,8 +563,7 @@ class CylindricalStorageTank : public StorageTank {
 public:
   constexpr CylindricalStorageTank(const quantity<isq::radius[m]>& radius,
                                    const quantity<isq::height[m]>& height) :
-    StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),
-                height)
+    StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)
   {
   }
 };
diff --git a/docs/users_guide/framework_basics/systems_of_units.md b/docs/users_guide/framework_basics/systems_of_units.md
@@ -277,12 +277,13 @@ For some units, a magnitude might also be irrational. The best example here is a
 which is defined using a floating-point magnitude having a factor of the number π (Pi):
 
 ```cpp
-inline constexpr struct pi final : mag_constant<symbol_text{u8"π", "pi"}, std::numbers::pi_v<long double>> {} pi;
+inline constexpr struct pi_c final : mag_constant<symbol_text{u8"π", "pi"}, std::numbers::pi_v<long double>> {} pi_c;
+inline constexpr struct pi final : named_unit<symbol_text{u8"π", "pi"}, mag<pi_c> * one> {} pi;
 inline constexpr auto π = pi;
 ```
 
 ```cpp
-inline constexpr struct degree final : named_unit<{u8"°", "deg"}, mag<π> / mag<180> * si::radian> {} degree;
+inline constexpr struct degree final : named_unit<{u8"°", "deg"}, mag_ratio<1, 180> * π * si::radian> {} degree;
 ```
 
 
diff --git a/example/measurement.cpp b/example/measurement.cpp
@@ -64,14 +64,14 @@ void example()
   std::cout << "Scalar multiplication:  d = 10 * " << length << " = " << 10 * length << '\n';
 
   const auto radius = measurement{5.0, 0.1} * m;
-  const auto circumference = radius * (mag<2> * mag<π> * one);
-  const auto area = pow<2>(radius) * (mag<π> * one);
+  const auto circumference = radius * (mag<2> * π);
+  const auto area = pow<2>(radius) * π;
   std::cout << "Radius:                 r = " << radius << '\n';
   std::cout << "Circular circumference: 2πr = " << circumference << " = " << circumference.in(m) << '\n';
   std::cout << "Circular area:          πr² = " << area << " = " << area.in(m2) << '\n';
 
-  const auto area_measured = measurement{25.0, 1.0} * (mag<π> * m2);
-  const auto radius_from_area = sqrt(area_measured / (mag<π> * one));
+  const auto area_measured = measurement{25.0, 1.0} * π * m2;
+  const auto radius_from_area = sqrt(area_measured / π);
   std::cout << "Radius from area:       A = " << area_measured << " -> r = √(A/π) = " << radius_from_area << '\n';
 }
 
diff --git a/example/storage_tank.cpp b/example/storage_tank.cpp
@@ -97,7 +97,7 @@ class StorageTank {
 class CylindricalStorageTank : public StorageTank {
 public:
   constexpr CylindricalStorageTank(const quantity<isq::radius[m]>& radius, const quantity<isq::height[m]>& height) :
-      StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)), height)
+      StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)
   {
   }
 };
diff --git a/src/core/include/mp-units/framework/unit.h b/src/core/include/mp-units/framework/unit.h
@@ -658,6 +658,9 @@ inline constexpr struct percent final : named_unit<"%", mag_ratio<1, 100> * one>
 inline constexpr struct per_mille final : named_unit<symbol_text{u8"‰" /* U+2030 PER MILLE SIGN */, "%o"}, mag_ratio<1, 1000> * one> {} per_mille;
 inline constexpr struct parts_per_million final : named_unit<"ppm", mag_ratio<1, 1'000'000> * one> {} parts_per_million;
 inline constexpr auto ppm = parts_per_million;
+// TODO make it a unit constant rather than a named unit when such support will be provided
+inline constexpr struct pi final : named_unit<symbol_text{u8"π" /* U+03C0 GREEK SMALL LETTER PI */, "pi"}, mag<pi_c> * one> {} pi;
+inline constexpr auto π /* U+03C0 GREEK SMALL LETTER PI */ = pi;
 // clang-format on
 
 
diff --git a/src/core/include/mp-units/framework/unit_magnitude.h b/src/core/include/mp-units/framework/unit_magnitude.h
@@ -87,16 +87,15 @@ constexpr UnitMagnitude auto mag_power = pow<Num, Den>(mag<Base>);
  * @brief  A convenient Magnitude constant for pi, which we can manipulate like a regular number.
  */
 #if defined MP_UNITS_COMP_CLANG && MP_UNITS_COMP_CLANG < 18
-inline constexpr struct pi final : mag_constant<symbol_text{u8"π" /* U+03C0 GREEK SMALL LETTER PI */, "pi"}> {
+inline constexpr struct pi_c final : mag_constant<symbol_text{u8"π" /* U+03C0 GREEK SMALL LETTER PI */, "pi"}> {
   static constexpr auto _value_ = std::numbers::pi_v<long double>;
 #else
-inline constexpr struct pi final :
+inline constexpr struct pi_c final :
     mag_constant<symbol_text{u8"π" /* U+03C0 GREEK SMALL LETTER PI */, "pi"}, std::numbers::pi_v<long double> > {
 #endif
-} pi;
-inline constexpr auto π /* U+03C0 GREEK SMALL LETTER PI */ = pi;
+} pi_c;
 
-[[deprecated("2.3.0: Use `mag<pi>` instead")]] inline constexpr UnitMagnitude auto mag_pi = mag<pi>;
+[[deprecated("2.3.0: Use `mag<pi>` instead")]] inline constexpr UnitMagnitude auto mag_pi = mag<pi_c>;
 
 MP_UNITS_EXPORT_END
 
diff --git a/src/systems/include/mp-units/systems/angular/units.h b/src/systems/include/mp-units/systems/angular/units.h
@@ -41,7 +41,7 @@ QUANTITY_SPEC(angle, dim_angle);
 QUANTITY_SPEC(solid_angle, pow<2>(angle));
 
 inline constexpr struct radian final : named_unit<"rad", kind_of<angle>> {} radian;
-inline constexpr struct revolution final : named_unit<"rev", mag<2> * mag<π> * radian> {} revolution;
+inline constexpr struct revolution final : named_unit<"rev", mag<2> * π * radian> {} revolution;
 inline constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_ratio<1, 360> * revolution> {} degree;
 inline constexpr struct gradian final : named_unit<symbol_text{u8"ᵍ", "grad"}, mag_ratio<1, 400> * revolution> {} gradian;
 inline constexpr struct steradian final : named_unit<"sr", square(radian)> {} steradian;
diff --git a/src/systems/include/mp-units/systems/si/constants.h b/src/systems/include/mp-units/systems/si/constants.h
@@ -57,7 +57,7 @@ inline constexpr struct luminous_efficacy final :
 inline constexpr struct standard_gravity final :
   named_unit<symbol_text{u8"g₀", "g_0"}, mag_ratio<980'665, 100'000> * metre / square(second)> {} standard_gravity;
 inline constexpr struct magnetic_constant final :
-  named_unit<symbol_text{u8"μ₀", "u_0"}, mag<4> * mag<π> * mag_power<10, -7> * henry / metre> {} magnetic_constant;
+  named_unit<symbol_text{u8"μ₀", "u_0"}, mag<4> * mag_power<10, -7> * π * henry / metre> {} magnetic_constant;
 // clang-format on
 
 }  // namespace mp_units::si
diff --git a/src/systems/include/mp-units/systems/si/units.h b/src/systems/include/mp-units/systems/si/units.h
@@ -100,7 +100,7 @@ inline constexpr struct minute final : named_unit<"min", mag<60> * si::second> {
 inline constexpr struct hour final : named_unit<"h", mag<60> * minute> {} hour;
 inline constexpr struct day final : named_unit<"d", mag<24> * hour> {} day;
 inline constexpr struct astronomical_unit final : named_unit<"au", mag<149'597'870'700> * si::metre> {} astronomical_unit;
-inline constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag<π> / mag<180> * si::radian> {} degree;
+inline constexpr struct degree final : named_unit<symbol_text{u8"°", "deg"}, mag_ratio<1, 180> * π * si::radian> {} degree;
 inline constexpr struct arcminute final : named_unit<symbol_text{u8"′", "'"}, mag_ratio<1, 60> * degree> {} arcminute;
 inline constexpr struct arcsecond final : named_unit<symbol_text{u8"″", "''"}, mag_ratio<1, 60> * arcminute> {} arcsecond;
 inline constexpr struct are final : named_unit<"a", square(si::deca<si::metre>)> {} are;
diff --git a/test/runtime/truncation_test.cpp b/test/runtime/truncation_test.cpp
@@ -41,12 +41,10 @@ using namespace mp_units;
 using namespace mp_units::angular;
 using namespace mp_units::angular::unit_symbols;
 
-inline constexpr struct half_revolution final : named_unit<"hrev", mag<π> * radian> {
+inline constexpr struct half_revolution final : named_unit<"hrev", π * radian> {
 } half_revolution;
 inline constexpr auto hrev = half_revolution;
 
-// constexpr auto revb6 = mag_ratio<1,3> * mag<π> * rad;
-
 TEST_CASE("value_cast should not truncate for valid inputs", "[value_cast]")
 {
   SECTION("num > den > 1, irr = 1")
diff --git a/test/static/unit_magnitude_test.cpp b/test/static/unit_magnitude_test.cpp
@@ -199,9 +199,9 @@ static_assert(std::is_same_v<decltype(get_base(power_v<mag_2, 5, 8>{})), mag_2_>
 
 //   SECTION("pi to the 1 supplies correct values")
 //   {
-//     check_same_type_and_value(get_value<float>(mag<π>), std::numbers::pi_v<float>);
-//     check_same_type_and_value(get_value<double>(mag<π>), std::numbers::pi_v<double>);
-//     check_same_type_and_value(get_value<long double>(mag<π>), std::numbers::pi_v<long double>);
+//     check_same_type_and_value(get_value<float>(mag<pi_c>), std::numbers::pi_v<float>);
+//     check_same_type_and_value(get_value<double>(mag<pi_c>), std::numbers::pi_v<double>);
+//     check_same_type_and_value(get_value<long double>(mag<pi_c>), std::numbers::pi_v<long double>);
 //   }
 
 //   SECTION("pi to arbitrary power performs computations in most accurate type at compile time")
diff --git a/test/static/unit_symbol_test.cpp b/test/static/unit_symbol_test.cpp
@@ -150,58 +150,59 @@ inline constexpr struct e final : mag_constant<"e", std::numbers::e_v<long doubl
 #endif
 } e;
 
-static_assert(unit_symbol(mag<π> * one) == "(π)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<π> * one) == "(pi)");
-static_assert(unit_symbol(mag<π> * metre) == "(π m)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<π> * metre) == "(pi m)");
-static_assert(unit_symbol(mag<2> * mag<π> * metre) == "(2 π m)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<2> * mag<π> * metre) == "(2 pi m)");
-static_assert(unit_symbol<usf{.separator = half_high_dot}>(mag<2> * mag<π> * metre) == "(2⋅π m)");
+static_assert(unit_symbol(mag<pi_c> * one) == "(π)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<pi_c> * one) == "(pi)");
+static_assert(unit_symbol(mag<pi_c> * metre) == "(π m)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<pi_c> * metre) == "(pi m)");
+static_assert(unit_symbol(mag<2> * mag<pi_c> * metre) == "(2 π m)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<2> * mag<pi_c> * metre) == "(2 pi m)");
+static_assert(unit_symbol<usf{.separator = half_high_dot}>(mag<2> * mag<pi_c> * metre) == "(2⋅π m)");
 
-static_assert(unit_symbol(mag<1> / mag<π> * one) == "(1/π)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<1> / mag<π> * one) == "(1/pi)");
-static_assert(unit_symbol<usf{.solidus = never}>(mag<1> / mag<π> * one) == "(π⁻¹)");
-static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<1> / mag<π> * one) == "(pi^-1)");
+static_assert(unit_symbol(mag<1> / mag<pi_c> * one) == "(1/π)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<1> / mag<pi_c> * one) == "(1/pi)");
+static_assert(unit_symbol<usf{.solidus = never}>(mag<1> / mag<pi_c> * one) == "(π⁻¹)");
+static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<1> / mag<pi_c> * one) == "(pi^-1)");
 
-static_assert(unit_symbol(mag<1> / mag<π> * metre) == "(1/π m)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<1> / mag<π> * metre) == "(1/pi m)");
-static_assert(unit_symbol<usf{.solidus = never}>(mag<1> / mag<π> * metre) == "(π⁻¹ m)");
-static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<1> / mag<π> * metre) == "(pi^-1 m)");
+static_assert(unit_symbol(mag<1> / mag<pi_c> * metre) == "(1/π m)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<1> / mag<pi_c> * metre) == "(1/pi m)");
+static_assert(unit_symbol<usf{.solidus = never}>(mag<1> / mag<pi_c> * metre) == "(π⁻¹ m)");
+static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<1> / mag<pi_c> * metre) == "(pi^-1 m)");
 
-static_assert(unit_symbol(mag<2> / mag<π> * metre) == "(2/π m)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<2> / mag<π> * metre) == "(2/pi m)");
-static_assert(unit_symbol<usf{.solidus = never}>(mag<2> / mag<π> * metre) == "(2 π⁻¹ m)");
-static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<2> / mag<π> * metre) == "(2 pi^-1 m)");
-static_assert(unit_symbol<usf{.solidus = never, .separator = half_high_dot}>(mag<2> / mag<π> * metre) == "(2⋅π⁻¹ m)");
+static_assert(unit_symbol(mag<2> / mag<pi_c> * metre) == "(2/π m)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<2> / mag<pi_c> * metre) == "(2/pi m)");
+static_assert(unit_symbol<usf{.solidus = never}>(mag<2> / mag<pi_c> * metre) == "(2 π⁻¹ m)");
+static_assert(unit_symbol<usf{.char_set = portable, .solidus = never}>(mag<2> / mag<pi_c> * metre) == "(2 pi^-1 m)");
+static_assert(unit_symbol<usf{.solidus = never, .separator = half_high_dot}>(mag<2> / mag<pi_c> * metre) ==
+              "(2⋅π⁻¹ m)");
 
-static_assert(unit_symbol(mag<1> / (mag<2> * mag<π>)*metre) == "(2⁻¹ π⁻¹ m)");
-static_assert(unit_symbol<usf{.solidus = always}>(mag<1> / (mag<2> * mag<π>)*metre) == "(1/(2 π) m)");
-static_assert(unit_symbol<usf{.char_set = portable, .solidus = always}>(mag<1> / (mag<2> * mag<π>)*metre) ==
+static_assert(unit_symbol(mag<1> / (mag<2> * mag<pi_c>)*metre) == "(2⁻¹ π⁻¹ m)");
+static_assert(unit_symbol<usf{.solidus = always}>(mag<1> / (mag<2> * mag<pi_c>)*metre) == "(1/(2 π) m)");
+static_assert(unit_symbol<usf{.char_set = portable, .solidus = always}>(mag<1> / (mag<2> * mag<pi_c>)*metre) ==
               "(1/(2 pi) m)");
-static_assert(unit_symbol(mag_ratio<1, 2> / mag<π> * metre) == "(2⁻¹ π⁻¹ m)");
-static_assert(unit_symbol<usf{.solidus = always}>(mag_ratio<1, 2> / mag<π> * metre) == "(1/(2 π) m)");
-static_assert(unit_symbol<usf{.char_set = portable, .solidus = always}>(mag_ratio<1, 2> / mag<π> * metre) ==
+static_assert(unit_symbol(mag_ratio<1, 2> / mag<pi_c> * metre) == "(2⁻¹ π⁻¹ m)");
+static_assert(unit_symbol<usf{.solidus = always}>(mag_ratio<1, 2> / mag<pi_c> * metre) == "(1/(2 π) m)");
+static_assert(unit_symbol<usf{.char_set = portable, .solidus = always}>(mag_ratio<1, 2> / mag<pi_c> * metre) ==
               "(1/(2 pi) m)");
-static_assert(unit_symbol(mag_ratio<1, 2> * mag<π> * metre) == "(π/2 m)");
+static_assert(unit_symbol(mag_ratio<1, 2> * mag<pi_c> * metre) == "(π/2 m)");
 
-static_assert(unit_symbol(mag_power<pi, 2> * one) == "(π²)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag_power<pi, 2> * one) == "(pi^2)");
-static_assert(unit_symbol(mag_power<pi, 1, 2> * metre) == "(π^(1/2) m)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag_power<pi, 1, 2> * metre) == "(pi^(1/2) m)");
+static_assert(unit_symbol(mag_power<pi_c, 2> * one) == "(π²)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag_power<pi_c, 2> * one) == "(pi^2)");
+static_assert(unit_symbol(mag_power<pi_c, 1, 2> * metre) == "(π^(1/2) m)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag_power<pi_c, 1, 2> * metre) == "(pi^(1/2) m)");
 
-static_assert(unit_symbol(mag<π> * mag<e> * one) == "(e π)");
-static_assert(unit_symbol(mag<e> * mag<π> * one) == "(e π)");
-static_assert(unit_symbol<usf{.char_set = portable}>(mag<π> * mag<e> * one) == "(e pi)");
-static_assert(unit_symbol(mag<π> / mag<e> * one) == "(π/e)");
-static_assert(unit_symbol(mag<1> / mag<e> * mag<π> * one) == "(π/e)");
-static_assert(unit_symbol<usf{.solidus = never}>(mag<π> / mag<e> * one) == "(π e⁻¹)");
-static_assert(unit_symbol(mag<e> / mag<π> * one) == "(e/π)");
-static_assert(unit_symbol(mag<1> / mag<π> * mag<e> * one) == "(e/π)");
-static_assert(unit_symbol<usf{.solidus = never}>(mag<e> / mag<π> * one) == "(e π⁻¹)");
-static_assert(unit_symbol(mag<1> / (mag<π> * mag<e>)*one) == "(e⁻¹ π⁻¹)");
-static_assert(unit_symbol<usf{.solidus = always}>(mag<1> / (mag<π> * mag<e>)*one) == "(1/(e π))");
-static_assert(unit_symbol(mag<2> / (mag<π> * mag<e>)*one) == "(2 e⁻¹ π⁻¹)");
-static_assert(unit_symbol<usf{.solidus = always}>(mag<2> / (mag<π> * mag<e>)*one) == "(2/(e π))");
+static_assert(unit_symbol(mag<pi_c> * mag<e> * one) == "(e π)");
+static_assert(unit_symbol(mag<e> * mag<pi_c> * one) == "(e π)");
+static_assert(unit_symbol<usf{.char_set = portable}>(mag<pi_c> * mag<e> * one) == "(e pi)");
+static_assert(unit_symbol(mag<pi_c> / mag<e> * one) == "(π/e)");
+static_assert(unit_symbol(mag<1> / mag<e> * mag<pi_c> * one) == "(π/e)");
+static_assert(unit_symbol<usf{.solidus = never}>(mag<pi_c> / mag<e> * one) == "(π e⁻¹)");
+static_assert(unit_symbol(mag<e> / mag<pi_c> * one) == "(e/π)");
+static_assert(unit_symbol(mag<1> / mag<pi_c> * mag<e> * one) == "(e/π)");
+static_assert(unit_symbol<usf{.solidus = never}>(mag<e> / mag<pi_c> * one) == "(e π⁻¹)");
+static_assert(unit_symbol(mag<1> / (mag<pi_c> * mag<e>)*one) == "(e⁻¹ π⁻¹)");
+static_assert(unit_symbol<usf{.solidus = always}>(mag<1> / (mag<pi_c> * mag<e>)*one) == "(1/(e π))");
+static_assert(unit_symbol(mag<2> / (mag<pi_c> * mag<e>)*one) == "(2 e⁻¹ π⁻¹)");
+static_assert(unit_symbol<usf{.solidus = always}>(mag<2> / (mag<pi_c> * mag<e>)*one) == "(2/(e π))");
 
 // common units
 static_assert(unit_symbol(get_common_unit(kilo<metre>, mile)) == "[(1/25146 mi), (1/15625 km)]");
diff --git a/test/static/unit_test.cpp b/test/static/unit_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -284,7 +284,7 @@ Let's see another example:`
`284`	`284`	`public:`
`285`	`285`	`constexpr CylindricalStorageTank(const quantity<si::metre>& radius,`
`286`	`286`	`const quantity<si::metre>& height) :`
`287`		`- StorageTank(std::numbers::pi * pow<2>(radius), height)`
	`287`	`+ StorageTank(pow<2>(radius) * π, height)`
`288`	`288`	`{`
`289`	`289`	`}`
`290`	`290`	`};`
`@@ -341,8 +341,7 @@ Let's see another example:`
`341`	`341`	`public:`
`342`	`342`	`constexpr CylindricalStorageTank(const quantity<isq::radius[si::metre]>& radius,`
`343`	`343`	`const quantity<isq::height[si::metre]>& height) :`
`344`		`- StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),`
`345`		`- height)`
	`344`	`+ StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)`
`346`	`345`	`{`
`347`	`346`	`}`
`348`	`347`	`};`
`@@ -395,7 +394,7 @@ Let's see another example:`
`395`	`394`	`public:`
`396`	`395`	`constexpr CylindricalStorageTank(const quantity<si::metre>& radius,`
`397`	`396`	`const quantity<si::metre>& height) :`
`398`		`- StorageTank(std::numbers::pi * pow<2>(radius), height)`
	`397`	`+ StorageTank(pow<2>(radius) * π, height)`
`399`	`398`	`{`
`400`	`399`	`}`
`401`	`400`	`};`
`@@ -454,8 +453,7 @@ Let's see another example:`
`454`	`453`	`public:`
`455`	`454`	`constexpr CylindricalStorageTank(const quantity<isq::radius[si::metre]>& radius,`
`456`	`455`	`const quantity<isq::height[si::metre]>& height) :`
`457`		`- StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),`
`458`		`- height)`
	`456`	`+ StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)`
`459`	`457`	`{`
`460`	`458`	`}`
`461`	`459`	`};`
`@@ -565,8 +563,7 @@ class CylindricalStorageTank : public StorageTank {`
`565`	`563`	`public:`
`566`	`564`	`constexpr CylindricalStorageTank(const quantity<isq::radius[m]>& radius,`
`567`	`565`	`const quantity<isq::height[m]>& height) :`
`568`		`- StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)),`
`569`		`- height)`
	`566`	`+ StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)`
`570`	`567`	`{`
`571`	`568`	`}`
`572`	`569`	`};`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ class StorageTank {`
`97`	`97`	`class CylindricalStorageTank : public StorageTank {`
`98`	`98`	`public:`
`99`	`99`	`constexpr CylindricalStorageTank(const quantity<isq::radius[m]>& radius, const quantity<isq::height[m]>& height) :`
`100`		`- StorageTank(quantity_cast<horizontal_area>(std::numbers::pi * pow<2>(radius)), height)`
	`100`	`+ StorageTank(quantity_cast<horizontal_area>(pow<2>(radius) * π), height)`
`101`	`101`	`{`
`102`	`102`	`}`
`103`	`103`	`};`