fix vector

Author: Jullija

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

@@ -46,6 +46,12 @@ import std;
 #endif
 #endif
 
+#if MP_UNITS_HOSTED
+#ifndef MP_UNITS_STD_FMT
+#define MP_UNITS_STD_FMT std
+#endif
+#endif
+
 namespace mp_units {
 
 template<class X>
@@ -209,7 +215,7 @@ inline constexpr bool treat_as_floating_point<cartesian_tensor<T, R, C>> = treat
 template<class S, class T, std::size_t R, std::size_t C>
 inline constexpr bool is_value_preserving<S, cartesian_tensor<T, R, C>> = is_value_preserving<S, T>;
 
-
+MP_UNITS_EXPORT
 template<class T, class U, std::size_t R, std::size_t K, std::size_t C>
 [[nodiscard]] constexpr auto matmul(const cartesian_tensor<T, R, K>& A, const cartesian_tensor<U, K, C>& B)
 {
@@ -225,6 +231,7 @@ template<class T, class U, std::size_t R, std::size_t K, std::size_t C>
   return out;
 }
 
+MP_UNITS_EXPORT
 template<class T, class U>
 [[nodiscard]] constexpr auto matvec(const cartesian_tensor<T, 3, 3>& M, const cartesian_vector<U>& x)
 {
@@ -239,6 +246,7 @@ template<class T, class U>
   return y;
 }
 
+MP_UNITS_EXPORT
 template<class T, class U, std::size_t R, std::size_t C>
 [[nodiscard]] constexpr auto double_contraction(const cartesian_tensor<T, R, C>& A, const cartesian_tensor<U, R, C>& B)
 {
@@ -248,6 +256,7 @@ template<class T, class U, std::size_t R, std::size_t C>
   return acc;
 }
 
+MP_UNITS_EXPORT
 template<class T, class U>
 [[nodiscard]] constexpr auto outer_numeric(const cartesian_vector<T>& a, const cartesian_vector<U>& b)
 {

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

@@ -47,11 +47,22 @@ import std;
 #endif
 #endif
 
+#if MP_UNITS_HOSTED
+#ifndef MP_UNITS_STD_FMT
+#define MP_UNITS_STD_FMT std
+#endif
+#endif
+
 namespace mp_units {
 
 MP_UNITS_EXPORT template<detail::Scalar T>
 class cartesian_vector;
 
+template<class X>
+struct is_exact_cartesian_vector : std::false_type {};
+template<detail::Scalar U>
+struct is_exact_cartesian_vector<cartesian_vector<U>> : std::true_type {};
+
 MP_UNITS_EXPORT template<detail::Scalar T = double>
 class cartesian_vector {
 public:
@@ -128,7 +139,8 @@ class cartesian_vector {
   }
 
   template<typename S>
-    requires requires(T& t, const S& s) { t *= s; }
+    requires detail::Scalar<S> && (!is_exact_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             requires(T& t, const S& s) { t *= s; }
   constexpr cartesian_vector& operator*=(const S& scalar)
   {
     _coordinates_[0] *= scalar;
@@ -138,7 +150,8 @@ class cartesian_vector {
   }
 
   template<typename S>
-    requires requires(T& t, const S& s) { t /= s; }
+    requires detail::Scalar<S> && (!is_exact_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             requires(T& t, const S& s) { t /= s; }
   constexpr cartesian_vector& operator/=(const S& scalar)
   {
     _coordinates_[0] /= scalar;
@@ -196,8 +209,10 @@ class cartesian_vector {
                                             static_cast<CT>(lhs._coordinates_[2] % rhs[2])};
   }
 
+
   template<typename S>
-    requires requires(const T& t, const S& s) { t * s; }
+    requires detail::Scalar<S> && (!is_exact_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             requires(const T& t, const S& s) { t * s; }
   [[nodiscard]] friend constexpr auto operator*(const cartesian_vector<T>& vector, const S& scalar)
   {
     using CT = std::common_type_t<T, S>;
@@ -207,14 +222,16 @@ class cartesian_vector {
   }
 
   template<typename S>
-    requires requires(const S& s, const T& t) { s * t; }
+    requires detail::Scalar<S> && (!is_exact_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             requires(const S& s, const T& t) { s * t; }
   [[nodiscard]] friend constexpr auto operator*(const S& scalar, const cartesian_vector<T>& vector)
   {
     return vector * scalar;
   }
 
   template<typename S>
-    requires requires(const T& t, const S& s) { t / s; }
+    requires detail::Scalar<S> && (!is_exact_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             requires(const T& t, const S& s) { t / s; }
   [[nodiscard]] friend constexpr auto operator/(const cartesian_vector<T>& vector, const S& scalar)
   {
     using CT = std::common_type_t<T, S>;
@@ -261,11 +278,6 @@ template<typename Arg, typename... Args>
   requires(sizeof...(Args) <= 2) && requires { typename std::common_type_t<Arg, Args...>; }
 cartesian_vector(Arg, Args...) -> cartesian_vector<std::common_type_t<Arg, Args...>>;
 
-// NOTE: We do NOT specialize treat_as_floating_point for cartesian_vector<T>.
-// Doing so would make the vector attempt to model a "scalar" in mp-units'
-// concept lattice and triggers recursive constraints.
-
-// Keep value-preserving semantics delegated to element type.
 template<class S, class T>
 inline constexpr bool is_value_preserving<S, cartesian_vector<T>> = is_value_preserving<S, T>;