sparseqr 1.2__tar.gz → 1.3__tar.gz

{sparseqr-1.2 → sparseqr-1.3}/PKG-INFO

@@ -1,17 +1,20 @@
 Metadata-Version: 2.1
 Name: sparseqr
-Version: 1.2
+Version: 1.3
 Summary: Python wrapper for SuiteSparseQR
 License: Public Domain CC0
 Author: Yotam Gingold
 Author-email: yotam@yotamgingold.com
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: cffi (>=1.0,<2.0)
-Requires-Dist: numpy (>=1.21,<2.0)
+Requires-Dist: numpy (>1.2)
 Requires-Dist: scipy (>=1.0,<2.0)
+Requires-Dist: setuptools (>35)

{sparseqr-1.2 → sparseqr-1.3}/README.md

@@ -20,7 +20,7 @@ import sparseqr
 #
 M = scipy.sparse.rand( 10, 10, density = 0.1 )
 Q, R, E, rank = sparseqr.qr( M )
-print( abs( Q*R - M*sparseqr.permutation_vector_to_matrix(E) ).sum() )  # should be approximately zero
+print( "Should be approximately zero:", abs( Q*R - M*sparseqr.permutation_vector_to_matrix(E) ).sum() ) 
 
 # Solve many linear systems "M x = b for b in columns(B)"
 #
@@ -34,6 +34,8 @@ x = sparseqr.solve( M, B, tolerance = 0 )
 A = scipy.sparse.rand( 20, 10, density = 0.1 )  # 20 equations, 10 unknowns
 b = numpy.random.random(20)  # one RHS, dense, but could also have many (in shape (20,k))
 x = sparseqr.solve( A, b, tolerance = 0 )
+## Call `rz()`:
+sparseqr.rz( A, b, tolerance = 0 )
 
 # Solve a linear system  M x = B  via QR decomposition
 #
@@ -45,31 +47,31 @@ Q, R, E, rank = sparseqr.qr( M )
 r = rank  # r could be min(M.shape) if M is full-rank
 
 # The system is only solvable if the lower part of Q.T @ B is all zero:
-print( "System is solvable if this is zero:", abs( (( Q.tocsc()[:,r:] ).T ).dot( B ) ).sum() )
+print( "System is solvable if this is zero (unlikely for a random matrix):", abs( (( Q.tocsc()[:,r:] ).T ).dot( B ) ).sum() )
 
 # Systems with large non-square matrices can benefit from "economy" decomposition.
 M = scipy.sparse.rand( 20, 5, density=0.1 )
 B = scipy.sparse.rand( 20, 5, density = 0.1 )
 Q, R, E, rank = sparseqr.qr( M )
-print("Q shape:", Q.shape)  # Q shape: (20, 20)
-print("R shape:", R.shape)  # R shape: (20, 5)
+print("Q shape (should be 20x20):", Q.shape)
+print("R shape (should be 20x5):", R.shape)
 Q, R, E, rank = sparseqr.qr( M, economy=True )
-print("Q shape:", Q.shape)  # Q shape: (20, 5)
-print("R shape:", R.shape)  # R shape: (5, 5)
+print("Q shape (should be 20x5):", Q.shape)
+print("R shape (should be 5x5):", R.shape)
 
-# Use CSC format for fast indexing of columns.
-R = R.tocsc()[:r,:r]
-Q = Q.tocsc()[:,:r]
-QB = (Q.T).dot(B).tocsc()  # for best performance, spsolve() wants the RHS to be in CSC format.
-result = scipy.sparse.linalg.spsolve(R, QB)
+
+R = R.tocsr()[:r,:r] #for best performance, spsolve_triangular() wants the Matrix to be in CSR format.
+Q = Q.tocsc()[:,:r] # Use CSC format for fast indexing of columns.
+QB = (Q.T).dot(B).todense()  # spsolve_triangular() need the RHS in array format.
+result = scipy.sparse.linalg.spsolve_triangular(R, QB, lower=False)
 
 # Recover a solution (as a dense array):
 x = numpy.zeros( ( M.shape[1], B.shape[1] ), dtype = result.dtype )
