math3d-py 1.3.0__tar.gz → 1.4.1__tar.gz

{math3d_py-1.3.0 → math3d_py-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: math3d_py
-Version: 1.3.0
+Version: 1.4.1
 Summary: Python bindings for 3dmath
 Author-Email: Murali Dhanakoti <dhanakoti.murali@gmail.com>
 Requires-Python: <3.14,>=3.13

{math3d_py-1.3.0 → math3d_py-1.4.1}/include/3dmath/SupportingTypes.h

@@ -21,9 +21,13 @@ namespace math3d {
         T length() const { return max - min; }
         T center() const { return static_cast<T>(0.5*(max + min)); }
         void scale(T const scale) { min *= scale; max *= scale; }
-        std::string asString() const {
+        [[nodiscard]] std::string asString() const {
             return std::format("[{},{}]", min, max);
         }
+        void merge(Extent const& another) {
+            min = std::min(min, another.min);
+            max = std::max(max, another.max);
+        }
     };
 
     template<typename T>
@@ -130,9 +134,81 @@ namespace math3d {
             return ss.str();
         }
 
-        bool isValid() const {
+        [[nodiscard]] bool isValid() const {
             return x.min < x.max && y.min < y.max && z.min < z.max;
         }
+
+        void merge(Bounds3D const& another) {
+            x.merge(another.x);
+            y.merge(another.y);
+            z.merge(another.z);
+        }
+
+        [[nodiscard]]
+        Vector3<T> min() const {
+            return {x.min, y.min, z.min};
+        }
+
+        [[nodiscard]]
+        Vector3<T> max() const {
+            return {x.max, y.max, z.max};
+        }
+
+        /// @brief Gets the corner vertices of this bounding box
+        ///
+        /// The corners are returned lower back to front with the bottom corners appearing before the top ones
+        [[nodiscard]]
+        std::array<Vector3<T>, 8> corners() const {
+            using Vec3 = Vector3<T>;
+
+            auto lower_left_back = min();
+            auto lower_right_back = lower_left_back + Vec3{x.length(), 0, 0};
+            auto upper_right_back= lower_right_back + Vec3{0, y.length(), 0};
+            auto upper_left_back = upper_right_back - Vec3{x.length(), 0, 0};
+
+            auto upper_right_front = max();
+            auto upper_left_front = upper_right_front - Vec3{x.length(), 0, 0};
+            auto lower_left_front  = upper_left_front - Vec3{0, y.length(), 0};
+            auto lower_right_front = lower_left_front + Vec3{x.length(), 0, 0};
+
+            return {lower_left_back, lower_right_back, upper_right_back, upper_left_back,
+                    lower_left_front, lower_right_front, upper_right_front, upper_left_front};
+        }
+
+        /// @brief Gets vertex indices of the quadrilateral faces of this bounding box
+        ///
+        /// Edges are returned in the following face order: front, right, back, left, bottom, and top
+        [[nodiscard]]
+        static constexpr std::array<std::array<uint8_t , 4>, 6> edges() {
+
+            using Face = std::array<uint8_t, 4>;
+
+            return {
+                    Face{4, 5, 6, 7},
+                    Face{5, 1, 2, 6},
+                    Face{0, 1, 2, 3},
+                    Face{0, 4, 7, 3},
+                    Face{0, 1, 5, 4},
+                    Face{6, 2, 3, 7}
+                };
+        }
+
+        [[nodiscard]]
+        Extent<T> extent(Direction dir) const {
+            if (dir == Direction::x) {
+                return x;
+            }
+            if (dir == Direction::y) {
+                return y;
+            }
+            if (dir == Direction::z) {
+                return z;
+            }
+            throw std::runtime_error(
+                std::format("Direction {} is not supported in the extent accessor",
+                            std::underlying_type_t<Direction>(dir))
+            );
+        }
     };
 
     template<typename T>

{math3d_py-1.3.0 → math3d_py-1.4.1}/py/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.24.2)
 
-project(3dmath_python VERSION 1.1.0)
+project(3dmath_python VERSION 1.3.0)
 
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED True)

