Merge branch 'master' into chiphogg/mod#509

test/static/cgs_test.cpp

@@ -25,24 +25,28 @@
 #include <mp-units/systems/isq/mechanics.h>
 #include <mp-units/systems/isq/space_and_time.h>
 #include <mp-units/systems/si/units.h>
-
-template<class T>
-  requires mp_units::is_scalar<T>
-constexpr bool mp_units::is_vector<T> = true;
+#if MP_UNITS_HOSTED
+#include <mp-units/cartesian_vector.h>
+#endif
 
 namespace {
 
 using namespace mp_units;
 using namespace mp_units::cgs;
 using namespace mp_units::cgs::unit_symbols;
+#if MP_UNITS_HOSTED
+using v = cartesian_vector<double>;
+#endif
 
 // https://en.wikipedia.org/wiki/Centimetre%E2%80%93gram%E2%80%93second_system_of_units#Definitions_and_conversion_factors_of_CGS_units_in_mechanics
 static_assert(isq::length(100 * cm) == isq::length(1 * si::metre));
 static_assert(isq::mass(1000 * g) == isq::mass(1 * si::kilogram));
 static_assert(isq::time(1 * s) == isq::time(1 * si::second));
 static_assert(isq::speed(100 * cm / s) == isq::speed(1 * si::metre / si::second));
-static_assert(isq::acceleration(100 * Gal) == isq::acceleration(1 * si::metre / square(si::second)));
-static_assert(isq::force(100'000 * dyn) == isq::force(1 * si::newton));
+#if MP_UNITS_HOSTED
+static_assert(isq::acceleration(v{100} * Gal) == isq::acceleration(v{1} * si::metre / square(si::second)));
+static_assert(isq::force(v{100'000} * dyn) == isq::force(v{1} * si::newton));
+#endif
 static_assert(isq::energy(10'000'000 * erg) == isq::energy(1 * si::joule));
 static_assert(isq::power(10'000'000 * erg / s) == isq::power(1 * si::watt));
 static_assert(isq::pressure(10 * Ba) == isq::pressure(1 * si::pascal));

test/static/math_test.cpp

@@ -237,17 +237,17 @@ static_assert(compare(round<si::second>(-1999. * isq::time[ms]), -2. * isq::time
 #endif
 
 // non-truncating
-static_assert(compare(inverse<us>(250 * Hz), 4000 * us));
-static_assert(compare(inverse<us>(250 * kHz), 4 * us));
-static_assert(compare(inverse<ks>(250 * uHz), 4 * ks));
+static_assert(compare(kind_of<isq::time>(inverse<us>(250 * Hz)), 4000 * us));
+static_assert(compare(kind_of<isq::time>(inverse<us>(250 * kHz)), 4 * us));
+static_assert(compare(kind_of<isq::time>(inverse<ks>(250 * uHz)), 4 * ks));
 
 // truncating
-static_assert(compare(inverse<s>(1 * kHz), 0 * s));
+static_assert(compare(kind_of<isq::time>(inverse<s>(1 * kHz)), 0 * s));
 
 // floating-point representation does not truncate
-static_assert(compare(inverse<s>(1. * kHz), 0.001 * s));
+static_assert(compare(kind_of<isq::time>(inverse<s>(1. * kHz)), 0.001 * s));
 
 // check if constraints work properly for a derived unit of a narrowed kind
-static_assert(compare(inverse<Hz>(1 * s), 1 * Hz));
+static_assert(compare(kind_of<isq::frequency>(inverse<Hz>(1 * s)), 1 * Hz));
 
 }  // namespace

test/static/reference_test.cpp

@@ -378,4 +378,14 @@ static_assert(invalid_comparison<frequency(1 * hertz), activity(1 * becquerel)>)
 static_assert(invalid_comparison<angular_measure(1 * radian), solid_angular_measure(1 * steradian)>);
 static_assert(invalid_comparison<angular_measure(1 * radian), storage_capacity(1 * bit)>);
 
+// make_reference
+static_assert(is_of_type<make_reference(length, metre), reference<length_, metre_>>);
+static_assert(is_of_type<make_reference(width, metre), reference<width_, metre_>>);
+static_assert(is_of_type<make_reference(kind_of<length>, metre), metre_>);
+static_assert(is_of_type<make_reference(get_quantity_spec(metre), metre), metre_>);
+static_assert(is_of_type<make_reference(get_quantity_spec(hertz), hertz), hertz_>);
+static_assert(is_of_type<make_reference(kind_of<frequency>, hertz), hertz_>);
+static_assert(is_of_type<make_reference(get_quantity_spec(watt), watt), watt_>);
+static_assert(is_of_type<make_reference(kind_of<power>, watt), reference<kind_of_<power_>, watt_>>);
+
 }  // namespace