From 08e94171cb86be5425187390811c8a6d25523a6b Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Fri, 15 Nov 2024 12:59:18 +0100
Subject: [PATCH] test: vector quantities unit tests addded

---
 test/static/quantity_test.cpp | 89 +++++++++++++++++++++++++++++++++--
 1 file changed, 86 insertions(+), 3 deletions(-)

diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index afcac7d7..bce1316f 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -29,6 +29,7 @@
 #include <mp-units/systems/isq/space_and_time.h>
 #include <mp-units/systems/si.h>
 #if MP_UNITS_HOSTED
+#include <mp-units/cartesian_vector.h>
 #include <mp-units/complex.h>
 #include <mp-units/math.h>
 #endif
@@ -55,6 +56,7 @@ using namespace mp_units;
 using namespace mp_units::si::unit_symbols;
 #if MP_UNITS_HOSTED
 using namespace std::complex_literals;
+using v = cartesian_vector<double>;
 #endif
 
 //////////////////////////////
@@ -74,6 +76,9 @@ concept invalid_types = requires {
   requires !requires { typename Q<isq::length[m], quantity<isq::length[m]>>; };  // quantity used as Rep
   requires !requires { typename Q<isq::position_vector[si::metre], double>; };   // vector representation expected
 #if MP_UNITS_HOSTED
+  requires !requires {
+    typename Q<isq::length[si::metre], cartesian_vector<double>>;
+  };  // scalar representation expected
   requires !requires { typename Q<isq::voltage[V], std::complex<double>>; };  // incompatible character
   requires !requires { typename Q<isq::voltage_phasor[V], double>; };         // incompatible character
 #endif
@@ -192,6 +197,15 @@ static_assert(std::constructible_from<quantity<isq::voltage_phasor[V], std::comp
                                       quantity<si::volt, std::complex<double>>>);
 static_assert(std::convertible_to<quantity<si::volt, std::complex<double>>,
                                   quantity<isq::voltage_phasor[V], std::complex<double>>>);
+
+static_assert(std::constructible_from<quantity<si::metre, cartesian_vector<double>>,
+                                      quantity<isq::position_vector[m], cartesian_vector<double>>>);
+static_assert(std::convertible_to<quantity<isq::position_vector[m], cartesian_vector<double>>,
+                                  quantity<si::metre, cartesian_vector<double>>>);
+static_assert(std::constructible_from<quantity<isq::position_vector[m], cartesian_vector<double>>,
+                                      quantity<si::metre, cartesian_vector<double>>>);
+static_assert(std::convertible_to<quantity<si::metre, cartesian_vector<double>>,
+                                  quantity<isq::position_vector[m], cartesian_vector<double>>>);
 #endif
 
 // conversion between different quantities not allowed
@@ -258,6 +272,10 @@ static_assert(!std::convertible_to<quantity<one, std::complex<double>>, std::com
 static_assert(std::constructible_from<std::complex<double>, quantity<one, std::complex<double>>>);
 static_assert(!std::convertible_to<quantity<one, double>, std::complex<double>>);
 static_assert(std::constructible_from<std::complex<double>, quantity<one, double>>);
+static_assert(!std::convertible_to<quantity<one, cartesian_vector<double>>, cartesian_vector<double>>);
+static_assert(std::constructible_from<cartesian_vector<double>, quantity<one, cartesian_vector<double>>>);
+static_assert(!std::convertible_to<quantity<one, double>, cartesian_vector<double>>);
+static_assert(std::constructible_from<cartesian_vector<double>, quantity<one, double>>);
 #endif
 
 
@@ -308,6 +326,9 @@ static_assert(((2. + 1i) * isq::voltage_phasor[V]).in(mV).numerical_value_in(mV)
 static_assert(((2. + 1i) * isq::voltage_phasor[V]).in(mV).numerical_value_in(V) == 2. + 1i);
 static_assert(((2.L + 1il) * isq::voltage_phasor[V]).in(mV).numerical_value_in(mV) == 2000.L + 1000il);
 static_assert(((2.L + 1il) * isq::voltage_phasor[V]).in(mV).numerical_value_in(V) == 2.L + 1il);
+
+static_assert((v{1., 2., 3.} * isq::position_vector[m]).in(mm).numerical_value_in(mm) == v{1000., 2000., 3000.});
+static_assert((v{1., 2., 3.} * isq::position_vector[m]).in(mm).numerical_value_in(m) == v{1., 2., 3.});
 #endif
 
 template<template<auto, typename> typename Q>
@@ -407,6 +428,9 @@ static_assert(quantity{123}.quantity_spec == kind_of<dimensionless>);
 static_assert(quantity{123. + 1i}.unit == one);
 static_assert(quantity{123. + 1i}.quantity_spec == kind_of<dimensionless>);
 
+static_assert(quantity{v{1., 2., 3}}.unit == one);
+static_assert(quantity{v{1., 2., 3}}.quantity_spec == kind_of<dimensionless>);
+
 using namespace std::chrono_literals;
 static_assert(std::is_same_v<decltype(quantity{123s})::rep, std::chrono::seconds::rep>);
 static_assert(std::is_same_v<decltype(quantity{123.s})::rep, long double>);
@@ -496,6 +520,13 @@ static_assert(((1. + 1i) * V *= 2. + 1i).numerical_value_in(V) == (1. + 1i) * (2
 static_assert(((2. + 2i) * V /= 2. + 1i).numerical_value_in(V) == (2. + 2i) / (2. + 1i));
 static_assert(((1. + 1i) * V *= (2. + 1i) * one).numerical_value_in(V) == (1. + 1i) * (2. + 1i));
 static_assert(((2. + 2i) * V /= (2. + 1i) * one).numerical_value_in(V) == (2. + 2i) / (2. + 1i));
+
+static_assert((v{1., 2., 3.}* m += v{1., 2., 3.} * m).numerical_value_in(m) == v{2., 4., 6.});
+static_assert((v{2., 4., 6.}* m -= v{1., 2., 3.} * m).numerical_value_in(m) == v{1., 2., 3.});
+static_assert((v{1., 2., 3.}* m *= 2.).numerical_value_in(m) == v{2., 4., 6.});
+static_assert((v{2., 4., 6.}* m /= 2.).numerical_value_in(m) == v{1., 2., 3.});
+static_assert((v{1., 2., 3.}* m *= 2. * one).numerical_value_in(m) == v{2., 4., 6.});
+static_assert((v{2., 4., 6.}* m /= 2. * one).numerical_value_in(m) == v{1., 2., 3.});
 #endif
 
 // different representation types
@@ -513,6 +544,8 @@ static_assert((3500 * m %= 1 * km).numerical_value_in(m) == 500);
 #if MP_UNITS_HOSTED
 static_assert(((1000. + 1000i) * V += (1. + 1i) * kV).numerical_value_in(V) == 2000. + 2000i);
 static_assert(((2000. + 2000i) * V -= (1. + 1i) * kV).numerical_value_in(V) == 1000. + 1000i);
+static_assert((v{1000., 2000., 3000.}* m += v{1., 2., 3.} * km).numerical_value_in(m) == v{2000., 4000., 6000.});
+static_assert((v{2000., 4000., 6000.}* m -= v{1., 2., 3.} * km).numerical_value_in(m) == v{1000., 2000., 3000.});
 #endif
 
 // convertible quantity types
@@ -577,7 +610,22 @@ concept invalid_compound_assignments = requires() {
 
 #if MP_UNITS_HOSTED
   // modulo operations on a complex representation type not allowed
-  requires !requires(Q<V, std::complex<double>> l) { l %= (2. + 2i) * V; };
+  requires !requires(Q<si::volt, std::complex<double>> l) { l %= (2. + 2i) * V; };
+
+  // modulo operations on a vector representation type not allowed
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l %= v{2.} * m; };
+
+  // arithmetics of vector and scalar quantities not allowed
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l += 2. * m; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l -= 2. * m; };
+
+  // multiplication and division of vector quantities not allowed
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l *= v{1., 2., 3.}; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l /= v{1., 2., 3.}; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l *= v{1., 2., 3.} * one; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l /= v{1., 2., 3.} * one; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l *= v{1., 2., 3.} * m; };
+  requires !requires(Q<si::metre, cartesian_vector<double>> l) { l /= v{1., 2., 3.} * m; };
 #endif
 
   // no unit constants
@@ -610,7 +658,9 @@ concept invalid_binary_operations = requires {
 
 #if MP_UNITS_HOSTED
   // no complex modulo
-  requires !requires(Q<V, std::complex<double>> a) { a % (2. + 2i) * V; };
+  requires !requires(Q<si::volt, std::complex<double>> a) { a % ((2. + 2i) * V); };
+  // no vector modulo
+  requires !requires(Q<si::metre, cartesian_vector<double>> a) { a % (v{2.} * m); };
 #endif
 
   // unit constants
@@ -928,6 +978,9 @@ static_assert((2. + 2i) * one * (2. + 2i) == (2. + 2i) * (2. + 2i) * one);
 static_assert((4. + 4i) * one / ((2. + 2i) * one) == (4. + 4i) / (2. + 2i) * one);
 static_assert((4. + 4i) / ((2. + 2i) * one) == (4. + 4i) / (2. + 2i) * one);
 static_assert((4. + 4i) * one / (2. + 2i) == (4. + 4i) / (2. + 2i) * one);
+
+static_assert(v{1., 2., 3.} * one + v{1., 2., 3.} * one == v{2., 4., 6.} * one);
+static_assert(v{2., 4., 6.} * one - v{1., 2., 3.} * one == v{1., 2., 3.} * one);
 #endif
 
 static_assert(1 * one + 1 == 2);
@@ -944,8 +997,17 @@ static_assert(4 % (2 * one) == 0);
 #if MP_UNITS_HOSTED
 static_assert((1. + 1i) * one + (1. + 1i) == 2. + 2i);
 static_assert((1. + 1i) + (1. + 1i) * one == 2. + 2i);
+static_assert((2. + 2i) * one - (1. + 1i) == 1. + 1i);
+static_assert((2. + 2i) - (1. + 1i) * one == 1. + 1i);
+static_assert(1. * one + (1. + 1i) == (2. + 1i));
+static_assert(1. + (1. + 1i) * one == (2. + 1i));
 static_assert(2. * one - (1. + 1i) == (1. - 1i));
 static_assert(2. - (1. + 1i) * one == (1. - 1i));
+
+static_assert(v{1., 2., 3.} * one + v{1., 2., 3.} == v{2., 4., 6.});
+static_assert(v{1., 2., 3.} + v{1., 2., 3.} * one == v{2., 4., 6.});
+static_assert(v{2., 4., 6.} * one - v{1., 2., 3.} == v{1., 2., 3.});
+static_assert(v{2., 4., 6.} - v{1., 2., 3.} * one == v{1., 2., 3.});
 #endif
 
 static_assert(2 * rad * (2 * rad) == 4 * pow<2>(rad));
@@ -987,11 +1049,12 @@ static_assert(is_same_v<decltype(std::uint8_t{0} * one % (std::uint8_t{0} * one)
 static_assert(2 * one * (1 * m) == 2 * m);
 static_assert(2 * one / (1 * m) == 2 / (1 * m));
 
+#if MP_UNITS_HOSTED
+
 ///////////////////////
 // complex quantities
 ///////////////////////
 
-#if MP_UNITS_HOSTED
 static_assert((1. + 1i) * V + (1. + 1i) * V == (2. + 2i) * V);
 static_assert((1. + 1i) * V + 1. * V == (2. + 1i) * V);
 static_assert((1000. + 1000i) * V + (1. + 1i) * kV == (2000. + 2000i) * V);
@@ -1015,6 +1078,24 @@ static_assert((1. + 1i) * V * (2. + 1i) * one == (1. + 1i) * (2. + 1i) * V);
 static_assert((2. + 2i) * V / (2. + 1i) * one == (2. + 2i) / (2. + 1i) * V);
 static_assert((1. + 1i) * V * (2. + 1i) * A == (1. + 1i) * (2. + 1i) * V * A);
 static_assert((2. + 2i) * V / ((2. + 1i) * A) == (2. + 2i) / (2. + 1i) * V / A);
+
+//////////////////////
+// vector quantities
+//////////////////////
+
+static_assert(v{1., 2., 3.} * m + v{1., 2., 3.} * m == v{2., 4., 6.} * m);
+static_assert(v{1000., 2000., 3000.} * m + v{1., 2., 3.} * km == v{2000., 4000., 6000.} * m);
+static_assert(v{2., 4., 6.} * m - v{1., 2., 3.} * m == v{1., 2., 3.} * m);
+static_assert(v{2000., 4000., 6000.} * m - v{1., 2., 3.} * km == v{1000., 2000., 3000.} * m);
+static_assert(v{1., 2., 3.} * m + isq::displacement(v{1., 2., 3.} * m) == v{2., 4., 6.} * m);
+static_assert(v{2., 4., 6.} * m - isq::displacement(v{1., 2., 3.} * m) == v{1., 2., 3.} * m);
+
+static_assert(v{1., 2., 3.} * m * 2. == v{2., 4., 6.} * m);
+static_assert(v{1., 2., 3.} * m * (2. * one) == v{2., 4., 6.} * m);
+static_assert(v{1., 2., 3.} * m * (2. * s) == v{2., 4., 6.} * m * s);
+static_assert(v{2., 4., 6.} * m / 2. == v{1., 2., 3.} * m);
+static_assert(v{2., 4., 6.} * m / (2. * one) == v{1., 2., 3.} * m);
+static_assert(v{2., 4., 6.} * m / (2. * s) == v{1., 2., 3.} * m / s);
 #endif
 
 
@@ -1086,6 +1167,8 @@ static_assert(invalid_comparison<isq::activity[Bq], isq::frequency[Hz]>);
 #if MP_UNITS_HOSTED
 static_assert((1. + 1i) * one == 1. + 1i);
 static_assert(1. + 1i != (2. + 2i) * one);
+static_assert(v{1., 2., 3.} * one == v{1., 2., 3.});
+static_assert(v{1., 2., 3.} != v{3., 2., 1.} * one);
 #endif
 
 ///////////////////////