formatting

Author: Jullija

CMakeLists.txt

@@ -81,4 +81,4 @@ endif()
 
 # add unit tests
 enable_testing()
-add_subdirectory(test)
+add_subdirectory(test)

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

@@ -29,21 +29,21 @@
 #include <mp-units/framework/representation_concepts.h>
 
 #if MP_UNITS_HOSTED
-  #include <mp-units/bits/fmt.h>
+#include <mp-units/bits/fmt.h>
 #endif
 
 #ifndef MP_UNITS_IN_MODULE_INTERFACE
-#  ifdef MP_UNITS_IMPORT_STD
-     import std;
-#  else
-#    include <cmath>
-#    include <concepts>
-#    include <cstddef>
-#    include <type_traits>
-#    if MP_UNITS_HOSTED
-#      include <ostream>
-#    endif
-#  endif
+#ifdef MP_UNITS_IMPORT_STD
+import std;
+#else
+#include <cmath>
+#include <concepts>
+#include <cstddef>
+#include <type_traits>
+#if MP_UNITS_HOSTED
+#include <ostream>
+#endif
+#endif
 #endif
 
 namespace mp_units {
@@ -73,13 +73,14 @@ class cartesian_tensor {
 
   // fill ctor (row-major R*C)
   template<typename... Args>
-    requires (sizeof...(Args) == R * C) && (... && std::constructible_from<T, Args>)
-  constexpr explicit(!(... && std::convertible_to<Args, T>))
-  cartesian_tensor(Args&&... args)
-    : _data_{ static_cast<T>(std::forward<Args>(args))... } {}
+    requires(sizeof...(Args) == R * C) && (... && std::constructible_from<T, Args>)
+  constexpr explicit(!(... && std::convertible_to<Args, T>)) cartesian_tensor(Args&&... args) :
+      _data_{static_cast<T>(std::forward<Args>(args))...}
+  {
+  }
 
   // element access
-  [[nodiscard]] constexpr       T& operator()(std::size_t r, std::size_t c)       { return _data_[r * C + 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]; }
 
   // elementwise +, -
@@ -89,8 +90,7 @@ class cartesian_tensor {
   {
     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]);
+    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;
   }
 
@@ -100,15 +100,13 @@ class cartesian_tensor {
   {
     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]);
+    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;
   }
 
   // elementwise % (integral uses %, floating uses fmod)
   template<typename U>
-    requires (requires(const T& t, const U& u) { t % u; }) ||
-             (std::floating_point<T> && std::floating_point<U>)
+    requires(requires(const T& t, const U& u) { t % u; }) || (std::floating_point<T> && std::floating_point<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>;
@@ -117,11 +115,9 @@ class cartesian_tensor {
       using std::fmod;
       for (std::size_t i = 0; i < R * C; ++i)
         Rm._data_[i] =
-          static_cast<CT>(fmod(static_cast<long double>(A._data_[i]),
-                               static_cast<long double>(B._data_[i])));
+          static_cast<CT>(fmod(static_cast<long double>(A._data_[i]), static_cast<long double>(B._data_[i])));
     } else {
-      for (std::size_t i = 0; i < R * C; ++i)
-        Rm._data_[i] = static_cast<CT>(A._data_[i] % B._data_[i]);
+      for (std::size_t i = 0; i < R * C; ++i) Rm._data_[i] = static_cast<CT>(A._data_[i] % B._data_[i]);
     }
     return Rm;
   }
@@ -132,8 +128,7 @@ class cartesian_tensor {
   {
     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);
+    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;
   }
 
@@ -148,8 +143,7 @@ class cartesian_tensor {
   {
     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);
+    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;
   }
 
@@ -177,71 +171,64 @@ inline constexpr bool is_tensor<cartesian_tensor<T, R, C>> = true;
 
 // Matrix × Matrix
 template<typename T, typename 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)
+[[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)
     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));
+      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;
     }
   return Rm;
 }
 
 // Matrix × Vector (3×3)
 template<typename T, typename U>
-[[nodiscard]] constexpr auto matvec(const cartesian_tensor<T, 3, 3>& M,
-                                    const cartesian_vector<U>& x)
+[[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>(M(r, c)) * static_cast<CT>(x[c]);
+    for (std::size_t c = 0; c < 3; ++c) acc += static_cast<CT>(M(r, c)) * static_cast<CT>(x[c]);
     y[r] = acc;
   }
   return y;
 }
 
 // Double contraction: A : B
 template<typename T, typename 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)
+[[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 += static_cast<CT>(A._data_[i]) * static_cast<CT>(B._data_[i]);
   return acc;  // numeric scalar
 }
 
 // Outer product: vector ⊗ vector -> 3x3 matrix
 template<typename T, typename U>
-[[nodiscard]] constexpr auto outer_numeric(const cartesian_vector<T>& a,
-                                           const cartesian_vector<U>& b)
+[[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{};
   for (std::size_t i = 0; i < 3; ++i)
-    for (std::size_t j = 0; j < 3; ++j)
-      Rm(i, j) = static_cast<CT>(a[i]) * static_cast<CT>(b[j]);
+    for (std::size_t j = 0; j < 3; ++j) Rm(i, j) = static_cast<CT>(a[i]) * static_cast<CT>(b[j]);
   return Rm;
 }
 
-} // namespace mp_units
+}  // namespace mp_units
 
 #if MP_UNITS_HOSTED
 // fmt/format (or std::format) support
 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> {
+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 {
+  auto format(const mp_units::cartesian_tensor<T, R, C>& A, Ctx& ctx) const
+  {
     auto out = ctx.out();
     for (std::size_t r = 0; r < R; ++r) {
       out = format_to(out, "{}", (r == 0 ? "[[" : " ["));

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

@@ -28,8 +28,8 @@
 #include <mp-units/framework.h>
 
 #if MP_UNITS_HOSTED
-#include <mp-units/cartesian_vector.h>
 #include <mp-units/cartesian_tensor.h>
+#include <mp-units/cartesian_vector.h>
 #include <mp-units/math.h>
 #include <mp-units/random.h>
 #endif