Implement simple vector and tensor types by Jullija · Pull Request #735 · mpusz/mp-units

Jullija · 2025-10-26T14:16:57Z

Added

Types

cartesian_vector — fixed 3D vector

Vector ops (a,b : cartesian_vector ; s : scalar)

a + b — elementwise addition
a - b — elementwise subtraction
a % b — elementwise modulo (% for integral, fmod for floating)
a * s, s * a — scalar multiply
a / s — scalar divide
a ⋅ b (scalar_product, alias dot) — dot product → scalar
a × b (vector_product, alias cross) — cross product → vector
|a| (magnitude, norm) — Euclidean length (floating reps only)
a/|a| (unit) — unit vector (floating reps only)

mpusz

Hi!

Thanks for contributing! I had time to review only cartesian_vector changes and provided some feedback that I believe will also be meaningful to another type as well.

mpusz · 2025-10-26T17:03:21Z

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

-#include <mp-units/bits/requires_hosted.h>
-//
 #include <mp-units/bits/module_macros.h>
+#include <mp-units/bits/requires_hosted.h>


We put requires_hosted.h as the first header in all HOSTED implementations. Do not use alphabetical order for this header.

Still left to resolve.

with this order, clang-format is failing

Because you removed the comment below which was there to separate two header lists.

mpusz · 2025-10-26T17:04:56Z

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

 namespace mp_units {

-MP_UNITS_EXPORT template<detail::Scalar T>
+MP_UNITS_EXPORT template<detail::Scalar T = double>


It is better to provide template defaults in the implementation rather than in one of (possibly many) forward declarations.

mpusz · 2025-10-26T17:05:51Z

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

-    requires requires(T t, U u) { t + u; }
+    requires requires(const T& t, const U& u) { t + u; }


Does it make any difference?

I've read that adding const doesn't mutate an input which is desired in arithmetic operations (https://en.cppreference.com/w/cpp/language/operator_arithmetic.html)

You are right: https://godbolt.org/z/3zW8ns6YP. Thanks!

mpusz · 2025-10-26T17:06:18Z

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

 namespace detail {

 struct cartesian_vector_iface {
+  // A + B


Such comments do not improve anything.

mpusz · 2025-10-26T17:10:32Z

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

+  // A % B  (integral: %, floating: fmod into CT)
  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)
+    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_vector<T>& lhs, const cartesian_vector<U>& rhs)
+  {
+    using CT = std::common_type_t<T, U>;
+    if constexpr (std::floating_point<T> && std::floating_point<U>) {
+      using std::fmod;
+      return ::mp_units::cartesian_vector<CT>{static_cast<CT>(fmod(static_cast<long double>(lhs._coordinates_[0]),
+                                                                   static_cast<long double>(rhs._coordinates_[0]))),
+                                              static_cast<CT>(fmod(static_cast<long double>(lhs._coordinates_[1]),
+                                                                   static_cast<long double>(rhs._coordinates_[1]))),
+                                              static_cast<CT>(fmod(static_cast<long double>(lhs._coordinates_[2]),
+                                                                   static_cast<long double>(rhs._coordinates_[2])))};
+    } else {
+      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])};
+    }
+  }


There is no op% for floating-point types for a reason. We should behave like fundamental types, so it should not be available as well for floating-point representation types. If we care about modulo for such types, we should provide fmod non-member function. See fmod from math.h for more info.

mpusz · 2025-10-26T17:27:15Z

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