-x[:r] = result.todense()
+x[:r] = result
 x[E] = x.copy()
 
 # Recover a solution (as a sparse matrix):
-x = scipy.sparse.vstack( ( result.tocoo(), scipy.sparse.coo_matrix( ( M.shape[1] - rank, B.shape[1] ), dtype = result.dtype ) ) )
+x = scipy.sparse.vstack( ( result, scipy.sparse.coo_matrix( ( M.shape[1] - rank, B.shape[1] ), dtype = result.dtype ) ) )
 x.row = E[ x.row ]
 ```
 
@@ -115,16 +117,20 @@ or leave them in their directory and call it as a module.
 
 1. Change the version in:
 
+    ```
     sparseqr/__init__.py
-    setup.py 
-    pyproject.toml 
+    setup.py
+    pyproject.toml
+    ```
 
 2. Update `CHANGELOG.md`
 
 3. Run:
 
+    ```
     poetry build -f sdist
     poetry publish
+    ```
 
 # Known issues
 
@@ -132,9 +138,9 @@ or leave them in their directory and call it as a module.
 
 # Tested on
 
- - Python 2.7, 3.4, 3.5, and 3.9.
+ - Python 2.7, 3.4, 3.5, 3.9, 3.13.
  - Conda and not conda.
- - Mac OS X, Ubuntu Linux and Linux Mint.
+ - macOS, Ubuntu Linux, and Linux Mint.
 
     PYTHONPATH='.:$PYTHONPATH' python3 test/test.py
 
@@ -142,7 +148,7 @@ or leave them in their directory and call it as a module.
 
 * [SciPy/NumPy](http://www.scipy.org)
 * [SuiteSparseQR](http://faculty.cse.tamu.edu/davis/suitesparse.html) (macOS: `brew install suitesparse`; debian/ubuntu linux: `apt-get install libsuitesparse-dev`)
-* [cffi](http://cffi.readthedocs.io/) (`pip install cffi`)
+* [cffi](http://cffi.readthedocs.io/)
 
 # License
 

{sparseqr-1.2 → sparseqr-1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sparseqr"
-version = "1.2"
+version = "1.3"
 description = "Python wrapper for SuiteSparseQR"
 authors = ["Yotam Gingold <yotam@yotamgingold.com>"]
 license = "Public Domain CC0"
@@ -9,10 +9,11 @@ include = ["test/*.py", "README.md", "LICENSE.md"]
 exclude = ["sparseqr/_sparseqr*"]
 
 [tool.poetry.dependencies]
-python = "^3.7"
-numpy = "^1.21"
+python = "^3.8"
+numpy = ">1.2"
 scipy = "^1.0"
 cffi = "^1.0"
+setuptools = ">35"
 
 [tool.poetry.dev-dependencies]
 

{sparseqr-1.2 → sparseqr-1.3}/sparseqr/__init__.py

@@ -17,8 +17,8 @@ See the docstrings of the individual functions for details.
 
 from __future__ import absolute_import
 
-__version__ = '1.2'
+__version__ = '1.3'
 
 # import the important things into the package's top-level namespace.
-from .sparseqr import qr, rz, solve, permutation_vector_to_matrix
+from .sparseqr import qr, rz, solve, permutation_vector_to_matrix, qr_factorize,qmult
 

{sparseqr-1.2 → sparseqr-1.3}/sparseqr/sparseqr.py

@@ -240,6 +240,8 @@ def rz(A, B, tolerance = None):
     ## Free cholmod stuff
     cholmod_free_dense( chol_Z[0] )
     cholmod_free_sparse( chol_R[0] )
+    cholmod_free_sparse( chol_A )
+    cholmod_free_dense(  chol_b )
 
     return scipy_Z, scipy_R, E, rank
 
@@ -342,12 +344,84 @@ def qr( A, tolerance = None, economy = None ):
     ## Free cholmod stuff
     cholmod_free_sparse( chol_Q[0] )
     cholmod_free_sparse( chol_R[0] )
+    cholmod_free_sparse( chol_A )
     ## Apparently we don't need to do this. (I get a malloc error.)
     # lib.cholmod_l_free( A.shape[1], ffi.sizeof("SuiteSparse_long"), chol_E, cc )
 
     return scipy_Q, scipy_R, E, rank
 
 
+def qr_factorize( A, tolerance = None):
+    '''
+    Given a sparse matrix A,
+    returns a QR factorization in householder form    
+
+    If optional `tolerance` parameter is negative, it has the following meanings:
+        #define SPQR_DEFAULT_TOL ...       /* if tol <= -2, the default tol is used */
+        #define SPQR_NO_TOL ...            /* if -2 < tol < 0, then no tol is used */
+
+    For A an m-by-n matrix, Q will be m-by-m and R will be m-by-n.
+
+        The performance-optimal format for A is scipy.sparse.coo_matrix.
+
+    '''
+
+    chol_A = scipy2cholmodsparse( A )
+
+    if tolerance is None: tolerance = lib.SPQR_DEFAULT_TOL
+
+    QR = lib.SuiteSparseQR_C_factorize(
+        ## Input
+        lib.SPQR_ORDERING_DEFAULT,
+        tolerance,
+        chol_A,
+        cc
+        )
+
+    cholmod_free_sparse( chol_A )
+    ## Apparently we don't need to do this. (I get a malloc error.)
+    # lib.cholmod_l_free( A.shape[1], ffi.sizeof("SuiteSparse_long"), chol_E, cc )
+
+    return QR
+
+
+def qmult( QR, X, method=1):
+    '''
+    Given a QR factorization struct
+        a dense matrix
+    returns Q applied to X in a dense matrix    
+
+    From the suitesparse documentation:
+    /*
+    Applies Q in Householder form (as stored in the QR factorization object
+    returned by SuiteSparseQR_C_factorize) to a dense matrix X.
+
+    method SPQR_QTX (0): Y = Q'*X
+    method SPQR_QX  (1): Y = Q*X
+    method SPQR_XQT (2): Y = X*Q'
+    method SPQR_XQ  (3): Y = X*Q
+    */
+
+    '''
+
+    chol_X = numpy2cholmoddense(  X )
+
+    chol_Y = lib.SuiteSparseQR_C_qmult(
+        ## Input
+        method, 
+        QR,
+        chol_X,
+        cc
+        )
+    numpy_Y = cholmoddense2numpy( chol_Y )
+
+    ## Free cholmod stuff
+    cholmod_free_dense(  chol_X )
+    cholmod_free_dense(  chol_Y )
+
+    return numpy_Y
+
+
 def solve( A, b, tolerance = None ):
     '''
     Given a sparse m-by-n matrix A, and dense or sparse m-by-k matrix (storing k RHS vectors) b,

{sparseqr-1.2 → sparseqr-1.3}/sparseqr/sparseqr_gen.py

@@ -21,14 +21,20 @@ else:
     include_dirs.append( '/usr/include/suitesparse' )
     ## Homebrew on macOS arm64 puts headers and libraries
     ## in `/opt/homebrew`. That's not on the default path, so add them:
+    include_dirs.append( '/opt/homebrew/include/suitesparse' )
+    # Does this work for anyone? At one point I thought it worked for me, but maybe I didn't test properly.
     include_dirs.append( '/opt/homebrew/include' )
     library_dirs.append( '/opt/homebrew/lib' )
 
 # for compatibility with conda envs
 if 'CONDA_DEFAULT_ENV' in os.environ:
     homedir = expanduser("~")
-    include_dirs.append( join(homedir, 'anaconda3', 'envs', os.environ['CONDA_DEFAULT_ENV'], 'Library', 'include', 'suitesparse') )
-    include_dirs.append( join(homedir, 'miniconda3', 'envs', os.environ['CONDA_DEFAULT_ENV'], 'Library', 'include', 'suitesparse') )
+
+    for packager in ['anaconda3','miniconda3','condaforge','miniforge','mambaforge']:
+        for sub in ['','Library']:
+            thedir=join(homedir, packager, 'envs', os.environ['CONDA_DEFAULT_ENV'], sub, 'include', 'suitesparse')
+            if os.path.isdir(thedir):
+                include_dirs.append(thedir)
 
 if platform.system() == 'Windows':
     # https://github.com/yig/PySPQR/issues/6
@@ -362,6 +368,105 @@ cholmod_sparse *SuiteSparseQR_C_backslash_sparse   /* returns X, or NULL */
     cholmod_common *cc          /* workspace and parameters */
 ) ;
 
+/* ========================================================================== */
+/* === SuiteSparseQR_C_factorization ======================================== */
+/* ========================================================================== */
+
+/* A real or complex QR factorization, computed by SuiteSparseQR_C_factorize */
+typedef struct SuiteSparseQR_C_factorization_struct
+{
+    int xtype ;                 /* CHOLMOD_REAL or CHOLMOD_COMPLEX */
+    void *factors ;             /* from SuiteSparseQR_factorize <double> or
+                                        SuiteSparseQR_factorize <Complex> */
+
+} SuiteSparseQR_C_factorization ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_factorize ============================================ */
+/* ========================================================================== */
+
+SuiteSparseQR_C_factorization *SuiteSparseQR_C_factorize
+(
+    /* inputs: */
+    int ordering,               /* all, except 3:given treated as 0:fixed */
+    double tol,                 /* columns with 2-norm <= tol treated as 0 */
+    cholmod_sparse *A,          /* m-by-n sparse matrix */
+    cholmod_common *cc          /* workspace and parameters */
+) ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_symbolic ============================================= */
+/* ========================================================================== */
+
+SuiteSparseQR_C_factorization *SuiteSparseQR_C_symbolic
+(
+    /* inputs: */
+    int ordering,               /* all, except 3:given treated as 0:fixed */
+    int allow_tol,              /* if TRUE allow tol for rank detection */
+    cholmod_sparse *A,          /* m-by-n sparse matrix, A->x ignored */
+    cholmod_common *cc          /* workspace and parameters */
+) ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_numeric ============================================== */
+/* ========================================================================== */
+
+int SuiteSparseQR_C_numeric
+(
+    /* inputs: */
+    double tol,                 /* treat columns with 2-norm <= tol as zero */
+    cholmod_sparse *A,          /* sparse matrix to factorize */
+    /* input/output: */
+    SuiteSparseQR_C_factorization *QR,
+    cholmod_common *cc          /* workspace and parameters */
+) ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_free ================================================= */
+/* ========================================================================== */
+
+/* Free the QR factors computed by SuiteSparseQR_C_factorize */
+int SuiteSparseQR_C_free        /* returns TRUE (1) if OK, FALSE (0) otherwise*/
+(
+    SuiteSparseQR_C_factorization **QR,
+    cholmod_common *cc          /* workspace and parameters */
+) ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_solve ================================================ */
+/* ========================================================================== */
+
+cholmod_dense* SuiteSparseQR_C_solve    /* returnx X, or NULL if failure */
+(
+    int system,                 /* which system to solve */
+    SuiteSparseQR_C_factorization *QR,  /* of an m-by-n sparse matrix A */
+    cholmod_dense *B,           /* right-hand-side, m-by-k or n-by-k */
+    cholmod_common *cc          /* workspace and parameters */
+) ;
+
+/* ========================================================================== */
+/* === SuiteSparseQR_C_qmult ================================================ */
+/* ========================================================================== */
+
+/*
+    Applies Q in Householder form (as stored in the QR factorization object
+    returned by SuiteSparseQR_C_factorize) to a dense matrix X.
+
+    method SPQR_QTX (0): Y = Q'*X
+    method SPQR_QX  (1): Y = Q*X
+    method SPQR_XQT (2): Y = X*Q'
+    method SPQR_XQ  (3): Y = X*Q
+*/
+
+cholmod_dense *SuiteSparseQR_C_qmult /* returns Y, or NULL on failure */
+(
+    /* inputs: */
+    int method,                 /* 0,1,2,3 */
+    SuiteSparseQR_C_factorization *QR,  /* of an m-by-n sparse matrix A */
+    cholmod_dense *X,           /* size m-by-n with leading dimension ldx */
+    cholmod_common *cc          /* workspace and parameters */
+) ;   
+                        
 #define SPQR_ORDERING_FIXED ...
 #define SPQR_ORDERING_NATURAL ...
 #define SPQR_ORDERING_COLAMD ...

{sparseqr-1.2 → sparseqr-1.3}/test/test.py

@@ -25,6 +25,8 @@ x = sparseqr.solve( M, B, tolerance = 0 )
 A = scipy.sparse.rand( 20, 10, density = 0.1 )  # 20 equations, 10 unknowns
 b = numpy.random.random(20)  # one RHS, dense, but could also have many (in shape (20,k))
 x = sparseqr.solve( A, b, tolerance = 0 )
+## Call `rz()`:
+sparseqr.rz( A, b, tolerance = 0 )
 
 # Solve a linear system  M x = B  via QR decomposition
 #
@@ -38,6 +40,16 @@ r = rank  # r could be min(M.shape) if M is full-rank
 # The system is only solvable if the lower part of Q.T @ B is all zero:
 print( "System is solvable if this is zero (unlikely for a random matrix):", abs( (( Q.tocsc()[:,r:] ).T ).dot( B ) ).sum() )
 
+# Systems with large non-square matrices can benefit from "economy" decomposition.
+M = scipy.sparse.rand( 20, 5, density=0.1 )
+B = scipy.sparse.rand( 20, 5, density = 0.1 )
+Q, R, E, rank = sparseqr.qr( M )
+print("Q shape (should be 20x20):", Q.shape)
+print("R shape (should be 20x5):", R.shape)
+Q, R, E, rank = sparseqr.qr( M, economy=True )
+print("Q shape (should be 20x5):", Q.shape)
+print("R shape (should be 5x5):", R.shape)
+
 # Use CSC format for fast indexing of columns.
 R = R.tocsc()[:r,:r]
 Q = Q.tocsc()[:,:r]
@@ -53,3 +65,15 @@ x[E] = x.copy()
 x = scipy.sparse.vstack( ( result.tocoo(), scipy.sparse.coo_matrix( ( M.shape[1] - rank, B.shape[1] ), dtype = result.dtype ) ) )
 x.row = E[ x.row ]
 
+#initialize QR Factorization object
+M = scipy.sparse.rand( 100, 100, density=0.05 )
+
+#perform QR factorization, but store in Householder form
+QR= sparseqr.qr_factorize( M )
+X = numpy.zeros((M.shape[0],1))
+#change last entry of the first column to a 1 
+# this allows us to construct only the first column of Q
+X[-1,0]=1 
+
+Y = sparseqr.qmult(QR,X)
+print("Y shape (should be 100x1):",Y.shape)

sparseqr-1.2/setup.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['sparseqr']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['cffi>=1.0,<2.0', 'numpy>=1.21,<2.0', 'scipy>=1.0,<2.0']
-
-setup_kwargs = {
-    'name': 'sparseqr',
-    'version': '1.2',
-    'description': 'Python wrapper for SuiteSparseQR',
-    'long_description': None,
-    'author': 'Yotam Gingold',
-    'author_email': 'yotam@yotamgingold.com',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': None,
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.7,<4.0',
-}
-
-
-setup(**setup_kwargs)