refactor: dimensions design cleanup

src/core/include/units/dimension.h

@@ -104,19 +104,41 @@ using type_list_of_base_dimension_less = expr_less<T1, T2, base_dimension_less>;
 template<typename T>
 inline constexpr bool is_one_dim = false;
 
+template<typename T>
+inline constexpr bool is_power_of_dim =
+  requires {
+    requires is_specialization_of_power<T> && (BaseDimension<typename T::factor> || is_one_dim<typename T::factor>);
+  };
+
+template<typename T>
+inline constexpr bool is_per_of_dims = false;
+
+template<typename... Ts>
+inline constexpr bool is_per_of_dims<per<Ts...>> =
+  (... && (BaseDimension<Ts> || is_one_dim<Ts> || is_power_of_dim<Ts>));
+
 }  // namespace detail
 
-// TODO add checking for `per` and power elements as well
 template<typename T>
 concept DimensionSpec =
-  BaseDimension<T> || detail::is_one_dim<T> || is_specialization_of<T, per> || detail::is_specialization_of_power<T>;
+  BaseDimension<T> || detail::is_one_dim<T> || detail::is_power_of_dim<T> || detail::is_per_of_dims<T>;
+
+template<DimensionSpec... Ds>
+struct derived_dimension;
+
+namespace detail {
+
+template<typename... Ds>
+struct derived_dimension_impl : detail::expr_fractions<derived_dimension<>, Ds...> {
+  using _type_ = derived_dimension<Ds...>;  // exposition only
+};
+
+}  // namespace detail
 
 // User should not instantiate this type!!!
 // It should not be exported from the module
 template<DimensionSpec... Ds>
