diff --git a/docs/blog/posts/isq-part-6-challenges.md b/docs/blog/posts/isq-part-6-challenges.md
index 9058e82b..f658813e 100644
--- a/docs/blog/posts/isq-part-6-challenges.md
+++ b/docs/blog/posts/isq-part-6-challenges.md
@@ -386,7 +386,7 @@ the same kind.
We can try to do this by ourselves, but it is tough. Probably no one, for sure we are
not, is an expert in all the fields of ISO/IEC 80000 applicability.
-
+
We need the help of subject matter experts who will help us build those trees for their domains
and then verify that everything works as expected.
@@ -401,8 +401,8 @@ Some quantities are more complicated than others. For example, _power_ has:
- var (e.g., _reactive power_),
- complex quantities expressed in VA (volt-ampere) (e.g., _complex power_).
-How should we model this? Maybe those should be two independent trees of quantities, each having
-a different unit?
+How should we model this? Maybe those should be two or three independent trees of quantities, each
+having its own unit?
```mermaid
flowchart TD
@@ -411,14 +411,50 @@ flowchart TD
power --- electromagnetism_power["electromagnetism_power | instantaneous_power
(instantaneous_voltage * instantaneous_electric_current)"]
power --- active_power["active_power
(1 / period * instantaneous_power * time)
(re(complex_power))"]
- apparent_power["apparent_power
(voltage * electric_current)
(mod(complex_power))
[VA]"]
+ nonactive_power["nonactive_power
(mass * length2 / time3)
[VA]"]
+ nonactive_power --- reactive_power["reactive_power
(im(complex_power))
[var]"]
+
+ complex_power["complex_power
{complex}
(voltage_phasor * electric_current_phasor)
(active_power + j * reactive_power)
[VA]"]
+ complex_power --- apparent_power["apparent_power
(voltage * electric_current)
(mod(complex_power))"]
+```
+
+This will mean that we will not be able to add or compare _active power_, _reactive power_, and
+_apparent power_, which probably makes a lot of sense. However, it also means that the following
+will fail to compile:
+
+```cpp
+quantity apparent = isq::apparent_power(100 * VA);
+quantity active = isq::active_power(60 * W);
+quantity q = sqrt(pow<2>(apparent) - pow<2>(active)); // Compile-time error
+```
+
+Also the following will not work:
+
+```cpp
+quantity active = isq::active_power(60 * W);
+quantity reactive = isq::reactive_power(40 * var);
+quantity q = sqrt(pow<2>(active) + pow<2>(reactive)); // Compile-time error
+```
+
+If we want the above to work maybe we need to implement the tree as follows?
+
+```mermaid
+flowchart TD
+ power["power
(mass * length2 / time3)
[W]"]
+ power --- mechanical_power["mechanical_power
(scalar_product(force, velocity))"]
+ power --- electromagnetism_power["electromagnetism_power | instantaneous_power
(instantaneous_voltage * instantaneous_electric_current)"]
+ power --- apparent_power["apparent_power
(voltage * electric_current)
(mod(complex_power))
[VA]"]
+ apparent_power --- active_power["active_power
(1 / period * instantaneous_power * time)
(re(complex_power))"]
apparent_power --- nonactive_power["nonactive_power
(sqrt(apparent_power2 - active_power2))
"]
nonactive_power --- reactive_power["reactive_power
(im(complex_power))
[var]"]
apparent_power --- complex_power["complex_power
{complex}
(voltage_phasor * electric_current_phasor)
(active_power + j * reactive_power)"]
```
-This will mean that we will not be able to add or compare _active power_ with _apparent power_,
-which probably makes a lot of sense. Again, ISQ does not provide a direct answer here.
+However, the above allows direct addition and comparison of _active power_ and _nonactive power_,
+and also will not complain if someone will try to use watt (W) as a unit of _apparent power_ or
+_reactive power_.
+
+Again, ISQ does not provide a direct answer here.
## More base quantities?
@@ -490,5 +526,5 @@ a daily basis.
I hope you enjoyed following this series and learned more about the International System
of Quantities. Please try it out in your domain and share feedback with us. We always love to
-hear about the projects in which our library is being used and about use cases it helps
+hear about the projects in which our library is being used and about use cases it helps
address.
diff --git a/docs/users_guide/examples/si_constants.md b/docs/users_guide/examples/si_constants.md
index f5feb153..847520f4 100644
--- a/docs/users_guide/examples/si_constants.md
+++ b/docs/users_guide/examples/si_constants.md
@@ -16,19 +16,11 @@ work in practice.
--8<-- "example/si_constants.cpp:28:40"
```
-As always, we start with the inclusion of all the needed header files. After that, for
-the simplicity of this example, we
-[hack the character of quantities](../framework_basics/character_of_a_quantity.md#hacking-the-character)
-to be able to express vector quantities with simple scalar types.
-
-```cpp title="si_constants.cpp" linenums="14"
---8<-- "example/si_constants.cpp:42:44"
-```
-
+As always, we start with the inclusion of all the needed header files.
The main part of the example prints all of the SI-defining constants:
-```cpp title="si_constants.cpp" linenums="17"
---8<-- "example/si_constants.cpp:45:"
+```cpp title="si_constants.cpp" linenums="14"
+--8<-- "example/si_constants.cpp:42:"
```
While analyzing the output of this program (provided below), we can easily notice that a direct
diff --git a/example/include/validated_type.h b/example/include/validated_type.h
index c8b5dc6a..70be6dac 100644
--- a/example/include/validated_type.h
+++ b/example/include/validated_type.h
@@ -129,8 +129,8 @@ std::basic_ostream& operator<<(std::basic_ostream&
template
struct MP_UNITS_STD_FMT::formatter, Char> : formatter {
template
- auto format(const validated_type& v, FormatContext& ctx) const -> decltype(ctx.out())
+ auto format(const validated_type& val, FormatContext& ctx) const -> decltype(ctx.out())
{
- return formatter::format(v.value(), ctx);
+ return formatter::format(val.value(), ctx);
}
};
diff --git a/example/si_constants.cpp b/example/si_constants.cpp
index e09588c4..a43779ab 100644
--- a/example/si_constants.cpp
+++ b/example/si_constants.cpp
@@ -39,10 +39,6 @@ import mp_units;
#include
#endif
-template
- requires mp_units::is_scalar
-constexpr bool mp_units::is_vector = true;
-
int main()
{
using namespace mp_units;
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 2132d71a..e6251cf2 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -91,6 +91,7 @@ if(NOT ${projectPrefix}API_FREESTANDING)
include/mp-units/bits/fmt.h
include/mp-units/bits/requires_hosted.h
include/mp-units/ext/format.h
+ include/mp-units/cartesian_vector.h
include/mp-units/complex.h
include/mp-units/format.h
include/mp-units/math.h
diff --git a/src/core/include/mp-units/cartesian_vector.h b/src/core/include/mp-units/cartesian_vector.h
new file mode 100644
index 00000000..0749fae0
--- /dev/null
+++ b/src/core/include/mp-units/cartesian_vector.h
@@ -0,0 +1,230 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#pragma once
+
+#include
+//
+#include
+#include
+
+#if MP_UNITS_HOSTED
+#include
+#endif
+
+#ifndef MP_UNITS_IN_MODULE_INTERFACE
+#ifdef MP_UNITS_IMPORT_STD
+import std;
+#else
+#include
+#include
+#include
+#if MP_UNITS_HOSTED
+#include
+#endif
+#endif
+#endif
+
+namespace mp_units {
+
+MP_UNITS_EXPORT template
+class cartesian_vector {
+public:
+ // public members required to satisfy structural type requirements :-(
+ T _coordinates_[3];
+ using value_type = T;
+
+ cartesian_vector() = default;
+ cartesian_vector(const cartesian_vector&) = default;
+ cartesian_vector(cartesian_vector&&) = default;
+ cartesian_vector& operator=(const cartesian_vector&) = default;
+ cartesian_vector& operator=(cartesian_vector&&) = default;
+
+ template Arg1, std::convertible_to... Args>
+ constexpr cartesian_vector(Arg1&& arg1, Args&&... args) :
+ _coordinates_(std::forward(arg1), std::forward(args)...)
+ {
+ }
+
+ template U>
+ constexpr cartesian_vector(const cartesian_vector& other) : _coordinates_{other[0], other[1], other[2]}
+ {
+ }
+
+ template U>
+ constexpr cartesian_vector(cartesian_vector&& other) :
+ _coordinates_{std::move(other[0]), std::move(other[1]), std::move(other[2])}
+ {
+ }
+
+ template U>
+ constexpr cartesian_vector& operator=(const cartesian_vector& other)
+ {
+ _coordinates_[0] = other[0];
+ _coordinates_[1] = other[1];
+ _coordinates_[2] = other[2];
+ return *this;
+ }
+
+ template U>
+ constexpr cartesian_vector& operator=(cartesian_vector&& other)
+ {
+ _coordinates_[0] = std::move(other[0]);
+ _coordinates_[1] = std::move(other[1]);
+ _coordinates_[2] = std::move(other[2]);
+ return *this;
+ }
+
+ [[nodiscard]] constexpr T magnitude() const
+ requires treat_as_floating_point
+ {
+ return std::hypot(_coordinates_[0], _coordinates_[1], _coordinates_[2]);
+ }
+
+ [[nodiscard]] constexpr cartesian_vector unit() const
+ requires treat_as_floating_point
+ {
+ return *this / magnitude();
+ }
+
+ [[nodiscard]] constexpr T& operator[](std::size_t i) { return _coordinates_[i]; }
+ [[nodiscard]] constexpr const T& operator[](std::size_t i) const { return _coordinates_[i]; }
+
+ [[nodiscard]] constexpr cartesian_vector operator+() const { return *this; }
+ [[nodiscard]] constexpr cartesian_vector operator-() const
+ {
+ return {-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};
+ }
+
+ template U, typename V>
+ requires requires(U u, V v) { u + v; }
+ [[nodiscard]] friend constexpr auto operator+(const cartesian_vector& lhs, const cartesian_vector& rhs)
+ {
+ return ::mp_units::cartesian_vector{lhs._coordinates_[0] + rhs._coordinates_[0],
+ lhs._coordinates_[1] + rhs._coordinates_[1],
+ lhs._coordinates_[2] + rhs._coordinates_[2]};
+ }
+
+ template U, typename V>
+ requires requires(U u, V v) { u - v; }
+ [[nodiscard]] friend constexpr auto operator-(const cartesian_vector& lhs, const cartesian_vector& rhs)
+ {
+ return ::mp_units::cartesian_vector{lhs._coordinates_[0] - rhs._coordinates_[0],
+ lhs._coordinates_[1] - rhs._coordinates_[1],
+ lhs._coordinates_[2] - rhs._coordinates_[2]};
+ }
+
+ template U>
+ requires requires(U u, T t) { u* t; }
+ [[nodiscard]] friend constexpr auto operator*(const cartesian_vector& lhs, const T& rhs)
+ {
+ return ::mp_units::cartesian_vector{lhs._coordinates_[0] * rhs, lhs._coordinates_[1] * rhs,
+ lhs._coordinates_[2] * rhs};
+ }
+
+ template U>
+ requires requires(T t, U u) { t* u; }
+ [[nodiscard]] friend constexpr auto operator*(const T& lhs, const cartesian_vector& rhs)
+ {
+ return rhs * lhs;
+ }
+
+ template U>
+ requires requires(U u, T t) { u / t; }
+ [[nodiscard]] friend constexpr auto operator/(const cartesian_vector& lhs, const T& rhs)
+ {
+ return ::mp_units::cartesian_vector{lhs._coordinates_[0] / rhs, lhs._coordinates_[1] / rhs,
+ lhs._coordinates_[2] / rhs};
+ }
+
+ template U, std::equality_comparable_with V>
+ [[nodiscard]] friend constexpr bool operator==(const cartesian_vector& lhs, const cartesian_vector& rhs)
+ {
+ return lhs._coordinates_[0] == rhs._coordinates_[0] && lhs._coordinates_[1] == rhs._coordinates_[1] &&
+ lhs._coordinates_[2] == rhs._coordinates_[2];
+ }
+
+ [[nodiscard]] friend constexpr T norm(const cartesian_vector& vec)
+ requires treat_as_floating_point
+ {
+ return vec.magnitude();
+ }
+
+ [[nodiscard]] friend constexpr cartesian_vector unit_vector(const cartesian_vector& vec)
+ requires treat_as_floating_point
+ {
+ return vec.unit();
+ }
+
+ template U, typename V>
+ requires requires(U u, V v, decltype(u * v) t) {
+ u* v;
+ t + t;
+ }
+ [[nodiscard]] friend constexpr auto scalar_product(const cartesian_vector& lhs, const cartesian_vector& rhs)
+ {
+ return lhs._coordinates_[0] * rhs._coordinates_[0] + lhs._coordinates_[1] * rhs._coordinates_[1] +
+ lhs._coordinates_[2] * rhs._coordinates_[2];
+ }
+
+ template U, typename V>
+ requires requires(U u, V v, decltype(u * v) t) {
+ u* v;
+ t - t;
+ }
+ [[nodiscard]] friend constexpr auto vector_product(const cartesian_vector& lhs, const cartesian_vector& rhs)
+ {
+ return ::mp_units::cartesian_vector{
+ lhs._coordinates_[1] * rhs._coordinates_[2] - lhs._coordinates_[2] * rhs._coordinates_[1],
+ lhs._coordinates_[2] * rhs._coordinates_[0] - lhs._coordinates_[0] * rhs._coordinates_[2],
+ lhs._coordinates_[0] * rhs._coordinates_[1] - lhs._coordinates_[1] * rhs._coordinates_[0]};
+ }
+
+#if MP_UNITS_HOSTED
+ friend constexpr std::ostream& operator<<(std::ostream& os, const cartesian_vector& vec)
+ {
+ return os << '[' << vec[0] << ", " << vec[1] << ", " << vec[2] << ']';
+ }
+#endif
+};
+
+template
+ requires(sizeof...(Args) <= 2) && requires { typename std::common_type_t; }
+cartesian_vector(Arg, Args...) -> cartesian_vector>;
+
+template
+constexpr bool is_vector> = true;
+
+} // namespace mp_units
+
+#if MP_UNITS_HOSTED
+// TODO use parse and use formatter for the underlying type
+template
+struct MP_UNITS_STD_FMT::formatter, Char> :
+ formatter, Char> {
+ template
+ auto format(const mp_units::cartesian_vector& vec, FormatContext& ctx) const
+ {
+ return format_to(ctx.out(), "[{}, {}, {}]", vec[0], vec[1], vec[2]);
+ }
+};
+#endif
diff --git a/src/core/include/mp-units/core.h b/src/core/include/mp-units/core.h
index a99978f8..702f3b6b 100644
--- a/src/core/include/mp-units/core.h
+++ b/src/core/include/mp-units/core.h
@@ -28,6 +28,7 @@
#include
#if MP_UNITS_HOSTED
+#include
#include
#include
#include
diff --git a/src/core/include/mp-units/ext/inplace_vector.h b/src/core/include/mp-units/ext/inplace_vector.h
index 1e93caf4..8074b09b 100644
--- a/src/core/include/mp-units/ext/inplace_vector.h
+++ b/src/core/include/mp-units/ext/inplace_vector.h
@@ -90,16 +90,16 @@ public:
constexpr T* data() noexcept { return data_; }
constexpr const T* data() const noexcept { return data_; }
- constexpr reference push_back(const T& v)
+ constexpr reference push_back(const T& val)
requires std::constructible_from
{
- return emplace_back(v);
+ return emplace_back(val);
}
- constexpr reference push_back(T&& v)
+ constexpr reference push_back(T&& val)
requires std::constructible_from
{
- return emplace_back(std::forward(v));
+ return emplace_back(std::forward(val));
}
template
diff --git a/src/core/include/mp-units/framework/quantity.h b/src/core/include/mp-units/framework/quantity.h
index bfd55b92..71bbc699 100644
--- a/src/core/include/mp-units/framework/quantity.h
+++ b/src/core/include/mp-units/framework/quantity.h
@@ -174,21 +174,21 @@ public:
template
requires detail::SameValueAs, Rep>
- constexpr quantity(FwdValue&& v, R2) : numerical_value_is_an_implementation_detail_(std::forward(v))
+ constexpr quantity(FwdValue&& val, R2) : numerical_value_is_an_implementation_detail_(std::forward(val))
{
}
template>
requires(!detail::SameValueAs) &&
detail::QuantityConvertibleTo, quantity>
- constexpr quantity(FwdValue&& v, R2) : quantity(quantity{std::forward(v), R2{}})
+ constexpr quantity(FwdValue&& val, R2) : quantity(quantity{std::forward(val), R2{}})
{
}
template FwdValue>
requires(unit == ::mp_units::one)
- constexpr explicit(false) quantity(FwdValue&& v) :
- numerical_value_is_an_implementation_detail_(std::forward(v))
+ constexpr explicit(false) quantity(FwdValue&& val) :
+ numerical_value_is_an_implementation_detail_(std::forward(val))
{
}
@@ -214,9 +214,9 @@ public:
template FwdValue>
requires(unit == ::mp_units::one)
- constexpr quantity& operator=(FwdValue&& v)
+ constexpr quantity& operator=(FwdValue&& val)
{
- numerical_value_is_an_implementation_detail_ = std::forward(v);
+ numerical_value_is_an_implementation_detail_ = std::forward(val);
return *this;
}
@@ -422,11 +422,11 @@ public:
requires(!Quantity) && requires(rep a, Value b) {
{ a *= b } -> std::same_as;
}
- friend constexpr decltype(auto) operator*=(Q&& lhs, const Value& v)
+ friend constexpr decltype(auto) operator*=(Q&& lhs, const Value& val)
{
// TODO use *= when compiler bug is resolved:
// https://developercommunity.visualstudio.com/t/Discrepancy-in-Behavior-of-operator-an/10732445
- lhs.numerical_value_is_an_implementation_detail_ = lhs.numerical_value_is_an_implementation_detail_ * v;
+ lhs.numerical_value_is_an_implementation_detail_ = lhs.numerical_value_is_an_implementation_detail_ * val;
return std::forward(lhs);
}
@@ -444,12 +444,12 @@ public:
requires(!Quantity) && requires(rep a, Value b) {
{ a /= b } -> std::same_as;
}
- friend constexpr decltype(auto) operator/=(Q&& lhs, const Value& v)
+ friend constexpr decltype(auto) operator/=(Q&& lhs, const Value& val)
{
- MP_UNITS_EXPECTS_DEBUG(v != quantity_values::zero());
+ MP_UNITS_EXPECTS_DEBUG(val != quantity_values::zero());
// TODO use /= when compiler bug is resolved:
// https://developercommunity.visualstudio.com/t/Discrepancy-in-Behavior-of-operator-an/10732445
- lhs.numerical_value_is_an_implementation_detail_ = lhs.numerical_value_is_an_implementation_detail_ / v;
+ lhs.numerical_value_is_an_implementation_detail_ = lhs.numerical_value_is_an_implementation_detail_ / val;
return std::forward(lhs);
}
@@ -551,17 +551,17 @@ public:
template Q, typename Value>
requires(!Quantity) &&
(!Reference) && detail::InvokeResultOf, Rep, const Value&>
- [[nodiscard]] friend constexpr QuantityOf auto operator*(const Q& q, const Value& v)
+ [[nodiscard]] friend constexpr QuantityOf auto operator*(const Q& q, const Value& val)
{
- return ::mp_units::quantity{q.numerical_value_ref_in(unit) * v, R};
+ return ::mp_units::quantity{q.numerical_value_ref_in(unit) * val, R};
}
template Q>
requires(!Quantity) &&
(!Reference) && detail::InvokeResultOf, const Value&, Rep>
- [[nodiscard]] friend constexpr QuantityOf auto operator*(const Value& v, const Q& q)
+ [[nodiscard]] friend constexpr QuantityOf auto operator*(const Value& val, const Q& q)
{
- return ::mp_units::quantity{v * q.numerical_value_ref_in(unit), R};
+ return ::mp_units::quantity{val * q.numerical_value_ref_in(unit), R};
}
template Q, auto R2, typename Rep2>
@@ -575,18 +575,18 @@ public:
template Q, typename Value>
requires(!Quantity) &&
(!Reference) && detail::InvokeResultOf, Rep, const Value&>
- [[nodiscard]] friend constexpr QuantityOf auto operator/(const Q& q, const Value& v)
+ [[nodiscard]] friend constexpr QuantityOf auto operator/(const Q& q, const Value& val)
{
- MP_UNITS_EXPECTS_DEBUG(v != quantity_values::zero());
- return ::mp_units::quantity{q.numerical_value_ref_in(unit) / v, R};
+ MP_UNITS_EXPECTS_DEBUG(val != quantity_values::zero());
+ return ::mp_units::quantity{q.numerical_value_ref_in(unit) / val, R};
}
template Q>
requires(!Quantity) &&
(!Reference) && detail::InvokeResultOf, const Value&, Rep>
- [[nodiscard]] friend constexpr QuantityOf auto operator/(const Value& v, const Q& q)
+ [[nodiscard]] friend constexpr QuantityOf auto operator/(const Value& val, const Q& q)
{
- return ::mp_units::quantity{v / q.numerical_value_ref_in(unit), ::mp_units::one / R};
+ return ::mp_units::quantity{val / q.numerical_value_ref_in(unit), ::mp_units::one / R};
}
template Q, auto R2, typename Rep2>
diff --git a/src/core/include/mp-units/framework/representation_concepts.h b/src/core/include/mp-units/framework/representation_concepts.h
index 4ddbcb88..8be28d05 100644
--- a/src/core/include/mp-units/framework/representation_concepts.h
+++ b/src/core/include/mp-units/framework/representation_concepts.h
@@ -118,12 +118,11 @@ concept ComplexRepresentation = Complex && WeaklyRegular && requires(T a,
{ a - b } -> Complex;
{ a* b } -> Complex;
{ a / b } -> Complex;
- // TBD
- // { re(a) } -> Scalar;
- // { im(a) } -> Scalar;
- // { mod(a) } -> Scalar;
- // { arg(a) } -> Scalar;
- // { conj(a) } -> Complex;
+ { real(a) } -> Scalar;
+ { imag(a) } -> Scalar;
+ { abs(a) } -> Scalar;
+ { arg(a) } -> Scalar;
+ { conj(a) } -> Complex;
};
// TODO how to check for a complex(Scalar, Scalar) -> Complex?
diff --git a/src/core/include/mp-units/ostream.h b/src/core/include/mp-units/ostream.h
index 15b6127b..1b3f63ac 100644
--- a/src/core/include/mp-units/ostream.h
+++ b/src/core/include/mp-units/ostream.h
@@ -68,8 +68,8 @@ void to_stream_impl(std::basic_ostream& os, const quantity
-std::basic_ostream& to_stream(std::basic_ostream& os, const T& v)
- requires requires { detail::to_stream_impl(os, v); }
+std::basic_ostream& to_stream(std::basic_ostream& os, const T& val)
+ requires requires { detail::to_stream_impl(os, val); }
{
if (os.width()) {
// std::setw() applies to the whole output so it has to be first put into std::string
@@ -77,11 +77,11 @@ std::basic_ostream& to_stream(std::basic_ostream&
oss.flags(os.flags());
oss.imbue(os.getloc());
oss.precision(os.precision());
- detail::to_stream_impl(oss, v);
+ detail::to_stream_impl(oss, val);
return os << std::move(oss).str();
}
- detail::to_stream_impl(os, v);
+ detail::to_stream_impl(os, val);
return os;
}
@@ -93,10 +93,10 @@ constexpr bool is_mp_units_stream = requires(OStream os, T v) { detail::to_strea
MP_UNITS_EXPORT_BEGIN
template
-std::basic_ostream& operator<<(std::basic_ostream& os, const T& v)
+std::basic_ostream& operator<<(std::basic_ostream& os, const T& val)
requires detail::is_mp_units_stream, T>
{
- return detail::to_stream(os, v);
+ return detail::to_stream(os, val);
}
MP_UNITS_EXPORT_END
diff --git a/src/systems/include/mp-units/systems/si/chrono.h b/src/systems/include/mp-units/systems/si/chrono.h
index a856fc15..51434421 100644
--- a/src/systems/include/mp-units/systems/si/chrono.h
+++ b/src/systems/include/mp-units/systems/si/chrono.h
@@ -83,10 +83,10 @@ struct quantity_like_traits> {
return q.count();
}
- [[nodiscard]] static constexpr T from_numerical_value(const rep& v) noexcept(
+ [[nodiscard]] static constexpr T from_numerical_value(const rep& val) noexcept(
std::is_nothrow_copy_constructible_v)
{
- return T(v);
+ return T(val);
}
};
@@ -113,10 +113,10 @@ struct quantity_point_like_traits)
{
- return T(std::chrono::duration(v));
+ return T(std::chrono::duration(val));
}
};
diff --git a/test/runtime/CMakeLists.txt b/test/runtime/CMakeLists.txt
index d79ed54b..c1d990ba 100644
--- a/test/runtime/CMakeLists.txt
+++ b/test/runtime/CMakeLists.txt
@@ -24,13 +24,14 @@ find_package(Catch2 3 REQUIRED)
add_executable(
unit_tests_runtime
+ atomic_test.cpp
+ cartesian_vector_test.cpp
distribution_test.cpp
fixed_string_test.cpp
fmt_test.cpp
math_test.cpp
- atomic_test.cpp
- truncation_test.cpp
quantity_test.cpp
+ truncation_test.cpp
)
if(${projectPrefix}BUILD_CXX_MODULES)
target_compile_definitions(unit_tests_runtime PUBLIC ${projectPrefix}MODULES)
diff --git a/test/runtime/cartesian_vector_test.cpp b/test/runtime/cartesian_vector_test.cpp
new file mode 100644
index 00000000..252134d0
--- /dev/null
+++ b/test/runtime/cartesian_vector_test.cpp
@@ -0,0 +1,381 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Mateusz Pusz
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "almost_equals.h"
+#include
+#include
+#include
+#include
+#ifdef MP_UNITS_IMPORT_STD
+import std;
+#else
+#include
+#endif
+#ifdef MP_UNITS_MODULES
+import mp_units;
+#else
+#include
+#endif
+
+using namespace mp_units;
+using namespace Catch::Matchers;
+
+TEST_CASE("cartesian_vector operations", "[vector]")
+{
+ SECTION("cartesian_vector initialization and access")
+ {
+ SECTION("one argument")
+ {
+ cartesian_vector v{1.0};
+ REQUIRE(v[0] == 1.0);
+ REQUIRE(v[1] == 0);
+ REQUIRE(v[2] == 0);
+ }
+
+ SECTION("two arguments")
+ {
+ cartesian_vector v{1.0, 2.0};
+ REQUIRE(v[0] == 1.0);
+ REQUIRE(v[1] == 2.0);
+ REQUIRE(v[2] == 0);
+ }
+
+ SECTION("all arguments")
+ {
+ cartesian_vector v{1.0, 2.0, 3.0};
+ REQUIRE(v[0] == 1.0);
+ REQUIRE(v[1] == 2.0);
+ REQUIRE(v[2] == 3.0);
+ }
+ }
+
+ SECTION("convertibility")
+ {
+ cartesian_vector v1{1, 2, 3};
+
+ SECTION("construction")
+ {
+ cartesian_vector v2 = v1;
+ REQUIRE(v2[0] == 1.0);
+ REQUIRE(v2[1] == 2.0);
+ REQUIRE(v2[2] == 3.0);
+ }
+
+ SECTION("assignment")
+ {
+ cartesian_vector v2{3.0, 2.0, 1.0};
+ v2 = v1;
+ REQUIRE(v2[0] == 1.0);
+ REQUIRE(v2[1] == 2.0);
+ REQUIRE(v2[2] == 3.0);
+ }
+ }
+
+ SECTION("cartesian_vector addition")
+ {
+ SECTION("double + double")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ cartesian_vector result = v1 + v2;
+ REQUIRE(result[0] == 5.0);
+ REQUIRE(result[1] == 7.0);
+ REQUIRE(result[2] == 9.0);
+ }
+
+ SECTION("double + int")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4, 5, 6};
+ cartesian_vector result = v1 + v2;
+ REQUIRE(result[0] == 5.0);
+ REQUIRE(result[1] == 7.0);
+ REQUIRE(result[2] == 9.0);
+ }
+
+ SECTION("int + double")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ cartesian_vector result = v1 + v2;
+ REQUIRE(result[0] == 5.0);
+ REQUIRE(result[1] == 7.0);
+ REQUIRE(result[2] == 9.0);
+ }
+
+ SECTION("int + int")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4, 5, 6};
+ cartesian_vector result = v1 + v2;
+ REQUIRE(result[0] == 5);
+ REQUIRE(result[1] == 7);
+ REQUIRE(result[2] == 9);
+ }
+ }
+
+ SECTION("cartesian_vector subtraction")
+ {
+ SECTION("double - double")
+ {
+ cartesian_vector v1{4.0, 5.0, 6.0};
+ cartesian_vector v2{1.0, 2.0, 3.0};
+ cartesian_vector result = v1 - v2;
+ REQUIRE(result[0] == 3.0);
+ REQUIRE(result[1] == 3.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("double - int")
+ {
+ cartesian_vector v1{4.0, 5.0, 6.0};
+ cartesian_vector v2{1, 2, 3};
+ cartesian_vector result = v1 - v2;
+ REQUIRE(result[0] == 3.0);
+ REQUIRE(result[1] == 3.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("int - double")
+ {
+ cartesian_vector v1{4, 5, 6};
+ cartesian_vector v2{1.0, 2.0, 3.0};
+ cartesian_vector result = v1 - v2;
+ REQUIRE(result[0] == 3.0);
+ REQUIRE(result[1] == 3.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("int - int")
+ {
+ cartesian_vector v1{4, 5, 6};
+ cartesian_vector v2{1, 2, 3};
+ cartesian_vector result = v1 - v2;
+ REQUIRE(result[0] == 3);
+ REQUIRE(result[1] == 3);
+ REQUIRE(result[2] == 3);
+ }
+ }
+
+ SECTION("cartesian_vector scalar multiplication")
+ {
+ SECTION("double * double")
+ {
+ cartesian_vector v{1.0, 2.0, 3.0};
+ cartesian_vector result = v * 2.0;
+ REQUIRE(result[0] == 2.0);
+ REQUIRE(result[1] == 4.0);
+ REQUIRE(result[2] == 6.0);
+ }
+
+ SECTION("double * int")
+ {
+ cartesian_vector v{1.0, 2.0, 3.0};
+ cartesian_vector result = v * 2;
+ REQUIRE(result[0] == 2.0);
+ REQUIRE(result[1] == 4.0);
+ REQUIRE(result[2] == 6.0);
+ }
+
+ SECTION("int * double")
+ {
+ cartesian_vector v{1, 2, 3};
+ cartesian_vector result = v * 2.0;
+ REQUIRE(result[0] == 2.0);
+ REQUIRE(result[1] == 4.0);
+ REQUIRE(result[2] == 6.0);
+ }
+
+ SECTION("int * int")
+ {
+ cartesian_vector v{1, 2, 3};
+ cartesian_vector result = v * 2;
+ REQUIRE(result[0] == 2);
+ REQUIRE(result[1] == 4);
+ REQUIRE(result[2] == 6);
+ }
+ }
+
+ SECTION("cartesian_vector scalar division")
+ {
+ SECTION("double / double")
+ {
+ cartesian_vector v{2.0, 4.0, 6.0};
+ cartesian_vector result = v / 2.0;
+ REQUIRE(result[0] == 1.0);
+ REQUIRE(result[1] == 2.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("double / int")
+ {
+ cartesian_vector v{2.0, 4.0, 6.0};
+ cartesian_vector result = v / 2;
+ REQUIRE(result[0] == 1.0);
+ REQUIRE(result[1] == 2.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("int / double")
+ {
+ cartesian_vector v{2, 4, 6};
+ cartesian_vector result = v / 2.0;
+ REQUIRE(result[0] == 1.0);
+ REQUIRE(result[1] == 2.0);
+ REQUIRE(result[2] == 3.0);
+ }
+
+ SECTION("int / int")
+ {
+ cartesian_vector v{2, 4, 6};
+ cartesian_vector result = v / 2;
+ REQUIRE(result[0] == 1);
+ REQUIRE(result[1] == 2);
+ REQUIRE(result[2] == 3);
+ }
+ }
+
+ SECTION("cartesian_vector magnitude")
+ {
+ cartesian_vector v1{3.0, 4.0, 0.0};
+ cartesian_vector v2{2.0, 3.0, 6.0};
+ REQUIRE(v1.magnitude() == 5.0);
+ REQUIRE(v2.magnitude() == 7.0);
+ }
+
+ SECTION("cartesian_vector unit vector")
+ {
+ cartesian_vector v{3.0, 4.0, 0.0};
+ cartesian_vector unit_v = v.unit();
+ REQUIRE_THAT(unit_v.magnitude(), WithinULP(1.0, 1));
+ }
+
+ SECTION("cartesian_vector equality")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{1, 2, 3};
+ cartesian_vector v3{1.1, 2.0, 3.0};
+ cartesian_vector v4{1.0, 2.1, 3.0};
+ cartesian_vector v5{1.0, 2.0, 3.1};
+ REQUIRE(v1 == v2);
+ REQUIRE(v1 != v3);
+ REQUIRE(v1 != v4);
+ REQUIRE(v1 != v5);
+ }
+
+ SECTION("cartesian_vector scalar product")
+ {
+ SECTION("double * double")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ REQUIRE(scalar_product(v1, v2) == 32.0);
+ }
+
+ SECTION("double * int")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4, 5, 6};
+ REQUIRE(scalar_product(v1, v2) == 32.0);
+ }
+
+ SECTION("int * double")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ REQUIRE(scalar_product(v1, v2) == 32.0);
+ }
+
+ SECTION("int * int")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4, 5, 6};
+ REQUIRE(scalar_product(v1, v2) == 32);
+ }
+ }
+
+ SECTION("cartesian_vector vector product")
+ {
+ SECTION("double * double")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ cartesian_vector result = vector_product(v1, v2);
+ REQUIRE(result[0] == -3.0);
+ REQUIRE(result[1] == 6.0);
+ REQUIRE(result[2] == -3.0);
+ }
+
+ SECTION("double * int")
+ {
+ cartesian_vector v1{1.0, 2.0, 3.0};
+ cartesian_vector v2{4, 5, 6};
+ cartesian_vector result = vector_product(v1, v2);
+ REQUIRE(result[0] == -3.0);
+ REQUIRE(result[1] == 6.0);
+ REQUIRE(result[2] == -3.0);
+ }
+
+ SECTION("int * double")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4.0, 5.0, 6.0};
+ cartesian_vector result = vector_product(v1, v2);
+ REQUIRE(result[0] == -3.0);
+ REQUIRE(result[1] == 6.0);
+ REQUIRE(result[2] == -3.0);
+ }
+
+ SECTION("int * int")
+ {
+ cartesian_vector v1{1, 2, 3};
+ cartesian_vector v2{4, 5, 6};
+ cartesian_vector result = vector_product(v1, v2);
+ REQUIRE(result[0] == -3);
+ REQUIRE(result[1] == 6);
+ REQUIRE(result[2] == -3);
+ }
+ }
+}
+
+TEST_CASE("cartesian_vector text output", "[vector][fmt][ostream]")
+{
+ std::ostringstream os;
+
+ SECTION("integral representation")
+ {
+ cartesian_vector v{1, 2, 3};
+ os << v;
+
+ SECTION("iostream") { CHECK(os.str() == "[1, 2, 3]"); }
+ SECTION("fmt with default format {}") { CHECK(MP_UNITS_STD_FMT::format("{}", v) == os.str()); }
+ }
+
+ SECTION("floating-point representation")
+ {
+ cartesian_vector v{1.2, 2.3, 3.4};
+ os << v;
+
+ SECTION("iostream") { CHECK(os.str() == "[1.2, 2.3, 3.4]"); }
+ SECTION("fmt with default format {}") { CHECK(MP_UNITS_STD_FMT::format("{}", v) == os.str()); }
+ }
+}
diff --git a/test/runtime/distribution_test.cpp b/test/runtime/distribution_test.cpp
index 9df1eb3b..1ea3da1d 100644
--- a/test/runtime/distribution_test.cpp
+++ b/test/runtime/distribution_test.cpp
@@ -43,618 +43,621 @@ import mp_units;
using namespace mp_units;
-TEST_CASE("uniform_int_distribution")
+TEST_CASE("distributions", "[random][distribution]")
{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
+ SECTION("uniform_int_distribution")
{
- auto dist = mp_units::uniform_int_distribution();
+ using rep = std::int64_t;
+ using q = quantity;
- CHECK(dist.a() == q::zero());
- CHECK(dist.b() == q::max());
+ SECTION("default")
+ {
+ auto dist = mp_units::uniform_int_distribution();
+
+ CHECK(dist.a() == q::zero());
+ CHECK(dist.b() == q::max());
+ }
+
+ SECTION("parametrized")
+ {
+ constexpr rep a = 2;
+ constexpr rep b = 5;
+
+ auto stl_dist = std::uniform_int_distribution(a, b);
+ auto units_dist = mp_units::uniform_int_distribution(a * si::metre, b * si::metre);
+
+ CHECK(units_dist.a() == stl_dist.a() * si::metre);
+ CHECK(units_dist.b() == stl_dist.b() * si::metre);
+ CHECK(units_dist.min() == stl_dist.min() * si::metre);
+ CHECK(units_dist.max() == stl_dist.max() * si::metre);
+ }
}
- SECTION("parametrized")
+ SECTION("uniform_real_distribution")
{
- constexpr rep a = 2;
- constexpr rep b = 5;
+ using rep = long double;
+ using q = quantity;
- auto stl_dist = std::uniform_int_distribution(a, b);
- auto units_dist = mp_units::uniform_int_distribution(a * si::metre, b * si::metre);
+ SECTION("default")
+ {
+ auto dist = mp_units::uniform_real_distribution();
- CHECK(units_dist.a() == stl_dist.a() * si::metre);
- CHECK(units_dist.b() == stl_dist.b() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("uniform_real_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::uniform_real_distribution();
-
- CHECK(dist.a() == q::zero());
- CHECK(dist.b() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep a = 2.0;
- constexpr rep b = 5.0;
-
- auto stl_dist = std::uniform_real_distribution(a, b);
- auto units_dist = mp_units::uniform_real_distribution(a * si::metre, b * si::metre);
-
- CHECK(units_dist.a() == stl_dist.a() * si::metre);
- CHECK(units_dist.b() == stl_dist.b() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("binomial_distribution")
-{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::binomial_distribution();
-
- CHECK(dist.p() == 0.5);
- CHECK(dist.t() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep t = 5;
- constexpr double p = 0.25;
-
- auto stl_dist = std::binomial_distribution(t, p);
- auto units_dist = mp_units::binomial_distribution(t * si::metre, p);
-
- CHECK(units_dist.p() == stl_dist.p());
- CHECK(units_dist.t() == stl_dist.t() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("negative_binomial_distribution")
-{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::negative_binomial_distribution();
-
- CHECK(dist.p() == 0.5);
- CHECK(dist.k() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep k = 5;
- constexpr double p = 0.25;
-
- auto stl_dist = std::negative_binomial_distribution(k, p);
- auto units_dist = mp_units::negative_binomial_distribution(k * si::metre, p);
-
- CHECK(units_dist.p() == stl_dist.p());
- CHECK(units_dist.k() == stl_dist.k() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("geometric_distribution")
-{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::geometric_distribution();
-
- CHECK(dist.p() == 0.5);
- }
-
- SECTION("parametrized")
- {
- constexpr double p = 0.25;
-
- auto stl_dist = std::geometric_distribution(p);
- auto units_dist = mp_units::geometric_distribution(p);
-
- CHECK(units_dist.p() == stl_dist.p());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("poisson_distribution")
-{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::poisson_distribution();
-
- CHECK(dist.mean() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr double mean = 5.0;
-
- auto stl_dist = std::poisson_distribution(mean);
- auto units_dist = mp_units::poisson_distribution(mean);
-
- CHECK(units_dist.mean() == stl_dist.mean());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("exponential_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::exponential_distribution();
-
- CHECK(dist.lambda() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr double lambda = 2.0;
-
- auto stl_dist = std::exponential_distribution(lambda);
- auto units_dist = mp_units::exponential_distribution(lambda);
-
- CHECK(units_dist.lambda() == stl_dist.lambda());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("gamma_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::gamma_distribution();
-
- CHECK(dist.alpha() == 1.0);
- CHECK(dist.beta() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr double alpha = 5.0;
- constexpr double beta = 2.0;
-
- auto stl_dist = std::gamma_distribution(alpha, beta);
- auto units_dist = mp_units::gamma_distribution(alpha, beta);
-
- CHECK(units_dist.alpha() == stl_dist.alpha());
- CHECK(units_dist.beta() == stl_dist.beta());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("weibull_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::weibull_distribution();
-
- CHECK(dist.a() == 1.0);
- CHECK(dist.b() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr rep a = 5.0;
- constexpr rep b = 2.0;
-
- auto stl_dist = std::weibull_distribution(a, b);
- auto units_dist = mp_units::weibull_distribution(a, b);
-
- CHECK(units_dist.a() == stl_dist.a());
- CHECK(units_dist.b() == stl_dist.b());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("extreme_value_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::extreme_value_distribution();
-
- CHECK(dist.a() == q::zero());
- CHECK(dist.b() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr rep a = 5.0;
- constexpr rep b = 2.0;
-
- auto stl_dist = std::extreme_value_distribution(a, b);
- auto units_dist = mp_units::extreme_value_distribution(a * si::metre, b);
-
- CHECK(units_dist.a() == stl_dist.a() * si::metre);
- CHECK(units_dist.b() == stl_dist.b());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("normal_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::normal_distribution();
-
- CHECK(dist.mean() == q::zero());
- CHECK(dist.stddev() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep mean = 5.0;
- constexpr rep stddev = 2.0;
-
- auto stl_dist = std::normal_distribution(mean, stddev);
- auto units_dist = mp_units::normal_distribution(mean * si::metre, stddev * si::metre);
-
- CHECK(units_dist.mean() == stl_dist.mean() * si::metre);
- CHECK(units_dist.stddev() == stl_dist.stddev() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("lognormal_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::lognormal_distribution();
-
- CHECK(dist.m() == q::zero());
- CHECK(dist.s() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep m = 5.0;
- constexpr rep s = 2.0;
-
- auto stl_dist = std::lognormal_distribution(m, s);
- auto units_dist = mp_units::lognormal_distribution(m * si::metre, s * si::metre);
-
- CHECK(units_dist.m() == stl_dist.m() * si::metre);
- CHECK(units_dist.s() == stl_dist.s() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("chi_squared_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::chi_squared_distribution();
-
- CHECK(dist.n() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr rep n = 5.0;
-
- auto stl_dist = std::chi_squared_distribution(n);
- auto units_dist = mp_units::chi_squared_distribution(n);
-
- CHECK(units_dist.n() == stl_dist.n());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("cauchy_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::cauchy_distribution();
-
- CHECK(dist.a() == q::zero());
- CHECK(dist.b() == q::one());
- }
-
- SECTION("parametrized")
- {
- constexpr rep a = 5.0;
- constexpr rep b = 2.0;
-
- auto stl_dist = std::cauchy_distribution(a, b);
- auto units_dist = mp_units::cauchy_distribution(a * si::metre, b * si::metre);
-
- CHECK(units_dist.a() == stl_dist.a() * si::metre);
- CHECK(units_dist.b() == stl_dist.b() * si::metre);
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("fisher_f_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::fisher_f_distribution();
-
- CHECK(dist.m() == 1.0);
- CHECK(dist.n() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr rep m = 5.0;
- constexpr rep n = 2.0;
-
- auto stl_dist = std::fisher_f_distribution(m, n);
- auto units_dist = mp_units::fisher_f_distribution(m, n);
-
- CHECK(units_dist.m() == stl_dist.m());
- CHECK(units_dist.n() == stl_dist.n());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("student_t_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- SECTION("default")
- {
- auto dist = mp_units::student_t_distribution();
-
- CHECK(dist.n() == 1.0);
- }
-
- SECTION("parametrized")
- {
- constexpr rep n = 2.0;
-
- auto stl_dist = std::student_t_distribution(n);
- auto units_dist = mp_units::student_t_distribution(n);
-
- CHECK(units_dist.n() == stl_dist.n());
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- }
-}
-
-TEST_CASE("discrete_distribution")
-{
- using rep = std::int64_t;
- using q = quantity;
-
- SECTION("default")
- {
- auto stl_dist = std::discrete_distribution();
- auto units_dist = mp_units::discrete_distribution();
-
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- CHECK(units_dist.probabilities() == stl_dist.probabilities());
- }
-
- SECTION("parametrized_input_it")
- {
- constexpr std::array weights = {1.0, 2.0, 3.0};
-
- auto stl_dist = std::discrete_distribution(weights.cbegin(), weights.cend());
- auto units_dist = mp_units::discrete_distribution(weights.cbegin(), weights.cend());
-
- CHECK(units_dist.probabilities() == stl_dist.probabilities());
- }
-
- SECTION("parametrized_initializer_list")
- {
- const std::initializer_list weights = {1.0, 2.0, 3.0};
-
- auto stl_dist = std::discrete_distribution(weights);
- auto units_dist = mp_units::discrete_distribution(weights);
-
- CHECK(units_dist.probabilities() == stl_dist.probabilities());
- }
-
- SECTION("parametrized_range")
- {
- constexpr std::size_t count = 3;
- constexpr double xmin = 1, xmax = 3;
-
- auto stl_dist = std::discrete_distribution(count, xmin, xmax, [](double val) { return val; });
- auto units_dist = mp_units::discrete_distribution(count, xmin, xmax, [](double val) { return val; });
-
- CHECK(units_dist.probabilities() == stl_dist.probabilities());
- }
-}
-
-TEST_CASE("piecewise_constant_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- std::vector intervals_rep_vec = {1.0, 2.0, 3.0};
- std::vector intervals_qty_vec = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
-
- SECTION("default")
- {
- auto stl_dist = std::piecewise_constant_distribution();
- auto units_dist = mp_units::piecewise_constant_distribution();
-
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- CHECK(stl_dist.intervals().size() == 2);
- CHECK(units_dist.intervals().size() == 2);
- CHECK(stl_dist.densities().size() == 1);
- CHECK(units_dist.densities().size() == 1);
- }
-
- SECTION("parametrized_input_it")
- {
- constexpr std::array intervals_rep = {1.0, 2.0, 3.0};
- constexpr std::array intervals_qty = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
- constexpr std::array weights = {1.0, 2.0, 3.0};
-
- auto stl_dist =
- std::piecewise_constant_distribution(intervals_rep.cbegin(), intervals_rep.cend(), weights.cbegin());
- auto units_dist =
- mp_units::piecewise_constant_distribution(intervals_qty.cbegin(), intervals_qty.cend(), weights.cbegin());
-
- CHECK(stl_dist.intervals() == intervals_rep_vec);
- CHECK(units_dist.intervals() == intervals_qty_vec);
- CHECK(units_dist.densities() == stl_dist.densities());
- }
-
- SECTION("parametrized_initializer_list")
- {
- const std::initializer_list intervals_rep = {1.0, 2.0, 3.0};
- const std::initializer_list intervals_qty = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
-
- auto stl_dist = std::piecewise_constant_distribution(intervals_rep, [](rep val) { return val; });
- auto units_dist = mp_units::piecewise_constant_distribution(
- intervals_qty, [](q qty) { return qty.numerical_value_ref_in(qty.unit); });
-
- CHECK(units_dist.intervals() == intervals_qty_vec);
- CHECK(units_dist.densities() == stl_dist.densities());
- }
-
- SECTION("parametrized_range")
- {
- constexpr std::size_t nw = 2;
- constexpr rep xmin_rep = 1.0, xmax_rep = 3.0;
- constexpr q xmin_qty = 1.0 * isq::length[si::metre], xmax_qty = 3.0 * isq::length[si::metre];
-
- auto stl_dist = std::piecewise_constant_distribution(nw, xmin_rep, xmax_rep, [](rep val) { return val; });
- auto units_dist = mp_units::piecewise_constant_distribution(
- nw, xmin_qty, xmax_qty, [](q qty) { return qty.numerical_value_ref_in(qty.unit); });
-
- CHECK(units_dist.intervals() == intervals_qty_vec);
- CHECK(units_dist.densities() == stl_dist.densities());
- }
-}
-
-TEST_CASE("piecewise_linear_distribution")
-{
- using rep = long double;
- using q = quantity;
-
- std::vector intervals_rep_vec = {1.0, 2.0, 3.0};
- std::vector intervals_qty_vec = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
-
- SECTION("default")
- {
- auto stl_dist = std::piecewise_linear_distribution();
- auto units_dist = mp_units::piecewise_linear_distribution();
-
- CHECK(units_dist.min() == stl_dist.min() * si::metre);
- CHECK(units_dist.max() == stl_dist.max() * si::metre);
- CHECK(stl_dist.intervals().size() == 2);
- CHECK(units_dist.intervals().size() == 2);
- CHECK(stl_dist.densities().size() == 2);
- CHECK(units_dist.densities().size() == 2);
- }
-
- SECTION("parametrized_input_it")
- {
- constexpr std::array intervals_rep = {1.0, 2.0, 3.0};
- constexpr std::array intervals_qty = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
- constexpr std::array weights = {1.0, 2.0, 3.0};
-
- auto stl_dist =
- std::piecewise_linear_distribution(intervals_rep.cbegin(), intervals_rep.cend(), weights.cbegin());
- auto units_dist =
- mp_units::piecewise_linear_distribution(intervals_qty.cbegin(), intervals_qty.cend(), weights.cbegin());
-
- CHECK(stl_dist.intervals() == intervals_rep_vec);
- CHECK(units_dist.intervals() == intervals_qty_vec);
- CHECK(units_dist.densities() == stl_dist.densities());
- }
-
- SECTION("parametrized_initializer_list")
- {
- const std::initializer_list intervals_rep = {1.0, 2.0, 3.0};
- const std::initializer_list intervals_qty = {1.0 * isq::length[si::metre], 2.0 * isq::length[si::metre],
- 3.0 * isq::length[si::metre]};
-
- auto stl_dist = std::piecewise_linear_distribution