-  template<typename FormatContext>
-  auto format(const mp_units::cartesian_vector<T>& vec, FormatContext& ctx) const
+  template<typename Ctx>
+  auto format(const mp_units::cartesian_vector<T>& v, Ctx& ctx) const
  {
-    return format_to(ctx.out(), "[{}, {}, {}]", vec[0], vec[1], vec[2]);
+    return format_to(ctx.out(), "[{}, {}, {}]", v[0], v[1], v[2]);


Please restore the previous code. FormatContext provides more info and is used consistently in the entire project for all formatters.

v is too short as an identifier and often causes some stupid shadowing errors in MSVC.

mpusz · 2025-10-26T17:29:19Z

test/runtime/cartesian_vector_test.cpp

 import mp_units;
 #else
 #include <mp-units/cartesian_vector.h>
+#if MP_UNITS_HOSTED


Runtime tests are only run for HOSTED so no need to check here.

mpusz · 2025-10-26T17:30:22Z

test/runtime/cartesian_vector_test.cpp

+    REQUIRE(v[0] == 0);
+    REQUIRE(v[1] == 0);
+    REQUIRE(v[2] == 0);


Should be garbage

This is why I didn't provide default construction.

mpusz · 2025-10-26T17:31:15Z

test/runtime/cartesian_vector_test.cpp

+
+  SECTION("zero arguments")
+  {
+    cartesian_vector<double> v{};


This is how zeros should be set, but this collides with your default-constructor now

mpusz · 2025-10-26T17:36:59Z

test/runtime/cartesian_vector_test.cpp

-using namespace Catch::Matchers;
+using Catch::Matchers::WithinAbs;
+
+TEST_CASE("cartesian_vector initialization and access", "[vector]")


I personally prefer to have fewer TEST_CASES in catch, so it is easier to manage. For example, if I want to check if all vector tests still work, it can check the status of one easy-to-find test rather than searching for many different strings.

Filtering by a tag is not often an option.

Jullija · 2025-10-26T18:53:11Z

Hi! Thank you so much! I'll start reading and implementing changes - thank you and sorry in advance for any problems! :)

mpusz · 2025-10-26T21:09:54Z

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

+  cartesian_vector() = default;
  cartesian_vector(const cartesian_vector&) = default;
  cartesian_vector(cartesian_vector&&) = default;
  cartesian_vector& operator=(const cartesian_vector&) = default;
  cartesian_vector& operator=(cartesian_vector&&) = default;

  template<typename... Args>
-    requires(... && std::constructible_from<T, Args>)
+    requires(sizeof...(Args) <= 3) && (... && std::constructible_from<T, Args>)
  constexpr explicit(!(... && std::convertible_to<Args, T>)) cartesian_vector(Args&&... args) :
      _coordinates_{static_cast<T>(std::forward<Args>(args))...}
  {
  }

  template<typename U>
-    requires std::constructible_from<T, U>
+    requires std::constructible_from<T, const 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])}
  {
  }

  template<typename U>
-    requires std::constructible_from<T, U>
+    requires std::constructible_from<T, U&&>
  constexpr explicit(!std::convertible_to<U, T>) cartesian_vector(cartesian_vector<U>&& other) :
      _coordinates_{static_cast<T>(std::move(other[0])), static_cast<T>(std::move(other[1])),
                    static_cast<T>(std::move(other[2]))}


Let's remove all of those. This will result in an aggregate type (such as std::array), which should solve all our issues. Please, change the comment next to a public member to reflect that.

Jullija · 2025-11-11T07:35:19Z

@mpusz could you help me fix the pipeline? I tried in some many ways and I have no idea how to fix it :c

mpusz · 2025-11-12T17:35:27Z

I am currently on vacation in Hawaii, so I don't have much time to look into it. I will check it out when I am back.

mpusz · 2025-12-20T12:32:04Z

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

-#include <mp-units/bits/requires_hosted.h>
-//
 #include <mp-units/bits/module_macros.h>
+#include <mp-units/bits/requires_hosted.h>


Still left to resolve.

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

mpusz · 2025-12-26T18:19:46Z

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

+MP_UNITS_EXPORT template<typename T, typename U>
+  requires requires(const T& t, const U& u) { t + u; }
+[[nodiscard]] 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]};
+}


All of the operators and other customization points should be hidden friends as they were before.

mpusz · 2025-12-26T18:23:26Z

test/runtime/cartesian_vector_test.cpp

    {
-      cartesian_vector<double> v2 = v1;
+      cartesian_vector v1{1.0, 2.0, 3.0};
+      cartesian_vector<double> v2 = v1;  // Use initialization instead of assignment


This is not an assignment

mpusz · 2025-12-26T18:25:24Z

test/static/quantity_test.cpp

 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>>);