math3d_py-1.4.1/py/math3d/math3d.pyi

@@ -0,0 +1,327 @@
+from __future__ import annotations
+import pybind11_stubgen.typing_ext
+import typing
+__all__: list[str] = ['AABB', 'Extent', 'Identity2', 'Identity3', 'Identity4', 'LinearSystem2', 'LinearSystem3', 'LinearSystem4', 'Matrix2', 'Matrix3', 'Matrix4', 'Vector2', 'Vector3', 'Vector4', 'col_major', 'order', 'row_major']
+class AABB:
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: Extent, arg1: Extent, arg2: Extent) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: Vector3, arg1: Vector3) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def corners(self) -> typing.Annotated[list[Vector3], pybind11_stubgen.typing_ext.FixedSize(8)]:
+        ...
+    def edges(self) -> typing.Annotated[list[typing.Annotated[list[int], pybind11_stubgen.typing_ext.FixedSize(4)]], pybind11_stubgen.typing_ext.FixedSize(6)]:
+        ...
+    def max(self) -> Vector3:
+        ...
+    def merge(self, arg0: AABB) -> None:
+        ...
+    def min(self) -> Vector3:
+        ...
+    def x_extent(self) -> Extent:
+        ...
+    def y_extent(self) -> Extent:
+        ...
+    def z_extent(self) -> Extent:
+        ...
+class Extent:
+    max: float
+    min: float
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: float, arg1: float) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def center(self) -> float:
+        ...
+    def length(self) -> float:
+        ...
+    def update(self, arg0: float) -> None:
+        ...
+class Identity2(Matrix2):
+    def __init__(self) -> None:
+        ...
+class Identity3(Matrix3):
+    def __init__(self) -> None:
+        ...
+class Identity4(Matrix4):
+    def __init__(self) -> None:
+        ...
+class LinearSystem2:
+    @staticmethod
+    def solve(arg0: Matrix2, arg1: Vector2) -> Vector2:
+        ...
+class LinearSystem3:
+    @staticmethod
+    def solve(arg0: Matrix3, arg1: Vector3) -> Vector3:
+        ...
+class LinearSystem4:
+    @staticmethod
+    def solve(arg0: Matrix4, arg1: Vector4) -> Vector4:
+        ...
+class Matrix2:
+    @typing.overload
+    def __getitem__(self, arg0: int) -> Vector2:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: tuple[int, int]) -> float:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable, arg1: order) -> None:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Matrix2) -> Matrix2:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Vector2) -> Vector2:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def determinant(self) -> float:
+        ...
+    def inverse(self) -> Matrix2:
+        ...
+    def row(self, arg0: int) -> Vector2:
+        ...
+    def transpose(self) -> Matrix2:
+        ...
+    def upper_triangular(self) -> Matrix2:
+        ...
+class Matrix3:
+    @typing.overload
+    def __getitem__(self, arg0: int) -> Vector3:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: tuple[int, int]) -> float:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable, arg1: order) -> None:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Matrix3) -> Matrix3:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Vector3) -> Vector3:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def determinant(self) -> float:
+        ...
+    def inverse(self) -> Matrix3:
+        ...
+    def row(self, arg0: int) -> Vector3:
+        ...
+    def transpose(self) -> Matrix3:
+        ...
+    def upper_triangular(self) -> Matrix3:
+        ...
+class Matrix4:
+    @typing.overload
+    def __getitem__(self, arg0: int) -> Vector4:
+        ...
+    @typing.overload
+    def __getitem__(self, arg0: tuple[int, int]) -> float:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable, arg1: order) -> None:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Matrix4) -> Matrix4:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Vector4) -> Vector4:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __str__(self) -> str:
+        ...
+    def determinant(self) -> float:
+        ...
+    def inverse(self) -> Matrix4:
+        ...
+    def row(self, arg0: int) -> Vector4:
+        ...
+    def transpose(self) -> Matrix4:
+        ...
+    def upper_triangular(self) -> Matrix4:
+        ...
+class Vector2:
+    x: float
+    y: float
+    def __add__(self, arg0: Vector2) -> Vector2:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable) -> None:
+        ...
+    def __mul__(self, arg0: float) -> Vector2:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __rmul__(self, arg0: float) -> Vector2:
+        ...
+    def __str__(self) -> str:
+        ...
+    def __sub__(self, arg0: Vector2) -> Vector2:
+        ...
+    def __truediv__(self, arg0: float) -> Vector2:
+        ...
+    def dot(self, arg0: Vector2) -> float:
+        ...
+    def length(self) -> float:
+        ...
+    def length_sqr(self) -> float:
+        ...
+    def normalize(self) -> Vector2:
+        ...
+    def projection(self, arg0: Vector2) -> tuple[Vector2, Vector2]:
+        ...
+class Vector3:
+    x: float
+    y: float
+    z: float
+    def __add__(self, arg0: Vector3) -> Vector3:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: float, arg1: float, arg2: float) -> None:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: float) -> Vector3:
+        ...
+    @typing.overload
+    def __mul__(self, arg0: Vector3) -> Vector3:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __rmul__(self, arg0: float) -> Vector3:
+        ...
+    def __str__(self) -> str:
+        ...
+    def __sub__(self, arg0: Vector3) -> Vector3:
+        ...
+    def __truediv__(self, arg0: float) -> Vector3:
+        ...
+    def dot(self, arg0: Vector3) -> float:
+        ...
+    def length(self) -> float:
+        ...
+    def length_sqr(self) -> float:
+        ...
+    def normalize(self) -> Vector3:
+        ...
+    def projection(self, arg0: Vector3) -> tuple[Vector3, Vector3]:
+        ...
+class Vector4:
+    w: float
+    x: float
+    y: float
+    z: float
+    def __add__(self, arg0: Vector4) -> Vector4:
+        ...
+    @typing.overload
+    def __init__(self) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: typing.Iterable) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: float, arg1: float, arg2: float, arg3: float) -> None:
+        ...
+    @typing.overload
+    def __init__(self, arg0: Vector3) -> None:
+        ...
+    def __mul__(self, arg0: float) -> Vector4:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __rmul__(self, arg0: float) -> Vector4:
+        ...
+    def __str__(self) -> str:
+        ...
+    def __sub__(self, arg0: Vector4) -> Vector4:
+        ...
+    def __truediv__(self, arg0: float) -> Vector4:
+        ...
+    def dot(self, arg0: Vector4) -> float:
+        ...
+    def length(self) -> float:
+        ...
+    def length_sqr(self) -> float:
+        ...
+    def normalize(self) -> Vector4:
+        ...
+    def projection(self, arg0: Vector4) -> tuple[Vector4, Vector4]:
+        ...
+class order:
+    """
+    Members:
+    
+      row_major
+    
+      col_major
+    """
+    __members__: typing.ClassVar[dict[str, order]]  # value = {'row_major': <order.row_major: 1>, 'col_major': <order.col_major: 0>}
+    col_major: typing.ClassVar[order]  # value = <order.col_major: 0>
+    row_major: typing.ClassVar[order]  # value = <order.row_major: 1>
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: int) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: int) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+col_major: order  # value = <order.col_major: 0>
+row_major: order  # value = <order.row_major: 1>

