blocksolver 0.6.0__tar.gz

blocksolver-0.6.0/Makefile

@@ -0,0 +1,103 @@
+# Makefile for BLIT Python extension
+#
+# Run from python/ directory:
+#   make            # Build extension
+#   make install    # Install package
+#   make test       # Run tests
+
+PYTHON ?= python3
+PIP ?= $(PYTHON) -m pip
+F2PY ?= $(PYTHON) -m numpy.f2py
+
+# Compilers
+FC ?= gfortran
+CC ?= gcc
+FFLAGS ?= -O3 -fPIC -cpp
+CFLAGS ?= -O3 -fPIC
+
+# Directories
+SRC_DIR = ../src
+
+# Library paths (adjust for your system)
+UMFPACK_INC ?= /usr/include/suitesparse
+UMFPACK_LIB ?= /usr/lib
+LIBS = -lumfpack -lamd -lcholmod -lcolamd -lsuitesparseconfig -llapack -lblas
+
+# Sources
+FORTRAN_SRC = $(SRC_DIR)/blit_const.f90 \
+              $(SRC_DIR)/blit_matrixutil.f90 \
+              $(SRC_DIR)/blit_sparseutil.f90 \
+              $(SRC_DIR)/blit_ilupcond.f90 \
+              $(SRC_DIR)/blit_blqmr.f90 \
+              $(SRC_DIR)/blit_blqmr_f2py.f90
+
+C_SRC = $(SRC_DIR)/umf4_f77wrapper.c
+
+# Signature file for f2py
+SIGNATURE = blit_blqmr.pyf
+
+MODULE = _blqmr
+
+# ============================================================================
+.PHONY: all build install install-dev wheel test clean help
+
+all: build
+
+# Build using setup.py (recommended)
+build: setup.py
+	$(PYTHON) setup.py build_ext --inplace
+	@echo "Build complete! Run: make test"
+
+# Direct f2py build (faster, for development)
+build-direct: $(SIGNATURE)
+	$(F2PY) -c $(SIGNATURE) \
+		--f90flags="$(FFLAGS)" \
+		-I$(UMFPACK_INC) -L$(UMFPACK_LIB) $(LIBS) \
+		$(FORTRAN_SRC) $(C_SRC)
+	mv $(MODULE)*.so blit/
+	@echo "Build complete!"
+
+# Install
+install:
+	$(PIP) install .
+
+# Editable install
+install-dev:
+	$(PIP) install -e .
+
+# Build wheel
+wheel:
+	$(PIP) install build
+	$(PYTHON) -m build --wheel
+
+# Test
+test: build
+	$(PYTHON) -c "import blit; blit.test()"
+
+# Pytest
+pytest: build
+	$(PYTHON) -m pytest tests/ -v
+
+# Clean
+clean:
+	rm -rf build/ dist/ *.egg-info/ .eggs/
+	rm -f blit/*.so blit/*.pyd
+	rm -rf blit/__pycache__ __pycache__ tests/__pycache__
+	rm -rf .pytest_cache/
+
+# Help
+help:
+	@echo "BLIT Python Extension"
+	@echo ""
+	@echo "Targets:"
+	@echo "  make              Build extension (default)"
+	@echo "  make build-direct Build with f2py directly"
+	@echo "  make install      Install package"
+	@echo "  make install-dev  Editable install"
+	@echo "  make wheel        Build wheel"
+	@echo "  make test         Run tests"
+	@echo "  make clean        Clean build files"
+	@echo ""
+	@echo "Environment:"
+	@echo "  UMFPACK_INC=$(UMFPACK_INC)"
+	@echo "  UMFPACK_LIB=$(UMFPACK_LIB)"

blocksolver-0.6.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.1
+Name: blocksolver
+Version: 0.6.0
+Summary: Block Quasi-Minimal-Residual sparse linear solver
+Keywords: sparse,linear-algebra,iterative-solver,qmr,fortran,umfpack
+Author-Email: Qianqian Fang <q.fang@neu.edu>
+License: BSD-3-Clause OR LGPL-3.0-or-later OR GPL-3.0-or-later
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Fortran
+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
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Project-URL: Homepage, https://blit.sourceforge.net
+Project-URL: Repository, https://github.com/fangq/blocksolver
+Project-URL: Documentation, https://blit.sourceforge.net
+Project-URL: Bug Tracker, https://github.com/fangq/blocksolver/issues
+Requires-Python: >=3.8
+Requires-Dist: numpy>=1.20
+Requires-Dist: scipy>=1.0
+Provides-Extra: fast
+Requires-Dist: numba>=0.50; extra == "fast"
+Provides-Extra: test
+Requires-Dist: pytest>=6.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Description-Content-Type: text/markdown
+
+# BLIT Python Bindings
+
+Python interface for the BLIT (Block Iterative) sparse linear solver library.
+
+## Installation
+
+### Prerequisites
+
+- Python >= 3.8
+- NumPy
+- Fortran compiler (gfortran, ifort)
+- UMFPACK/SuiteSparse library
+- BLAS/LAPACK
+
+On Ubuntu/Debian:
+```bash
+sudo apt install gfortran libsuitesparse-dev libblas-dev liblapack-dev
+```
+
+On macOS (Homebrew):
+```bash
+brew install gcc suite-sparse openblas
+```
+
+### Install
+
+```bash
+cd python
+pip install .
+```
+
+For development:
+```bash
+pip install -e .
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import numpy as np
+from blocksolver import blqmr_solve
+
+# Define sparse matrix in CSC format (0-based indexing)
+Ap = np.array([0, 2, 5, 9, 10, 12], dtype=np.int32)
+Ai = np.array([0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4], dtype=np.int32)
+Ax = np.array([2., 3., 3., -1., 4., 4., -3., 1., 2., 2., 6., 1.])
+b = np.array([8.0, 45.0, -3.0, 3.0, 19.0])
+
+# Solve
+result = blqmr_solve(Ap, Ai, Ax, b, tol=1e-8)
+
+print(f"Solution: {result.x}")
+print(f"Converged: {result.converged}")
+print(f"Iterations: {result.iter}")
+```
+
+### With SciPy Sparse Matrices
+
+```python
+from scipy.sparse import csc_matrix
+from blocksolver import blqmr_scipy
+
+A = csc_matrix([[4, 1, 0], [1, 3, 1], [0, 1, 2]])
+b = np.array([1., 2., 3.])
+
+x, flag = blqmr_scipy(A, b, tol=1e-10)
+```
+
+### Multiple Right-Hand Sides
+
+```python
+from blocksolver import blqmr_solve_multi
+
+B = np.column_stack([b1, b2, b3])  # n x nrhs
+result = blqmr_solve_multi(Ap, Ai, Ax, B)
+# result.x is n x nrhs
+```
+
+## API Reference
+
+### `blqmr_solve(Ap, Ai, Ax, b, **kwargs) -> BLQMRResult`
+
+Solve sparse system Ax = b.
+
+**Parameters:**
+- `Ap`: Column pointers (int32, length n+1)
+- `Ai`: Row indices (int32, length nnz)
+- `Ax`: Non-zero values (float64, length nnz)
+- `b`: Right-hand side (float64, length n)
+- `tol`: Convergence tolerance (default: 1e-6)
+- `maxiter`: Maximum iterations (default: n)
+- `droptol`: ILU drop tolerance (default: 0.001)
+- `use_precond`: Use ILU preconditioner (default: True)
+- `zero_based`: Input uses 0-based indexing (default: True)
+
+**Returns:** `BLQMRResult` with attributes:
+- `x`: Solution vector
+- `flag`: 0=converged, 1=maxiter, 2=precond fail, 3=stagnation
+- `iter`: Iterations performed
+- `relres`: Relative residual
+- `converged`: Boolean property
+
+## Testing
+
+```bash
+make test
+# or
+pytest tests/ -v
+```
+
+## License
+
+BSD / LGPL / GPL - see LICENSE files in parent directory.

blocksolver-0.6.0/README.md

@@ -0,0 +1,115 @@
+# BLIT Python Bindings
+
+Python interface for the BLIT (Block Iterative) sparse linear solver library.
+
+## Installation
+
+### Prerequisites
+
+- Python >= 3.8
+- NumPy
+- Fortran compiler (gfortran, ifort)
+- UMFPACK/SuiteSparse library
+- BLAS/LAPACK
+
+On Ubuntu/Debian:
+```bash
+sudo apt install gfortran libsuitesparse-dev libblas-dev liblapack-dev
+```
+
+On macOS (Homebrew):
+```bash
+brew install gcc suite-sparse openblas
+```
+
+### Install
+
+```bash
+cd python
+pip install .
+```
+
+For development:
+```bash
+pip install -e .
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import numpy as np
+from blit import blqmr_solve
+
+# Define sparse matrix in CSC format (0-based indexing)
+Ap = np.array([0, 2, 5, 9, 10, 12], dtype=np.int32)
+Ai = np.array([0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4], dtype=np.int32)
+Ax = np.array([2., 3., 3., -1., 4., 4., -3., 1., 2., 2., 6., 1.])
+b = np.array([8.0, 45.0, -3.0, 3.0, 19.0])
+
+# Solve
+result = blqmr_solve(Ap, Ai, Ax, b, tol=1e-8)
+
+print(f"Solution: {result.x}")
+print(f"Converged: {result.converged}")
+print(f"Iterations: {result.iter}")
+```
+
+### With SciPy Sparse Matrices
+
+```python
+from scipy.sparse import csc_matrix
+from blit import blqmr_scipy
+
+A = csc_matrix([[4, 1, 0], [1, 3, 1], [0, 1, 2]])
+b = np.array([1., 2., 3.])
+
+x, flag = blqmr_scipy(A, b, tol=1e-10)
+```
+
+### Multiple Right-Hand Sides
+
+```python
+from blit import blqmr_solve_multi
+
+B = np.column_stack([b1, b2, b3])  # n x nrhs
+result = blqmr_solve_multi(Ap, Ai, Ax, B)
+# result.x is n x nrhs
+```
+
+## API Reference
+
+### `blqmr_solve(Ap, Ai, Ax, b, **kwargs) -> BLQMRResult`
+
+Solve sparse system Ax = b.
+
+**Parameters:**
+- `Ap`: Column pointers (int32, length n+1)
+- `Ai`: Row indices (int32, length nnz)
+- `Ax`: Non-zero values (float64, length nnz)
+- `b`: Right-hand side (float64, length n)
+- `tol`: Convergence tolerance (default: 1e-6)
+- `maxiter`: Maximum iterations (default: n)
+- `droptol`: ILU drop tolerance (default: 0.001)
+- `use_precond`: Use ILU preconditioner (default: True)
+- `zero_based`: Input uses 0-based indexing (default: True)
+
+**Returns:** `BLQMRResult` with attributes:
+- `x`: Solution vector
+- `flag`: 0=converged, 1=maxiter, 2=precond fail, 3=stagnation
+- `iter`: Iterations performed
+- `relres`: Relative residual
+- `converged`: Boolean property
+
+## Testing
+
+```bash
+make test
+# or
+pytest tests/ -v
+```
+
+## License
+
+BSD / LGPL / GPL - see LICENSE files in parent directory.

blocksolver-0.6.0/blit/__init__.py

@@ -0,0 +1,83 @@
+"""
+BLIT - Block Iterative Sparse Linear Solvers
+
+A Python interface to the BLIT Fortran library for solving sparse linear systems.
+Falls back to pure-Python implementation when Fortran extension is unavailable.
+
+Examples
+--------
+>>> from blit import blqmr_solve
+>>> result = blqmr_solve(Ap, Ai, Ax, b)
+>>> print(result.x, result.converged)
+
+>>> # With scipy sparse matrices:
+>>> from blit import blqmr_scipy
+>>> x, flag = blqmr_scipy(A, b)
+
+>>> # Direct block QMR with custom preconditioner:
+>>> from blit import blqmr, make_preconditioner
+>>> M1 = make_preconditioner(A, 'ilu')
+>>> x, flag, relres, niter, resv = blqmr(A, b, M1=M1)
+
+>>> # Check which backend is being used:
+>>> from blit import BLQMR_EXT
+>>> print("Using Fortran" if BLQMR_EXT else "Using pure Python")
+"""
+
+from .blqmr import (
+    blqmr_solve,
+    blqmr_solve_multi,
+    blqmr_scipy,
+    blqmr,
+    BLQMRResult,
+    BLQMR_EXT,
+    qqr,
+    BLQMRWorkspace,
+    SparsePreconditioner,
+    DensePreconditioner,
+    make_preconditioner,
+    HAS_NUMBA,
+)
+
+__version__ = "0.8.0"
+__author__ = "Qianqian Fang"
+
+__all__ = [
+    "blqmr_solve",
+    "blqmr_solve_multi",
+    "blqmr_scipy",
+    "blqmr",
+    "BLQMRResult",
+    "BLQMR_EXT",
+    "HAS_NUMBA",
+    "qqr",
+    "BLQMRWorkspace",
+    "SparsePreconditioner",
+    "DensePreconditioner",
+    "make_preconditioner",
+]
+
+
+def test():
+    """Run basic tests to verify installation."""
+    from .blqmr import _test
+
+    return _test()
+
+
+def get_backend_info():
+    """Return information about the active backend.
+
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - 'backend': 'binary' or 'native'
+        - 'has_fortran': bool
+        - 'has_numba': bool (for Python backend acceleration)
+    """
+    return {
+        "backend": "binary" if BLQMR_EXT else "native",
+        "has_fortran": BLQMR_EXT,
+        "has_numba": HAS_NUMBA,
+    }