ncca-ngl 0.3.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

ncca/ngl/mat3.py

@@ -1,15 +1,6 @@
 """
 Simple Mat3 class which can be used with the Vec3 class. By default it will be set to the identity matrix
-
-all matrix values are stored in a 3x3 list in the format
-
-.. highlight:: python
-.. code-block:: python
-
-  m=[[1.0,0.0,0.0],
-     [0.0,1.0,0.0],
-     [0.0,1.0,0.0]]
-
+NumPy-based implementation
 """
 
 import copy
@@ -32,9 +23,6 @@ class Mat3NotSquare(Exception):
     pass
 
 
-_identity = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
-
-
 class Mat3:
     """Simple Mat3 class for basic affine transforms"""
 
@@ -45,7 +33,7 @@ class Mat3:
 
     def __init__(self):
         """construct to identity matrix"""
-        self.m = copy.deepcopy(_identity)
+        self.m = np.eye(3, dtype=np.float64)
 
     def get_matrix(self):
         """return matrix elements as list ideal for OpenGL
@@ -56,12 +44,11 @@ class Mat3:
            the 9 float elements of the matrix, ideal
            for OpenGL or Renderman consumption
         """
-
-        return functools.reduce(operator.concat, self.m)
+        return self.m.flatten("C").tolist()
 
     def to_numpy(self):
         "return matrix as a numpy array ideal for WebGPU etc"
-        return np.array(self.get_matrix()).reshape([3, 3])
+        return self.m.astype(np.float32)
 
     @classmethod
     def identity(cls):
@@ -87,63 +74,35 @@ class Mat3:
 
         """
         v = Mat3()
-        v.m = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
+        v.m = np.zeros((3, 3), dtype=np.float64)
         return v
 
     @classmethod
     def from_list(cls, lst):
-        """class method to create Mat3 from list
-
-        Parameters
-        ----------
-        lst : list
-
-            list of 9 numbers to construct a new Mat3 from, we will accept either 9 floats or 3 lists of size 3
-
-            .. highlight:: python
-            .. code-block:: python
-
-                a=Mat3.from_list([1,2,3,4,5,6,7,8,9])
-                b=Mat3.from_list([1,2,3],[4,5,6],[7,8,9])
-
-        Returns
-        -------
-            Mat3
-                new Mat3 from list elements
-
-        :raises:
-            Mat3NotSquare : if we don't get a 3x3 we raise this
-
-        """
+        "class method to create mat3 from list"
         v = Mat3()
-        v.m = lst
-        if not v._is_square():
-            if len(lst) == 9:  # can convert
-                v.m = [lst[0:3], lst[3:6], lst[6:]]
+        if isinstance(lst, list) and len(lst) == 3 and all(isinstance(row, list) for row in lst):
+            # 2D list
+            if all(len(row) == 3 for row in lst):
+                v.m = np.array(lst, dtype=np.float64)
                 return v
-            else:
+            elif any(len(row) != 3 for row in lst):
                 raise Mat3NotSquare
-        else:
+        elif isinstance(lst, list) and len(lst) == 9:
+            # flat list - reshape to 3x3 in row-major order
+            v.m = np.array(lst, dtype=np.float64).reshape(3, 3, order="C")
             return v
-
-    def _is_square(self) -> bool:
-        """ensure matrix is square"""
-        return len(self.m) == 3 and all(len(i) == 3 for i in self.m)
+        else:
+            raise Mat3NotSquare
 
     def transpose(self):
         """transpose this matrix"""
-        self.m = [list(item) for item in zip(*self.m, strict=False)]
+        self.m = self.m.T
 
     def get_transpose(self):
-        """return a new matrix as the transpose of ourself
-
-        Returns
-        -------
-            Mat3
-                The transpose of the current matrix
-        """
+        "return a new matrix as the transpose of ourself"
         m = Mat3()
-        m.m = [list(item) for item in zip(*self.m, strict=False)]
+        m.m = self.m.T.copy()
         return m
 
     @classmethod
@@ -170,11 +129,11 @@ class Mat3:
                 matrix with diagonals set to the scale
 
         """