math3d_py-1.4.1/py/math3d/types.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "pybind11/pybind11.h"
+
+#include "SupportingTypes.h"
+
+namespace py = pybind11;
+namespace m3d = math3d;
+
+template<typename T>
+void bind_Extent(py::module_ const& module, std::string_view className) {
+    using Extent = m3d::Extent<T>;
+    py::class_<Extent>(module, className.data())
+    .def(py::init([] {
+        Extent extent;
+        extent.min = std::numeric_limits<T>::max();
+        extent.max = -std::numeric_limits<T>::max();
+        return extent;
+    }))
+    .def(py::init([](T min, T max) {
+        Extent extent {};
+        extent.min = min;
+        extent.max = max;
+        return extent;
+    }))
+    .def_property("min",
+        [](Extent const& extent) {
+            return extent.min;
+        },
+        [](Extent& extent, T min) {
+           extent.min = min;
+        }
+    )
+    .def_property("max",
+        [](Extent const& extent) {
+            return extent.max;
+        },
+        [](Extent& extent, T max) {
+           extent.max = max;
+        }
+    )
+    .def("length", [](Extent const& extent) {
+        return extent.length();
+    })
+    .def("center", [](Extent const& extent) {
+        return extent.center();
+    })
+    .def("update", [](Extent& extent, T val) {
+        extent.min = std::min(extent.min, val);
+        extent.max = std::max(extent.max, val);
+    })
+    .def("__str__", [](Extent const& extent) {
+        return extent.asString();
+    })
+    .def("__repr__", [](Extent const& extent) {
+        return std::format("Extent = {} Valid = {}", extent.asString(), extent.min < extent.max);
+    });
+}
+
+template<typename T>
+void bind_Bounds(py::module_ const& module, std::string_view className) {
+    using Bounds = m3d::Bounds3D<T>;
+    py::class_<Bounds>(module, className.data())
+    .def(py::init())
+    .def(py::init([](m3d::Extent<T> const& x, m3d::Extent<T> const& y, m3d::Extent<T> const& z) {
+        return Bounds {x, y, z};
+    }))
+    .def(py::init([](m3d::Vector3<T> const& min, m3d::Vector3<T> const& max) {
+        return Bounds(m3d::Extent<T>{min.x, max.x}, m3d::Extent<T>{min.y, max.y}, m3d::Extent<T>{min.z, max.z});
+    }))
+    .def("min", [](Bounds const& self) {
+        return self.min();
+    })
+    .def("max", [](Bounds const& self) {
+        return self.max();
+    })
+    .def("corners", [](Bounds const& self) {
+        return self.corners();
+    })
+    .def("edges", [](Bounds const& self) {
+        return self.edges();
+    })
+    .def("merge", [](Bounds& self, Bounds const& another) {
+        self.merge(another);
+    })
+    .def("x_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::x);
+    })
+    .def("y_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::y);
+    })
+    .def("z_extent", [](Bounds const& self) {
+        return self.extent(Bounds::Direction::z);
+    })
+    .def("__str__", [](Bounds const& bounds) {
+        return bounds.asString();
+    })
+    .def("__repr__", [](Bounds const& bounds) {
+        return std::format(
+            "{} Valid = {}\n"
+            "Center = {}\n"
+            "X Length = {}\n"
+            "Y Length = {}\n"
+            "Z Length = {}\n"
+            "Diagonal Length {}", bounds.asString(), bounds.isValid(), bounds.center().asString(),
+            bounds.x.length(), bounds.y.length(), bounds.z.length(), bounds.length());
+    });
+}

