change vector to build

Author: Jullija

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

@@ -36,10 +36,10 @@
 #ifdef MP_UNITS_IMPORT_STD
 import std;
 #else
-#include <cmath>
 #include <concepts>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 #if MP_UNITS_HOSTED
 #include <ostream>
 #endif
@@ -48,22 +48,75 @@ import std;
 
 namespace mp_units {
 
-MP_UNITS_EXPORT template<detail::Scalar T, std::size_t R, std::size_t C>
+template<class X>
+struct is_cartesian_vector : std::false_type {};
+template<class U>
+struct is_cartesian_vector<cartesian_vector<U>> : std::true_type {};
+
+MP_UNITS_EXPORT template<detail::Scalar U, std::size_t R, std::size_t C>
 class cartesian_tensor;
 
+template<class X>
+struct is_cartesian_tensor : std::false_type {};
+template<class U, std::size_t R, std::size_t C>
+struct is_cartesian_tensor<cartesian_tensor<U, R, C>> : std::true_type {};
+
 MP_UNITS_EXPORT template<detail::Scalar T, std::size_t R, std::size_t C>
 class cartesian_tensor {
   static_assert(R >= 1 && R <= 3 && C >= 1 && C <= 3, "cartesian_tensor supports sizes up to 3x3");
 
 public:
-  T _data_[R * C];
   using value_type = T;
   static constexpr std::size_t rows_v = R;
   static constexpr std::size_t cols_v = C;
 
+  // aggregate on purpose
+  T _data_[R * C];
+
   [[nodiscard]] constexpr T& operator()(std::size_t r, std::size_t c) { return _data_[r * C + c]; }
   [[nodiscard]] constexpr const T& operator()(std::size_t r, std::size_t c) const { return _data_[r * C + c]; }
 
+  [[nodiscard]] constexpr cartesian_tensor operator+() const { return *this; }
+  [[nodiscard]] constexpr cartesian_tensor operator-() const
+  {
+    cartesian_tensor out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = -_data_[i];
+    return out;
+  }
+
+  template<class U>
+    requires requires(T& t, const U& u) { t += u; }
+  constexpr cartesian_tensor& operator+=(const cartesian_tensor<U, R, C>& rhs)
+  {
+    for (std::size_t i = 0; i < R * C; ++i) _data_[i] += rhs._data_[i];
+    return *this;
+  }
+
+  template<class U>
+    requires requires(T& t, const U& u) { t -= u; }
+  constexpr cartesian_tensor& operator-=(const cartesian_tensor<U, R, C>& rhs)
+  {
+    for (std::size_t i = 0; i < R * C; ++i) _data_[i] -= rhs._data_[i];
+    return *this;
+  }
+
+  template<class S>
+    requires detail::Scalar<S> && (!is_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             (!is_cartesian_tensor<std::remove_cvref_t<S>>::value) && requires(T& t, const S& s) { t *= s; }
+  constexpr cartesian_tensor& operator*=(const S& scalar)
+  {
+    for (std::size_t i = 0; i < R * C; ++i) _data_[i] *= scalar;
+    return *this;
+  }
+
+  template<class S>
+    requires detail::Scalar<S> && (!is_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             (!is_cartesian_tensor<std::remove_cvref_t<S>>::value) && requires(T& t, const S& s) { t /= s; }
+  constexpr cartesian_tensor& operator/=(const S& scalar)
+  {
+    for (std::size_t i = 0; i < R * C; ++i) _data_[i] /= scalar;
+    return *this;
+  }
 
 #if MP_UNITS_HOSTED
   friend std::ostream& operator<<(std::ostream& os, const cartesian_tensor& A)
@@ -79,130 +132,164 @@ class cartesian_tensor {
     return os;
   }
 #endif
+
+  template<class U>
+    requires requires(const T& t, const U& u) { t + u; }
+  [[nodiscard]] friend constexpr auto operator+(const cartesian_tensor& A, const cartesian_tensor<U, R, C>& B)
+  {
+    using CT = std::common_type_t<T, U>;
+    cartesian_tensor<CT, R, C> out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = static_cast<CT>(A._data_[i]) + static_cast<CT>(B._data_[i]);
+    return out;
+  }
+
+  template<class U>
+    requires requires(const T& t, const U& u) { t - u; }
+  [[nodiscard]] friend constexpr auto operator-(const cartesian_tensor& A, const cartesian_tensor<U, R, C>& B)
+  {
+    using CT = std::common_type_t<T, U>;
+    cartesian_tensor<CT, R, C> out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = static_cast<CT>(A._data_[i]) - static_cast<CT>(B._data_[i]);
+    return out;
+  }
+
+  template<class U>
+    requires(!treat_as_floating_point<T> && !treat_as_floating_point<U> && requires(const T& t, const U& u) { t % u; })
+  [[nodiscard]] friend constexpr auto operator%(const cartesian_tensor& A, const cartesian_tensor<U, R, C>& B)
+  {
+    using CT = std::common_type_t<T, U>;
+    cartesian_tensor<CT, R, C> out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = static_cast<CT>(A._data_[i] % B._data_[i]);
+    return out;
+  }
+
+  template<class S>
+    requires detail::Scalar<S> && (!is_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             (!is_cartesian_tensor<std::remove_cvref_t<S>>::value) && requires(const T& t, const S& s) { t * s; }
+  [[nodiscard]] friend constexpr auto operator*(const cartesian_tensor& A, const S& scalar)
+  {
+    using CT = std::common_type_t<T, S>;
+    cartesian_tensor<CT, R, C> out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = static_cast<CT>(A._data_[i]) * static_cast<CT>(scalar);
+    return out;
+  }
+
+  template<class S>
+    requires detail::Scalar<S> && (!is_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             (!is_cartesian_tensor<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_tensor& A)
+  {
+    return A * scalar;
+  }
+
+  template<class S>
+    requires detail::Scalar<S> && (!is_cartesian_vector<std::remove_cvref_t<S>>::value) &&
+             (!is_cartesian_tensor<std::remove_cvref_t<S>>::value) && requires(const T& t, const S& s) { t / s; }
+  [[nodiscard]] friend constexpr auto operator/(const cartesian_tensor& A, const S& scalar)
+  {
+    using CT = std::common_type_t<T, S>;
+    cartesian_tensor<CT, R, C> out{};
+    for (std::size_t i = 0; i < R * C; ++i) out._data_[i] = static_cast<CT>(A._data_[i]) / static_cast<CT>(scalar);
+    return out;
+  }
+
+  template<class U>
+    requires std::equality_comparable_with<T, U>
+  [[nodiscard]] friend constexpr bool operator==(const cartesian_tensor& A, const cartesian_tensor<U, R, C>& B)
+  {
+    for (std::size_t i = 0; i < R * C; ++i)
+      if (!(A._data_[i] == B._data_[i])) return false;
+    return true;
+  }
 };
 
+template<class T, std::size_t R, std::size_t C>
+inline constexpr bool treat_as_floating_point<cartesian_tensor<T, R, C>> = treat_as_floating_point<T>;
+
+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>;
+
 
-template<typename T, typename U, std::size_t R, std::size_t K, std::size_t C>
+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)
 {
   using CT = std::common_type_t<T, U>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t r = 0; r < R; ++r)
+  cartesian_tensor<CT, R, C> out{};
+  for (std::size_t r = 0; r < R; ++r) {
     for (std::size_t c = 0; c < C; ++c) {
       CT acc{};
-      for (std::size_t k = 0; k < K; ++k) acc += static_cast<CT>(A(r, k)) * static_cast<CT>(B(k, c));
-      Rm(r, c) = acc;
+      for (std::size_t k = 0; k < K; ++k) acc = acc + static_cast<CT>(A(r, k)) * static_cast<CT>(B(k, c));
+      out(r, c) = acc;
     }
-  return Rm;
+  }
+  return out;
 }
 
-template<typename T, typename U>
-[[nodiscard]] constexpr auto matvec(const cartesian_tensor<T, 3, 3>& tensor, const cartesian_vector<U>& vector)
+template<class T, class U>
+[[nodiscard]] constexpr auto matvec(const cartesian_tensor<T, 3, 3>& M, const cartesian_vector<U>& x)
 {
   using CT = std::common_type_t<T, U>;
   cartesian_vector<CT> y{};
-  for (std::size_t r = 0; r < 3; ++r) {
-    CT acc{};
-    for (std::size_t c = 0; c < 3; ++c) acc += static_cast<CT>(tensor(r, c)) * static_cast<CT>(vector[c]);
-    y[r] = acc;
-  }
+  y[0] = static_cast<CT>(M(0, 0)) * static_cast<CT>(x[0]) + static_cast<CT>(M(0, 1)) * static_cast<CT>(x[1]) +
+         static_cast<CT>(M(0, 2)) * static_cast<CT>(x[2]);
+  y[1] = static_cast<CT>(M(1, 0)) * static_cast<CT>(x[0]) + static_cast<CT>(M(1, 1)) * static_cast<CT>(x[1]) +
+         static_cast<CT>(M(1, 2)) * static_cast<CT>(x[2]);
+  y[2] = static_cast<CT>(M(2, 0)) * static_cast<CT>(x[0]) + static_cast<CT>(M(2, 1)) * static_cast<CT>(x[1]) +
+         static_cast<CT>(M(2, 2)) * static_cast<CT>(x[2]);
   return y;
 }
 
-template<typename T, typename U, std::size_t R, std::size_t C>
+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)
 {
   using CT = std::common_type_t<T, U>;
   CT acc{};
-  for (std::size_t i = 0; i < R * C; ++i) acc += static_cast<CT>(A._data_[i]) * static_cast<CT>(B._data_[i]);
+  for (std::size_t i = 0; i < R * C; ++i) acc = acc + static_cast<CT>(A._data_[i]) * static_cast<CT>(B._data_[i]);
   return acc;
 }
 
-
-template<typename T, typename U>
-[[nodiscard]] constexpr auto outer_numeric(const cartesian_vector<T>& lhs, const cartesian_vector<U>& rhs)
+template<class T, class U>
+[[nodiscard]] constexpr auto outer_numeric(const cartesian_vector<T>& a, const cartesian_vector<U>& b)
 {
   using CT = std::common_type_t<T, U>;
-  cartesian_tensor<CT, 3, 3> Rm{};
+  cartesian_tensor<CT, 3, 3> out{};
   for (std::size_t i = 0; i < 3; ++i)
-    for (std::size_t j = 0; j < 3; ++j) Rm(i, j) = static_cast<CT>(lhs[i]) * static_cast<CT>(rhs[j]);
-  return Rm;
-}
-
-template<typename T, typename U, std::size_t R, std::size_t C>
-  requires requires(const T& t, const U& u) { t + u; }
-[[nodiscard]] constexpr auto operator+(const cartesian_tensor<T, R, C>& A, const cartesian_tensor<U, R, C>& B)
-{
-  using CT = std::common_type_t<T, U>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(A._data_[i]) + static_cast<CT>(B._data_[i]);
-  return Rm;
-}
-
-template<typename T, typename U, std::size_t R, std::size_t C>
-  requires requires(const T& t, const U& u) { t - u; }
-[[nodiscard]] constexpr auto operator-(const cartesian_tensor<T, R, C>& A, const cartesian_tensor<U, R, C>& B)
-{
-  using CT = std::common_type_t<T, U>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(A._data_[i]) - static_cast<CT>(B._data_[i]);
-  return Rm;
-}
-
-template<typename T, typename U, std::size_t R, std::size_t C>
-  requires(!treat_as_floating_point<T> && !treat_as_floating_point<U> && requires(const T& t, const U& u) { t % u; })
-[[nodiscard]] constexpr auto operator%(const cartesian_tensor<T, R, C>& A, const cartesian_tensor<U, R, C>& B)
-{
-  using CT = std::common_type_t<T, U>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(A._data_[i] % B._data_[i]);
-  return Rm;
-}
-
-template<typename T, typename S, std::size_t R, std::size_t C>
-  requires requires(const T& t, const S& s) { t * s; }
-[[nodiscard]] constexpr auto operator*(const cartesian_tensor<T, R, C>& tensor, const S& scalar)
-{
-  using CT = std::common_type_t<T, S>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(tensor._data_[i]) * static_cast<CT>(scalar);
-  return Rm;
-}
-
-template<typename S, typename U, std::size_t R, std::size_t C>
-  requires requires(const S& s, const U& u) { s * u; }
-[[nodiscard]] constexpr auto operator*(const S& scalar, const cartesian_tensor<U, R, C>& tensor)
-{
-  return tensor * scalar;
-}
-
-template<typename T, typename S, std::size_t R, std::size_t C>
-  requires requires(const T& t, const S& s) { t / s; }
-[[nodiscard]] constexpr auto operator/(const cartesian_tensor<T, R, C>& tensor, const S& scalar)
-{
-  using CT = std::common_type_t<T, S>;
-  cartesian_tensor<CT, R, C> Rm{};
-  for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(tensor._data_[i]) / static_cast<CT>(scalar);
-  return Rm;
+    for (std::size_t j = 0; j < 3; ++j) out(i, j) = static_cast<CT>(a[i]) * static_cast<CT>(b[j]);
+  return out;
 }
 
 }  // namespace mp_units
 
+namespace std {
+template<class T, class U, std::size_t R, std::size_t C>
+struct common_type<mp_units::cartesian_tensor<T, R, C>, mp_units::cartesian_tensor<U, R, C>> {
+  using type = mp_units::cartesian_tensor<common_type_t<T, U>, R, C>;
+};
+template<class T, class U, std::size_t R, std::size_t C>
+struct common_type<mp_units::cartesian_tensor<T, R, C>, U> {
+  using type = mp_units::cartesian_tensor<common_type_t<T, U>, R, C>;
+};
+template<class T, class U, std::size_t R, std::size_t C>
+struct common_type<U, mp_units::cartesian_tensor<T, R, C>> {
+  using type = mp_units::cartesian_tensor<common_type_t<U, T>, R, C>;
+};
+}  // namespace std
+
 #if MP_UNITS_HOSTED
 template<typename T, std::size_t R, std::size_t C, typename Char>
 struct MP_UNITS_STD_FMT::formatter<mp_units::cartesian_tensor<T, R, C>, Char> :
     formatter<std::basic_string_view<Char>, Char> {
-  template<typename Ctx>
-  auto format(const mp_units::cartesian_tensor<T, R, C>& A, Ctx& ctx) const
+  template<typename FormatContext>
+  auto format(const mp_units::cartesian_tensor<T, R, C>& A, FormatContext& ctx) const
   {
     auto out = ctx.out();
     for (std::size_t r = 0; r < R; ++r) {
-      out = format_to(out, "{}", (r == 0 ? "[[" : " ["));
+      out = MP_UNITS_STD_FMT::format_to(out, "{}", (r == 0 ? "[[" : " ["));
       for (std::size_t c = 0; c < C; ++c) {
-        out = format_to(out, "{}", A(r, c));
-        if (c + 1 != C) out = format_to(out, "{}", ", ");
+        out = MP_UNITS_STD_FMT::format_to(out, "{}", A(r, c));
+        if (c + 1 != C) out = MP_UNITS_STD_FMT::format_to(out, "{}", ", ");
       }
-      out = format_to(out, "{}", (r + 1 == R ? "]]" : "]\n"));
+      out = MP_UNITS_STD_FMT::format_to(out, "{}", (r + 1 == R ? "]]" : "]\n"));
     }
     return out;
   }