feat: quantity_point does not take a default origin anymore + common_qs logic removed from the binary operators

example/currency.cpp

@@ -33,6 +33,8 @@ inline constexpr struct dim_currency : base_dimension<"$"> {} dim_currency;
 
 QUANTITY_SPEC(currency, dim_currency);
 
+constexpr struct zero : absolute_point_origin<currency> {} zero;
+
 inline constexpr struct euro : named_unit<"EUR", kind_of<currency>> {} euro;
 inline constexpr struct us_dollar : named_unit<"USD", kind_of<currency>> {} us_dollar;
 inline constexpr struct great_british_pound : named_unit<"GBP", kind_of<currency>> {} great_british_pound;
@@ -41,6 +43,7 @@ inline constexpr struct japanese_jen : named_unit<"JPY", kind_of<currency>> {} j
 
 static_assert(!std::equality_comparable_with<quantity<euro, int>, quantity<us_dollar, int>>);
 
+
 #if 0
 
 // if you have only a few currencies to handle
@@ -78,13 +81,13 @@ quantity<To, Rep> exchange_to(quantity<From, Rep> q)
 template<ReferenceOf<currency> auto To, ReferenceOf<currency> auto From, auto PO, typename Rep>
 quantity_point<To, PO, Rep> exchange_to(quantity_point<From, PO, Rep> q)
 {
-  return quantity_point{static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.absolute().number()) * To};
+  return quantity_point{zero + static_cast<Rep>(exchange_rate<q.unit, get_unit(To)>() * q.absolute().number()) * To};
 }
 
 int main()
 {
-  auto price_usd = quantity_point{100 * us_dollar};
-  auto price_euro = quantity_point{exchange_to<euro>(price_usd)};
+  quantity_point price_usd = zero + 100 * us_dollar;
+  quantity_point price_euro = exchange_to<euro>(price_usd);
 
   std::cout << price_usd.absolute() << " -> " << price_euro.absolute() << "\n";
   // std::cout << price_usd.absolute() + price_euro.absolute() << "\n";  // does not compile

example/kalman_filter/kalman_filter-example_6.cpp

@@ -25,7 +25,7 @@
 #include <mp-units/math.h>
 #include <mp-units/quantity_point.h>
 #include <mp-units/systems/isq/thermodynamics.h>
-#include <mp-units/systems/si/unit_symbols.h>
+#include <mp-units/systems/si/si.h>
 #include <array>
 #include <iostream>
 
@@ -55,12 +55,12 @@ int main()
   using namespace kalman;
 
   const auto process_noise_variance = 0.0001 * (deg_C * deg_C);
-  const estimation initial = {state{quantity_point{10. * deg_C}}, pow<2>(100. * deg_C)};
-  const std::array measurements = {quantity_point{49.95 * deg_C},  quantity_point{49.967 * deg_C},
-                                   quantity_point{50.1 * deg_C},   quantity_point{50.106 * deg_C},
-                                   quantity_point{49.992 * deg_C}, quantity_point{49.819 * deg_C},
-                                   quantity_point{49.933 * deg_C}, quantity_point{50.007 * deg_C},
-                                   quantity_point{50.023 * deg_C}, quantity_point{49.99 * deg_C}};
+  const estimation initial = {state{si::ice_point + 10. * deg_C}, pow<2>(100. * deg_C)};
+  const std::array measurements = {si::ice_point + 49.95 * deg_C,  si::ice_point + 49.967 * deg_C,
+                                   si::ice_point + 50.1 * deg_C,   si::ice_point + 50.106 * deg_C,
+                                   si::ice_point + 49.992 * deg_C, si::ice_point + 49.819 * deg_C,
+                                   si::ice_point + 49.933 * deg_C, si::ice_point + 50.007 * deg_C,
+                                   si::ice_point + 50.023 * deg_C, si::ice_point + 49.99 * deg_C};
   const auto measurement_uncertainty = pow<2>(0.1 * deg_C);
 
   auto update = [=]<QuantityPoint QP>(const estimation<QP>& previous, const QP& meassurement,

example/kalman_filter/kalman_filter-example_7.cpp

@@ -25,7 +25,7 @@
 #include <mp-units/math.h>
 #include <mp-units/quantity_point.h>
 #include <mp-units/systems/isq/thermodynamics.h>
-#include <mp-units/systems/si/unit_symbols.h>
+#include <mp-units/systems/si/si.h>
 #include <array>
 #include <iostream>
 
@@ -55,12 +55,12 @@ int main()
   using namespace kalman;
 
   const auto process_noise_variance = 0.0001 * (deg_C * deg_C);
-  const estimation initial = {state{quantity_point{10. * deg_C}}, pow<2>(100. * deg_C)};
-  const std::array measurements = {quantity_point{50.45 * deg_C},  quantity_point{50.967 * deg_C},
-                                   quantity_point{51.6 * deg_C},   quantity_point{52.106 * deg_C},
-                                   quantity_point{52.492 * deg_C}, quantity_point{52.819 * deg_C},
-                                   quantity_point{53.433 * deg_C}, quantity_point{54.007 * deg_C},
-                                   quantity_point{54.523 * deg_C}, quantity_point{54.99 * deg_C}};
+  const estimation initial = {state{si::ice_point + 10. * deg_C}, pow<2>(100. * deg_C)};
+  const std::array measurements = {si::ice_point + 50.45 * deg_C,  si::ice_point + 50.967 * deg_C,
+                                   si::ice_point + 51.6 * deg_C,   si::ice_point + 52.106 * deg_C,
+                                   si::ice_point + 52.492 * deg_C, si::ice_point + 52.819 * deg_C,
+                                   si::ice_point + 53.433 * deg_C, si::ice_point + 54.007 * deg_C,
+                                   si::ice_point + 54.523 * deg_C, si::ice_point + 54.99 * deg_C};
   const auto measurement_uncertainty = pow<2>(0.1 * deg_C);
 
   auto update = [=]<QuantityPoint QP>(const estimation<QP>& previous, const QP& meassurement,

example/kalman_filter/kalman_filter-example_8.cpp

@@ -25,7 +25,7 @@
 #include <mp-units/math.h>
 #include <mp-units/quantity_point.h>
 #include <mp-units/systems/isq/thermodynamics.h>
-#include <mp-units/systems/si/unit_symbols.h>
+#include <mp-units/systems/si/si.h>
 #include <array>
 #include <iostream>
 
@@ -55,12 +55,12 @@ int main()
   using namespace kalman;
 
   const auto process_noise_variance = 0.15 * (deg_C * deg_C);
-  const estimation initial = {state{quantity_point{10. * deg_C}}, pow<2>(100. * deg_C)};
-  const std::array measurements = {quantity_point{50.45 * deg_C},  quantity_point{50.967 * deg_C},
-                                   quantity_point{51.6 * deg_C},   quantity_point{52.106 * deg_C},
-                                   quantity_point{52.492 * deg_C}, quantity_point{52.819 * deg_C},
-                                   quantity_point{53.433 * deg_C}, quantity_point{54.007 * deg_C},
-                                   quantity_point{54.523 * deg_C}, quantity_point{54.99 * deg_C}};
+  const estimation initial = {state{si::ice_point + 10. * deg_C}, pow<2>(100. * deg_C)};
+  const std::array measurements = {si::ice_point + 50.45 * deg_C,  si::ice_point + 50.967 * deg_C,
+                                   si::ice_point + 51.6 * deg_C,   si::ice_point + 52.106 * deg_C,
+                                   si::ice_point + 52.492 * deg_C, si::ice_point + 52.819 * deg_C,
+                                   si::ice_point + 53.433 * deg_C, si::ice_point + 54.007 * deg_C,
+                                   si::ice_point + 54.523 * deg_C, si::ice_point + 54.99 * deg_C};
   const auto measurement_uncertainty = pow<2>(0.1 * deg_C);
 
   auto update = [=]<QuantityPoint QP>(const estimation<QP>& previous, const QP& meassurement,

src/core/include/mp-units/bits/quantity_point_concepts.h

@@ -51,6 +51,10 @@ template<typename T>
 inline constexpr bool is_derived_from_specialization_of_absolute_point_origin =
   requires(T* t) { to_base_specialization_of_absolute_point_origin(t); };
 
+template<typename T>
+concept AbsolutePointOrigin =
+  is_derived_from_specialization_of_absolute_point_origin<T> && !is_specialization_of_absolute_point_origin<T>;
+
 }  // namespace detail
 
 /**
@@ -79,6 +83,10 @@ template<typename T>
 inline constexpr bool is_derived_from_specialization_of_relative_point_origin =
   requires(T* t) { to_base_specialization_of_relative_point_origin(t); };
 
+template<typename T>
+concept RelativePointOrigin =
+  is_derived_from_specialization_of_relative_point_origin<T> && !is_specialization_of_relative_point_origin<T>;
+
 }  // namespace detail
 
 /**
@@ -87,9 +95,7 @@ inline constexpr bool is_derived_from_specialization_of_relative_point_origin =
  * Satisfied by either quantity points or by all types derived from `absolute_point_origin` class template.
  */
 template<typename T>
-concept PointOrigin = detail::is_derived_from_specialization_of_absolute_point_origin<T> ||
-                      (detail::is_derived_from_specialization_of_relative_point_origin<T> &&
-                       !detail::is_specialization_of_relative_point_origin<T>);
+concept PointOrigin = detail::AbsolutePointOrigin<T> || detail::RelativePointOrigin<T>;
 
 /**
  * @brief A concept matching all quantity point origins for a specified quantity type in the library

src/core/include/mp-units/quantity_point.h

@@ -68,7 +68,7 @@ using quantity_point_like_type =
  * @tparam PO a type that represents the origin point from which the quantity point is measured from
  * @tparam Rep a type to be used to represent values of a quantity point
  */
-template<Reference auto R, PointOriginFor<get_quantity_spec(R)> auto PO = absolute_point_origin<get_quantity_spec(R)>{},
+template<Reference auto R, PointOriginFor<get_quantity_spec(R)> auto PO,
          RepresentationOf<get_quantity_spec(R).character> Rep = double>
 class quantity_point {
 public:
@@ -108,9 +108,10 @@ public:
   quantity_point(const quantity_point&) = default;
   quantity_point(quantity_point&&) = default;
 
-  template<typename T>
-    requires std::constructible_from<quantity_type, T>
-  constexpr explicit quantity_point(T&& v, decltype(point_origin) = point_origin) : q_(std::forward<T>(v))
+  template<Quantity Q>
+    requires std::constructible_from<quantity_type, Q> &&
+             ReferenceOf<std::remove_const_t<decltype(Q::reference)>, PO.quantity_spec>
+  constexpr explicit quantity_point(Q&& q, decltype(point_origin) = point_origin) : q_(std::forward<Q>(q))
   {
   }
 
@@ -245,7 +246,7 @@ explicit quantity_point(QP)
 
 template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
 // TODO simplify when gcc catches up
-  requires ReferenceOf<std::remove_const_t<decltype(R2)>, get_quantity_spec(R1)>
+  requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity_point<R1, PO1, Rep1>& qp,
                                                      const quantity<R2, Rep2>& q)
   requires requires { qp.quantity_from_origin() + q; }
@@ -257,7 +258,7 @@ template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
 
 template<auto R1, typename Rep1, auto R2, auto PO2, typename Rep2>
 // TODO simplify when gcc catches up
-  requires ReferenceOf<std::remove_const_t<decltype(R1)>, get_quantity_spec(R2)>
+  requires ReferenceOf<std::remove_const_t<decltype(R1)>, PO2.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator+(const quantity<R1, Rep1>& q,
                                                      const quantity_point<R2, PO2, Rep2>& qp)
   requires requires { q + qp.quantity_from_origin(); }
@@ -281,7 +282,7 @@ template<Quantity Q, PointOrigin PO>
 
 template<auto R1, auto PO1, typename Rep1, auto R2, typename Rep2>
 // TODO simplify when gcc catches up
-  requires ReferenceOf<std::remove_const_t<decltype(R2)>, get_quantity_spec(R1)>
+  requires ReferenceOf<std::remove_const_t<decltype(R2)>, PO1.quantity_spec>
 [[nodiscard]] constexpr QuantityPoint auto operator-(const quantity_point<R1, PO1, Rep1>& qp,
                                                      const quantity<R2, Rep2>& q)
   requires requires { qp.quantity_from_origin() - q; }
@@ -305,9 +306,7 @@ template<QuantityPoint QP1, QuantityPointOf<QP1::absolute_point_origin> QP2>
 {
   if constexpr (is_same_v<std::remove_const_t<decltype(QP1::point_origin)>,
                           std::remove_const_t<decltype(QP2::point_origin)>>) {
-    constexpr auto common_qs = common_quantity_spec(QP1::quantity_spec, QP1::point_origin.quantity_spec,
-                                                    QP2::quantity_spec, QP2::point_origin.quantity_spec);
-    return quantity_cast<common_qs>(lhs.quantity_from_origin() - rhs.quantity_from_origin());
+    return lhs.quantity_from_origin() - rhs.quantity_from_origin();
   } else
     return lhs.absolute() - rhs.absolute();
 }
@@ -316,17 +315,16 @@ template<PointOrigin PO, QuantityPointOf<PO{}> QP>
   requires ReferenceOf<std::remove_const_t<decltype(QP::reference)>, PO::quantity_spec>
 [[nodiscard]] constexpr Quantity auto operator-(const QP& qp, PO)
 {
-  constexpr auto common_qs = common_quantity_spec(PO::quantity_spec, QP::quantity_spec, QP::point_origin.quantity_spec);
   if constexpr (detail::is_derived_from_specialization_of_absolute_point_origin<PO>) {
     if constexpr (is_same_v<std::remove_const_t<PO>, std::remove_const_t<decltype(QP::point_origin)>>)
-      return quantity_cast<common_qs>(qp.quantity_from_origin());
+      return qp.quantity_from_origin();
     else
-      return quantity_cast<common_qs>(qp.absolute());
+      return qp.absolute();
   } else {
     if constexpr (is_same_v<std::remove_const_t<PO>, std::remove_const_t<decltype(QP::point_origin)>>)
-      return quantity_cast<common_qs>(qp.quantity_from_origin());
+      return qp.quantity_from_origin();
     else
-      return quantity_cast<common_qs>(qp.absolute() - PO::quantity_point.absolute());
+      return qp.absolute() - PO::quantity_point.absolute();
   }
 }
 
@@ -343,13 +341,12 @@ template<PointOrigin PO1, PointOriginOf<PO1{}> PO2>
             detail::is_derived_from_specialization_of_relative_point_origin<PO2>)
 [[nodiscard]] constexpr Quantity auto operator-(PO1 po1, PO2 po2)
 {
-  constexpr auto common_qs = common_quantity_spec(PO1::quantity_spec, PO2::quantity_spec);
   if constexpr (detail::is_derived_from_specialization_of_absolute_point_origin<PO1>) {
-    return quantity_cast<common_qs>(-po2.quantity_point.absolute());
+    return -po2.quantity_point.absolute();
   } else if constexpr (detail::is_derived_from_specialization_of_absolute_point_origin<PO2>) {
-    return quantity_cast<common_qs>(po1.quantity_point.absolute());
+    return po1.quantity_point.absolute();
   } else {
-    return quantity_cast<common_qs>(po1.quantity_point - po2.quantity_point);
+    return po1.quantity_point - po2.quantity_point;
   }
 }
 

test/unit_test/static/concepts_test.cpp

@@ -38,6 +38,13 @@ namespace {
 
 using namespace mp_units;
 
+inline constexpr struct my_origin : absolute_point_origin<isq::length> {
+} my_origin;
+inline constexpr struct another_origin : absolute_point_origin<isq::length> {
+} another_origin;
+inline constexpr struct my_relative_origin : relative_point_origin<my_origin + isq::length(42 * si::metre)> {
+} my_relative_origin;
+
 struct dim_speed : decltype(isq::dim_length / isq::dim_time) {};
 
 // BaseDimension
@@ -316,7 +323,7 @@ static_assert(Quantity<quantity<isq::length[si::metre]>>);
 static_assert(Quantity<quantity<si::metre, int>>);
 static_assert(Quantity<quantity<isq::length[si::metre], int>>);
 static_assert(!Quantity<std::chrono::seconds>);
-static_assert(!Quantity<quantity_point<si::metre>>);
+static_assert(!Quantity<quantity_point<si::metre, my_origin>>);
 static_assert(!Quantity<std::remove_const_t<decltype(isq::length[si::metre])>>);
 
 // QuantityOf
@@ -354,19 +361,14 @@ static_assert(!QuantityOf<quantity<dimensionless[one]>, isq::angular_measure>);
 static_assert(QuantityLike<std::chrono::seconds>);
 static_assert(QuantityLike<std::chrono::hours>);
 static_assert(!QuantityLike<quantity<isq::time[si::second]>>);
-static_assert(!QuantityLike<quantity_point<isq::time[si::second]>>);
+static_assert(!QuantityLike<quantity_point<isq::length[si::metre], my_origin>>);
 static_assert(!QuantityLike<int>);
 
 // QuantityPoint
-inline constexpr struct my_origin : absolute_point_origin<isq::length> {
-} my_origin;
-inline constexpr struct my_relative_origin : relative_point_origin<quantity_point{isq::length(42 * si::metre)}> {
-} my_relative_origin;
-
-static_assert(QuantityPoint<quantity_point<si::metre>>);
-static_assert(QuantityPoint<quantity_point<isq::length[si::metre]>>);
-static_assert(QuantityPoint<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>>);
-static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::length>{}, int>>);
+static_assert(QuantityPoint<quantity_point<si::metre, my_origin>>);
+static_assert(QuantityPoint<quantity_point<si::metre, my_relative_origin>>);
+static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_origin>>);
+static_assert(QuantityPoint<quantity_point<isq::length[si::metre], my_relative_origin, int>>);
 static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_origin>>);
 static_assert(QuantityPoint<quantity_point<isq::radius[si::metre], my_relative_origin>>);
 static_assert(!QuantityPoint<std::remove_const_t<decltype(isq::length[si::metre])>>);
