scikit-sparse 0.5.0__tar.gz → 0.5.1__tar.gz

{scikit_sparse-0.5.0/src/scikit_sparse.egg-info → scikit_sparse-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-sparse
-Version: 0.5.0
+Version: 0.5.1
 Summary: Scikit-sparse is a Python wrapper for the SuiteSparse sparse matrix library.
 Author-email: David Cournapeau <cournape@gmail.com>, Nathaniel Smith <njs@pobox.com>, Dag Sverre Seljebotn <dagss@student.matnat.uio.no>, Leon Barrett <lbarrett@climate.com>, Yuri <yuri@tsoft.com>, Antony Lee <anntzer.lee@gmail.com>, Alex Grigorievskiy <alex.grigorievskiy@gmail.com>, Joscha Reimer <jor@informatik.uni-kiel.de>, Justin Ellis <justin.ellis18@gmail.com>, Aaron Johnson <aaron9035@gmail.com>, Bernard Roesler <bernard.roesler@gmail.com>
 Maintainer-email: Bernard Roesler <bernard.roesler@gmail.com>
@@ -30,7 +30,7 @@ Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: ruff==0.14.3; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: furo; extra == "dev"
 Requires-Dist: sphinx-copybutton; extra == "dev"

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scikit-sparse"
-version = "0.5.0"
+version = "0.5.1"
 description = "Scikit-sparse is a Python wrapper for the SuiteSparse sparse matrix library."
 readme = "README.rst"
 requires-python = ">=3.10"
@@ -56,7 +56,7 @@ dev = [
     "build",
     "pre-commit",
     "pytest",
-    "ruff",
+    "ruff==0.14.3",
     "sphinx",
     "furo",
     "sphinx-copybutton",

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1/src/scikit_sparse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-sparse
-Version: 0.5.0
+Version: 0.5.1
 Summary: Scikit-sparse is a Python wrapper for the SuiteSparse sparse matrix library.
 Author-email: David Cournapeau <cournape@gmail.com>, Nathaniel Smith <njs@pobox.com>, Dag Sverre Seljebotn <dagss@student.matnat.uio.no>, Leon Barrett <lbarrett@climate.com>, Yuri <yuri@tsoft.com>, Antony Lee <anntzer.lee@gmail.com>, Alex Grigorievskiy <alex.grigorievskiy@gmail.com>, Joscha Reimer <jor@informatik.uni-kiel.de>, Justin Ellis <justin.ellis18@gmail.com>, Aaron Johnson <aaron9035@gmail.com>, Bernard Roesler <bernard.roesler@gmail.com>
 Maintainer-email: Bernard Roesler <bernard.roesler@gmail.com>
@@ -30,7 +30,7 @@ Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
+Requires-Dist: ruff==0.14.3; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: furo; extra == "dev"
 Requires-Dist: sphinx-copybutton; extra == "dev"

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1}/src/scikit_sparse.egg-info/requires.txt

@@ -6,7 +6,7 @@ packaging
 build
 pre-commit
 pytest
-ruff
+ruff==0.14.3
 sphinx
 furo
 sphinx-copybutton

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1}/src/sksparse/cholmod.pxd

@@ -205,6 +205,11 @@ cdef extern from "cholmod.h":
         int itype
         int xtype
         int dtype
+        size_t nsuper
+        size_t xsize
+        void *super
+        void *pi
+        void *px
 
     ctypedef struct cholmod_sparse:
         size_t nrow

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1}/src/sksparse/cholmod.pyx

@@ -112,6 +112,7 @@ import numpy as np
 
 from scipy.sparse import csc_array, diags_array, eye_array, issparse
 import warnings
+import weakref
 
 from .utils import validate_csc_input
 
@@ -955,47 +956,6 @@ cdef cnp.ndarray _ndarray_copy_from_intptr(void* ptr, size_t N, bint use_int32):
     return p.copy()  # return a copy in case ptr is freed
 
 
