nulapack 0.1.0__cp312-cp312-win_amd64.whl

nulapack/__init__.py

@@ -0,0 +1,16 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .cholesky import cholesky
+from .doolittle import doolittle
+from .gauss_seidel import gauss_seidel
+from .jacobi import jacobi
+from .thomas import thomas
+
+
+try:
+    __version__ = version("nulapack")
+except PackageNotFoundError:
+    # package is not installed
+    pass
+
+__all__ = ["__version__", "cholesky", "doolittle", "gauss_seidel", "jacobi", "thomas"]

nulapack/cholesky.py

@@ -0,0 +1,46 @@
+import _nulapack
+import numpy as np
+
+
+def cholesky(a: np.ndarray):
+    """
+    Compute the Cholesky factorization of a symmetric/Hermitian
+    positive-definite matrix A using NULAPACK.
+
+    Parameters
+    ----------
+    a : ndarray
+        Coefficient matrix (n x n) stored as a full matrix. Real matrices
+        should be symmetric, complex matrices should be Hermitian and
+        positive-definite.
+
+    Returns
+    -------
+    L : ndarray
+        Lower-triangular matrix from the factorization (A = L * L^T or
+        A = L * L^H).
+    info : int
+        0 if success, >0 if the matrix is not positive-definite.
+    """
+    a = np.ascontiguousarray(a)
+    n = a.shape[0]
+    lda = n
+
+    a_flat = a.ravel(order="C")
+    l_flat = np.zeros_like(a_flat)
+    info = np.zeros(1, dtype=np.int32)
+
+    if np.issubdtype(a.dtype, np.floating):
+        if a.dtype == np.float32:
+            _nulapack.spoctrf(n, a_flat, l_flat, lda, info)
+        else:  # float64
+            _nulapack.dpoctrf(n, a_flat, l_flat, lda, info)
+    elif np.issubdtype(a.dtype, np.complexfloating):
+        if a.dtype == np.complex64:
+            _nulapack.cpoctrf(n, a_flat, l_flat, lda, info)
+        else:  # complex128
+            _nulapack.zpoctrf(n, a_flat, l_flat, lda, info)
+    else:
+        raise TypeError(f"Unsupported array dtype: {a.dtype}")
+
+    return np.tril(l_flat.reshape(n, n, order="C")), int(info[0])

nulapack/doolittle.py

@@ -0,0 +1,44 @@
+import _nulapack
+import numpy as np
+
+
+def doolittle(a: np.ndarray):
+    """
+    Compute the LU Doolittle decomposition of a general matrix A.
+
+    Parameters
+    ----------
+    a : ndarray
+        Coefficient matrix (n x n) stored as a full matrix.
+
+    Returns
+    -------
+    L : ndarray
+        Lower triangular matrix from the factorization.
+    U : ndarray
+        Upper triangular matrix from the factorization.
+    info : int
+        0 if success, <0 if a zero diagonal in U was detected.
+    """
+    a = np.ascontiguousarray(a)
+    n = a.shape[0]
+
+    a_flat = a.ravel(order="C")
+    l_flat = np.zeros_like(a_flat)
+    u_flat = np.zeros_like(a_flat)
+    info = np.zeros(1, dtype=np.int32)
+
+    if np.issubdtype(a.dtype, np.floating):
+        if a.dtype == np.float32:
+            _nulapack.sgedtrf(n, a_flat, l_flat, u_flat, info)
+        else:  # float64
+            _nulapack.dgedtrf(n, a_flat, l_flat, u_flat, info)
+    elif np.issubdtype(a.dtype, np.complexfloating):
+        if a.dtype == np.complex64:
+            _nulapack.cgedtrf(n, a_flat, l_flat, u_flat, info)
+        else:  # complex128
+            _nulapack.zgedtrf(n, a_flat, l_flat, u_flat, info)
+    else:
+        raise TypeError(f"Unsupported array dtype: {a.dtype}")
+
+    return l_flat.reshape(n, n, order="C"), u_flat.reshape(n, n, order="C"), int(info[0])

nulapack/gauss_seidel.py