math3d_py-1.4.1/py/math3d/vector.hpp

@@ -0,0 +1,102 @@
+#pragma once
+#include "pybind11/pybind11.h"
+#include "pybind11/operators.h"
+#include "pybind11/stl.h"
+#include "util.h"
+#include "Vector.h"
+
+namespace py = pybind11;
+
+template<typename T, uint32_t Size>
+void bind_Vector(py::module_ const& module, char const* className) {
+    using vector = math3d::Vector<T, Size>;
+    auto pyVecClass =
+        py::class_<vector>(module, className)
+        // Construction
+        .def(py::init())
+        .def(py::init([](py::iterable const& list) {
+            auto const input = list.cast<std::vector<T>>();
+            return vector{input};
+        }))
+        // Formatted output
+        .def("__str__", [](vector const& v) {
+            return util::convertSpaceToNewLine(v.asString());
+        })
+        .def("__repr__", [](vector const& v) {
+            return util::convertSpaceToNewLine(v.asString());
+        })
+        // Operations
+        .def(py::self + py::self)
+        .def(py::self - py::self)
+        .def(py::self * T{})
+        .def(T{} * py::self)
+        .def(py::self / T{})
+        .def("dot", &vector::dot)
+        .def("normalize", [](vector& v) { v.normalize(); return v; })
+        .def("length", [](vector const& v) { return v.length(); })
+        .def("length_sqr", [](vector const& v) { return v.lengthSquared(); })
+        .def("projection", [](vector const& self, vector const& u) {
+            auto vectorProjection = self.getVectorProjection(u);
+            return std::pair{vectorProjection.parallel, vectorProjection.perpendicular};
+        });
+    if constexpr (Size == 3) {
+        pyVecClass
+        .def(py::init([](T x, T y, T z) {
+            return vector({x, y, z});
+        }))
+        .def(py::self * py::self);
+    }
+    if constexpr (Size == 4) {
+        pyVecClass
+        .def(py::init([](T x, T y, T z, T w) {
+            return vector({x, y, z, w});
+        }))
+        .def(py::init([](math3d::Vector3<T> const& vec3) {
+            std::vector<T> input {vec3.x, vec3.y, vec3.z, 1.F};
+            return vector{input};
+        }));
+    }
+
+    // Convenience member access (x, y, z, w)
+    // .x, .y, .z, .w are Vector<T, N>::Proxy and its conversion operator has to be invoked to get the raw value
+    // hence the static cast
+    if constexpr (Size >= 2 && Size <= 4) {
+        pyVecClass.def_property("x",
+            [](vector const& self) {
+                    return static_cast<T>(self.x);
+                },
+            [](vector& self, T value) {
+                    self.x = value;
+                }
+        )
+        .def_property("y",
+            [](vector const& self) {
+                    return static_cast<T>(self.y);
+                },
+            [](vector& self, T value) {
+                    self.y = value;
+                }
+        );
+    }
+    if constexpr (Size == 3 || Size == 4 ) {
+        pyVecClass.def_property("z",
+            [](vector const& self) {
+                    return static_cast<T>(self.z);
+                },
+            [](vector& self, T value) {
+                    self.z = value;
+                }
+        );
+    }
+    if constexpr (Size == 4) {
+        pyVecClass.def_property("w",
+            [](vector const& self) {
+                    return static_cast<T>(self.w);
+                },
+            [](vector& self, T value) {
+                    self.w = value;
+                }
+        );
+    }
+
+}