-        s = Mat3()
-        s.m[0][0] = x
-        s.m[1][1] = y
-        s.m[2][2] = z
-        return s
+        a = Mat3()
+        a.m[0, 0] = x
+        a.m[1, 1] = y
+        a.m[2, 2] = z
+        return a
 
     @classmethod
     def rotate_x(cls, angle: float):
@@ -196,15 +155,15 @@ class Mat3:
             Mat3
                 rotation matrix
         """
-        x = Mat3()
+        a = Mat3()
         beta = math.radians(angle)
         sr = math.sin(beta)
         cr = math.cos(beta)
-        x.m[1][1] = cr
-        x.m[1][2] = sr
-        x.m[2][1] = -sr
-        x.m[2][2] = cr
-        return x
+        a.m[1, 1] = cr
+        a.m[1, 2] = sr
+        a.m[2, 1] = -sr
+        a.m[2, 2] = cr
+        return a
 
     @classmethod
     def rotate_y(cls, angle: float):
@@ -226,15 +185,15 @@ class Mat3:
             Mat3
                 rotation matrix
         """
-        y = Mat3()
+        a = Mat3()
         beta = math.radians(angle)
         sr = math.sin(beta)
         cr = math.cos(beta)
-        y.m[0][0] = cr
-        y.m[0][2] = -sr
-        y.m[2][0] = sr
-        y.m[2][2] = cr
-        return y
+        a.m[0, 0] = cr
+        a.m[0, 2] = -sr
+        a.m[2, 0] = sr
+        a.m[2, 2] = cr
+        return a
 
     @classmethod
     def rotate_z(cls, angle: float):
@@ -256,15 +215,15 @@ class Mat3:
             Mat3
                 rotation matrix
         """
-        z = Mat3()
+        a = Mat3()
         beta = math.radians(angle)
         sr = math.sin(beta)
         cr = math.cos(beta)
-        z.m[0][0] = cr
-        z.m[0][1] = sr
-        z.m[1][0] = -sr
-        z.m[1][1] = cr
-        return z
+        a.m[0, 0] = cr
+        a.m[0, 1] = sr
+        a.m[1, 0] = -sr
+        a.m[1, 1] = cr
+        return a
 
     def __getitem__(self, idx):
         """access array elements remember this is a list of lists [[3],[3],[3]]
@@ -275,7 +234,7 @@ class Mat3:
 
 
         """
-        return self.m[idx]
+        return self.m[idx].tolist()
 
     def __setitem__(self, idx, item):
         """set array elements remember this is a list of lists [[3],[3],[3]]
