shifting to matmul ufunc

Author: SwayamInSync

quaddtype/numpy_quaddtype/__init__.py

@@ -3,7 +3,6 @@
     QuadPrecDType,
     is_longdouble_128,
     get_sleef_constant,
-    qblas_dot as dot,
     set_num_threads,
     get_num_threads,
     get_quadblas_version
@@ -17,7 +16,7 @@
     # Constants
     'pi', 'e', 'log2e', 'log10e', 'ln2', 'ln10', 'max_value', 'min_value', 'epsilon', 
     # QuadBLAS related functions
-    'dot', 'set_num_threads', 'get_num_threads', 'get_quadblas_version'
+    'set_num_threads', 'get_num_threads', 'get_quadblas_version'
 ]
 
 def SleefQuadPrecision(value):

quaddtype/numpy_quaddtype/src/quaddtype_main.c

@@ -19,45 +19,55 @@
 #include "quadblas_interface.h"
 #include "float.h"
 
-
-static PyObject* py_is_longdouble_128(PyObject* self, PyObject* args) {
-    if(sizeof(long double) == 16 && 
-        LDBL_MANT_DIG == 113 && 
-        LDBL_MAX_EXP == 16384) {
+static PyObject *
+py_is_longdouble_128(PyObject *self, PyObject *args)
+{
+    if (sizeof(long double) == 16 && LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384) {
         Py_RETURN_TRUE;
-    } else {
+    }
+    else {
         Py_RETURN_FALSE;
     }
 }
 
-static PyObject* get_sleef_constant(PyObject* self, PyObject* args) {
-    const char* constant_name;
+static PyObject *
+get_sleef_constant(PyObject *self, PyObject *args)
+{
+    const char *constant_name;
     if (!PyArg_ParseTuple(args, "s", &constant_name)) {
         return NULL;
     }
 
-    QuadPrecisionObject* result = QuadPrecision_raw_new(BACKEND_SLEEF);
+    QuadPrecisionObject *result = QuadPrecision_raw_new(BACKEND_SLEEF);
     if (result == NULL) {
         return NULL;
     }
 
     if (strcmp(constant_name, "pi") == 0) {
         result->value.sleef_value = SLEEF_M_PIq;
-    } else if (strcmp(constant_name, "e") == 0) {
+    }
+    else if (strcmp(constant_name, "e") == 0) {
         result->value.sleef_value = SLEEF_M_Eq;
-    } else if (strcmp(constant_name, "log2e") == 0) {
+    }
+    else if (strcmp(constant_name, "log2e") == 0) {
         result->value.sleef_value = SLEEF_M_LOG2Eq;
-    } else if (strcmp(constant_name, "log10e") == 0) {
+    }
+    else if (strcmp(constant_name, "log10e") == 0) {
         result->value.sleef_value = SLEEF_M_LOG10Eq;
-    } else if (strcmp(constant_name, "ln2") == 0) {
+    }
+    else if (strcmp(constant_name, "ln2") == 0) {
         result->value.sleef_value = SLEEF_M_LN2q;
-    } else if (strcmp(constant_name, "ln10") == 0) {
+    }
+    else if (strcmp(constant_name, "ln10") == 0) {
         result->value.sleef_value = SLEEF_M_LN10q;
-    } else if (strcmp(constant_name, "quad_max") == 0) {
+    }
+    else if (strcmp(constant_name, "quad_max") == 0) {
         result->value.sleef_value = SLEEF_QUAD_MAX;
-    } else if (strcmp(constant_name, "quad_min") == 0) {
+    }
+    else if (strcmp(constant_name, "quad_min") == 0) {
         result->value.sleef_value = SLEEF_QUAD_MIN;
-    } else if (strcmp(constant_name, "epsilon") == 0) {
+    }
+    else if (strcmp(constant_name, "epsilon") == 0) {
         result->value.sleef_value = SLEEF_QUAD_EPSILON;
     }
     else {
@@ -66,26 +76,23 @@ static PyObject* get_sleef_constant(PyObject* self, PyObject* args) {
         return NULL;
     }
 
-    return (PyObject*)result;
+    return (PyObject *)result;
 }
 
 static PyMethodDef module_methods[] = {
-    {"is_longdouble_128", py_is_longdouble_128, METH_NOARGS, "Check if long double is 128-bit"},
-    {"get_sleef_constant", get_sleef_constant, METH_VARARGS, "Get Sleef constant by name"},
-    {"qblas_dot", py_quadblas_dot, METH_VARARGS, "Optimized dot product using QuadBLAS"},
-    {"set_num_threads", py_quadblas_set_num_threads, METH_VARARGS, "Set number of threads for QuadBLAS"},
-    {"get_num_threads", py_quadblas_get_num_threads, METH_NOARGS, "Get number of threads for QuadBLAS"},
-    {"get_quadblas_version", py_quadblas_get_version, METH_NOARGS, "Get QuadBLAS version"},
-    {NULL, NULL, 0, NULL} 
-};
+        {"is_longdouble_128", py_is_longdouble_128, METH_NOARGS, "Check if long double is 128-bit"},
+        {"get_sleef_constant", get_sleef_constant, METH_VARARGS, "Get Sleef constant by name"},
+        {"set_num_threads", py_quadblas_set_num_threads, METH_VARARGS,
+         "Set number of threads for QuadBLAS"},
+        {"get_num_threads", py_quadblas_get_num_threads, METH_NOARGS,
+         "Get number of threads for QuadBLAS"},
+        {"get_quadblas_version", py_quadblas_get_version, METH_NOARGS, "Get QuadBLAS version"},
+        {NULL, NULL, 0, NULL}};
 
 static struct PyModuleDef moduledef = {
-        PyModuleDef_HEAD_INIT,
-        .m_name = "_quaddtype_main",
+        PyModuleDef_HEAD_INIT, .m_name = "_quaddtype_main",
         .m_doc = "Quad (128-bit) floating point Data Type for NumPy with multiple backends",
-        .m_size = -1,
-        .m_methods = module_methods
-};
+        .m_size = -1, .m_methods = module_methods};
 
 PyMODINIT_FUNC
 PyInit__quaddtype_main(void)

quaddtype/tests/test_dot.py

@@ -1,19 +1,6 @@
-"""
-Focused test suite for the dot function in numpy_quaddtype
-
-This module tests the QuadBLAS dot function for:
-- Vector-vector dot products
-- Matrix-vector multiplication  
-- Matrix-matrix multiplication
-- Small and large matrix operations
-- Basic correctness validation
-
-Uses only the Sleef backend for simplicity.
-"""
-
 import pytest
 import numpy as np
-from numpy_quaddtype import QuadPrecision, QuadPrecDType, dot
+from numpy_quaddtype import QuadPrecision, QuadPrecDType
 
 
 # ================================================================================
@@ -81,14 +68,14 @@ def create_quad_array(values, shape=None):
 # ================================================================================
 
 class TestVectorVectorDot:
-    """Test vector-vector dot products"""
+    """Test vector-vector np.matmul products"""
 
     def test_simple_dot_product(self):
-        """Test basic vector dot product"""
+        """Test basic vector np.matmul product"""
         x = create_quad_array([1, 2, 3])
         y = create_quad_array([4, 5, 6])
 
-        result = dot(x, y)
+        result = np.matmul(x, y)
         expected = 1*4 + 2*5 + 3*6  # = 32
 
         assert isinstance(result, QuadPrecision)
@@ -99,14 +86,14 @@ def test_orthogonal_vectors(self):
         x = create_quad_array([1, 0, 0])
         y = create_quad_array([0, 1, 0])
 
-        result = dot(x, y)
+        result = np.matmul(x, y)
         assert_quad_equal(result, 0.0)
 
     def test_same_vector(self):
-        """Test dot product of vector with itself"""
+        """Test np.matmul product of vector with itself"""
         x = create_quad_array([2, 3, 4])
 
-        result = dot(x, x)
+        result = np.matmul(x, x)
         expected = 2*2 + 3*3 + 4*4  # = 29
 
         assert_quad_equal(result, expected)
@@ -121,7 +108,7 @@ def test_various_vector_sizes(self, size):
         x = create_quad_array(x_vals)
         y = create_quad_array(y_vals)
 
-        result = dot(x, y)
+        result = np.matmul(x, y)
         expected = sum(x_vals[i] * y_vals[i] for i in range(size))
 
         assert_quad_equal(result, expected)
@@ -131,7 +118,7 @@ def test_negative_and_fractional_values(self):
         x = create_quad_array([1.5, -2.5, 3.25])
         y = create_quad_array([-1.25, 2.75, -3.5])
 
-        result = dot(x, y)
+        result = np.matmul(x, y)
         expected = 1.5*(-1.25) + (-2.5)*2.75 + 3.25*(-3.5)
 
         assert_quad_equal(result, expected)
@@ -151,7 +138,7 @@ def test_simple_matrix_vector(self):
         # 3x1 vector  
         x = create_quad_array([1, 1, 1])
 
-        result = dot(A, x)
+        result = np.matmul(A, x)
         expected = [1+2+3, 4+5+6]  # [6, 15]
 
         assert result.shape == (2,)
@@ -164,7 +151,7 @@ def test_identity_matrix_vector(self):
         I = create_quad_array([1, 0, 0, 0, 1, 0, 0, 0, 1], shape=(3, 3))
         x = create_quad_array([2, 3, 4])
 
-        result = dot(I, x)
+        result = np.matmul(I, x)
 
         assert result.shape == (3,)
         for i in range(3):
@@ -181,7 +168,7 @@ def test_various_matrix_vector_sizes(self, m, n):
         x_vals = [i + 1 for i in range(n)]
         x = create_quad_array(x_vals)
 
-        result = dot(A, x)
+        result = np.matmul(A, x)
 
         assert result.shape == (m,)
 
@@ -205,7 +192,7 @@ def test_simple_matrix_matrix(self):
         A = create_quad_array([1, 2, 3, 4], shape=(2, 2))
         B = create_quad_array([5, 6, 7, 8], shape=(2, 2))
 
-        result = dot(A, B)
+        result = np.matmul(A, B)
 
         # Expected: [[1*5+2*7, 1*6+2*8], [3*5+4*7, 3*6+4*8]] = [[19, 22], [43, 50]]
         expected = [[19, 22], [43, 50]]
@@ -221,11 +208,11 @@ def test_identity_matrix_multiplication(self):
         I = create_quad_array([1, 0, 0, 1], shape=(2, 2))
 
         # A * I should equal A
-        result1 = dot(A, I)
+        result1 = np.matmul(A, I)
         assert_quad_array_equal(result1, A)
 
         # I * A should equal A  
-        result2 = dot(I, A)
+        result2 = np.matmul(I, A)
         assert_quad_array_equal(result2, A)
 
     @pytest.mark.parametrize("m,n,k", [(2,2,2), (2,3,4), (3,2,5), (4,4,4), (5,6,7)])
@@ -239,7 +226,7 @@ def test_various_matrix_sizes(self, m, n, k):
         B_vals = [(i*n + j + 1) for i in range(k) for j in range(n)]
         B = create_quad_array(B_vals, shape=(k, n))
 
-        result = dot(A, B)
+        result = np.matmul(A, B)
 
         assert result.shape == (m, n)
 
@@ -258,12 +245,12 @@ def test_associativity(self):
         C = create_quad_array([1, 1, 2, 1], shape=(2, 2))
 
         # Compute (A*B)*C
-        AB = dot(A, B)
-        result1 = dot(AB, C)
+        AB = np.matmul(A, B)
+        result1 = np.matmul(AB, C)
 
         # Compute A*(B*C)
-        BC = dot(B, C)
-        result2 = dot(A, BC)
+        BC = np.matmul(B, C)
+        result2 = np.matmul(A, BC)
 
         assert_quad_array_equal(result1, result2, rtol=1e-25)
 
@@ -285,7 +272,7 @@ def test_large_square_matrices(self, size):
         A = create_quad_array(A_vals, shape=(size, size))
         B = create_quad_array(B_vals, shape=(size, size))
 
-        result = dot(A, B)
+        result = np.matmul(A, B)
 
         assert result.shape == (size, size)
 
@@ -303,7 +290,7 @@ def test_large_square_matrices(self, size):
             assert_quad_equal(result[size//2, size//2], expected_value, rtol=1e-15, atol=1e-15)
 
     def test_large_vector_operations(self):
-        """Test large vector dot products"""
+        """Test large vector np.matmul products"""
         size = 1000
 
         # Create vectors with known sum
@@ -313,7 +300,7 @@ def test_large_vector_operations(self):
         x = create_quad_array(x_vals)
         y = create_quad_array(y_vals)
 
-        result = dot(x, y)
+        result = np.matmul(x, y)
         expected = size * 1.0 * 2.0  # = 2000.0
 
         assert_quad_equal(result, expected)
@@ -329,7 +316,7 @@ def test_rectangular_large_matrices(self):
         A = create_quad_array(A_vals, shape=(m, k))
         B = create_quad_array(B_vals, shape=(k, n))
 
-        result = dot(A, B)
+        result = np.matmul(A, B)
 
         assert result.shape == (m, n)
 
@@ -354,23 +341,23 @@ def test_dimension_mismatch_vectors(self):
         y = create_quad_array([1, 2, 3])
 
         with pytest.raises(ValueError, match="same length"):
-            dot(x, y)
+            np.matmul(x, y)
 
     def test_dimension_mismatch_matrix_vector(self):
         """Test dimension mismatch in matrix-vector"""
         A = create_quad_array([1, 2, 3, 4], shape=(2, 2))
         x = create_quad_array([1, 2, 3])  # Wrong size
 
         with pytest.raises(ValueError, match="columns must match"):
-            dot(A, x)
+            np.matmul(A, x)
 
     def test_dimension_mismatch_matrices(self):
         """Test dimension mismatch in matrix-matrix"""
         A = create_quad_array([1, 2, 3, 4], shape=(2, 2))
         B = create_quad_array([1, 2, 3, 4, 5, 6], shape=(3, 2))  # Wrong size
 
         with pytest.raises(ValueError, match="Matrix inner dimensions must match"):
-            dot(A, B)
+            np.matmul(A, B)
 
 
 if __name__ == "__main__":