Merge pull request #591 from tkoyama010/feature/identity-matrix

Add identity matrix generation functionality to SimpleArray (#588)

Author: yungyuc

cpp/modmesh/buffer/SimpleArray.hpp

@@ -1248,6 +1248,26 @@ class SimpleArray
         return data;
     }
 
+    /**
+     * Create an identity matrix of size n x n.
+     *
+     * @param n Size of the square identity matrix
+     * @return SimpleArray representing an n x n identity matrix
+     */
+    static SimpleArray eye(size_t n)
+    {
+        shape_type shape{n, n};
+        SimpleArray result(shape, static_cast<value_type>(0));
+
+        // Set diagonal elements to 1
+        for (size_t i = 0; i < n; ++i)
+        {
+            result(i, i) = static_cast<value_type>(1);
+        }
+
+        return result;
+    }
+
     explicit operator bool() const noexcept { return bool(m_buffer) && bool(*m_buffer); }
 
     size_t nbytes() const noexcept { return size() * ITEMSIZE; }

cpp/modmesh/buffer/pymod/wrap_SimpleArray.cpp

@@ -315,6 +315,7 @@ class MODMESH_PYTHON_WRAPPER_VISIBILITY WrapSimpleArray
             .def("mul", &wrapped_type::mul)
             .def("div", &wrapped_type::div)
             .def("matmul", &wrapped_type::matmul)
+            .def_static("eye", &wrapped_type::eye, py::arg("n"), "Create an identity matrix of size n x n")
             // TODO: In-place operation should return reference to self to support function chaining
             .def("iadd", [](wrapped_type & self, wrapped_type const & other)
                  { self.iadd(other); })

tests/test_gemm.py

@@ -26,6 +26,7 @@
 
 import unittest
 import numpy as np
+from itertools import product
 import modmesh as mm
 
 
@@ -75,16 +76,47 @@ def test_identity_matrix(self):
         # 3x3 matrix
         a_data = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0],
                            [7.0, 8.0, 9.0]], dtype=self.dtype)
-        identity_data = np.eye(3, dtype=self.dtype)
 
         a = self.SimpleArray(array=a_data)
-        identity = self.SimpleArray(array=identity_data)
+        identity = self.SimpleArray.eye(3)
 
         result = a.matmul(identity)
 
         self.assertEqual(list(result.shape), [3, 3])
         np.testing.assert_array_almost_equal(result.ndarray, a_data)
 
+    def test_eye_method(self):
+        """Test eye method creates correct identity matrices"""
+        # Test cases: different sizes
+        test_sizes = [1, 2, 3, 4, 5, 10]
+
+        for size in test_sizes:
+            with self.subTest(size=size):
+                # Create identity matrix using our eye method
+                identity = self.SimpleArray.eye(size)
+
+                # Create expected identity matrix using NumPy
+                expected = np.eye(size, dtype=self.dtype)
+
+                # Check shape
+                self.assertEqual(list(identity.shape), [size, size])
+
+                # Check array values
+                np.testing.assert_array_almost_equal(identity.ndarray,
+                                                     expected)
+
+                # Verify diagonal and off-diagonal elements explicitly
+                # using product
+                for i, j in product(range(size), repeat=2):
+                    if i == j:
+                        self.assertEqual(identity[i, j], 1.0,
+                                         f"Diagonal element ({i},{j}) "
+                                         f"should be 1.0")
+                    else:
+                        self.assertEqual(identity[i, j], 0.0,
+                                         f"Off-diagonal element ({i},{j}) "
+                                         f"should be 0.0")
+
     def test_zero_matrix(self):
         """Test multiplication with zero matrix"""
         a_data = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=self.dtype)