@@ -0,0 +1,50 @@
+import _nulapack
+import numpy as np
+
+
+def gauss_seidel(a, b, max_iter=1000, tol=1e-8, omega=1.0):
+    """
+    Solve the linear system ax = b using the Gauss-Seidel method.
+
+    Parameters
+    ----------
+    a : ndarray
+        Coefficient matrix (n x n)
+    b : ndarray
+        Right-hand side vector (n,)
+    max_iter : int, optional
+        Maximum number of iterations
+    tol : float, optional
+        Convergence tolerance
+    omega : float, optional
+        Relaxation factor
+
+    Returns
+    -------
+    x : ndarray
+        Solution vector
+    status : int
+        0 if converged, non-zero otherwise
+    """
+    a = np.ascontiguousarray(a)
+    b = np.asfortranarray(b)
+    n = a.shape[0]
+
+    x = np.zeros_like(b)
+
+    a_flat = a.ravel()
+
+    if np.issubdtype(a.dtype, np.floating):
+        if a.dtype == np.float32:
+            status = _nulapack.sgegssv(a_flat, b, x, max_iter, tol, omega, 0, n)
+        else:  # float64
+            status = _nulapack.dgegssv(a_flat, b, x, max_iter, tol, omega, 0, n)
+    elif np.issubdtype(a.dtype, np.complexfloating):
+        if a.dtype == np.complex64:
+            status = _nulapack.cgegssv(a_flat, b, x, max_iter, tol, omega, 0, n)
+        else:  # complex128
+            status = _nulapack.zgegssv(a_flat, b, x, max_iter, tol, omega, 0, n)
+    else:
+        raise TypeError(f"Unsupported array dtype: {a.dtype}")
+
+    return x, int(status) if status is not None else 0

nulapack/jacobi.py

@@ -0,0 +1,50 @@
+import _nulapack
+import numpy as np
+
+
+def jacobi(a, b, max_iter=1000, tol=1e-8, omega=1.0):
+    """
+    Solve the linear system ax = b using the Jacobi method.
+
+    Parameters
+    ----------
+    a : ndarray
+        Coefficient matrix (n x n)
+    b : ndarray
+        Right-hand side vector (n,)
+    max_iter : int, optional
+        Maximum number of iterations
+    tol : float, optional
+        Convergence tolerance
+    omega : float, optional
+        Relaxation factor
+
+    Returns
+    -------
+    x : ndarray
+        Solution vector
+    status : int
+        0 if converged, non-zero otherwise
+    """
+    a = np.ascontiguousarray(a)
+    b = np.asfortranarray(b)
+    n = a.shape[0]
+
+    x = np.zeros_like(b)
+
+    a_flat = a.ravel()
+
+    if np.issubdtype(a.dtype, np.floating):
+        if a.dtype == np.float32:
+            status = _nulapack.sgejsv(a_flat, b, x, max_iter, tol, omega, 0, n)
+        else:  # float64
+            status = _nulapack.dgejsv(a_flat, b, x, max_iter, tol, omega, 0, n)
+    elif np.issubdtype(a.dtype, np.complexfloating):
+        if a.dtype == np.complex64:
+            status = _nulapack.cgejsv(a_flat, b, x, max_iter, tol, omega, 0, n)
+        else:  # complex128
+            status = _nulapack.zgejsv(a_flat, b, x, max_iter, tol, omega, 0, n)
+    else:
+        raise TypeError(f"Unsupported array dtype: {a.dtype}")
+
+    return x, int(status) if status is not None else 0

nulapack/thomas.py

@@ -0,0 +1,44 @@
+import _nulapack
+import numpy as np
+
+
+def thomas(a: np.ndarray, b: np.ndarray):
+    """
+    Solve a tridiagonal linear system A * X = B using the Thomas algorithm.
+
+    Parameters
+    ----------
+    a : ndarray
+        Coefficient matrix (n x n) stored as a full matrix.
+    b : ndarray
+        Right-hand side vector (n,)
+
+    Returns
+    -------
+    x : ndarray
+        Solution vector
+    info : int
+        0 if success, <0 if zero diagonal detected
+    """
+    a = np.ascontiguousarray(a)
+    b = np.asfortranarray(b)
+    n = a.shape[0]
+
+    x = np.zeros_like(b)
+
+    a_flat = a.ravel()
+
+    if np.issubdtype(a.dtype, np.floating):
+        if a.dtype == np.float32:
+            status = _nulapack.sgttsv(a_flat, b, x, 0, n)
+        else:  # float64
+            status = _nulapack.dgttsv(a_flat, b, x, 0, n)
+    elif np.issubdtype(a.dtype, np.complexfloating):
+        if a.dtype == np.complex64:
+            status = _nulapack.cgttsv(a_flat, b, x, 0, n)
+        else:  # complex128
+            status = _nulapack.zgttsv(a_flat, b, x, 0, n)
+    else:
+        raise TypeError(f"Unsupported array dtype: {a.dtype}")
+
+    return x, int(status) if status is not None else 0