feat!: 💥 dimensionless quantities refactored

Dimensionless quantities are now represented by quantity types rather
than by plain representation types. Only dimensionless quantities with
`unitless` unit are implicitly convertible from representation types.

`units::exp()` now is a function doing std::exp() on a representation
type (previous `units::exp` class template was renamed to
`units::exponent`).

BREAKING_CHANGE: gcc-9.3 support removed
BREAKING_CHANGE: `exp` and `Exp` renamed to `exponent` and `Exponent`
Resolves #27
Resolves #42

example/CMakeLists.txt

@@ -33,7 +33,6 @@ add_example(clcpp_response)
 add_example(conversion_factor)
 add_example(experimental_angle)
 add_example(foot_pound_second)
-add_example(glide_computer)
 add_example(kalman_filter-alpha_beta_filter_example2)
 
 conan_check_testing(linear_algebra)
@@ -51,6 +50,7 @@ if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 # TODO Those examples use Concepts terse syntax not yet supported by MSVC
 
 add_example(avg_speed)
+add_example(glide_computer)
 add_example(hello_units)
 add_example(total_energy)
 

example/alternative_namespaces/capacitor_time_curve.cpp

@@ -23,8 +23,8 @@
 #include <units/physical/si/capacitance.h>
 #include <units/physical/si/resistance.h>
 #include <units/physical/si/time.h>
+#include <units/math.h>
 #include "./voltage.h"
-#include <cmath>
 #include <iostream>
 
 using namespace units::experimental;
@@ -41,7 +41,7 @@ int main()
   constexpr auto R = 4.7q_kR;
 
   for (auto t = 0q_ms; t <= 50q_ms; ++t) {
-    const auto Vt = V0 * std::exp(-t / (R * C));
+    const auto Vt = V0 * units::exp(-t / (R * C));
 
     std::cout << "at " << t << " voltage is ";
 

example/capacitor_time_curve.cpp

@@ -24,7 +24,7 @@
 #include <units/physical/si/resistance.h>
 #include <units/physical/si/time.h>
 #include <units/physical/si/voltage.h>
-#include <cmath>
+#include <units/math.h>
 #include <iostream>
 
 int main()
@@ -41,7 +41,7 @@ int main()
   constexpr auto R = 4.7q_kR;
 
   for (auto t = 0q_ms; t <= 50q_ms; ++t) {
-    const Voltage AUTO Vt = V0 * std::exp(-t / (R * C));
+    const Voltage AUTO Vt = V0 * units::exp(-t / (R * C));
 
     std::cout << "at " << t << " voltage is ";
 

example/glide_computer.cpp

@@ -46,6 +46,7 @@ template<typename Q, direction D>
   requires Quantity<Q> || QuantityPoint<Q>
 class vector {
 public:
+  using value_type = Q;
   using magnitude_type = Q;
   static constexpr direction dir = D;
 
@@ -74,6 +75,43 @@ public:
     return *this;
   }
 
+  template<typename Q2>
+  [[nodiscard]] friend constexpr auto operator+(const vector& lhs, const vector<Q2, D>& rhs)
+    requires requires { lhs.magnitude() + rhs.magnitude(); }
+  {
+    using ret_type = decltype(lhs.magnitude() + rhs.magnitude());
+    return vector<ret_type, D>(lhs.magnitude() + rhs.magnitude());
+  }
+
+  template<typename Q2>
+  [[nodiscard]] friend constexpr auto operator-(const vector& lhs, const vector<Q2, D>& rhs)
+    requires requires { lhs.magnitude() - rhs.magnitude(); }
+  {
+    using ret_type = decltype(lhs.magnitude() - rhs.magnitude());
+    return vector<ret_type, D>(lhs.magnitude() - rhs.magnitude());
+  }
+
+  template<typename V>
+  [[nodiscard]] friend constexpr auto operator*(const vector& lhs, const V& value)
+    requires (Scalar<V> || Dimensionless<V>) && requires { lhs.magnitude() * value; }
+  {
+    return vector<Q, D>(lhs.magnitude() * value);
+  }
+
+  template<typename V>
+  [[nodiscard]] friend constexpr auto operator*(const V& value, const vector& rhs)
+    requires (Scalar<V> || Dimensionless<V>) && requires { value * rhs.magnitude(); }
+  {
+    return vector<Q, D>(value * rhs.magnitude());
+  }
+
+  template<typename Q2, direction D2>
+  [[nodiscard]] friend constexpr auto operator/(const vector& lhs, const vector<Q2, D2>& rhs)
+    requires requires { lhs.magnitude() / rhs.magnitude(); }
+  {
+    return lhs.magnitude() / rhs.magnitude();
+  }
+
 #if COMP_MSVC || COMP_GCC >= 10
 
   template<typename Q2>
@@ -149,42 +187,6 @@ private:
   Q magnitude_{};
 };
 
-template<typename Q1, typename Q2, direction D>
-[[nodiscard]] constexpr auto operator+(const vector<Q1, D>& lhs, const vector<Q2, D>& rhs)
-  requires requires { lhs.magnitude() + rhs.magnitude(); }
-{
-  using ret_type = decltype(lhs.magnitude() + rhs.magnitude());
-  return vector<ret_type, D>(lhs.magnitude() + rhs.magnitude());
-}
-
-template<typename Q1, typename Q2, direction D>
-[[nodiscard]] constexpr auto operator-(const vector<Q1, D>& lhs, const vector<Q2, D>& rhs)
-  requires requires { lhs.magnitude() - rhs.magnitude(); }
-{
-  using ret_type = decltype(lhs.magnitude() - rhs.magnitude());
-  return vector<ret_type, D>(lhs.magnitude() - rhs.magnitude());
-}
-
-template<typename Q, direction D, Scalar V>
-[[nodiscard]] constexpr auto operator*(const vector<Q, D>& lhs, const V& value)
-  requires requires { lhs.magnitude() * value; }
-{
-  return vector<Q, D>(lhs.magnitude() * value);
-}
-
-template<typename Q, direction D, Scalar V>
-[[nodiscard]] constexpr auto operator*(const V& value, const vector<Q, D>& rhs)
-  requires requires { value * rhs.magnitude(); }
-{
-  return vector<Q, D>(value * rhs.magnitude());
-}
-
-template<typename Q1, typename Q2, direction D1, direction D2>
-[[nodiscard]] constexpr auto operator/(const vector<Q1, D1>& lhs, const vector<Q2, D2>& rhs)
-  requires requires { lhs.magnitude() / rhs.magnitude(); }
-{
-  return lhs.magnitude() / rhs.magnitude();
-}
 
 template<typename T>
 inline constexpr bool is_vector = false;
@@ -276,7 +278,7 @@ auto get_gliders()
   return gliders;
 }
 
-constexpr double glide_ratio(const glider::polar_point& polar)
+constexpr Dimensionless AUTO glide_ratio(const glider::polar_point& polar)
 {
   return polar.v / -polar.climb;
 }