Feat/linalg

.clangd

@@ -1,2 +1,12 @@
 CompileFlags:
-    CompilationDatabase: .build
+    CompilationDatabase: .build
+    Add:
+        - -Wno-c2y-extensions
+        - -Wno-double-promotion
+
+Diagnostics:
+    Suppress:
+        - c2y-extensions
+        - -Wc2y-extensions
+        - typecheck_expression_not_modifiable_lvalue
+        - pp_including_mainfile_in_preamble

.vscode/settings.json

@@ -33,7 +33,7 @@
         "-i ${workspaceFolder}/external/Catch2/src" // adjust path as needed
     ],
     "files.associations": {
-        "*.tpp": "c++",
+        "*.tpp": "cpp",
         "type_traits": "cpp",
         "functional": "cpp",
         "array": "cpp",

CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file.
 
 ## Next Release
 
+### Feature
+
+- add static Vector3d with mp-units support
+
 <!-- insertion marker -->
 ## [0.1.4](https://github.com/repo/owner/releases/tag/0.1.4) - 2026-07-26
 

include/mstd/linAlg/concepts/vector3dConcepts.hpp

@@ -0,0 +1,45 @@
+/*****************************************************************************
+<GPL_HEADER>
+
+    mstd library
+    Copyright (C) 2025-now  Jakob Gamper
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+<GPL_HEADER>
+******************************************************************************/
+
+#ifndef __MSTD__LINALG__CONCEPTS__VECTOR3DCONCEPTS_HPP__
+#define __MSTD__LINALG__CONCEPTS__VECTOR3DCONCEPTS_HPP__
+
+#include <concepts>
+
+#include "vector3dDepth.hpp"
+
+namespace mstd
+{
+    template <class T>
+    class Vector3d;
+
+    /**
+     * @brief Concept for Vector3d types
+     *
+     * @tparam T
+     */
+    template <class T>
+    concept Vector3dConcept = std::same_as<T, Vector3d<typename T::value_type>>;
+
+}   // namespace mstd
+
+#endif   //  __MSTD__LINALG__CONCEPTS__VECTOR3DCONCEPTS_HPP__

include/mstd/linAlg/concepts/vector3dDepth.hpp

@@ -0,0 +1,75 @@
+/*****************************************************************************
+<GPL_HEADER>
+
+    mstd library
+    Copyright (C) 2025-now  Jakob Gamper
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+<GPL_HEADER>
+******************************************************************************/
+
+#ifndef __MSTD__LINALG__CONCEPTS__VECTOR3DDEPTH_HPP__
+#define __MSTD__LINALG__CONCEPTS__VECTOR3DDEPTH_HPP__
+
+namespace mstd
+{
+    template <class T>
+    class Vector3d;
+
+    /**
+     * @brief type trait to determine the depth of a Vector3d
+     *
+     * @tparam T
+     */
+    template <class T>
+    struct Vector3dDepth
+    {
+        static constexpr int value = 0;
+    };
+
+    /**
+     * @brief type trait to determine the depth of a Vector3d
+     *
+     * @details specialization for Vector3d
+     *
+     * @tparam T
+     */
+    template <class T>
+    struct Vector3dDepth<Vector3d<T>>
+    {
+        static constexpr int value = 1 + Vector3dDepth<T>::value;
+    };
+
+    /**
+     * @brief constexpr variable to check the depth of a Vector3d
+     *
+     * @tparam T
+     */
+    template <class T>
+    constexpr int Vector3dDepth_v = Vector3dDepth<T>::value;
+
+    /**
+     * @brief constexpr variable to check the depth difference of two Vector3ds
+     *
+     * @tparam T
+     * @tparam U
+     */
+    template <class T, class U>
+    constexpr int Vector3dDepthDifference_v =
+        Vector3dDepth_v<T> - Vector3dDepth_v<U>;
+
+}   // namespace mstd
+
+#endif   //  __MSTD__LINALG__CONCEPTS__VECTOR3DDEPTH_HPP__

include/mstd/linAlg/vector3d.hpp

@@ -0,0 +1,210 @@
+/*****************************************************************************
+<GPL_HEADER>
+
+    mstd library
+    Copyright (C) 2025-now  Jakob Gamper
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+<GPL_HEADER>
+******************************************************************************/
+
+#ifndef __MSTD__LINALG__VECTOR3D_HPP__
+#define __MSTD__LINALG__VECTOR3D_HPP__
+
+#include <mp-units/math.h>   // for mp_units::sqrt
+
+#include <cmath>   // for std:sqrt
+#include <concepts>
+#include <ostream>   // for std::ostream
+#include <utility>
+
+#include "concepts/vector3dConcepts.hpp"
+#include "vector3dClass.hpp"
+
+namespace mstd
+{
+    /************************
+     * comparison operators *
+     ************************/
+
+    template <typename U, typename V>
+    requires std::equality_comparable_with<U, V>
+    [[nodiscard]] constexpr bool operator==(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    );
+
+    template <typename U, typename V>
+    requires std::equality_comparable_with<U, V>
+    [[nodiscard]] constexpr bool operator!=(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    );
+
+    /*********************
+     * binary + operator *
+     *********************/
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u + v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto operator+(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    ) -> Vector3d<decltype(std::declval<U>() + std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u + v; }
+    [[nodiscard]] constexpr auto operator+(
+        const U           &scalar,
+        const Vector3d<V> &vector
+    ) -> Vector3d<decltype(std::declval<U>() + std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u + v; }
+    [[nodiscard]] constexpr auto operator+(
+        const Vector3d<U> &vector,
+        const V           &scalar
+    ) -> Vector3d<decltype(std::declval<U>() + std::declval<V>())>;
+
+    /*********************
+     * binary - operator *
+     *********************/
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u - v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto operator-(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    ) -> Vector3d<decltype(std::declval<U>() - std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u - v; }
+    [[nodiscard]] constexpr auto operator-(
+        const Vector3d<U> &vector,
+        const V           &scalar
+    ) -> Vector3d<decltype(std::declval<U>() - std::declval<V>())>;
+
+    /*********************
+     * binary * operator *
+     *********************/
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u * v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto operator*(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    ) -> Vector3d<decltype(std::declval<U>() * std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u * v; }
+    [[nodiscard]] constexpr auto operator*(
+        const U           &scalar,
+        const Vector3d<V> &vector
+    ) -> Vector3d<decltype(std::declval<U>() * std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u * v; }
+    [[nodiscard]] constexpr auto operator*(
+        const Vector3d<U> &vector,
+        const V           &scalar
+    ) -> Vector3d<decltype(std::declval<U>() * std::declval<V>())>;
+
+    /*********************
+     * binary / operator *
+     *********************/
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u / v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto operator/(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    ) -> Vector3d<decltype(std::declval<U>() / std::declval<V>())>;
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u / v; }
+    [[nodiscard]] constexpr auto operator/(
+        const Vector3d<U> &vector,
+        const V           &scalar
+    ) -> Vector3d<decltype(std::declval<U>() / std::declval<V>())>;
+
+    /******************
+     * norm functions *
+     ******************/
+
+    template <typename U>
+    requires requires(const U &u) { u * u + u * u; }
+    [[nodiscard]] constexpr auto normSquared(const Vector3d<U> &vec)
+        -> decltype(std::declval<U>() * std::declval<U>());
+
+    template <Vector3dConcept U>
+    requires requires(const U &vec) { std::sqrt(normSquared(vec)); }
+    [[nodiscard]] auto norm(const U &vec)
+        -> decltype(std::sqrt(normSquared(vec)));
+
+    template <Vector3dConcept U>
+    requires requires(const U &vec) { mp_units::sqrt(normSquared(vec)); }
+    [[nodiscard]] auto norm(const U &vec)
+        -> decltype(mp_units::sqrt(normSquared(vec)));
+
+    template <typename U>
+    requires requires(const Vector3d<U> &vec) { vec[0] / norm(vec); }
+    [[nodiscard]] auto normalize(const Vector3d<U> &vec) -> Vector3d<
+        decltype(std::declval<U>() / norm(std::declval<const Vector3d<U> &>()))>;
+
+    template <typename U>
+    requires requires(Vector3d<U> &vec) { vec /= norm(vec); }
+    void normalize(Vector3d<U> &vec);
+
+    /*********************
+     * product functions *
+     *********************/
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u * v + u * v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto dot(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    ) -> decltype(std::declval<U>() * std::declval<V>() + std::declval<U>() * std::declval<V>());
+
+    template <typename U, typename V>
+    requires requires(const U &u, const V &v) { u * v - u * v; } &&
+             (Vector3dDepthDifference_v<U, V> == 0)
+    [[nodiscard]] constexpr auto cross(
+        const Vector3d<U> &lhs,
+        const Vector3d<V> &rhs
+    )
+        -> Vector3d<
+            decltype(std::declval<U>() * std::declval<V>() - std::declval<U>() * std::declval<V>())>;
+
+    /**************
+     * ostream << *
+     **************/
+
+    template <typename U>
+    requires requires(std::ostream &os, const U &u) {
+        { os << u } -> std::same_as<std::ostream &>;
+    }
+    std::ostream &operator<<(std::ostream &os, const Vector3d<U> &vector);
+
+}   // namespace mstd
+
+#include "vector3d.tpp"
+
+#endif   //  __MSTD__LINALG__VECTOR3D_HPP__