@@ -378,56 +380,34 @@ static_assert(!QuantityPoint<std::chrono::time_point<std::chrono::system_clock>>
 static_assert(!QuantityPoint<int>);
 
 // QuantityPointOf
-static_assert(QuantityPointOf<quantity_point<si::metre>, isq::length>);
-static_assert(QuantityPointOf<quantity_point<si::metre>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre]>, isq::length>);
-static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre]>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre]>, isq::length>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre]>, isq::radius>);
-static_assert(
-  QuantityPointOf<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>, isq::length>);
-static_assert(
-  !QuantityPointOf<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>, isq::radius>);
-static_assert(
-  QuantityPointOf<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::length>{}, int>, isq::length>);
-static_assert(
-  QuantityPointOf<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::length>{}, int>, isq::radius>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::length>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, isq::radius>);
+static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
+static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::length>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, isq::radius>);
-static_assert(QuantityPointOf<quantity_point<si::metre>, absolute_point_origin<isq::length>{}>);
-static_assert(QuantityPointOf<quantity_point<si::metre>, absolute_point_origin<isq::radius>{}>);
-static_assert(!QuantityPointOf<quantity_point<si::metre>, my_origin>);
-static_assert(!QuantityPointOf<quantity_point<si::metre>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::length[si::metre]>, absolute_point_origin<isq::length>{}>);
-static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre]>, absolute_point_origin<isq::radius>{}>);
-static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre]>, my_origin>);
-static_assert(!QuantityPointOf<quantity_point<isq::length[si::metre]>, my_relative_origin>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre]>, absolute_point_origin<isq::length>{}>);
-static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre]>, absolute_point_origin<isq::radius>{}>);
-static_assert(!QuantityPointOf<quantity_point<isq::radius[si::metre]>, my_origin>);
-static_assert(!QuantityPointOf<quantity_point<isq::radius[si::metre]>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<si::metre, my_relative_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_relative_origin>);
+static_assert(QuantityPointOf<quantity_point<isq::length[si::metre], my_relative_origin>, my_origin>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_origin>);
+static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, my_relative_origin>);
 static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_relative_origin>);
