sparseqr 1.2.1__tar.gz → 1.4__tar.gz

sparseqr-1.4/.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+*.pyo
+_spqr.*

sparseqr-1.4/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [v1.4] - 2025-01-28
+### Fixed
+- Modernized the build system (`pyproject.toml`).
+- Changed the way suite-sparse is found to be more robust.
+
+## [v1.3] - 2025-01-09
+### Added
+- Bindings for `qr_factorize` and `qmult` (thanks to jkrokowski)
+
+### Fixed
+- Compatibility with more environments (more search paths, newer numpy, setuptools dependency)
+- Readme example uses `spsolve_triangular`.
+
+## [v1.2.1] - 2023-04-12
+### Fixed
+- Fixed a memory leak in `qr()` and `rz()`.
+### Changed
+- Bumped minimal Python version to 3.8.
+- `rz()` is called by the test script. Its output is ignored.
+
+## [v1.2] - 2022-05-27
+### Added
+- Added support for partial "economy" decompositions. (Christoph Hansknecht <c.hansknecht@tu-braunschweig.de>): 'The "economy" option can be used in SPQR to compute a QR factorization of a (m x n) matrix with m < n consisting of blocks Q_1, and Q_2, where Q_1 has as shape of (m x n) and Q_2 of (m x k - n). For k = n we get the reduced form, for k = m the full one. For k in between m and n, SPQR yields a block that spans part of the kernel of A. This patch adds this functionality to PySPQR.'
+- Added support for macOS on arm64.
+
+## [v1.1.2] - 2021-08-09
+### Added
+- Added rz recomposition (thanks to Ben Smith <bsmith@apl.washington.edu>)
+- Added support for "economy" decomposition. (Jeffrey Bouas <ignirtoq@gmail.com>)
+### Changed
+- Supports conda environments (thanks to Ben Smith <bsmith@apl.washington.edu> and Sterling Baird <sterling.baird@icloud.com>)
+
+## [v1.0.0] - 2017-08-31
+### Added
+ - Installation and packaging using `setuptools`
+### Changed
+ - Rename module `spqr` to `sparseqr`
+ - Clean up public API: `qr`, `solve`, `permutation_vector_to_matrix`
+
+## [v1.0.0] - 2017-08-31
+### Added
+ - Installation and packaging using `setuptools` (thanks to Juha Jeronen <juha.jeronen@tut.fi>)
+### Changed
+ - Rename module `spqr` to `sparseqr`
+ - Clean up public API: `qr`, `solve`, `permutation_vector_to_matrix`