@@ -299,105 +258,65 @@ class Mat3:
             if rhs is not a number
         """
         if isinstance(rhs, (int, float)):
-            for i in range(0, len(self.m)):
-                for j in range(0, len(self.m[i])):
-                    self.m[i][j] *= rhs
-            return self
+            result = Mat3()
+            result.m = self.m * rhs
+            return result
         raise Mat3Error
 
     def _mat_mul(self, rhs):
-        "matrix mult internal function"
-        # fmt: off
-        a00 = self.m[0][0] # cache values for speed? (works in C++ not sure about python)
-        a01 = self.m[0][1]
-        a02 = self.m[0][2]
-        a10 = self.m[1][0]
-        a11 = self.m[1][1]
-        a12 = self.m[1][2]
-        a20 = self.m[2][0]
-        a21 = self.m[2][1]
-        a22 = self.m[2][2]
-
-        b00 = rhs.m[0][0]
-        b01 = rhs.m[0][1]
-        b02 = rhs.m[0][2]
-        b10 = rhs.m[1][0]
-        b11 = rhs.m[1][1]
-        b12 = rhs.m[1][2]
-        b20 = rhs.m[2][0]
-        b21 = rhs.m[2][1]
-        b22 = rhs.m[2][2]
-
-        ret=Mat3() # result mat4
-        ret.m[0][0] = b00 * a00 + b01 * a10 + b02 * a20
-        ret.m[0][1] = b00 * a01 + b01 * a11 + b02 * a21
-        ret.m[0][2] = b00 * a02 + b01 * a12 + b02 * a22
-        ret.m[1][0] = b10 * a00 + b11 * a10 + b12 * a20
-        ret.m[1][1] = b10 * a01 + b11 * a11 + b12 * a21
-        ret.m[1][2] = b10 * a02 + b11 * a12 + b12 * a22
-        ret.m[2][0] = b20 * a00 + b21 * a10 + b22 * a20
-        ret.m[2][1] = b20 * a01 + b21 * a11 + b22 * a21
-        ret.m[2][2] = b20 * a02 + b21 * a12 + b22 * a22
-        return ret
-        # fmt: on
+        "matrix mult for 3D OpenGL style graphics"
+        result = Mat3()
+        # Use numpy's @ operator which does standard matrix multiplication
+        result.m = rhs.m @ self.m
+        return result
 
     def __matmul__(self, rhs):
         "multiply matrix by another matrix"
-        from .vec3 import Vec3  # note relative import
+        from .vec3 import Vec3
 
+        "multiply matrix by another matrix or vector"
         if isinstance(rhs, Mat3):
             return self._mat_mul(rhs)
         elif isinstance(rhs, Vec3):
-            return Vec3(
-                rhs.x * self.m[0][0] + rhs.y * self.m[0][1] + rhs.z * self.m[0][2],
-                rhs.x * self.m[1][0] + rhs.y * self.m[1][1] + rhs.z * self.m[1][2],
-                rhs.x * self.m[2][0] + rhs.y * self.m[2][1] + rhs.z * self.m[2][2],
-            )
+            # Vector transformation
+            vec = np.array([rhs.x, rhs.y, rhs.z], dtype=np.float64)
+            res = self.m @ vec
+            return Vec3(res[0], res[1], res[2])
         else:
             raise Mat3Error
 
-    def _add(self, rhs):
-        "internal add function"
-        temp = Mat3()
-        for i in range(0, len(temp.m)):
-            temp.m[i] = [a + b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
-        return temp
-
     def __add__(self, rhs):
         "piecewise addition of elements"
-        return self._add(rhs)
+        result = Mat3()
+        result.m = self.m + rhs.m
+        return result
 
     def __iadd__(self, rhs):
         "piecewise addition of elements to this"
-        return self._add(rhs)
-
-    def _sub(self, rhs):
-        "internal subtract function"
-        temp = Mat3()
-        for i in range(0, len(temp.m)):
-            temp.m[i] = [a - b for a, b in zip(self.m[i], rhs.m[i], strict=False)]
-        return temp
+        result = Mat3()
+        result.m = self.m + rhs.m
+        return result
 
     def __sub__(self, rhs):
         "piecewise subtraction of elements"
-        return self._sub(rhs)
+        result = Mat3()
+        result.m = self.m - rhs.m
+        return result
 
     def __isub__(self, rhs):
         "piecewise subtraction of elements to this"
-        return self._sub(rhs)
+        result = Mat3()
+        result.m = self.m - rhs.m
+        return result
 
     def determinant(self):
         "determinant of matrix"
-        return (
-            +self.m[0][0] * (self.m[1][1] * self.m[2][2] - self.m[2][1] * self.m[1][2])
-            - self.m[0][1] * (self.m[1][0] * self.m[2][2] - self.m[1][2] * self.m[2][0])
-            + self.m[0][2] * (self.m[1][0] * self.m[2][1] - self.m[1][1] * self.m[2][0])
-        )
+        return np.linalg.det(self.m)
 
     def to_list(self):
         "convert matrix to list"
         # flatten to single array
-        return functools.reduce(operator.concat, self.m)
+        return self.m.flatten("C").tolist()
 
     def copy(self) -> "Mat3":
         """Create a copy of the matrix.