-static_assert(
-  QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, absolute_point_origin<isq::length>{}>);
-static_assert(
-  !QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, absolute_point_origin<isq::length>{}>);
-static_assert(
-  !QuantityPointOf<quantity_point<isq::radius[si::metre], my_origin>, absolute_point_origin<isq::radius>{}>);
-static_assert(
-  !QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, absolute_point_origin<isq::radius>{}>);
+static_assert(QuantityPointOf<quantity_point<isq::radius[si::metre], my_relative_origin>, my_origin>);
 
 // PointOrigin
-static_assert(PointOrigin<absolute_point_origin<isq::length>>);
 static_assert(PointOrigin<struct my_origin>);
 static_assert(PointOrigin<struct my_relative_origin>);
-static_assert(!PointOrigin<relative_point_origin<quantity_point<si::metre>{42 * si::metre}>>);
-static_assert(!PointOrigin<quantity_point<si::metre>>);
-static_assert(!PointOrigin<quantity_point<isq::length[si::metre]>>);
-static_assert(!PointOrigin<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>>);
-static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::length>{}, int>>);
+static_assert(!PointOrigin<absolute_point_origin<isq::length>>);
+static_assert(!PointOrigin<relative_point_origin<my_origin + 42 * si::metre>>);
+static_assert(!PointOrigin<quantity_point<si::metre, my_origin>>);
+static_assert(!PointOrigin<quantity_point<isq::length[si::metre], my_origin>>);
 static_assert(!PointOrigin<quantity_point<isq::radius[si::metre], my_origin>>);
 static_assert(!PointOrigin<std::remove_const_t<decltype(isq::length[si::metre])>>);
 static_assert(!PointOrigin<std::chrono::seconds>);