sparseqr-1.4/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.3
+Name: sparseqr
+Version: 1.4
+Summary: Python wrapper for SuiteSparseQR
+Keywords: suitesparse,bindings,wrapper,scipy,numpy,qr-decomposition,qr-factorisation,sparse-matrix,sparse-linear-system,sparse-linear-solver
+Author-email: Yotam Gingold <yotam@yotamgingold.com>
+Requires-Python: >= 3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy >1.2
+Requires-Dist: scipy >= 1.0
+Requires-Dist: cffi >= 1.0
+Requires-Dist: setuptools >35
+Project-URL: homepage, https://github.com/yig/PySPQR
+Project-URL: source, https://github.com/yig/PySPQR
+
+# Python wrapper for SuiteSparseQR
+
+This module wraps the [SuiteSparseQR](http://faculty.cse.tamu.edu/davis/suitesparse.html)
+decomposition function for use with [SciPy](http://www.scipy.org).
+This is Matlab's sparse `[Q,R,E] = qr()`.
+For some reason, no one ever wrapped that function of SuiteSparseQR for Python.
+
+Also wrapped are the SuiteSparseQR solvers for ``A x = b`` for the cases with sparse `A` and dense or sparse `b`.
+This is especially useful for solving sparse overdetermined linear systems in the least-squares sense.
+Here `A` is of size m-by-n and `b` is m-by-k (storing `k` different right-hand side vectors, each considered separately).
+
+# Usage
+
+```python
+import numpy
+import scipy.sparse.linalg
+import sparseqr
+
+# QR decompose a sparse matrix M such that  Q R = M E
+#
+M = scipy.sparse.rand( 10, 10, density = 0.1 )
+Q, R, E, rank = sparseqr.qr( M )
+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)"
+#
+B = scipy.sparse.rand( 10, 5, density = 0.1 )  # many RHS, sparse (could also have just one RHS with shape (10,))
+x = sparseqr.solve( M, B, tolerance = 0 )
+
+# Solve an overdetermined linear system  A x = b  in the least-squares sense
+#
+# The same routine also works for the usual non-overdetermined case.
+#
+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
+#
+# This approach is slow due to the explicit construction of Q, but may be
+# useful if a large number of systems need to be solved with the same M.
+#
+M = scipy.sparse.rand( 10, 10, density = 0.1 )
+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 (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)
+
+
+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
+x[E] = x.copy()
+
+# Recover a solution (as a sparse matrix):
+x = scipy.sparse.vstack( ( result, scipy.sparse.coo_matrix( ( M.shape[1] - rank, B.shape[1] ), dtype = result.dtype ) ) )
+x.row = E[ x.row ]
+```
+
+# Installation
+
+Before installing this module, you must first install [SuiteSparseQR](http://faculty.cse.tamu.edu/davis/suitesparse.html). You can do that via conda (`conda install suitesparse`) or your system's package manager (macOS: `brew install suitesparse`; debian/ubuntu linux: `apt-get install libsuitesparse-dev`).
+
+Now you are ready to install this module.
+
+## Via `pip`
+
+From PyPI:
+
+```bash
+pip install sparseqr
+```
+
+From GitHub:
+
+```bash
+pip install git+https://github.com/yig/PySPQR.git
+```
+
+## Directly
+
+Copy the three `sparseqr/*.py` files next to your source code,
+or leave them in their directory and call it as a module.
+
+
+# Deploy
+
+1. Change the version in:
+
+    ```
+    sparseqr/__init__.py
+    pyproject.toml
+    ```
+
+2. Update `CHANGELOG.md`
+
+3. Run:
+
+    ```
+    flit publish --format sdist
+    ```
+
+We don't publish binary wheels, because it must be compiled against suite-sparse as a system dependency. We could publish a `none-any` wheel, which would cause compilation to happen the first time the module is imported rather than when it is installed. Is there a point to that?
+
+# Known issues
+
+`pip uninstall sparseqr` won't remove the generated libraries. It will list them with a warning.
+
+# Tested on
+
+ - Python 3.9, 3.13.
+ - Conda and not conda.
+ - macOS, Ubuntu Linux, and Linux Mint.
+
+    PYTHONPATH='.:$PYTHONPATH' python3 test/test.py
+
+# Dependencies
+
+These are installed via pip:
+
+* [SciPy/NumPy](http://www.scipy.org)
+* [cffi](http://cffi.readthedocs.io/)
+
+These must be installed manually:
+
+* [SuiteSparseQR](http://faculty.cse.tamu.edu/davis/suitesparse.html) (macOS: `brew install suitesparse`; debian/ubuntu linux: `apt-get install libsuitesparse-dev`)
+
+# License
+
+Public Domain [CC0](http://creativecommons.org/publicdomain/zero/1.0/)
+

{sparseqr-1.2.1 → sparseqr-1.4}/README.md

@@ -59,24 +59,28 @@ 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 ]
 ```
 
 # Installation
 
+Before installing this module, you must first install [SuiteSparseQR](http://faculty.cse.tamu.edu/davis/suitesparse.html). You can do that via conda (`conda install suitesparse`) or your system's package manager (macOS: `brew install suitesparse`; debian/ubuntu linux: `apt-get install libsuitesparse-dev`).
+
+Now you are ready to install this module.
+
 ## Via `pip`
 
 From PyPI:
@@ -91,22 +95,6 @@ From GitHub:
 pip install git+https://github.com/yig/PySPQR.git
 ```
 
-## Manually from GitHub
-
-As user:
-
-```bash
-git clone https://github.com/yig/PySPQR.git
-cd PySPQR
-python setup.py install --user
-```
-
-As admin, change the last command to
-
-```bash
-sudo python setup.py install
-```
-
 ## Directly
 
 Copy the three `sparseqr/*.py` files next to your source code,
@@ -119,7 +107,6 @@ or leave them in their directory and call it as a module.
 
     ```
     sparseqr/__init__.py
-    setup.py
     pyproject.toml
     ```
 
@@ -128,27 +115,33 @@ or leave them in their directory and call it as a module.
 3. Run:
 
     ```
-    poetry build -f sdist
-    poetry publish
+    flit publish --format sdist
     ```
 
+We don't publish binary wheels, because it must be compiled against suite-sparse as a system dependency. We could publish a `none-any` wheel, which would cause compilation to happen the first time the module is imported rather than when it is installed. Is there a point to that?
+
 # Known issues
 
 `pip uninstall sparseqr` won't remove the generated libraries. It will list them with a warning.
 
 # Tested on
 
- - Python 2.7, 3.4, 3.5, and 3.9.
+ - Python 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
 
 # Dependencies
 
+These are installed via pip:
+
 * [SciPy/NumPy](http://www.scipy.org)
+* [cffi](http://cffi.readthedocs.io/)
+
+These must be installed manually:
+
 * [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`)
 
 # License
 

sparseqr-1.4/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "sparseqr"
+version = "1.4"
+description = "Python wrapper for SuiteSparseQR"
+authors = [{name = "Yotam Gingold", email = "yotam@yotamgingold.com"}]
+license = {text = "Public Domain CC0"}
+readme = "README.md"
+keywords = ["suitesparse", "bindings", "wrapper", "scipy", "numpy", "qr-decomposition", "qr-factorisation", "sparse-matrix", "sparse-linear-system", "sparse-linear-solver"]
+
+requires-python = ">= 3.8"
+
+dependencies = [
+    "numpy >1.2",
+    "scipy >= 1.0",
+    "cffi >= 1.0",
+    "setuptools >35",
+]
+
+[project.urls]
+homepage = "https://github.com/yig/PySPQR"
+source = "https://github.com/yig/PySPQR"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+#[tool.setuptools.packages.find]
+# include = ["test/*.py", "README.md", "LICENSE.md"]
+#exclude = ["sparseqr/_sparseqr*"]

sparseqr-1.4/setup.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+#
+from __future__ import division, print_function, absolute_import
+
+from setuptools import setup #, dist
+import os
+
+setup(
+    # See
+    #    http://setuptools.readthedocs.io/en/latest/setuptools.html
+    #
+    setup_requires = ["cffi>=1.0.0"],
+    cffi_modules = ["sparseqr/sparseqr_gen.py:ffibuilder"],
+    install_requires = ["cffi>=1.0.0"],
+)

{sparseqr-1.2.1 → sparseqr-1.4}/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.4'
 
 # 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.4}/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.4}/sparseqr/sparseqr_gen.py

@@ -4,9 +4,7 @@ License: Public Domain [CC0](http://creativecommons.org/publicdomain/zero/1.0/)
 Description: Wrapper for SuiteSparse qr() and solve() functions. Matlab and Julia have it, Python should have it, too.
 '''
 
-from __future__ import print_function, division, absolute_import
 import os
-from os.path import join, expanduser
 import platform
 
 from cffi import FFI
@@ -15,20 +13,21 @@ include_dirs = []
 library_dirs = []
 libraries = ['spqr']
 
-if platform.system() == 'Windows':
-    include_dirs.append( join('C:', 'Program Files', 'Python', 'suitesparse') )
+## If we're using conda, use the conda paths
+if 'CONDA_PREFIX' in os.environ:
+    include_dirs.append( os.path.join(os.environ['CONDA_PREFIX'], 'include', 'suitesparse') )
+    library_dirs.append( os.path.join(os.environ['CONDA_PREFIX'], 'lib') )
+
+## Otherwise, add common system-wide directories
 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' )
-    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') )
+    if platform.system() == 'Windows':
+        include_dirs.append( join('C:', 'Program Files', 'Python', 'suitesparse') )
+    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' )
+        library_dirs.append( '/opt/homebrew/lib' )
 
 if platform.system() == 'Windows':
     # https://github.com/yig/PySPQR/issues/6
@@ -37,6 +36,11 @@ if platform.system() == 'Windows':
 
 ffibuilder = FFI()
 
+## Uncomment this and install with `pip install -v` to see the arguments to `set_source`.
+# print( "cffi include_dirs:", include_dirs )
+# print( "cffi library_dirs:", library_dirs )
+# print( "cffi libraries:", libraries )
+
 ffibuilder.set_source( "sparseqr._sparseqr",
     """#include <SuiteSparseQR_C.h>
 """,
@@ -362,6 +366,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.4}/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)

sparseqr-1.2.1/PKG-INFO

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

sparseqr-1.2.1/pyproject.toml

@@ -1,21 +0,0 @@
-[tool.poetry]
-name = "sparseqr"
-version = "1.2.1"
-description = "Python wrapper for SuiteSparseQR"
-authors = ["Yotam Gingold <yotam@yotamgingold.com>"]
-license = "Public Domain CC0"
-
-include = ["test/*.py", "README.md", "LICENSE.md"]
-exclude = ["sparseqr/_sparseqr*"]
-
-[tool.poetry.dependencies]
-python = "^3.8"
-numpy = "^1.21"
-scipy = "^1.0"
-cffi = "^1.0"
-
-[tool.poetry.dev-dependencies]
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"