-cdef cnp.ndarray _ndarray_int_view_from_factor(
-    void* ptr, size_t N, CholeskyFactor py_factor
-):
-    """Create a NumPy array from the an integer vector in a CHOLMOD factor.
-
-    Parameters
-    ----------
-    ptr : void*
-        A pointer to the C array, *e.g.* ``cholmod_factor.Perm``.
-    N : size_t
-        The size of the vector.
-    py_factor : CholeskyFactor
-        The CholeskyFactor object from which to extract the permutation.
-
-    Returns
-    -------
-    p : ndarray
-        The permutation vector as a NumPy array. This array is *read-only*,
-        so attempts to modify it will raise an error.
-    """
-    cdef cholmod_factor *L = py_factor._factor
-
-    if L is NULL:
-        raise ValueError("The factor pointer is NULL.")
-
-    if ptr is NULL:
-        raise ValueError("The input pointer is NULL.")
-
-    cdef int np_itypenum = _np_itypenum_from_cholmod(L.itype)
-    p = cnp.PyArray_SimpleNewFromData(1, [N], np_itypenum, ptr)
-
-    # NOTE need to increment reference count of base manually,
-    # since the PyArray_SetBaseObject steals a reference.
-    Py_INCREF(py_factor)
-    if cnp.PyArray_SetBaseObject(p, py_factor) < 0:
-        raise MemoryError("Failed to set base object for array.")
-    cnp.PyArray_CLEARFLAGS(p, cnp.NPY_ARRAY_WRITEABLE)  # set to be read-only
-
-    return p
-
-
 # -----------------------------------------------------------------------------
 #         Utilities
 # -----------------------------------------------------------------------------
@@ -1332,7 +1292,7 @@ cdef class CholeskyFactor:
         The ordering method used for the factorization. If an unknown ordering
         was used, returns the integer value.
     perm : *(N,)* :obj:`numpy.ndarray` of int
-        A read-only view of the permutation vector used for the factorization.
+        A read-only copy of the permutation vector used for the factorization.
     factor : :obj:`~scipy.sparse.csc_array`
         A view of the the Cholesky factor in Compressed Sparse Column (CSC)
         format. If ``self.is_ll``, the returned matrix is lower triangular.
@@ -1407,6 +1367,7 @@ cdef class CholeskyFactor:
         # Cached factors
         cnp.ndarray _perm
         cnp.ndarray _colcount
+        object _pattern
         object _L
         object _R
         object _D
@@ -1508,6 +1469,10 @@ cdef class CholeskyFactor:
         cdef int minor = -1 if self._factor is NULL else self._factor.minor
         _handle_errors(self._cm.status, minor)
 
+        # The supernodal algorithm requires A to have the analyzed pattern
+        if self._factor.is_super:
+            self._pattern = (A.shape, A.indptr.copy(), A.indices.copy())
+
     def __dealloc__(self):
         """Deallocate memory used by the CholeskyFactor."""
         if self._use_int32:
@@ -1522,6 +1487,23 @@ cdef class CholeskyFactor:
         if not self.is_numeric:
             raise CholmodError("Factor is symbolic. Call `factorize` before updating.")
 
+    cdef int _to_simplicial(self) except -1:
+        """Convert the factor to simplicial format, keeping its values."""
+        cdef cholmod_factor *L = self._factor
+        if self._use_int32:
+            cholmod_change_factor(L.xtype, L.is_ll, False, True, True, L, self._cm)
+        else:
+            cholmod_l_change_factor(L.xtype, L.is_ll, False, True, True, L, self._cm)
+        return _handle_errors(self._cm.status)
+
+    cdef bint _has_pattern(self, object A) except -1:
+        """Check whether A has the analyzed (supernodal) sparsity pattern."""
+        return self._pattern is not None and (
+            A.shape == self._pattern[0]
+            and np.array_equal(A.indptr, self._pattern[1])
+            and np.array_equal(A.indices, self._pattern[2])
+        )
+
     def _clear_cache(self):
         """Clear cached properties."""
         self._factor_view = None
@@ -1590,9 +1572,10 @@ cdef class CholeskyFactor:
     @property
     def colcount(self):
         if self._colcount is None:
-            self._colcount = _ndarray_int_view_from_factor(
-                self._factor.ColCount, self._factor.n, self
+            self._colcount = _ndarray_copy_from_intptr(
+                self._factor.ColCount, self._factor.n, self._use_int32
             )
+            self._colcount.flags.writeable = False
         return self._colcount
 
     @property
@@ -1607,14 +1590,21 @@ cdef class CholeskyFactor:
     @property
     def perm(self):
         if self._perm is None:
-            self._perm = _ndarray_int_view_from_factor(self._factor.Perm, self._factor.n, self)
+            self._perm = _ndarray_copy_from_intptr(
+                self._factor.Perm, self._factor.n, self._use_int32
+            )
+            self._perm.flags.writeable = False
         return self._perm
 
     @property
     def factor(self):
-        if self._factor_view is None:
-            self._factor_view = _csc_view_from_cholmod_factor(self)
-        return self._factor_view
+        # NOTE cache a weak reference, since the view has self as its base,
+        # and a reference cycle through a NumPy array is never garbage collected.
+        Lv = None if self._factor_view is None else self._factor_view()
+        if Lv is None:
+            Lv = _csc_view_from_cholmod_factor(self)
+            self._factor_view = weakref.ref(Lv)
+        return Lv
 
     @property
     def L(self):
@@ -1687,6 +1677,7 @@ cdef class CholeskyFactor:
         cf._stype = self._stype
         cf.sym_kind = self.sym_kind
         cf.rcond = self.rcond
+        cf._pattern = self._pattern
 
         return cf
 
@@ -1722,7 +1713,7 @@ cdef class CholeskyFactor:
         self._clear_cache()
 
         cdef int to_ll = (kind == "LL")
-        cdef int to_super = self._factor.is_super
+        cdef int to_super = self._factor.is_super and to_ll
         cdef int to_packed = True
         cdef int to_monotonic = self._factor.is_monotonic
 
@@ -1784,16 +1775,20 @@ cdef class CholeskyFactor:
         if lower is None:
             lower = self.is_lower
 
+        # Convert a copy of the factor if needed, so that this one is unchanged
+        same_kind = self.is_ll == (kind == "LL")
+        cf = self if same_kind and not self.is_super else self.copy()
+
         # Drop explicit zeros from returned copies
         if kind == "LL":
-            L = _csc_view_from_cholmod_factor(self, ldl=False).copy()
+            L = _csc_view_from_cholmod_factor(cf, ldl=False).copy()
             L.eliminate_zeros()
             if not lower:
                 L = L.T.conj()
             return L
         else:
             # Extract L and D from combined LD factor
-            L = _csc_view_from_cholmod_factor(self, ldl=True).copy()
+            L = _csc_view_from_cholmod_factor(cf, ldl=True).copy()
             D = diags_array(L.diagonal())
             L.setdiag(1.0)
             L.eliminate_zeros()
@@ -1887,7 +1882,17 @@ cdef class CholeskyFactor:
         """
         assert self._factor is not NULL, "The factor has not been initialized."
 
-        A, _, _ = validate_csc_input(A, ensure_double=False)
+        # Skip validation of a matrix with exactly the analyzed pattern, which
+        # is canonical, as is common when refactorizing
+        cdef bint same_pattern = (
+            issparse(A) and A.format == "csc" and A.dtype.kind in "fc"
+            and A.indptr.dtype == A.indices.dtype == self.itype
+            and A.data.shape == A.indices.shape and A.data.flags.c_contiguous
+            and self._has_pattern(A)
+        )
+        if not same_pattern:
+            A, _, _ = validate_csc_input(A, ensure_double=False, itype=self.itype)
+            same_pattern = self._has_pattern(A)
 
         if ldl is None:
             if self.is_numeric:
@@ -1898,12 +1903,26 @@ cdef class CholeskyFactor:
         if not isinstance(ldl, bool):
             raise ValueError("ldl must be a boolean value.")
 
+        # Check A as CHOLMOD does, since CHOLMOD may change the factor (e.g.,
+        # is_ll) before it rejects A, and the factor is converted below
+        n = A.shape[1] if self.sym_kind == "col" else A.shape[0]
+        if n != self.N or (self._stype != 0 and A.shape[0] != A.shape[1]) or (
+            self.is_numeric and A.dtype != self.dtype
+        ):
+            raise CholmodInvalidInputError("A does not match the factor.")
+
         # Clear cached properties
         self._clear_cache()
 
+        # A supernodal factor is LL.T only, and silently gives a wrong result
+        # for a matrix outside of the analyzed pattern, so use the simplicial
+        # algorithm instead.
+        if self._factor.is_super and ((ldl and self.is_numeric) or not same_pattern):
+            self._to_simplicial()
+
         # See CHOLMOD/MATLAB/ldlchol.c and/or lchol.c for details
         self._cm.final_asis = False
-        self._cm.final_super = False
+        self._cm.final_super = not ldl  # keep a supernodal LL.T factor
         self._cm.final_ll = not ldl  # LL.T for Cholesky, LDL.T for LDL
         self._cm.final_pack = True
         self._cm.final_monotonic = True
@@ -2109,7 +2128,7 @@ cdef class CholeskyFactor:
 
         cdef int stype = 0
 
-        b, _, _ = validate_csc_input(b, ensure_double=False)
+        b, _, _ = validate_csc_input(b, ensure_double=False, itype=self.itype)
 
         _cholmod_sparse_from_csc(
             b.shape, b.indptr, b.indices, b.data, stype, <uintptr_t>&Bspmatrix
@@ -2203,7 +2222,7 @@ cdef class CholeskyFactor:
             C = C.reshape((-1, 1)).tocsc()  # (N, 1)
 
         cdef int stype = 0  # use all of C
-        C, _, _ = validate_csc_input(C, ensure_double=False)
+        C, _, _ = validate_csc_input(C, ensure_double=False, itype=self.itype)
 
         cdef cholmod_sparse Cmatrix
         cdef cholmod_sparse* Cc = &Cmatrix
@@ -2256,6 +2275,7 @@ cdef class CholeskyFactor:
             cholmod_l_free_sparse(&C_perm, self._cm)
 
         if not ok:
+            _handle_errors(self._cm.status)
             raise CholmodError("Update or downdate failed.")
 
         return self
@@ -2313,7 +2333,7 @@ cdef class CholeskyFactor:
         if C.ndim == 1:
             C = C.reshape((-1, 1)).tocsc()  # (N, 1)
 
-        C, _, _ = validate_csc_input(C, ensure_double=False)
+        C, _, _ = validate_csc_input(C, ensure_double=False, itype=self.itype)
         _cholmod_sparse_from_csc(
             C.shape, C.indptr, C.indices, C.data, stype, <uintptr_t>&Cmatrix
         )
@@ -2327,6 +2347,7 @@ cdef class CholeskyFactor:
             ok = cholmod_l_rowadd(k, Cc, self._factor, self._cm)
 
         if not ok:
+            _handle_errors(self._cm.status)
             raise CholmodError("cholmod_rowadd failed.")
 
         return self
@@ -2368,6 +2389,7 @@ cdef class CholeskyFactor:
             ok = cholmod_l_rowdel(k, NULL, self._factor, self._cm)
 
         if not ok:
+            _handle_errors(self._cm.status)
             raise CholmodError("cholmod_rowdel failed.")
 
         return self
@@ -2416,21 +2438,16 @@ cdef class CholeskyFactor:
         """
         self._require_factorized()
 
-        cdef bint A_use_int32
         # TODO support non-square matrices with sym_kind='row'
-        A, A_use_int32, _ = validate_csc_input(A, require_square=True, ensure_double=False)
+        A, _, _ = validate_csc_input(
+            A, require_square=True, ensure_double=False, itype=self.itype
+        )
 
         if A.shape[0] != self.N:
             raise ValueError(
                 "Input matrix A must have the same number of rows as L."
             )
 
-        if self._use_int32 and not A_use_int32:
-            raise ValueError(
-                "A and factor must have the same integer type. "
-                f"Got {A.indptr.dtype=}, but {self._use_int32=}."
-            )
-
         # Special Cases
         if self.N == 0:
             return self
@@ -2441,6 +2458,8 @@ cdef class CholeskyFactor:
         # Clear cached properties
         self._clear_cache()
 
+        self._to_simplicial()  # CHOLMOD cannot resymbol a supernodal factor
+
         # Get sparse *pattern*
         cdef cholmod_sparse Amatrix
         cdef cholmod_sparse* Ac = &Amatrix
@@ -2466,6 +2485,7 @@ cdef class CholeskyFactor:
             else:
                 cholmod_l_resymbol(Ac, NULL, 0, True, self._factor, self._cm)
 
+        _handle_errors(self._cm.status)
         return self
 
     def logdet(self):
@@ -2502,12 +2522,25 @@ cdef class CholeskyFactor:
         .. versionadded:: 0.2
         """
         self._require_factorized()
-        if self.is_ll:
-            L = self.get_factor()
-            return 2 * np.sum(np.log(L.diagonal()))
+        cdef cholmod_factor *L = self._factor
+        cdef int it = _np_itypenum_from_cholmod(L.itype)
+        cdef int dt = _np_dtypenum_from_cholmod(L.xtype, L.dtype)
+        # The diagonal of L (or D) is the first entry of each column of
+        # a simplicial factor. A supernodal factor stores each supernode as
+        # a dense column-major block with nsrow rows. See cholmod_rcond.c.
+        if L.is_super:
+            S = cnp.PyArray_SimpleNewFromData(1, [L.nsuper + 1], it, L.super)
+            pi = cnp.PyArray_SimpleNewFromData(1, [L.nsuper + 1], it, L.pi)
+            px = cnp.PyArray_SimpleNewFromData(1, [L.nsuper + 1], it, L.px)
+            x = cnp.PyArray_SimpleNewFromData(1, [L.xsize], dt, L.x)
+            s = np.repeat(np.arange(L.nsuper), np.diff(S))
+            j = np.arange(L.n) - S[s]
+            d = x[px[s] + j * (np.diff(pi)[s] + 1)]
         else:
-            _, D = self.get_factor()
-            return np.sum(np.log(D.diagonal()))
+            Lp = cnp.PyArray_SimpleNewFromData(1, [L.n + 1], it, L.p)
+            x = cnp.PyArray_SimpleNewFromData(1, [L.nzmax], dt, L.x)
+            d = x[Lp[:-1]]
+        return (2 if self.is_ll else 1) * np.sum(np.log(d))
 
     def slogdet(self):
         """Compute the sign and (natural) log-determinant of the matrix from

{scikit_sparse-0.5.0 → scikit_sparse-0.5.1}/src/sksparse/utils.py

@@ -20,7 +20,7 @@ from scipy.sparse import SparseEfficiencyWarning, csc_array, issparse
 _HAS_SCIPY_SORT_BUG = version.parse(scipy_version) < version.parse("1.17.0")
 
 
-def validate_csc_input(A, require_square=False, ensure_double=True):
+def validate_csc_input(A, require_square=False, ensure_double=True, itype=None):
     """Validate and convert input matrix to CSC format.
 
     Integer and boolean data types are converted to float32 by default.
@@ -39,6 +39,8 @@ def validate_csc_input(A, require_square=False, ensure_double=True):
         Otherwise, it will retain its original floating-point precision
         (float32 or complex64), or the minimum precision required to convert
         integer or boolean types.
+    itype : dtype, optional
+        If given, the index arrays are converted to this integer type.
 
     Returns
     -------
@@ -114,6 +116,12 @@ def validate_csc_input(A, require_square=False, ensure_double=True):
     if not (A.has_sorted_indices and A.has_canonical_format):
         raise ValueError("Failed to convert input to canonical CSC format.")
 
+    # NOTE set the index arrays after construction, since the constructor
+    # may choose a different index type.
+    if itype is not None and not (A.indptr.dtype == A.indices.dtype == itype):
+        A = csc_array((A.data, A.indices, A.indptr), shape=A.shape)
+        A.indptr, A.indices = A.indptr.astype(itype), A.indices.astype(itype)
+
     # Choose index width: int32 or int64
     use_int32 = A.indptr.dtype == np.int32 and A.indices.dtype == np.int32
     out_itype = np.dtype(np.int32 if use_int32 else np.int64)