@@ -411,46 +330,46 @@ class Mat3:
 
     def inverse(self):
         "Inverse of matrix raise MatrixError if not calculable"
-        det = self.determinant()
         try:
-            invdet = 1 / det
-            tmp = Mat3()
-            # minor matrix + co-factor
-            tmp.m[0][0] = +(self.m[1][1] * self.m[2][2] - self.m[1][2] * self.m[2][1]) * invdet
-            tmp.m[1][0] = -(self.m[1][0] * self.m[2][2] - self.m[1][2] * self.m[2][0]) * invdet
-            tmp.m[2][0] = +(self.m[1][0] * self.m[2][1] - self.m[1][1] * self.m[2][0]) * invdet
-
-            tmp.m[0][1] = -(self.m[0][1] * self.m[2][2] - self.m[0][2] * self.m[2][1]) * invdet
-            tmp.m[1][1] = +(self.m[0][0] * self.m[2][2] - self.m[0][2] * self.m[2][0]) * invdet
-            tmp.m[2][1] = -(self.m[0][0] * self.m[2][1] - self.m[0][1] * self.m[2][0]) * invdet
-
-            tmp.m[0][2] = +(self.m[0][1] * self.m[1][2] - self.m[0][2] * self.m[1][1]) * invdet
-            tmp.m[1][2] = -(self.m[0][0] * self.m[1][2] - self.m[0][2] * self.m[1][0]) * invdet
-            tmp.m[2][2] = +(self.m[0][0] * self.m[1][1] - self.m[0][1] * self.m[1][0]) * invdet
-
-            return tmp
-        except ZeroDivisionError:
+            result = Mat3()
+            result.m = np.linalg.inv(self.m)
+            return result
+        except np.linalg.LinAlgError:
             raise Mat3Error
 
     def __str__(self):
-        """return string representation"""
-        return f"[{self.m[0]}\n{self.m[1]}\n{self.m[2]}]"
+        rows = [self.m[i].tolist() for i in range(3)]
+        return f"[{rows[0]}\n{rows[1]}\n{rows[2]}]"
 
     def __repr__(self):
-        """return string representation"""
-        return f"Mat3({self.m})"
+        rows = [self.m[i].tolist() for i in range(3)]
+        return f"Mat3({rows})"
 
     @classmethod
     def from_mat4(cls, mat4):
         """Create a Mat3 from a Mat4"""
-        return Mat3.from_list([
-            mat4.m[0][0],
-            mat4.m[0][1],
-            mat4.m[0][2],
-            mat4.m[1][0],
-            mat4.m[1][1],
-            mat4.m[1][2],
-            mat4.m[2][0],
-            mat4.m[2][1],
-            mat4.m[2][2],
-        ])
+        m = Mat3()
+        m.m = mat4.m[:3, :3].copy()
+        return m
+
+    def __eq__(self, other):
+        """Value-based equality for Mat3: compare underlying matrices numerically.
+
+        Returns NotImplemented for non-Mat3 types so Python can try reflected comparisons
+        or handle it appropriately.
+        """
+        if not isinstance(other, Mat3):
+            return NotImplemented
+        # self.m and other.m should be numpy arrays; compare with tolerance
+        return np.allclose(self.m, other.m, rtol=1e-8, atol=1e-12)
+
+    def __ne__(self, other):
+        """Value-based inequality for Mat3: compare underlying matrices numerically.
+
+        Returns NotImplemented for non-Mat3 types so Python can try reflected comparisons
+        or handle it appropriately.
+        """
+        if not isinstance(other, Mat3):
+            return NotImplemented
+        # Return the negation of equality
+        return not np.allclose(self.m, other.m, rtol=1e-8, atol=1e-12)