sparseqr 1.2.1__tar.gz → 1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sparseqr
-Version: 1.2.1
+Version: 1.3
 Summary: Python wrapper for SuiteSparseQR
 License: Public Domain CC0
 Author: Yotam Gingold
@@ -12,6 +12,9 @@ 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.1 → sparseqr-1.3}/README.md

@@ -59,19 +59,19 @@ 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]
-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 ]
 ```
 
@@ -138,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
 
@@ -148,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.1 → sparseqr-1.3}/pyproject.toml

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

{sparseqr-1.2.1 → 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.1'
+__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.1 → sparseqr-1.3}/sparseqr/sparseqr.py

@@ -351,6 +351,77 @@ def qr( A, tolerance = None, economy = None ):
     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.1 → 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.1 → sparseqr-1.3}/test/test.py

@@ -64,3 +64,16 @@ 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.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)