@@ -435,50 +415,18 @@ static_assert(!PointOrigin<std::chrono::time_point<std::chrono::system_clock>>);
 static_assert(!PointOrigin<int>);
 
 // PointOriginFor
-static_assert(PointOriginFor<absolute_point_origin<isq::length>, isq::length>);
-static_assert(!PointOriginFor<absolute_point_origin<isq::radius>, isq::length>);
-static_assert(PointOriginFor<absolute_point_origin<isq::length>, isq::radius>);
-static_assert(PointOriginFor<absolute_point_origin<isq::radius>, isq::radius>);
-static_assert(!PointOriginFor<absolute_point_origin<isq::length>, isq::time>);
 static_assert(PointOriginFor<struct my_origin, isq::length>);
 static_assert(PointOriginFor<struct my_origin, isq::radius>);
 static_assert(!PointOriginFor<struct my_origin, isq::time>);
 static_assert(PointOriginFor<struct my_relative_origin, isq::length>);
 static_assert(PointOriginFor<struct my_relative_origin, isq::radius>);
 static_assert(!PointOriginFor<struct my_relative_origin, isq::time>);
-static_assert(!PointOriginFor<quantity_point<si::metre>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<si::metre>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<si::metre>, isq::time>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre]>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre]>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<isq::length[si::metre]>, isq::time>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre]>, isq::length>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre]>, isq::radius>);
-static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre]>, isq::time>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>, isq::length>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>, isq::radius>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::length[si::metre], absolute_point_origin<isq::length>{}, int>, isq::time>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::radius>{}, int>, isq::length>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::radius>{}, int>, isq::radius>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::radius>{}, int>, isq::time>);
-static_assert(!PointOriginFor<
-              quantity_point<isq::length[si::metre], absolute_point_origin<kind_of<isq::length>>{}, int>, isq::length>);
-static_assert(!PointOriginFor<
-              quantity_point<isq::length[si::metre], absolute_point_origin<kind_of<isq::length>>{}, int>, isq::radius>);
-static_assert(!PointOriginFor<
-              quantity_point<isq::length[si::metre], absolute_point_origin<kind_of<isq::length>>{}, int>, isq::time>);
-static_assert(!PointOriginFor<
-              quantity_point<isq::radius[si::metre], absolute_point_origin<kind_of<isq::length>>{}, int>, isq::length>);
-static_assert(!PointOriginFor<
-              quantity_point<isq::radius[si::metre], absolute_point_origin<kind_of<isq::length>>{}, int>, isq::radius>);
-static_assert(
-  !PointOriginFor<quantity_point<isq::radius[si::metre], absolute_point_origin<isq::length>{}, int>, isq::time>);
+static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::length>);
+static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::radius>);
+static_assert(!PointOriginFor<quantity_point<si::metre, my_origin>, isq::time>);
+static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::length>);
+static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::radius>);
+static_assert(!PointOriginFor<quantity_point<isq::length[si::metre], my_origin>, isq::time>);
 static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::length>);
 static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::radius>);
 static_assert(!PointOriginFor<quantity_point<isq::radius[si::metre], my_origin>, isq::time>);
@@ -494,7 +442,7 @@ static_assert(!PointOriginFor<int, isq::length>);
 static_assert(QuantityPointLike<std::chrono::time_point<std::chrono::system_clock>>);
 static_assert(!QuantityPointLike<std::chrono::seconds>);
 static_assert(!QuantityPointLike<quantity<isq::time[si::second]>>);
-static_assert(!QuantityPointLike<quantity_point<isq::time[si::second]>>);
+static_assert(!QuantityPointLike<quantity_point<si::metre, my_origin>>);
 static_assert(!QuantityPointLike<int>);
 
 }  // namespace