+static_assert(std::is_aggregate_v<cartesian_vector<double>>);


This change makes no sense and removes proper test

mpusz · 2025-12-26T18:26:10Z

test/runtime/cartesian_vector_test.cpp

 #else
 #include <mp-units/cartesian_vector.h>
+#include <mp-units/ext/format.h>
+#include <sstream>


Included twice

mpusz · 2025-12-26T18:26:21Z

test/runtime/cartesian_vector_test.cpp

+#endif
+
+#ifndef MP_UNITS_MODULES
+#include <sstream>


import std; missing.

mpusz · 2025-12-26T18:30:14Z

test/runtime/cartesian_vector_test.cpp

+    REQUIRE_THAT(u.magnitude(), WithinAbs(1.0, 1e-12));
+    REQUIRE_THAT(u[0], WithinAbs(3.0 / 5.0, 1e-12));
+    REQUIRE_THAT(u[1], WithinAbs(4.0 / 5.0, 1e-12));
+    REQUIRE_THAT(u[2], WithinAbs(0.0, 1e-12));


Use AlmostEquals instead

mpusz · 2025-12-26T18:32:15Z

test/runtime/cartesian_vector_test.cpp

  }
-}
-
-TEST_CASE("cartesian_vector text output", "[vector][fmt][ostream]")


Why did you remove my tests that were testing each text output separately for different representation types?

mpusz · 2026-01-20T19:53:16Z

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

-#include <mp-units/bits/requires_hosted.h>
-//
 #include <mp-units/bits/module_macros.h>
+#include <mp-units/bits/requires_hosted.h>


Because you removed the comment below which was there to separate two header lists.

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

Jullija · 2026-01-22T21:09:17Z

In this discussion you mentioned to delete constructors to create an aggregate type. But after that I believe it is impossible to use static_assert(std::constructible_from<cartesian_vector<double>, quantity<one, double>>); 😅

Should I add this

  constexpr cartesian_vector() = default;
  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} {}

or delete/modify this test? Or I misunderstood something?

mpusz · 2026-01-27T20:46:05Z

In this discussion you mentioned to delete constructors to create an aggregate type. But after that I believe it is impossible to use static_assert(std::constructible_from<cartesian_vector<double>, quantity<one, double>>); 😅

It is hard for me to judge without seeing the actual issue. Making this class an aggregate should not prevent this test from working. Unless I forgot about something now.

mpusz · 2026-01-27T20:46:58Z

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

 #include <mp-units/bits/module_macros.h>
 #include <mp-units/framework/customization_points.h>
 #include <mp-units/framework/representation_concepts.h>
+#include <type_traits>


I believe this is not needed (included below). Also, this is not a correct section to include this file as it will collide with import std; if used.

mpusz · 2026-01-27T20:50:35Z

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

-  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;
-  }


Why did you delete those?

mpusz · 2026-01-27T20:51:22Z

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

-    return {-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};
+    return cartesian_vector{-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};


This should not be needed.

mpusz · 2026-01-27T20:54:40Z

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

+  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]};
+  }
+


All of those make the class template operations asymmetrical. RHS argument will not convert, while the LHS will. Please restore my cartesian_vector_iface to fix it -> both arguments will not convert. If you would like to enable conversion for the arguments, it is doable, but requires even more overloads.

mpusz · 2026-01-27T20:56:14Z

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

+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>;


Not needed as this class provides value_type (https://mpusz.github.io/mp-units/latest/how_to_guides/integration/using_custom_representation_types/#value_type-or-element_type).

mpusz · 2026-01-27T20:57:45Z

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

+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>>;
+};


OK, it seems correct, but why did you have to do it? Was it required by some specific test?

mpusz · 2026-01-27T21:02:13Z

test/runtime/cartesian_vector_test.cpp

-    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);
+    }
  }


It seems to be formatted incorrectly, making it hard to compare. Please use pre-commit to format your files before commit (https://mpusz.github.io/mp-units/latest/getting_started/contributing/#unified-code-formatting).

mpusz · 2026-01-27T21:02:22Z

test/runtime/cartesian_vector_test.cpp

-  SECTION("cartesian_vector subtraction")
+  SECTION("cartesian_vector substraction")


mpusz · 2026-01-27T21:02:55Z

test/static/quantity_test.cpp

 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>>);