{math3d_py-1.3.0 → math3d_py-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "math3d_py"
-version = "1.3.0"
+version = "1.4.1"
 description = "Python bindings for 3dmath"
 authors = [{ name = "Murali Dhanakoti", email = "dhanakoti.murali@gmail.com" }]
 requires-python = ">=3.13,<3.14"

{math3d_py-1.3.0 → math3d_py-1.4.1}/pypublish

@@ -27,8 +27,8 @@ if [[ $# -eq 1 && "$1" == "major_ver" ]]; then
 fi
 
 rm -rf dist/*
-CMAKE_BUILD_PARALLEL_LEVEL=$(sysctl -n hw.ncpu) \
-CMAKE_ARGS="-DenableTesting=OFF" poetry run python -m build
 touch py/math3d/py.typed
 poetry run pybind11-stubgen math3d -o py
+CMAKE_BUILD_PARALLEL_LEVEL="$(sysctl -n hw.ncpu)" \
+CMAKE_ARGS="-DenableTesting=OFF" poetry run python -m build
 poetry run twine upload dist/*

{math3d_py-1.3.0 → math3d_py-1.4.1}/tests/Types.cpp

@@ -122,3 +122,35 @@ TEST(Bounds3D, Validity) {
                            {+0.5, +0.5, +0.5}};
     ASSERT_TRUE(bounds.isValid()) << "Bounds initialized with a unit cube must have been classified as valid";
 }
+
+TEST(Extent, Merging) {
+    Extent e1 {-10.F, 0.F};
+    Extent constexpr e2 {5.F, 10.F};
+    e1.merge(e2);
+    ASSERT_EQ(e1.min, -10.F);
+    ASSERT_EQ(e1.max, 10.F);
+}
+
+TEST(Bounds, Merging) {
+    Bounds3D smallerBounds {{-10, -10, -10}, {10, 10, 10}};
+    Bounds3D const biggerBounds {{-100, -100, -100}, {100, 100, 100}};
+    ASSERT_FALSE(smallerBounds.contains({-100, -100, -100}));
+    smallerBounds.merge(biggerBounds);
+    ASSERT_TRUE(smallerBounds.contains({-100, -100, -100}));
+    ASSERT_TRUE(smallerBounds.contains({100, 100, 100}));
+
+    Bounds3D boundsA {{-10, -10, -10}, { 10,  10,  10}};
+    Bounds3D const boundsB {{-100,  -1,  -2}, {  5, 200,   3}};
+    boundsA.merge(boundsB);
+    ASSERT_NEAR((boundsA.min() - Vector3{-100, -10, -10}).lengthSquared(), 0, 1e-6);
+    ASSERT_NEAR((boundsA.max() - Vector3{10, 200, 10}).lengthSquared(), 0, 1e-6);
+}
+
+TEST(Bounds, Corners) {
+    Bounds3D const bounds {{-10, -10, -10}, { 10,  10,  10}};
+    auto const corners = bounds.corners();
+    ASSERT_EQ((bounds.min() - corners.at(0)).lengthSquared(), 0);
+    ASSERT_EQ(((bounds.min() + Vector3{bounds.x.length(), bounds.y.length(), 0}) - corners.at(2)).lengthSquared(), 0);
+    ASSERT_EQ((bounds.max() - corners.at(6)).lengthSquared(), 0);
+    ASSERT_EQ(((bounds.max() - Vector3{bounds.x.length(), bounds.y.length(), 0}) - corners.at(4)).lengthSquared(), 0);
+}

math3d_py-1.4.1/tmp/math3d/__init__.py

@@ -0,0 +1 @@
+from .math3d import *

math3d_py-1.4.1/tmp/math3d/__init__.pyi

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from math3d.math3d import AABB
+from math3d.math3d import Extent
+from math3d.math3d import Identity2
+from math3d.math3d import Identity3
+from math3d.math3d import Identity4
+from math3d.math3d import LinearSystem2
+from math3d.math3d import LinearSystem3
+from math3d.math3d import LinearSystem4
+from math3d.math3d import Matrix2
+from math3d.math3d import Matrix3
+from math3d.math3d import Matrix4
+from math3d.math3d import Vector2
+from math3d.math3d import Vector3
+from math3d.math3d import Vector4
+from math3d.math3d import order
+from . import math3d
+__all__: list[str] = ['AABB', 'Extent', 'Identity2', 'Identity3', 'Identity4', 'LinearSystem2', 'LinearSystem3', 'LinearSystem4', 'Matrix2', 'Matrix3', 'Matrix4', 'Vector2', 'Vector3', 'Vector4', 'col_major', 'math3d', 'order', 'row_major']
+col_major: order  # value = <order.col_major: 0>
+row_major: order  # value = <order.row_major: 1>

math3d_py-1.4.1/tmp/math3d/linear_system.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "pybind11/pybind11.h"
+#include "LinearSystem.h"
+
+namespace py = pybind11;
+
+template<typename T, uint32_t Size>
+void bind_linearSystem(py::module_ const& module, char const* className) {
+
+    using linear_system = math3d::LinearSystem<T, Size>;
+
+    py::class_<linear_system>(module, className)
+    .def_static("solve", &linear_system::solveLinearSystem);
+
+}

math3d_py-1.4.1/tmp/math3d/math3d.cpp

@@ -0,0 +1,116 @@
+#include "pybind11/pybind11.h"
+#include "vector.hpp"
+#include "matrix.hpp"
+#include "linear_system.hpp"
+#include "types.hpp"
+
+#include <unordered_map>
+#include <format>
+
+namespace {
+
+#ifdef MAX_DIMENSIONS
+    auto constexpr MaxDimension {MAX_DIMENSIONS};
+#else
+    auto constexpr MaxDimension {4};
+#endif
+
+    enum class Type : uint8_t {
+        Vector,
+        Matrix,
+        LinearSystem,
+        IdentityMatrix,
+        Extent,
+        Bounds
+    };
+    std::unordered_map<Type, char const*> TypePrefixMap {
+        {Type::Vector, "Vector"},
+        {Type::Matrix, "Matrix"},
+        {Type::LinearSystem, "LinearSystem"},
+        {Type::IdentityMatrix, "Identity"},
+        {Type::Bounds, "AABB"},
+        {Type::Extent, "Extent"}
+    };
+
+    template<typename Type, Type Start, Type End>
+    class TypeIterator {
+    public:
+        TypeIterator() = default;
+
+        TypeIterator begin() {
+            return *this;
+        }
+
+        TypeIterator end() {
+            return TypeIterator{End + 1};
+        }
+
+        bool operator==(TypeIterator const& another) {
+            return value == another.value;
+        }
+
+    private:
+        std::underlying_type_t<Type> value {Start};
+    };
+
+    auto pyCompositeTypeCreator = [](Type const type, pybind11::module_ const& pythonModule, auto const integerConstant) {
+        constexpr uint8_t dimension = integerConstant + 2;
+        auto const typeName = TypePrefixMap[type] + std::to_string(dimension);
+        if (typeName.empty()) {
+            throw std::runtime_error{std::format("Unknown type {}", std::to_underlying(type))};
+        }
+        switch (type) {
+            case Type::Vector:
+                bind_Vector<double, dimension>(pythonModule, typeName.c_str());
+                break;
+            case Type::Matrix:
+                bind_Matrix<double, dimension, dimension>(pythonModule, typeName.c_str());
+                break;
+            case Type::LinearSystem:
+                bind_linearSystem<double, dimension>(pythonModule, typeName.c_str());
+                break;
+            case Type::IdentityMatrix:
+                bind_identityMatrix<double, dimension, dimension>(pythonModule, typeName.c_str());
+                break;
+            default:
+                break;
+        }
+    };
+
+    void createSimpleType(Type const type, pybind11::module_ const& module) {
+        auto const typeName = TypePrefixMap.at(type);
+        switch (type) {
+            case Type::Extent:
+                bind_Extent<double>(module, typeName);
+                break;
+            case Type::Bounds:
+                bind_Bounds<double>(module, typeName);
+                break;
+            default:
+                throw std::runtime_error(std::format("Unknown simple type {}", std::to_underlying(type)));
+        }
+
+    }
+
+    template <uint8_t... integers>
+    void createCompositeType(Type const type, pybind11::module_& module, std::integer_sequence<uint8_t, integers...>) {
+        (pyCompositeTypeCreator(type, module, std::integral_constant<uint8_t, integers>{}), ...);
+    }
+}
+
+PYBIND11_MODULE(math3d, module) {
+    // NOTE: std::make_integer_sequence returns integer_sequence<unsigned, 0, 1, ... , N-1>
+    // Therefore, when MaxDimension is 4, the integer sequence is 0, 1, 2 (range [0, 3)), which gets is translated to
+    // types with suffix 2, 3, 4 e.g. vec2, vec3, and vec4
+    auto constexpr intSeq  = std::make_integer_sequence<uint8_t, MaxDimension-1>{};
+    createCompositeType(Type::Vector, module, intSeq);
+    py::enum_<math3d::Order>(module, "order")
+        .value("row_major", math3d::Order::RowMajor)
+        .value("col_major", math3d::Order::ColumnMajor)
+        .export_values();
+    createCompositeType(Type::Matrix, module, intSeq);
+    createCompositeType(Type::LinearSystem, module, intSeq);
+    createCompositeType(Type::IdentityMatrix, module, intSeq);
+    createSimpleType(Type::Extent, module);
+    createSimpleType(Type::Bounds, module);
+}

math3d_py-1.4.1/tmp/math3d/matrix.hpp

@@ -0,0 +1,57 @@
+#pragma once
+#include "pybind11/pybind11.h"
+#include "pybind11/operators.h"
+
+#include "MatrixOperations.h"
+
+namespace py = pybind11;
+
+template<typename T, uint32_t Rows, uint32_t Cols>
+void bind_Matrix(py::module_ const& module, char const* className) {
+
+    using matrix = math3d::Matrix<T, Rows, Cols>;
+    using vector = math3d::Vector<T, Cols>;
+
+    py::class_<matrix>(module, className)
+    .def(py::init())
+    .def(py::init([](py::iterable const& data, math3d::Order const order) {
+        std::vector<std::vector<T>> dataAsVec;
+        for (auto outer : data) {
+            std::vector<T> inner = outer.cast<std::vector<T>>();
+            dataAsVec.push_back(std::move(inner));
+        }
+        return matrix{dataAsVec, order};
+    }))
+    .def("__getitem__", [](matrix const& matrix, uint32_t const index) {
+        return matrix.operator[](index);
+    })
+    .def("__getitem__", [](matrix const& matrix, std::pair<uint32_t, uint32_t> const& index_pair) {
+        return matrix.operator()(index_pair.first, index_pair.second);
+    })
+    .def("row", [](matrix const& matrix, uint32_t row) {
+        return matrix.operator()(row);
+    })
+    .def(py::self * py::self)
+    .def(py::self * vector{})
+    .def("__str__", &matrix::asString)
+    .def("__repr__", &matrix::asString)
+
+    // Operations
+    .def("transpose", &matrix::transpose)
+    .def("upper_triangular", [](matrix const& input) {
+        matrix output;
+        input.convertToUpperTriangular(output);
+        return output;
+    })
+    .def("determinant", &matrix::determinant)
+    .def("inverse", &matrix::inverse)
+    ;
+}
+
+template<typename T, uint32_t Rows, uint32_t Cols>
+void bind_identityMatrix(py::module_ const& module, char const* className) {
+    using identityMatrix = math3d::IdentityMatrix<T, Rows, Cols>;
+    using matrix = math3d::Matrix<T, Rows, Cols>;
+    py::class_<identityMatrix, matrix>(module, className)
+    .def(py::init());
+}

{math3d_py-1.3.0/py → math3d_py-1.4.1/tmp}/math3d/types.hpp

@@ -11,18 +11,44 @@ template<typename T>
 void bind_Extent(py::module_ const& module, std::string_view className) {
     using Extent = m3d::Extent<T>;
     py::class_<Extent>(module, className.data())
+    .def(py::init([] {
+        Extent extent;
+        extent.min = std::numeric_limits<T>::max();
+        extent.max = -std::numeric_limits<T>::max();
+        return extent;
+    }))
     .def(py::init([](T min, T max) {
         Extent extent {};
         extent.min = min;
         extent.max = max;
         return extent;
     }))
+    .def_property("min",
+        [](Extent const& extent) {
+            return extent.min;
+        },
+        [](Extent& extent, T min) {
+           extent.min = min;
+        }
+    )
+    .def_property("max",
+        [](Extent const& extent) {
+            return extent.max;
+        },
+        [](Extent& extent, T max) {
+           extent.max = max;
+        }
+    )
     .def("length", [](Extent const& extent) {
         return extent.length();
     })
     .def("center", [](Extent const& extent) {
         return extent.center();
     })
+    .def("update", [](Extent& extent, T val) {
+        extent.min = std::min(extent.min, val);
+        extent.max = std::max(extent.max, val);
+    })
     .def("__str__", [](Extent const& extent) {
         return extent.asString();
     })

math3d_py-1.4.1/tmp/math3d/util.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <ranges>
+#include <string>
+#include <algorithm>
+
+namespace util {
+    inline auto convertSpaceToNewLine = [](std::string&& str) {
+        std::string result{std::move(str)};
+        std::ranges::replace(result.begin(), result.end(), ' ', '\n');
+        result = result.substr(1, result.size()-2);
+        return result;
+    };
+}