diff --git a/src/core/include/mp-units/cartesian_vector.h b/src/core/include/mp-units/cartesian_vector.h
index cbc9cda0f4..900b2f7094 100644
--- a/src/core/include/mp-units/cartesian_vector.h
+++ b/src/core/include/mp-units/cartesian_vector.h
@@ -27,6 +27,7 @@
 #include <mp-units/bits/module_macros.h>
 #include <mp-units/framework/customization_points.h>
 #include <mp-units/framework/representation_concepts.h>
+#include <type_traits>
 
 #if MP_UNITS_HOSTED
 #include <mp-units/bits/fmt.h>
@@ -37,8 +38,10 @@
 import std;
 #else
 #include <cmath>
+#include <concepts>
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 #if MP_UNITS_HOSTED
 #include <ostream>
 #endif
@@ -50,104 +53,18 @@ namespace mp_units {
 MP_UNITS_EXPORT template<detail::Scalar T>
 class cartesian_vector;
 
-namespace detail {
-
-struct cartesian_vector_iface {
-  template<typename T, typename U>
-    requires requires(T t, U u) { t + u; }
-  [[nodiscard]] friend constexpr auto operator+(const cartesian_vector<T>& lhs, const cartesian_vector<U>& 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<typename T, typename U>
-    requires requires(T t, U u) { t - u; }
-  [[nodiscard]] friend constexpr auto operator-(const cartesian_vector<T>& lhs, const cartesian_vector<U>& 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<typename T, typename U>
-    requires requires(T t, U u) { t * u; }
-  [[nodiscard]] friend constexpr auto operator*(const cartesian_vector<T>& lhs, const U& rhs)
-  {
-    return ::mp_units::cartesian_vector{lhs._coordinates_[0] * rhs, lhs._coordinates_[1] * rhs,
-                                        lhs._coordinates_[2] * rhs};
-  }
-
-  template<typename T, typename U>
-    requires requires(T t, U u) { t * u; }
-  [[nodiscard]] friend constexpr auto operator*(const T& lhs, const cartesian_vector<U>& rhs)
-  {
-    return rhs * lhs;
-  }
-
-  template<typename T, typename U>
-    requires requires(T t, U u) { t / u; }
-  [[nodiscard]] friend constexpr auto operator/(const cartesian_vector<T>& lhs, const U& rhs)
-  {
-    return ::mp_units::cartesian_vector{lhs._coordinates_[0] / rhs, lhs._coordinates_[1] / rhs,
-                                        lhs._coordinates_[2] / rhs};
-  }
-
-  template<typename T, std::equality_comparable_with<T> U>
-  [[nodiscard]] friend constexpr bool operator==(const cartesian_vector<T>& lhs, const cartesian_vector<U>& rhs)
-  {
-    return lhs._coordinates_[0] == rhs._coordinates_[0] && lhs._coordinates_[1] == rhs._coordinates_[1] &&
-           lhs._coordinates_[2] == rhs._coordinates_[2];
-  }
-
-  template<typename T, typename U>
-    requires requires(T t, U u, decltype(t * u) v) {
-      t * u;
-      v + v;
-    }
-  [[nodiscard]] friend constexpr auto scalar_product(const cartesian_vector<T>& lhs, const cartesian_vector<U>& rhs)
-  {
-    return lhs._coordinates_[0] * rhs._coordinates_[0] + lhs._coordinates_[1] * rhs._coordinates_[1] +
-           lhs._coordinates_[2] * rhs._coordinates_[2];
-  }
-
-  template<typename T, typename U>
-    requires requires(T t, U u, decltype(t * u) v) {
-      t * u;
-      v - v;
-    }
-  [[nodiscard]] friend constexpr auto vector_product(const cartesian_vector<T>& lhs, const cartesian_vector<U>& 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]};
-  }
-};
-
-}  // namespace detail
-
 MP_UNITS_EXPORT template<detail::Scalar T = double>
-class cartesian_vector : public detail::cartesian_vector_iface {
+class cartesian_vector {
 public:
   // public members required to satisfy structural type requirements :-(
   T _coordinates_[3];
   using value_type = T;
 
-  template<typename... Args>
-    requires(... && std::constructible_from<T, Args>)
-  constexpr explicit(!(... && std::convertible_to<Args, T>)) cartesian_vector(Args&&... args) :
-      _coordinates_{static_cast<T>(std::forward<Args>(args))...}
-  {
-  }
+  constexpr cartesian_vector() = default;
 
-  template<typename U>
-    requires std::constructible_from<T, U>
-  constexpr explicit(!std::convertible_to<U, T>) cartesian_vector(const cartesian_vector<U>& other) :
-      _coordinates_{static_cast<T>(other[0]), static_cast<T>(other[1]), static_cast<T>(other[2])}
-  {
-  }
+  explicit constexpr cartesian_vector(T x) : _coordinates_{x, T{}, T{}} {}
+  constexpr cartesian_vector(T x, T y) : _coordinates_{x, y, T{}} {}
+  constexpr cartesian_vector(T x, T y, T z) : _coordinates_{x, y, z} {}
 
   template<typename U>
     requires std::constructible_from<T, U>
@@ -157,23 +74,6 @@ class cartesian_vector : public detail::cartesian_vector_iface {
   {
   }
 
-  template<std::convertible_to<T> U>
-  constexpr cartesian_vector& operator=(const cartesian_vector<U>& other)
-  {
-    _coordinates_[0] = other[0];
-    _coordinates_[1] = other[1];
-    _coordinates_[2] = other[2];
-    return *this;
-  }
-
-  template<std::convertible_to<T> U>
-  constexpr cartesian_vector& operator=(cartesian_vector<U>&& 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<T>
@@ -198,11 +98,11 @@ class cartesian_vector : public detail::cartesian_vector_iface {
   [[nodiscard]] constexpr cartesian_vector operator+() const { return *this; }
   [[nodiscard]] constexpr cartesian_vector operator-() const
   {
-    return {-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};
+    return cartesian_vector{-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};
   }
 
   template<typename U>
-    requires requires(T t, U u) {
+    requires requires(T& t, const U& u) {
       { t += u } -> std::same_as<T&>;
     }
   constexpr cartesian_vector& operator+=(const cartesian_vector<U>& other)
@@ -214,7 +114,7 @@ class cartesian_vector : public detail::cartesian_vector_iface {
   }
 
   template<typename U>
-    requires requires(T t, U u) {
+    requires requires(T& t, const U& u) {
       { t -= u } -> std::same_as<T&>;
     }
   constexpr cartesian_vector& operator-=(const cartesian_vector<U>& other)
@@ -225,27 +125,27 @@ class cartesian_vector : public detail::cartesian_vector_iface {
     return *this;
   }
 
-  template<typename U>
-    requires requires(T t, U u) {
-      { t *= u } -> std::same_as<T&>;
+  template<typename S>
+    requires requires(T& t, const S& s) {
+      { t *= s } -> std::same_as<T&>;
     }
-  constexpr cartesian_vector& operator*=(const U& value)
+  constexpr cartesian_vector& operator*=(const S& scalar)
   {
-    _coordinates_[0] *= value;
-    _coordinates_[1] *= value;
-    _coordinates_[2] *= value;
+    _coordinates_[0] *= scalar;
+    _coordinates_[1] *= scalar;
+    _coordinates_[2] *= scalar;
     return *this;
   }
 
-  template<typename U>
-    requires requires(T t, U u) {
-      { t /= u } -> std::same_as<T&>;
+  template<typename S>
+    requires requires(T& t, const S& s) {
+      { t /= s } -> std::same_as<T&>;
     }
-  constexpr cartesian_vector& operator/=(const U& value)
+  constexpr cartesian_vector& operator/=(const S& scalar)
   {
-    _coordinates_[0] /= value;
-    _coordinates_[1] /= value;
-    _coordinates_[2] /= value;
+    _coordinates_[0] /= scalar;
+    _coordinates_[1] /= scalar;
+    _coordinates_[2] /= scalar;
     return *this;
   }
 
@@ -261,8 +161,90 @@ class cartesian_vector : public detail::cartesian_vector_iface {
     return vec.unit();
   }
 
+  template<typename U>
+    requires requires(const T& t, const U& u) { t + u; }
+  [[nodiscard]] friend constexpr auto operator+(const cartesian_vector& lhs, const cartesian_vector<U>& 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<typename U>
+    requires requires(const T& t, const U& u) { t - u; }
+  [[nodiscard]] friend constexpr auto operator-(const cartesian_vector& lhs, const cartesian_vector<U>& 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<typename 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_vector& lhs, const cartesian_vector<U>& rhs)
+  {
+    using CT = std::common_type_t<T, U>;
+    return ::mp_units::cartesian_vector<CT>{static_cast<CT>(lhs._coordinates_[0] % rhs._coordinates_[0]),
+                                            static_cast<CT>(lhs._coordinates_[1] % rhs._coordinates_[1]),
+                                            static_cast<CT>(lhs._coordinates_[2] % rhs._coordinates_[2])};
+  }
+
+  template<typename S>
+    requires(!std::same_as<std::remove_cvref_t<S>, cartesian_vector>) && detail::NotQuantity<S>
+  [[nodiscard]] friend constexpr auto operator*(const cartesian_vector& vector, const S& scalar)
+  {
+    return ::mp_units::cartesian_vector{vector._coordinates_[0] * scalar, vector._coordinates_[1] * scalar,
+                                        vector._coordinates_[2] * scalar};
+  }
+
+  template<typename S>
+    requires(!std::same_as<std::remove_cvref_t<S>, cartesian_vector>) && detail::NotQuantity<S>
+  [[nodiscard]] friend constexpr auto operator*(const S& scalar, const cartesian_vector& vector)
+  {
+    return vector * scalar;
+  }
+
+  template<typename S>
+    requires(!std::same_as<std::remove_cvref_t<S>, cartesian_vector>) && detail::NotQuantity<S>
+  [[nodiscard]] friend constexpr auto operator/(const cartesian_vector& vector, const S& scalar)
+  {
+    return ::mp_units::cartesian_vector{vector._coordinates_[0] / scalar, vector._coordinates_[1] / scalar,
+                                        vector._coordinates_[2] / scalar};
+  }
+
+  template<std::equality_comparable_with<T> U>
+  [[nodiscard]] friend constexpr bool operator==(const cartesian_vector& lhs, const cartesian_vector<U>& rhs)
+  {
+    return lhs._coordinates_[0] == rhs._coordinates_[0] && lhs._coordinates_[1] == rhs._coordinates_[1] &&
+           lhs._coordinates_[2] == rhs._coordinates_[2];
+  }
+
+  template<typename U>
+    requires requires(const T& t, const U& u, decltype(t * u) v) {
+      t * u;
+      v + v;
+    }
+  [[nodiscard]] friend constexpr auto scalar_product(const cartesian_vector& lhs, const cartesian_vector<U>& rhs)
+  {
+    return lhs._coordinates_[0] * rhs._coordinates_[0] + lhs._coordinates_[1] * rhs._coordinates_[1] +
+           lhs._coordinates_[2] * rhs._coordinates_[2];
+  }
+
+  template<typename U>
+    requires requires(const T& t, const U& u, decltype(t * u) v) {
+      t * u;
+      v - v;
+    }
+  [[nodiscard]] friend constexpr auto vector_product(const cartesian_vector& lhs, const cartesian_vector<U>& 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)
+  friend std::ostream& operator<<(std::ostream& os, const cartesian_vector& vec)
   {
     return os << '[' << vec[0] << ", " << vec[1] << ", " << vec[2] << ']';
   }
@@ -273,8 +255,30 @@ 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...>>;
 
+template<class T>
+inline constexpr bool treat_as_floating_point<cartesian_vector<T>> = treat_as_floating_point<T>;
+
+template<class S, class T>
+inline constexpr bool is_value_preserving<S, cartesian_vector<T>> = is_value_preserving<S, T>;
 }  // namespace mp_units
 
+namespace std {
+template<class T, class U>
+struct common_type<mp_units::cartesian_vector<T>, mp_units::cartesian_vector<U>> {
+  using type = mp_units::cartesian_vector<common_type_t<T, U>>;
+};
+
+template<class T, class U>
+struct common_type<mp_units::cartesian_vector<T>, U> {
+  using type = mp_units::cartesian_vector<common_type_t<T, U>>;
+};
+
+template<class T, class U>
+struct common_type<U, mp_units::cartesian_vector<T>> {
+  using type = mp_units::cartesian_vector<common_type_t<U, T>>;
+};
+}  // namespace std
+
 #if MP_UNITS_HOSTED
 // TODO use parse and use formatter for the underlying type
 template<typename T, typename Char>
diff --git a/test/runtime/cartesian_vector_test.cpp b/test/runtime/cartesian_vector_test.cpp
index 6aac39f229..dadacf3892 100644
--- a/test/runtime/cartesian_vector_test.cpp
+++ b/test/runtime/cartesian_vector_test.cpp
@@ -20,11 +20,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-#include "almost_equals.h"
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <mp-units/compat_macros.h>
 #include <mp-units/ext/format.h>
+
 #ifdef MP_UNITS_IMPORT_STD
 import std;
 #else
@@ -43,14 +42,6 @@ TEST_CASE("cartesian_vector operations", "[vector]")
 {
   SECTION("cartesian_vector initialization and access")
   {
-    SECTION("no arguments")
-    {
-      cartesian_vector<double> v;
-      REQUIRE(v[0] == 0);
-      REQUIRE(v[1] == 0);
-      REQUIRE(v[2] == 0);
-    }
-
     SECTION("zero arguments")
     {
       cartesian_vector<double> v{};
@@ -58,31 +49,27 @@ TEST_CASE("cartesian_vector operations", "[vector]")
       REQUIRE(v[1] == 0);
       REQUIRE(v[2] == 0);
     }
-
-    SECTION("one argument")
+    SECTION("one argument -> [x,0,0]")
     {
       cartesian_vector v{1.0};
       REQUIRE(v[0] == 1.0);
-      REQUIRE(v[1] == 0);
-      REQUIRE(v[2] == 0);
+      REQUIRE(v[1] == 0.0);
+      REQUIRE(v[2] == 0.0);
     }
-
-    SECTION("two arguments")
+    SECTION("two arguments -> [x,y,0]")
     {
       cartesian_vector v{1.0, 2.0};
       REQUIRE(v[0] == 1.0);
       REQUIRE(v[1] == 2.0);
-      REQUIRE(v[2] == 0);
+      REQUIRE(v[2] == 0.0);
     }
-
-    SECTION("all arguments")
+    SECTION("three 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("convertible arguments")
     {
       cartesian_vector<double> v{1, 2, 3};
@@ -94,7 +81,7 @@ TEST_CASE("cartesian_vector operations", "[vector]")
 
   SECTION("convertibility from another vector")
   {
-    cartesian_vector v1{1, 2, 3};
+    cartesian_vector v1{1.0, 2.0, 3.0};
 
     SECTION("construction")
     {
@@ -116,40 +103,40 @@ TEST_CASE("cartesian_vector operations", "[vector]")
 
   SECTION("cartesian_vector compound assignment addition")
   {
-    cartesian_vector v1{1.0, 2.0, 3.0};
-    cartesian_vector v2{4.0, 5.0, 6.0};
-    v1 += v2;
-    REQUIRE(v1[0] == 5.0);
-    REQUIRE(v1[1] == 7.0);
-    REQUIRE(v1[2] == 9.0);
-  }
-
-  SECTION("cartesian_vector compound assignment subtraction")
-  {
-    cartesian_vector v1{4.0, 5.0, 6.0};
-    cartesian_vector v2{1.0, 2.0, 3.0};
-    v1 -= v2;
-    REQUIRE(v1[0] == 3.0);
-    REQUIRE(v1[1] == 3.0);
-    REQUIRE(v1[2] == 3.0);
-  }
-
-  SECTION("cartesian_vector compound assignment scalar multiplication")
-  {
-    cartesian_vector v{1.0, 2.0, 3.0};
-    v *= 2.0;
-    REQUIRE(v[0] == 2.0);
-    REQUIRE(v[1] == 4.0);
-    REQUIRE(v[2] == 6.0);
-  }
-
-  SECTION("cartesian_vector compound assignment scalar division")
-  {
-    cartesian_vector v{2.0, 4.0, 6.0};
-    v /= 2.0;
-    REQUIRE(v[0] == 1.0);
-    REQUIRE(v[1] == 2.0);
-    REQUIRE(v[2] == 3.0);
+    SECTION("operator+=")
+    {
+      cartesian_vector v1{1.0, 2.0, 3.0};
+      cartesian_vector v2{4.0, 5.0, 6.0};
+      v1 += v2;
+      REQUIRE(v1[0] == 5.0);
+      REQUIRE(v1[1] == 7.0);
+      REQUIRE(v1[2] == 9.0);
+    }
+    SECTION("cartesian_vector compound assignment subtraction")
+    {
+      cartesian_vector v1{4.0, 5.0, 6.0};
+      cartesian_vector v2{1.0, 2.0, 3.0};
+      v1 -= v2;
+      REQUIRE(v1[0] == 3.0);
+      REQUIRE(v1[1] == 3.0);
+      REQUIRE(v1[2] == 3.0);
+    }
+    SECTION("cartesian_vector compound assignment scalar multiplication")
+    {
+      cartesian_vector v{1.0, 2.0, 3.0};
+      v *= 2.0;
+      REQUIRE(v[0] == 2.0);
+      REQUIRE(v[1] == 4.0);
+      REQUIRE(v[2] == 6.0);
+    }
+    SECTION("cartesian_vector compound assignment scalar division")
+    {
+      cartesian_vector v{2.0, 4.0, 6.0};
+      v /= 2.0;
+      REQUIRE(v[0] == 1.0);
+      REQUIRE(v[1] == 2.0);
+      REQUIRE(v[2] == 3.0);
+    }
   }
 
   SECTION("cartesian_vector addition")
@@ -195,7 +182,7 @@ TEST_CASE("cartesian_vector operations", "[vector]")
     }
   }
 
-  SECTION("cartesian_vector subtraction")
+  SECTION("cartesian_vector substraction")
   {
     SECTION("double - double")
     {
diff --git a/test/static/quantity_test.cpp b/test/static/quantity_test.cpp
index 011330c192..19f7ca8a12 100644
--- a/test/static/quantity_test.cpp
+++ b/test/static/quantity_test.cpp
@@ -305,6 +305,7 @@ static_assert(!std::convertible_to<quantity<one, cartesian_vector<double>>, cart
 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
 
 static_assert(!std::convertible_to<quantity<rad>, double>);