+


Julia Smerdel and others added 5 commits October 11, 2025 21:31

add % operation and aliases

edec240

add header with vector and tensors

ab3c2e8

spli into 2 files

a4f0682

add tests

73d8554

small changes

fa57a3a

Jullija changed the title ~~Implement simple vector and tensor types~~ [DRAFT] Implement simple vector and tensor types Oct 26, 2025

Jullija marked this pull request as draft October 26, 2025 16:29

formatting

7bc1e18

Jullija force-pushed the feature/la-vectors branch from 20a6db0 to 7bc1e18 Compare October 26, 2025 16:33

mpusz requested changes Oct 26, 2025

View reviewed changes

vector fixes after review

90a371c

mpusz requested changes Oct 26, 2025

View reviewed changes

Jullija added 2 commits November 2, 2025 14:57

fix tensor and vector after review

26c88fe

fix tensor test

00b2e74

Jullija force-pushed the feature/la-vectors branch 9 times, most recently from f3f2391 to 00b2e74 Compare November 10, 2025 20:46

Jullija force-pushed the feature/la-vectors branch 2 times, most recently from 1618ca3 to e564751 Compare November 20, 2025 18:41

fix pipeline by adding export

59f9298

Jullija force-pushed the feature/la-vectors branch from e564751 to 59f9298 Compare November 20, 2025 18:52

Jullija changed the title ~~[DRAFT] Implement simple vector and tensor types~~ Implement simple vector and tensor types Nov 20, 2025

format change

1ecb38f

Jullija force-pushed the feature/la-vectors branch from 3e231f3 to 1ecb38f Compare November 20, 2025 19:19

Merge branch 'master' into feature/la-vectors

40fb1ee

Jullija marked this pull request as ready for review November 20, 2025 19:21

Jullija requested a review from mpusz November 20, 2025 19:38

mpusz requested changes Dec 26, 2025

View reviewed changes

Jullija force-pushed the feature/la-vectors branch 2 times, most recently from 3d9fce9 to 69567bc Compare December 28, 2025 20:09

fixes after review

8cfa4c8

Jullija force-pushed the feature/la-vectors branch from 61635aa to 8cfa4c8 Compare December 28, 2025 20:16

Jullija and others added 2 commits December 28, 2025 21:16

Merge branch 'master' into feature/la-vectors

5b8ffe3

little order fix

7313258

Jullija requested a review from mpusz January 14, 2026 20:31

mpusz requested changes Jan 20, 2026

View reviewed changes

fix style and cast

dedc039

Jullija force-pushed the feature/la-vectors branch 2 times, most recently from f69ccc8 to edcaf11 Compare January 21, 2026 07:58

add tensor

bfde546

Jullija force-pushed the feature/la-vectors branch from edcaf11 to bfde546 Compare January 21, 2026 07:59

Jullija added 3 commits January 21, 2026 09:01

Merge branch 'master' into feature/la-vectors

84ebb5c

remove tensors

b516aa7

merge

e82ac7d

Jullija force-pushed the feature/la-vectors branch from 9300ec9 to e82ac7d Compare January 22, 2026 20:48

Jullija added 2 commits January 23, 2026 12:38

fix tests

9ffc374

add concepts

1f6e9f0

mpusz requested changes Jan 27, 2026

View reviewed changes

		requires requires(T t, U u) { t + u; }
		requires requires(const T& t, const U& u) { t + u; }

		return {-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};
		return cartesian_vector{-_coordinates_[0], -_coordinates_[1], -_coordinates_[2]};

		SECTION("cartesian_vector subtraction")
		SECTION("cartesian_vector substraction")

Uh oh!

Conversation

Jullija commented Oct 26, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

mpusz left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Jullija commented Oct 26, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Jullija commented Nov 11, 2025

Uh oh!

mpusz commented Nov 12, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Jullija commented Jan 22, 2026

Uh oh!

mpusz commented Jan 27, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Jullija commented Oct 26, 2025 •

edited

Loading