-struct derived_dimension : detail::expr_fractions<derived_dimension<>, Ds...> {
+struct derived_dimension : detail::derived_dimension_impl<Ds...> {};
-  using type = derived_dimension<Ds...>;
-};
 
 namespace detail {
 
@@ -154,7 +176,7 @@ struct dim_type_impl {
 
 template<DerivedDimension T>
 struct dim_type_impl<T> {
-  using type = T::type;
+  using type = T::_type_;
 };
 
 template<Dimension T>
@@ -189,11 +211,11 @@ template<Dimension D1, Dimension D2>
   return is_same_v<D1, D2>;
 }
 
-template<Dimension D1, Dimension D2>
+// template<Dimension D1, Dimension D2>
-[[nodiscard]] consteval bool equivalent(D1, D2)
+// [[nodiscard]] consteval bool equivalent(D1, D2)
-{
+// {
-  return is_same_v<detail::dim_type<D1>, detail::dim_type<D2>>;
+//   return is_same_v<detail::dim_type<D1>, detail::dim_type<D2>>;
-}
+// }
 
 template<Dimension D1, Dimension D2>
 [[nodiscard]] consteval bool convertible(D1, D2)

src/core/include/units/magnitude.h

@@ -514,15 +514,12 @@ inline constexpr struct mag_pi : magnitude<std::numbers::pi_v<long double>> {
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Magnitude equality implementation.
 
-// template<auto... LeftBPs, auto... RightBPs>
+template<Magnitude M1, Magnitude M2>
-// constexpr bool operator==(magnitude<LeftBPs...>, magnitude<RightBPs...>)
+[[nodiscard]] consteval bool operator==(M1, M2)
-// {
+{
-//   if constexpr (sizeof...(LeftBPs) == sizeof...(RightBPs)) {
+  return std::is_same_v<M1, M2>;
-//     return ((LeftBPs == RightBPs) && ...);
+}
-//   } else {
+
-//     return false;
-//   }
-// }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // Magnitude rational powers implementation.

src/core/include/units/quantity.h

@@ -69,8 +69,8 @@ concept harmonic_ =  // exposition only
 
 template<typename QFrom, typename QTo>
 concept quantity_convertible_to_ =  // exposition only
-  Quantity<QFrom> && Quantity<QTo> && convertible(QFrom::dimension, QTo::dimension) &&
+  Quantity<QFrom> && Quantity<QTo> &&
-  convertible(QFrom::unit, QTo::unit) && scalable_with_<typename QFrom::rep, typename QTo::rep> &&
+  convertible(QFrom::reference, QTo::reference) && scalable_with_<typename QFrom::rep, typename QTo::rep> &&
   (floating_point_<QTo> || (!floating_point_<QFrom> && harmonic_<QFrom, QTo>));
 
 template<typename Func, typename T, typename U>

src/core/include/units/quantity_cast.h

@@ -99,11 +99,10 @@ namespace detail {
  * @tparam To a target quantity type to cast to
  */
 template<Quantity To, auto R, scalable_with_<typename To::rep> Rep>
-  requires(convertible(R, To::reference))
+  requires(convertible(To::reference, R))
 [[nodiscard]] constexpr auto quantity_cast(const quantity<R, Rep>& q)
 {
-  // TODO implement same unit magnitude check
+  if constexpr (R.unit == To::unit) {
-  if constexpr (std::same_as<decltype(R.unit), decltype(To::unit)>) {
     return To(static_cast<TYPENAME To::rep>(q.number()));
   } else {
     // using traits = detail::cast_traits<Rep, typename To::rep>;
@@ -202,7 +201,7 @@ template<Representation ToRep, auto R, scalable_with_<ToRep> Rep>
 // requires(std::constructible_from<ToRep, std::common_type_t<ToRep, Rep>>)
 [[nodiscard]] constexpr auto quantity_cast(const quantity<R, Rep>& q)
 {
-  return To(static_cast<ToRep>(q.number()));
+  return quantity_cast<quantity<R, ToRep>>(q);
 }
 
 // /**

src/core/include/units/reference.h

@@ -136,11 +136,11 @@ template<Representation Rep, Reference R>
 
 void /*Use `q * (1 * r)` rather than `q * r`.*/ operator*(Quantity auto, Reference auto) = delete;
 
-template<Reference R1, Reference R2>
+// template<Reference R1, Reference R2>
-[[nodiscard]] consteval bool equivalent(R1, R2)
+// [[nodiscard]] consteval bool equivalent(R1, R2)
-{
+// {
-  return equivalent(R1::dimension, R2::dimension) && equivalent(R1::unit, R2::unit);
+//   return equivalent(R1::dimension, R2::dimension) && R1::unit == R2::unit;
-}
+// }
 
 template<Reference R1, Reference R2>
 [[nodiscard]] consteval bool convertible(R1, R2)
@@ -148,6 +148,12 @@ template<Reference R1, Reference R2>
   return convertible(R1::dimension, R2::dimension) && convertible(R1::unit, R2::unit);
 }
 
+// template<Reference R1, Reference R2>
+// [[nodiscard]] consteval bool castable(R1, R2)
+// {
+//   return equivalent(R1::dimension, R2::dimension) && convertible(R1::unit, R2::unit);
+// }
+
 
 template<Dimension auto Dim, Unit auto CoU>
 struct system_reference {

test/unit_test/static/dimension_test.cpp

@@ -22,10 +22,10 @@
 
 #include <units/dimension.h>
 
-using namespace units;
-
 namespace {
 
+using namespace units;
+
 template<auto V, typename T>
 inline constexpr bool is_of_type = std::is_same_v<std::remove_cvref_t<decltype(V)>, T>;
 
@@ -34,6 +34,7 @@ using one_dim_ = struct one_dim;
 // clang-format off
 inline constexpr struct length_dim_ : base_dimension<"L"> {} length_dim;
 inline constexpr struct time_dim_ : base_dimension<"T"> {} time_dim;
+inline constexpr struct mass_dim_ : base_dimension<"M"> {} mass_dim;
 
 inline constexpr struct frequency_dim_ : decltype(1 / time_dim) {} frequency_dim;
 inline constexpr struct action_dim_ : decltype(1 / time_dim) {} action_dim;
@@ -42,6 +43,15 @@ inline constexpr struct volume_dim_ : decltype(area_dim * length_dim) {} volume_
 inline constexpr struct speed_dim_ : decltype(length_dim / time_dim) {} speed_dim;
 inline constexpr struct velocity_dim_ : speed_dim_ {} velocity_dim;
 inline constexpr struct acceleration_dim_ : decltype(speed_dim / time_dim) {} acceleration_dim;
+inline constexpr struct force_dim_ : decltype(mass_dim * acceleration_dim) {} force_dim;
+inline constexpr struct moment_of_force_dim_ : decltype(length_dim * force_dim) {} moment_of_force_dim;
+inline constexpr struct torque_dim_ : decltype(moment_of_force_dim) {} torque_dim;
+inline constexpr struct pressure_dim_ : decltype(force_dim / area_dim) {} pressure_dim;
+inline constexpr struct stress_dim_ : decltype(pressure_dim) {} stress_dim;
+inline constexpr struct strain_dim_ : decltype(stress_dim / stress_dim) {} strain_dim;
+inline constexpr struct power_dim_ : decltype(force_dim * speed_dim) {} power_dim;
+inline constexpr struct efficiency_dim_ : decltype(power_dim / power_dim) {} efficiency_dim;
+inline constexpr struct energy_dim_ : decltype(force_dim * length_dim) {} energy_dim;
 // clang-format on
 
 // concepts verification
@@ -102,11 +112,15 @@ static_assert(
 static_assert(is_of_type<1 / (speed_dim * speed_dim) * length_dim,
                          derived_dimension<units::power<time_dim_, 2>, per<length_dim_>>>);
 
-// comparisons of equivalent dimensions
+// comparisons of the same dimensions
+static_assert(length_dim == length_dim);
+static_assert(speed_dim == speed_dim);
+
+// comparisons of equivalent dimensions (named vs unnamed/derived)
 static_assert(length_dim / length_dim == one_dim);
 
 static_assert(1 / time_dim != frequency_dim);
-static_assert(equivalent(1 / time_dim, frequency_dim));
+// static_assert(equivalent(1 / time_dim, frequency_dim));
 static_assert(convertible(1 / time_dim, frequency_dim));
 static_assert(1 / frequency_dim == time_dim);
 static_assert(frequency_dim * time_dim == one_dim);
@@ -114,7 +128,7 @@ static_assert(std::is_same_v<std::common_type_t<decltype(1 / time_dim), decltype
 static_assert(std::is_same_v<std::common_type_t<decltype(frequency_dim), decltype(1 / time_dim)>, frequency_dim_>);
 
 static_assert(length_dim * length_dim != area_dim);
-static_assert(equivalent(length_dim * length_dim, area_dim));
+// static_assert(equivalent(length_dim * length_dim, area_dim));
 static_assert(convertible(length_dim * length_dim, area_dim));
 static_assert(length_dim * length_dim != volume_dim);
 static_assert(area_dim / length_dim == length_dim);
@@ -122,20 +136,20 @@ static_assert(std::is_same_v<std::common_type_t<decltype(length_dim * length_dim
 static_assert(std::is_same_v<std::common_type_t<decltype(area_dim), decltype(length_dim * length_dim)>, area_dim_>);
 
 static_assert(length_dim * length_dim * length_dim != volume_dim);
-static_assert(equivalent(length_dim * length_dim * length_dim, volume_dim));
+// static_assert(equivalent(length_dim * length_dim * length_dim, volume_dim));
 static_assert(area_dim * length_dim != volume_dim);
-static_assert(equivalent(area_dim * length_dim, volume_dim));
+// static_assert(equivalent(area_dim * length_dim, volume_dim));
 static_assert(volume_dim / length_dim != area_dim);
-static_assert(equivalent(volume_dim / length_dim, area_dim));
+// static_assert(equivalent(volume_dim / length_dim, area_dim));
 static_assert(volume_dim / length_dim / length_dim == length_dim);
 static_assert(area_dim * area_dim / length_dim != volume_dim);
-static_assert(equivalent(area_dim * area_dim / length_dim, volume_dim));
+// static_assert(equivalent(area_dim * area_dim / length_dim, volume_dim));
 static_assert(area_dim * (area_dim / length_dim) != volume_dim);
-static_assert(equivalent(area_dim * (area_dim / length_dim), volume_dim));
+// static_assert(equivalent(area_dim * (area_dim / length_dim), volume_dim));
 static_assert(volume_dim / (length_dim * length_dim) == length_dim);
 
 static_assert(length_dim / time_dim != speed_dim);
-static_assert(equivalent(length_dim / time_dim, speed_dim));
+// static_assert(equivalent(length_dim / time_dim, speed_dim));
 static_assert(length_dim * time_dim != speed_dim);
 static_assert(length_dim / time_dim / time_dim != speed_dim);
 static_assert(length_dim / speed_dim == time_dim);
@@ -146,32 +160,72 @@ static_assert(std::is_same_v<std::common_type_t<decltype(length_dim / time_dim),
                              decltype(length_dim / time_dim)>);
 
 static_assert(length_dim / time_dim / time_dim != acceleration_dim);
-static_assert(equivalent(length_dim / time_dim / time_dim, acceleration_dim));
+// static_assert(equivalent(length_dim / time_dim / time_dim, acceleration_dim));
 static_assert(length_dim / (time_dim * time_dim) != acceleration_dim);
-static_assert(equivalent(length_dim / (time_dim * time_dim), acceleration_dim));
+// static_assert(equivalent(length_dim / (time_dim * time_dim), acceleration_dim));
 static_assert(speed_dim / time_dim != acceleration_dim);
-static_assert(equivalent(speed_dim / time_dim, acceleration_dim));
+// static_assert(equivalent(speed_dim / time_dim, acceleration_dim));
 static_assert(speed_dim / acceleration_dim == time_dim);
 static_assert(acceleration_dim * time_dim != speed_dim);
-static_assert(equivalent(acceleration_dim * time_dim, speed_dim));
+// static_assert(equivalent(acceleration_dim * time_dim, speed_dim));
 static_assert(acceleration_dim * (time_dim * time_dim) == length_dim);
 static_assert(acceleration_dim / speed_dim != frequency_dim);
-static_assert(equivalent(acceleration_dim / speed_dim, frequency_dim));
+// static_assert(equivalent(acceleration_dim / speed_dim, frequency_dim));
 
-static_assert(frequency_dim != action_dim);
+// comparison of convertible named dimensions
-static_assert(equivalent(frequency_dim, action_dim));
+static_assert(velocity_dim != speed_dim);
-static_assert(!convertible(frequency_dim, action_dim));
+// static_assert(equivalent(velocity_dim, speed_dim));
+static_assert(convertible(speed_dim, velocity_dim));
+static_assert(std::is_same_v<std::common_type_t<decltype(velocity_dim), decltype(speed_dim)>, velocity_dim_>);
+static_assert(std::is_same_v<std::common_type_t<decltype(speed_dim), decltype(velocity_dim)>, velocity_dim_>);
+
+// comparisons of equivalent but not convertible dimensions
+static_assert(energy_dim != torque_dim);
+// static_assert(equivalent(energy_dim, torque_dim));
+static_assert(!convertible(energy_dim, torque_dim));
+
+static_assert(force_dim * length_dim != energy_dim);
+static_assert(force_dim * length_dim != torque_dim);
+// static_assert(equivalent(force_dim * length_dim, energy_dim));
+// static_assert(equivalent(force_dim * length_dim, torque_dim));
+static_assert(convertible(force_dim * length_dim, energy_dim));
+static_assert(convertible(force_dim * length_dim, torque_dim));
 template<auto T1, auto T2>
 concept no_common_type = requires {
                            requires !requires { typename std::common_type_t<decltype(T1), decltype(T2)>; };
                            requires !requires { typename std::common_type_t<decltype(T2), decltype(T1)>; };
                          };
+static_assert(no_common_type<energy_dim, torque_dim>);
+
+static_assert(frequency_dim != action_dim);
+// static_assert(equivalent(frequency_dim, action_dim));
+static_assert(!convertible(frequency_dim, action_dim));
 static_assert(no_common_type<frequency_dim, action_dim>);
 
-static_assert(velocity_dim != speed_dim);
+// Dimensionless
-static_assert(equivalent(velocity_dim, speed_dim));
+// static_assert(equivalent(power_dim / power_dim, efficiency_dim));
-static_assert(convertible(speed_dim, velocity_dim));
+static_assert(convertible(power_dim / power_dim, efficiency_dim));
-static_assert(std::is_same_v<std::common_type_t<decltype(velocity_dim), decltype(speed_dim)>, velocity_dim_>);
+static_assert(power_dim / power_dim != efficiency_dim);
-static_assert(std::is_same_v<std::common_type_t<decltype(speed_dim), decltype(velocity_dim)>, velocity_dim_>);
+static_assert(one_dim != efficiency_dim);
+
+// static_assert(equivalent(efficiency_dim, strain_dim));
+static_assert(!convertible(efficiency_dim, strain_dim));
+static_assert(efficiency_dim != strain_dim);
+
+static_assert(stress_dim / stress_dim != strain_dim);
+static_assert(stress_dim / stress_dim != efficiency_dim);
+// static_assert(equivalent(stress_dim / stress_dim, strain_dim));
+// static_assert(equivalent(stress_dim / stress_dim, efficiency_dim));
+static_assert(convertible(stress_dim / stress_dim, strain_dim));
+static_assert(convertible(stress_dim / stress_dim, efficiency_dim));
+
+// comparison of not equivalent dimensions
+static_assert(length_dim != time_dim);
+// static_assert(!equivalent(length_dim, time_dim));
+static_assert(!convertible(length_dim, time_dim));
+
+static_assert(acceleration_dim != speed_dim);
+// static_assert(!equivalent(acceleration_dim, speed_dim));
+static_assert(!convertible(acceleration_dim, speed_dim));
 
 }  // namespace