blocksolver 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

blocksolver/__init__.py

@@ -39,7 +39,7 @@ from .blqmr import (
     HAS_NUMBA,
 )
 
-__version__ = "0.8.1"
+__version__ = "0.8.3"
 __author__ = "Qianqian Fang"
 
 __all__ = [

blocksolver/blqmr.py

@@ -50,7 +50,7 @@ try:
     from numba import njit
 
     HAS_NUMBA = True
-except ImportError:
+except (ImportError, Exception) as e:
     HAS_NUMBA = False
 
     def njit(*args, **kwargs):
@@ -134,6 +134,52 @@ def _qqr_kernel_real(Q, R, n, m):
                     Q[i, k] -= Q[i, j] * dot
 
 
+@njit(cache=True)
+def _qqr_kernel_complex(Q, R, n, m):
+    """Numba-accelerated quasi-QR kernel for complex arrays."""
+    for j in range(m):
+        # Quasi inner product: sum(q*q) WITHOUT conjugation
+        r_jj_sq = 0.0j
+        for i in range(n):
+            r_jj_sq += Q[i, j] * Q[i, j]  # No conjugation!
+        r_jj = np.sqrt(r_jj_sq)
+        R[j, j] = r_jj
+        if abs(r_jj) > 1e-14:
+            inv_r_jj = 1.0 / r_jj
+            for i in range(n):
+                Q[i, j] *= inv_r_jj
+            for k in range(j + 1, m):
+                # Quasi inner product: sum(q_j * q_k) WITHOUT conjugation
+                dot = 0.0j
+                for i in range(n):
+                    dot += Q[i, j] * Q[i, k]  # No conjugation!
+                R[j, k] = dot
+                for i in range(n):
+                    Q[i, k] -= Q[i, j] * dot
+
+
+@njit(cache=True)
+def _qqr_kernel_real(Q, R, n, m):
+    """Numba-accelerated quasi-QR kernel for real arrays."""
+    for j in range(m):
+        r_jj_sq = 0.0
+        for i in range(n):
+            r_jj_sq += Q[i, j] * Q[i, j]
+        r_jj = np.sqrt(r_jj_sq)
+        R[j, j] = r_jj
+        if abs(r_jj) > 1e-14:
+            inv_r_jj = 1.0 / r_jj
+            for i in range(n):
+                Q[i, j] *= inv_r_jj
+            for k in range(j + 1, m):
+                dot = 0.0
+                for i in range(n):
+                    dot += Q[i, j] * Q[i, k]
+                R[j, k] = dot
+                for i in range(n):
+                    Q[i, k] -= Q[i, j] * dot
+
+
 def qqr(
     A: np.ndarray, tol: float = 0, use_numba: bool = True
 ) -> Tuple[np.ndarray, np.ndarray]:
@@ -173,14 +219,20 @@ def qqr(
     else:
         for j in range(m):
             qj = Q[:, j]
-            r_jj_sq = np.dot(qj, qj)
+            # CRITICAL FIX: Use sum(qj * qj) NOT np.dot(qj, qj)
+            # np.dot conjugates the first argument for complex arrays!
+            # Fortran: R(k,k)=dsqrt(sum(Q(:,k)*Q(:,k))) - no conjugation
+            r_jj_sq = np.sum(qj * qj)  # Quasi inner product - NO conjugation
             r_jj = np.sqrt(r_jj_sq)
             R[j, j] = r_jj
             if np.abs(r_jj) > 1e-14:
                 Q[:, j] *= 1.0 / r_jj
                 if j < m - 1:
-                    R[j, j + 1 :] = np.dot(Q[:, j], Q[:, j + 1 :])
-                    Q[:, j + 1 :] -= np.outer(Q[:, j], R[j, j + 1 :])
+                    # CRITICAL FIX: Quasi inner product for off-diagonal
+                    # Fortran: R(k,j)=sum(Q(:,k)*Q(:,j)) - no conjugation
+                    for k in range(j + 1, m):
+                        R[j, k] = np.sum(Q[:, j] * Q[:, k])  # NO conjugation
+                        Q[:, k] -= R[j, k] * Q[:, j]
 
     return Q, R
 
@@ -217,8 +269,12 @@ class SparsePreconditioner:
 
     def __init__(self, M1, M2=None):
         self.is_two_part = M2 is not None
-        self.is_ilu1 = isinstance(M1, _ILUPreconditioner)
-        self.is_ilu2 = isinstance(M2, _ILUPreconditioner) if M2 is not None else False
+        self.is_ilu1 = isinstance(M1, (_ILUPreconditioner, _LUPreconditioner))
+        self.is_ilu2 = (
+            isinstance(M2, (_ILUPreconditioner, _LUPreconditioner))
+            if M2 is not None
+            else False
+        )
 
         if M1 is not None:
             if self.is_ilu1:
@@ -382,7 +438,7 @@ class BLQMRWorkspace:
 # =============================================================================
 
 
-def make_preconditioner(A: sparse.spmatrix, precond_type: str = "diag"):
+def make_preconditioner(A: sparse.spmatrix, precond_type: str = "diag", **kwargs):
     """
     Create a preconditioner for iterative solvers.
 
@@ -392,8 +448,14 @@ def make_preconditioner(A: sparse.spmatrix, precond_type: str = "diag"):
         System matrix
     precond_type : str
         'diag' or 'jacobi': Diagonal (Jacobi) preconditioner
-        'ilu' or 'ilu0': Incomplete LU
+        'ilu' or 'ilu0': Incomplete LU with minimal fill
+        'ilut': Incomplete LU with threshold (better quality)
+        'lu': Full LU factorization (exact, use as reference)
         'ssor': Symmetric SOR
+    **kwargs : dict
+        Additional parameters for ILU:
+        - drop_tol: Drop tolerance (default: 1e-4 for ilut, 0 for ilu0)
+        - fill_factor: Fill factor (default: 10 for ilut, 1 for ilu0)
 
     Returns
     -------
@@ -403,18 +465,46 @@ def make_preconditioner(A: sparse.spmatrix, precond_type: str = "diag"):
     if precond_type in ("diag", "jacobi"):
         diag = A.diagonal().copy()
         diag[np.abs(diag) < 1e-14] = 1.0
-        return sparse.diags(diag, format="csr")
+        return sparse.diags(
+            1.0 / diag, format="csr"
+        )  # Return inverse for preconditioning!
 
-    elif precond_type in ("ilu", "ilu0"):
+    elif precond_type == "ilu0":
+        # ILU(0) - no fill-in, fast but may be poor quality
         try:
             ilu = spilu(A.tocsc(), drop_tol=0, fill_factor=1)
             return _ILUPreconditioner(ilu)
         except Exception as e:
-            warnings.warn(f"ILU factorization failed: {e}, falling back to diagonal")
+            warnings.warn(f"ILU(0) factorization failed: {e}, falling back to diagonal")
             return make_preconditioner(A, "diag")
 
+    elif precond_type in ("ilu", "ilut"):
+        # ILUT - ILU with threshold, better quality (similar to UMFPACK)
+        drop_tol = kwargs.get("drop_tol", 1e-4)
+        fill_factor = kwargs.get("fill_factor", 10)
+        try:
+            ilu = spilu(A.tocsc(), drop_tol=drop_tol, fill_factor=fill_factor)
+            return _ILUPreconditioner(ilu)
+        except Exception as e:
+            warnings.warn(f"ILUT factorization failed: {e}, trying ILU(0)")
+            try:
+                ilu = spilu(A.tocsc(), drop_tol=0, fill_factor=1)
+                return _ILUPreconditioner(ilu)
+            except Exception as e2:
+                warnings.warn(f"ILU(0) also failed: {e2}, falling back to diagonal")
+                return make_preconditioner(A, "diag")
+
+    elif precond_type == "lu":
+        # Full LU - exact factorization (for reference/debugging)
+        try:
+            lu = splu(A.tocsc())
+            return _LUPreconditioner(lu)
+        except Exception as e:
+            warnings.warn(f"LU factorization failed: {e}, falling back to ILUT")
+            return make_preconditioner(A, "ilut")
+
     elif precond_type == "ssor":
-        omega = 1.0
+        omega = kwargs.get("omega", 1.0)
         D = sparse.diags(A.diagonal(), format="csr")
         L = sparse.tril(A, k=-1, format="csr")
         return (D + omega * L).tocsr()
@@ -423,6 +513,24 @@ def make_preconditioner(A: sparse.spmatrix, precond_type: str = "diag"):
         raise ValueError(f"Unknown preconditioner type: {precond_type}")
 
 
+class _LUPreconditioner:
+    """Wrapper for full LU preconditioner."""
+
+    def __init__(self, lu_factor):
+        self.lu = lu_factor
+        self.shape = (lu_factor.shape[0], lu_factor.shape[1])
+        self.dtype = np.float64  # Assume real for now
+
+    def solve(self, b):
+        if b.ndim == 1:
+            return self.lu.solve(b)
+        else:
+            x = np.zeros_like(b)
+            for i in range(b.shape[1]):
+                x[:, i] = self.lu.solve(b[:, i])
+            return x
+
+
 # =============================================================================
 # Pure-Python Block QMR Solver
 # =============================================================================
@@ -448,7 +556,7 @@ def _blqmr_python_impl(
     dtype = np.complex128 if is_complex_input else np.float64
 
     if maxiter is None:
-        maxiter = min(n, 20)
+        maxiter = min(n, 100)
 
     if (
         workspace is None
@@ -463,10 +571,13 @@ def _blqmr_python_impl(
 
     # Setup preconditioner
     if M1 is not None:
-        if isinstance(M1, _ILUPreconditioner):
+        if isinstance(M1, (_ILUPreconditioner, _LUPreconditioner)):
             precond = SparsePreconditioner(M1, M2)
         elif sparse.issparse(M1):
             precond = SparsePreconditioner(M1, M2)
+        elif hasattr(M1, "solve"):
+            # Custom preconditioner with .solve() method
+            precond = M1  # Use directly
         else:
             precond = DensePreconditioner(M1, M2)
     else:
@@ -477,7 +588,16 @@ def _blqmr_python_impl(
     else:
         x = np.asarray(x0, dtype=dtype).reshape(n, m).copy()
 
-    t3, t3n, t3p, t3nn = 0, 2, 1, 1
+    # Initialize indices: Fortran t3=mod(0,3)+1=1 -> Python t3=0
+    t3 = 0
+    t3n = 2
+    t3p = 1
+
+    # Initialize Q matrices (identity)
+    ws.Qa[:, :, :] = 0
+    ws.Qb[:, :, :] = 0
+    ws.Qc[:, :, :] = 0
+    ws.Qd[:, :, :] = 0
     ws.Qa[:, :, t3] = np.eye(m, dtype=dtype)
     ws.Qd[:, :, t3n] = np.eye(m, dtype=dtype)
     ws.Qd[:, :, t3] = np.eye(m, dtype=dtype)
@@ -493,105 +613,151 @@ def _blqmr_python_impl(
         if np.any(np.isnan(ws.vt)):
             return x, 2, 1.0, 0, np.array([])
 
+    # QQR decomposition
     Q, R = qqr(ws.vt)
     ws.v[:, :, t3p] = Q
     ws.beta[:, :, t3p] = R
 
-    col_norms = np.sqrt(np.einsum("ij,ij->j", Q.conj(), Q).real)
-    ws.omega[:, :, t3p] = np.diag(col_norms)
-    np.matmul(ws.omega[:, :, t3p], ws.beta[:, :, t3p], out=ws.taot)
+    # Compute omega - standard norm WITH conjugation (Hermitian norm)
+    # Fortran: omega(i,i,t3p)=sqrt(sum(conjg(v(:,i,t3p))*v(:,i,t3p)))
+    for i in range(m):
+        col = ws.v[:, i, t3p]
+        if is_complex_input:
+            ws.omega[i, i, t3p] = np.sqrt(np.sum(np.conj(col) * col).real)
+        else:
+            ws.omega[i, i, t3p] = np.sqrt(np.sum(col * col))
+
+    # taut = omega * beta
+    ws.taot[:] = ws.omega[:, :, t3p] @ ws.beta[:, :, t3p]
 
     isquasires = not residual
     if isquasires:
-        Qres0 = np.sqrt(np.einsum("ij,ij->j", ws.taot.conj(), ws.taot).real).max()
+        # Fortran: Qres0=maxval(sqrt(sum(abs(conjg(taut)*taut),1))) for complex
+        if is_complex_input:
+            Qres0 = np.max(np.sqrt(np.sum(np.abs(np.conj(ws.taot) * ws.taot), axis=0)))
+        else:
+            Qres0 = np.max(np.sqrt(np.sum(ws.taot * ws.taot, axis=0)))
     else:
-        omegat = Q @ np.diag(1.0 / (col_norms + 1e-16))
-        Qres0 = np.sqrt(np.einsum("ij,ij->j", ws.vt.conj(), ws.vt).real).max()
+        omegat = np.zeros((n, m), dtype=dtype)
+        for i in range(m):
+            if np.abs(ws.omega[i, i, t3p]) > 1e-14:
+                omegat[:, i] = ws.v[:, i, t3p] / ws.omega[i, i, t3p]
+        if is_complex_input:
+            Qres0 = np.max(np.sqrt(np.sum(np.abs(np.conj(ws.vt) * ws.vt), axis=0)))
+        else:
+            Qres0 = np.max(np.sqrt(np.sum(ws.vt * ws.vt, axis=0)))
 
     if Qres0 < 1e-16:
         result = x.real if not is_complex_input else x
         return result, 0, 0.0, 0, np.array([0.0])
 
-    flag, resv, Qres1, relres, iter_count = 1, np.zeros(maxiter), None, 1.0, 0
-    omegat = None if isquasires else Q @ np.diag(1.0 / (col_norms + 1e-16))
+    flag, resv, Qres1, relres, iter_count = 1, np.zeros(maxiter), -1.0, 1.0, 0
 
     for k in range(1, maxiter + 1):
-        t3, t3n, t3p, t3nn = k % 3, (k - 1) % 3, (k + 1) % 3, (k - 2) % 3
+        # Index cycling
+        t3 = k % 3
+        t3p = (k + 1) % 3
+        t3n = (k - 1) % 3
+        t3nn = (k - 2) % 3
 
+        # tmp = A * v(:,:,t3)
         if A_is_sparse:
             ws.Av[:] = A @ ws.v[:, :, t3]
         else:
             np.matmul(A, ws.v[:, :, t3], out=ws.Av)
 
+        # Apply preconditioner
         if precond is not None:
             precond.solve(ws.Av, out=ws.vt)
-            ws.vt -= ws.v[:, :, t3n] @ ws.beta[:, :, t3].T
+            ws.vt[:] = ws.vt - ws.v[:, :, t3n] @ ws.beta[:, :, t3].T
         else:
-            np.matmul(ws.v[:, :, t3n], ws.beta[:, :, t3].T, out=ws.vt)
-            np.subtract(ws.Av, ws.vt, out=ws.vt)
+            ws.vt[:] = ws.Av - ws.v[:, :, t3n] @ ws.beta[:, :, t3].T
 
-        np.matmul(ws.v[:, :, t3].T, ws.vt, out=ws.alpha)
-        ws.vt -= ws.v[:, :, t3] @ ws.alpha
+        # alpha = v^T * vt (transpose, not conjugate transpose)
+        ws.alpha[:] = ws.v[:, :, t3].T @ ws.vt
+        ws.vt[:] = ws.vt - ws.v[:, :, t3] @ ws.alpha
 
+        # QQR decomposition
         Q, R = qqr(ws.vt)
         ws.v[:, :, t3p] = Q
         ws.beta[:, :, t3p] = R
 
-        col_norms = np.sqrt(np.einsum("ij,ij->j", Q.conj(), Q).real)
-        ws.omega[:, :, t3p] = np.diag(col_norms)
-
-        np.matmul(ws.omega[:, :, t3n], ws.beta[:, :, t3].T, out=ws.tmp0)
-        np.matmul(ws.Qb[:, :, t3nn], ws.tmp0, out=ws.theta)
-
-        np.matmul(ws.Qd[:, :, t3nn], ws.tmp0, out=ws.tmp1)
-        np.matmul(ws.omega[:, :, t3], ws.alpha, out=ws.tmp2)
-        np.matmul(ws.Qa[:, :, t3n], ws.tmp1, out=ws.eta)
-        ws.eta += ws.Qb[:, :, t3n] @ ws.tmp2
+        # Compute omega (standard Hermitian norm)
+        for i in range(m):
+            col = ws.v[:, i, t3p]
+            if is_complex_input:
+                ws.omega[i, i, t3p] = np.sqrt(np.sum(np.conj(col) * col).real)
+            else:
+                ws.omega[i, i, t3p] = np.sqrt(np.sum(col * col))
 
-        np.matmul(ws.Qc[:, :, t3n], ws.tmp1, out=ws.zetat)
-        ws.zetat += ws.Qd[:, :, t3n] @ ws.tmp2
+        # Compute intermediate matrices
+        ws.tmp0[:] = ws.omega[:, :, t3n] @ ws.beta[:, :, t3].T
+        ws.theta[:] = ws.Qb[:, :, t3nn] @ ws.tmp0
+        ws.tmp1[:] = ws.Qd[:, :, t3nn] @ ws.tmp0
+        ws.tmp2[:] = ws.omega[:, :, t3] @ ws.alpha
+        ws.eta[:] = ws.Qa[:, :, t3n] @ ws.tmp1 + ws.Qb[:, :, t3n] @ ws.tmp2
+        ws.zetat[:] = ws.Qc[:, :, t3n] @ ws.tmp1 + ws.Qd[:, :, t3n] @ ws.tmp2
 
+        # Build ZZ matrix and do standard QR
         ws.stacked[:m, :] = ws.zetat
-        np.matmul(ws.omega[:, :, t3p], ws.beta[:, :, t3p], out=ws.stacked[m:, :])
+        ws.stacked[m:, :] = ws.omega[:, :, t3p] @ ws.beta[:, :, t3p]
 
         QQ, zeta_full = np.linalg.qr(ws.stacked, mode="complete")
         ws.zeta[:] = zeta_full[:m, :]
-        ws.QQ_full[:] = QQ.conj().T
+
+        if is_complex_input:
+            ws.QQ_full[:] = np.conj(QQ.T)
+        else:
+            ws.QQ_full[:] = QQ.T
 
         ws.Qa[:, :, t3] = ws.QQ_full[:m, :m]
         ws.Qb[:, :, t3] = ws.QQ_full[:m, m : 2 * m]
         ws.Qc[:, :, t3] = ws.QQ_full[m : 2 * m, :m]
         ws.Qd[:, :, t3] = ws.QQ_full[m : 2 * m, m : 2 * m]
 
+        # Invert zeta
         try:
             zeta_inv = np.linalg.inv(ws.zeta)
         except np.linalg.LinAlgError:
             zeta_inv = np.linalg.pinv(ws.zeta)
 
+        # Update p, tau, x, taut
         ws.p[:, :, t3] = (
             ws.v[:, :, t3] - ws.p[:, :, t3n] @ ws.eta - ws.p[:, :, t3nn] @ ws.theta
         ) @ zeta_inv
+        ws.tau[:] = ws.Qa[:, :, t3] @ ws.taot
+        x[:] = x + ws.p[:, :, t3] @ ws.tau
+        ws.taot[:] = ws.Qc[:, :, t3] @ ws.taot
 
-        np.matmul(ws.Qa[:, :, t3], ws.taot, out=ws.tau)
-        x += ws.p[:, :, t3] @ ws.tau
-
-        taot_copy = ws.taot.copy()
-        np.matmul(ws.Qc[:, :, t3], taot_copy, out=ws.taot)
-
+        # Compute residual
         if isquasires:
-            Qres = np.sqrt(np.einsum("ij,ij->j", ws.taot.conj(), ws.taot).real).max()
+            if is_complex_input:
+                Qres = np.max(
+                    np.sqrt(np.sum(np.abs(np.conj(ws.taot) * ws.taot), axis=0))
+                )
+            else:
+                Qres = np.max(np.sqrt(np.sum(ws.taot * ws.taot, axis=0)))
         else:
-            omega_diag_inv = np.diag(1.0 / (col_norms + 1e-16))
-            omegat = (
-                omegat @ ws.Qc[:, :, t3].conj().T
-                + ws.v[:, :, t3p] @ (ws.Qd[:, :, t3] @ omega_diag_inv).conj().T
-            )
-            R_resid = omegat @ ws.taot
-            Qres = np.sqrt(np.einsum("ij,ij->j", R_resid.conj(), R_resid).real).max()
+            tmp0_diag = np.zeros((m, m), dtype=dtype)
+            for i in range(m):
+                if np.abs(ws.omega[i, i, t3p]) > 1e-14:
+                    tmp0_diag[i, :] = ws.Qd[:, i, t3] / ws.omega[i, i, t3p]
+            if is_complex_input:
+                omegat = omegat @ np.conj(ws.Qc[:, :, t3].T) + ws.v[
+                    :, :, t3p
+                ] @ np.conj(tmp0_diag)
+                tmp_res = np.conj(omegat @ ws.taot)
+                Qres = np.max(
+                    np.sqrt(np.sum(np.abs(np.conj(tmp_res) * tmp_res), axis=0))
+                )
+            else:
+                omegat = omegat @ ws.Qc[:, :, t3].T + ws.v[:, :, t3p] @ tmp0_diag
+                tmp_res = omegat @ ws.taot
+                Qres = np.max(np.sqrt(np.sum(tmp_res * tmp_res, axis=0)))
 
         resv[k - 1] = Qres
 
-        if Qres1 is not None and Qres == Qres1:
+        if k > 1 and abs(Qres - Qres1) < np.finfo(dtype).eps:
             flag, iter_count = 3, k
             break
 
@@ -739,7 +905,10 @@ def _blqmr_solve_native_csc(
         try:
             M1 = make_preconditioner(A, "ilu")
         except Exception:
-            M1 = make_preconditioner(A, "diag")
+            try:
+                M1 = make_preconditioner(A, "diag")  # FIX: Changed A_sp to A
+            except Exception:
+                M1 = None  # Fall back to no preconditioning
 
     x, flag, relres, niter, resv = _blqmr_python_impl(
         A, b, tol=tol, maxiter=maxiter, M1=M1, x0=x0
@@ -846,7 +1015,10 @@ def _blqmr_solve_multi_native(
         try:
             M1 = make_preconditioner(A, "ilu")
         except Exception:
-            M1 = make_preconditioner(A, "diag")
+            try:
+                M1 = make_preconditioner(A, "diag")  # FIX: Changed A_sp to A
+            except Exception:
+                M1 = None  # Fall back to no preconditioning
 
     if B.ndim == 1:
         B = B.reshape(-1, 1)
@@ -986,40 +1158,75 @@ def _blqmr_fortran(
 ) -> BLQMRResult:
     """Fortran backend for blqmr()."""
     A_csc = sparse.csc_matrix(A)
+
+    # CRITICAL: Sort indices for UMFPACK compatibility
+    if not A_csc.has_sorted_indices:
+        A_csc.sort_indices()
+
     Ap = A_csc.indptr.astype(np.int32)
     Ai = A_csc.indices.astype(np.int32)
-    Ax = A_csc.data.astype(np.float64)
 
     n = A_csc.shape[0]
-    nnz = len(Ax)
+    nnz = A_csc.nnz
 
     if maxiter is None:
         maxiter = n
 
-    # Convert to Fortran format
-    Ap_f = np.asfortranarray(Ap + 1, dtype=np.int32)  # 1-based
-    Ai_f = np.asfortranarray(Ai + 1, dtype=np.int32)  # 1-based
-    Ax_f = np.asfortranarray(Ax, dtype=np.float64)
+    # Convert to Fortran format (1-based indexing)
+    Ap_f = np.asfortranarray(Ap + 1, dtype=np.int32)
+    Ai_f = np.asfortranarray(Ai + 1, dtype=np.int32)
 
     dopcond = 1 if use_precond else 0
 
-    if B.ndim == 1 or (B.ndim == 2 and B.shape[1] == 1):
-        b = np.asfortranarray(B.ravel(), dtype=np.float64)
-        x, flag, niter, relres = _blqmr.blqmr_solve_real(
-            n, nnz, Ap_f, Ai_f, Ax_f, b, maxiter, tol, droptol, dopcond
-        )
-        return BLQMRResult(
-            x=x.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
-        )
+    # Check if complex
+    is_complex = np.iscomplexobj(A) or np.iscomplexobj(B)
+
+    if is_complex:
+        # Complex path
+        Ax_f = np.asfortranarray(A_csc.data, dtype=np.complex128)
+
+        if B.ndim == 1 or (B.ndim == 2 and B.shape[1] == 1):
+            # Single RHS
+            b_f = np.asfortranarray(B.ravel(), dtype=np.complex128)
+            x, flag, niter, relres = _blqmr.blqmr_solve_complex(
+                n, nnz, Ap_f, Ai_f, Ax_f, b_f, maxiter, tol, droptol, dopcond
+            )
+            return BLQMRResult(
+                x=x.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
+            )
+        else:
+            # Multiple RHS - use block method
+            B_f = np.asfortranarray(B, dtype=np.complex128)
+            nrhs = B_f.shape[1]
+            X, flag, niter, relres = _blqmr.blqmr_solve_complex_multi(
+                n, nnz, nrhs, Ap_f, Ai_f, Ax_f, B_f, maxiter, tol, droptol, dopcond
+            )
+            return BLQMRResult(
+                x=X.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
+            )
     else:
-        B_f = np.asfortranarray(B, dtype=np.float64)
-        nrhs = B_f.shape[1]
-        X, flag, niter, relres = _blqmr.blqmr_solve_real_multi(
-            n, nnz, nrhs, Ap_f, Ai_f, Ax_f, B_f, maxiter, tol, droptol, dopcond
-        )
-        return BLQMRResult(
-            x=X.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
-        )
+        # Real path
+        Ax_f = np.asfortranarray(A_csc.data, dtype=np.float64)
+
+        if B.ndim == 1 or (B.ndim == 2 and B.shape[1] == 1):
+            # Single RHS
+            b_f = np.asfortranarray(B.ravel(), dtype=np.float64)
+            x, flag, niter, relres = _blqmr.blqmr_solve_real(
+                n, nnz, Ap_f, Ai_f, Ax_f, b_f, maxiter, tol, droptol, dopcond
+            )
+            return BLQMRResult(
+                x=x.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
+            )
+        else:
+            # Multiple RHS - use block method
+            B_f = np.asfortranarray(B, dtype=np.float64)
+            nrhs = B_f.shape[1]
+            X, flag, niter, relres = _blqmr.blqmr_solve_real_multi(
+                n, nnz, nrhs, Ap_f, Ai_f, Ax_f, B_f, maxiter, tol, droptol, dopcond
+            )
+            return BLQMRResult(
+                x=X.copy(), flag=int(flag), iter=int(niter), relres=float(relres)
+            )
 
 
 def _blqmr_native(
@@ -1042,7 +1249,10 @@ def _blqmr_native(
         try:
             M1 = make_preconditioner(A_sp, "ilu")
         except Exception:
-            M1 = make_preconditioner(A_sp, "diag")
+            try:
+                M1 = make_preconditioner(A_sp, "diag")
+            except Exception:
+                M1 = None  # Fall back to no preconditioning
 
     x, flag, relres, niter, resv = _blqmr_python_impl(
         A,

blocksolver-0.8.3.dist-info/METADATA

@@ -0,0 +1,442 @@
+Metadata-Version: 2.4
+Name: blocksolver
+Version: 0.8.3
+Summary: Block Quasi-Minimal-Residual sparse linear solver
+Home-page: https://blit.sourceforge.net
+Author: Qianqian Fang
+Author-email: Qianqian Fang <q.fang@neu.edu>
+License: BSD-3-Clause OR LGPL-3.0-or-later OR GPL-3.0-or-later
+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
+Keywords: sparse,linear-algebra,iterative-solver,qmr,fortran,umfpack
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+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"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# BlockSolver - Block Quasi-Minimal Residual (BLQMR) Sparse Linear Solver
+
+**BlockSolver** is a Python package for solving large sparse linear systems using the Block Quasi-Minimal Residual (BLQMR) algorithm. It provides both a high-performance Fortran backend and a pure Python/NumPy implementation for maximum portability.
+
+## Features
+
+- **Block QMR Algorithm**: Efficiently solves multiple right-hand sides simultaneously
+- **Complex Symmetric Support**: Designed for complex symmetric matrices (A = Aᵀ, not A = A†)
+- **Dual Backend**: Fortran extension for speed, Python fallback for portability
+- **ILU Preconditioning**: Built-in incomplete LU preconditioner for faster convergence
+- **SciPy Integration**: Works seamlessly with SciPy sparse matrices
+- **Optional Numba Acceleration**: JIT-compiled kernels for the Python backend
+
+## Algorithm
+
+### Block Quasi-Minimal Residual (BLQMR)
+
+The BLQMR algorithm is an iterative Krylov subspace method specifically designed for:
+
+1. **Complex symmetric systems**: Unlike standard methods that assume Hermitian (A = A†) or general matrices, BLQMR exploits complex symmetry (A = Aᵀ) which arises in electromagnetics, acoustics, and diffuse optical tomography.
+
+2. **Multiple right-hand sides**: Instead of solving each system independently, BLQMR processes all right-hand sides together in a block fashion, sharing Krylov subspace information and reducing total computation.
+
+3. **Quasi-minimal residual**: The algorithm minimizes a quasi-residual norm at each iteration, providing smooth convergence without the erratic behavior of some Krylov methods.
+
+### Key Components
+
+- **Quasi-QR Decomposition**: A modified Gram-Schmidt process using the quasi inner product ⟨x,y⟩ = Σ xₖyₖ (without conjugation) for complex symmetric systems.
+
+- **Three-term Lanczos Recurrence**: Builds an orthonormal basis for the Krylov subspace with short recurrences, minimizing memory usage.
+
+- **Block Updates**: Processes m right-hand sides simultaneously, with typical block sizes of 1-16.
+
+### When to Use BLQMR
+
+| Use Case | Recommendation |
+|----------|----------------|
+| Complex symmetric matrix (A = Aᵀ) | ✅ Ideal |
+| Multiple right-hand sides | ✅ Ideal |
+| Real symmetric positive definite | Consider CG first |
+| General non-symmetric | Consider GMRES or BiCGSTAB |
+| Very large systems (>10⁶ unknowns) | ✅ Good with preconditioning |
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install blocksolver
+```
+
+### From Source
+
+Prerequisites:
+- Python ≥ 3.8
+- NumPy ≥ 1.20
+- SciPy ≥ 1.0
+- (Optional) Fortran compiler + UMFPACK for the accelerated backend
+- (Optional) Numba for accelerated Python backend
+
+```bash
+# Ubuntu/Debian
+sudo apt install gfortran libsuitesparse-dev libblas-dev liblapack-dev
+
+# macOS
+brew install gcc suite-sparse openblas
+
+# Install
+cd python
+pip install .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from scipy.sparse import csc_matrix
+from blocksolver import blqmr
+
+# Create a sparse matrix
+A = csc_matrix([
+    [4, 1, 0, 0],
+    [1, 4, 1, 0],
+    [0, 1, 4, 1],
+    [0, 0, 1, 4]
+], dtype=float)
+
+b = np.array([1., 2., 3., 4.])
+
+# Solve Ax = b
+result = blqmr(A, b, tol=1e-10)
+
+print(f"Solution: {result.x}")
+print(f"Converged: {result.converged}")
+print(f"Iterations: {result.iter}")
+print(f"Relative residual: {result.relres:.2e}")
+```
+
+## Usage
+
+### Main Interface: `blqmr()`
+
+The primary function `blqmr()` automatically selects the best available backend (Fortran if available, otherwise Python).
+
+```python
+from blocksolver import blqmr, BLQMR_EXT
+
+# Check which backend is active
+print(f"Using Fortran backend: {BLQMR_EXT}")
+
+# Basic usage
+result = blqmr(A, b)
+
+# With options
+result = blqmr(A, b, 
+    tol=1e-8,           # Convergence tolerance
+    maxiter=1000,       # Maximum iterations
+    use_precond=True,   # Use ILU preconditioning
+)
+```
+
+### Multiple Right-Hand Sides
+
+BLQMR excels when solving the same system with multiple right-hand sides:
+
+```python
+import numpy as np
+from blocksolver import blqmr
+
+# 100 different right-hand sides
+B = np.random.randn(n, 100)
+
+# Solve all systems at once (much faster than solving individually)
+result = blqmr(A, B, tol=1e-8)
+
+# result.x has shape (n, 100)
+```
+
+### Complex Symmetric Systems
+
+BLQMR is specifically designed for complex symmetric matrices (common in frequency-domain wave problems):
+
+```python
+import numpy as np
+from blocksolver import blqmr
+
+# Complex symmetric matrix (A = A.T, NOT A.conj().T)
+A = create_helmholtz_matrix(frequency=1000)  # Your application
+b = np.complex128(source_term)
+
+result = blqmr(A, b, tol=1e-8)
+```
+
+### Custom Preconditioning
+
+For the Python backend, you can provide custom preconditioners:
+
+```python
+from blocksolver import blqmr, make_preconditioner
+
+# Create ILU preconditioner
+M1 = make_preconditioner(A, 'ilu')
+
+# Or diagonal (Jacobi) preconditioner
+M1 = make_preconditioner(A, 'diag')
+
+# Solve with custom preconditioner
+result = blqmr(A, b, M1=M1, use_precond=False)
+```
+
+### SciPy-Compatible Interface
+
+For drop-in replacement in existing code:
+
+```python
+from blocksolver import blqmr_scipy
+
+# Returns (x, flag) like scipy.sparse.linalg solvers
+x, flag = blqmr_scipy(A, b, tol=1e-10)
+```
+
+### Low-Level CSC Interface
+
+For maximum control, use the CSC component interface:
+
+```python
+from blocksolver import blqmr_solve
+
+# CSC format components (0-based indexing)
+Ap = np.array([0, 2, 5, 9, 10, 12], dtype=np.int32)  # Column pointers
+Ai = np.array([0, 1, 0, 2, 4, 1, 2, 3, 4, 2, 1, 4], dtype=np.int32)  # Row indices
+Ax = np.array([2., 3., 3., -1., 4., 4., -3., 1., 2., 2., 6., 1.])  # Values
+b = np.array([8., 45., -3., 3., 19.])
+
+result = blqmr_solve(Ap, Ai, Ax, b, 
+    tol=1e-8,
+    droptol=0.001,      # ILU drop tolerance (Fortran only)
+    use_precond=True,
+    zero_based=True,    # 0-based indexing (default)
+)
+```
+
+## API Reference
+
+### `blqmr(A, B, **kwargs) -> BLQMRResult`
+
+Main solver interface.
+
+**Parameters:**
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `A` | sparse matrix or ndarray | required | System matrix (n × n) |
+| `B` | ndarray | required | Right-hand side (n,) or (n × m) |
+| `tol` | float | 1e-6 | Convergence tolerance |
+| `maxiter` | int | n | Maximum iterations |
+| `M1`, `M2` | preconditioner | None | Custom preconditioners (Python backend) |
+| `x0` | ndarray | None | Initial guess |
+| `use_precond` | bool | True | Use ILU preconditioning |
+| `droptol` | float | 0.001 | ILU drop tolerance (Fortran backend) |
+| `residual` | bool | False | Use true residual for convergence (Python) |
+| `workspace` | BLQMRWorkspace | None | Pre-allocated workspace (Python) |
+
+**Returns:** `BLQMRResult` object with:
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `x` | ndarray | Solution vector(s) |
+| `flag` | int | 0=converged, 1=maxiter, 2=precond fail, 3=stagnation |
+| `iter` | int | Iterations performed |
+| `relres` | float | Final relative residual |
+| `converged` | bool | True if flag == 0 |
+| `resv` | ndarray | Residual history (Python backend only) |
+
+### `blqmr_solve(Ap, Ai, Ax, b, **kwargs) -> BLQMRResult`
+
+Low-level CSC interface.
+
+### `blqmr_solve_multi(Ap, Ai, Ax, B, **kwargs) -> BLQMRResult`
+
+Multiple right-hand sides with CSC input.
+
+### `blqmr_scipy(A, b, **kwargs) -> Tuple[ndarray, int]`
+
+SciPy-compatible interface returning `(x, flag)`.
+
+### `make_preconditioner(A, type) -> Preconditioner`
+
+Create a preconditioner for the Python backend.
+
+**Types:** `'diag'`/`'jacobi'`, `'ilu'`/`'ilu0'`, `'ssor'`
+
+### Utility Functions
+
+```python
+from blocksolver import (
+    BLQMR_EXT,        # True if Fortran backend available
+    HAS_NUMBA,        # True if Numba acceleration available
+    get_backend_info, # Returns dict with backend details
+    test,             # Run built-in tests
+)
+```
+
+## Performance Tips
+
+1. **Use the Fortran backend** when available (10-100× faster than Python)
+
+2. **Enable preconditioning** for ill-conditioned systems:
+   ```python
+   result = blqmr(A, b, use_precond=True)
+   ```
+
+3. **Batch multiple right-hand sides** instead of solving one at a time:
+   ```python
+   # Fast: single call with all RHS
+   result = blqmr(A, B_matrix)
+   
+   # Slow: multiple calls
+   for b in B_columns:
+       result = blqmr(A, b)
+   ```
+
+4. **Install Numba** for faster Python backend:
+   ```bash
+   pip install numba
+   ```
+
+5. **Reuse workspace** for repeated solves with the same dimensions:
+   ```python
+   from blocksolver import BLQMRWorkspace
+   ws = BLQMRWorkspace(n, m)
+   for b in many_rhs:
+       result = blqmr(A, b, workspace=ws)
+   ```
+
+## Examples
+
+### Diffuse Optical Tomography
+
+```python
+import numpy as np
+from scipy.sparse import diags, kron, eye
+from blocksolver import blqmr
+
+def create_diffusion_matrix(nx, ny, D=1.0, mu_a=0.01, omega=1e9):
+    """Create 2D diffusion matrix for DOT."""
+    n = nx * ny
+    h = 1.0 / nx
+    
+    # Laplacian
+    Lx = diags([-1, 2, -1], [-1, 0, 1], shape=(nx, nx)) / h**2
+    Ly = diags([-1, 2, -1], [-1, 0, 1], shape=(ny, ny)) / h**2
+    L = kron(eye(ny), Lx) + kron(Ly, eye(nx))
+    
+    # Diffusion equation: (-D∇² + μ_a + iω/c) φ = q
+    c = 3e10  # speed of light in tissue (cm/s)
+    A = -D * L + mu_a * eye(n) + 1j * omega / c * eye(n)
+    
+    return A.tocsc()
+
+# Setup problem
+A = create_diffusion_matrix(100, 100, omega=2*np.pi*100e6)
+sources = np.random.randn(10000, 16)  # 16 source positions
+
+# Solve for all sources at once
+result = blqmr(A, sources, tol=1e-8)
+print(f"Solved {sources.shape[1]} systems in {result.iter} iterations")
+```
+
+### Frequency-Domain Acoustics
+
+```python
+import numpy as np
+from blocksolver import blqmr
+
+# Helmholtz equation: (∇² + k²)p = f
+# Results in complex symmetric matrix
+
+def solve_helmholtz(K, M, f, frequencies):
+    """Solve Helmholtz at multiple frequencies."""
+    solutions = []
+    for omega in frequencies:
+        # A = K - ω²M (complex symmetric if K, M are symmetric)
+        A = K - omega**2 * M
+        result = blqmr(A, f, tol=1e-10)
+        solutions.append(result.x)
+    return np.array(solutions)
+```
+
+## Troubleshooting
+
+### "No Fortran backend available"
+
+Install the package with Fortran support:
+```bash
+# Install dependencies first
+sudo apt install gfortran libsuitesparse-dev  # Linux
+brew install gcc suite-sparse                  # macOS
+
+# Reinstall blocksolver
+pip install --no-cache-dir blocksolver
+```
+
+### Slow convergence
+
+1. Enable preconditioning: `use_precond=True`
+2. Reduce ILU drop tolerance: `droptol=1e-4` (Fortran backend)
+3. Check matrix conditioning with `np.linalg.cond(A.toarray())`
+
+### Memory issues with large systems
+
+1. Use the Fortran backend (more memory efficient)
+2. Reduce block size for multiple RHS
+3. Use iterative refinement instead of tighter tolerance
+
+## License
+
+BSD-3-Clause / LGPL-3.0+ / GPL-3.0+ (tri-licensed)
+
+## Citation
+
+If you use BlockSolver in your research, please cite:
+
+```bibtex
+@software{blocksolver,
+  author = {Qianqian Fang},
+  title = {BlockSolver: Block Quasi-Minimal Residual Sparse Linear Solver},
+  url = {https://github.com/fangq/blit},
+  year = {2024}
+}
+```
+
+## See Also
+
+- [BLIT](https://github.com/fangq/blit) - The underlying Fortran library
+- [SciPy sparse.linalg](https://docs.scipy.org/doc/scipy/reference/sparse.linalg.html) - Other iterative solvers
+- [PyAMG](https://github.com/pyamg/pyamg) - Algebraic multigrid solvers

blocksolver-0.8.3.dist-info/RECORD

@@ -0,0 +1,6 @@
+blocksolver/__init__.py,sha256=uiwFH4fykkobMnkGeFrumVpE5uBaBqcRlc0uZd4SXF8,1899
+blocksolver/blqmr.py,sha256=b2xJ3MiB7UKyMDLG1Y90B_73nSm7sGxdCSqjBNZF6Y8,39741
+blocksolver-0.8.3.dist-info/METADATA,sha256=EfQ7I6rza5PVtpHqdD2ZSxF5TwN3gFiHR9yNlJ02Yu4,13387
+blocksolver-0.8.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+blocksolver-0.8.3.dist-info/top_level.txt,sha256=R5OAf1b8tkdMHqg8VgcfGMg6vbYt25p9JNq2Pk_VlbA,12
+blocksolver-0.8.3.dist-info/RECORD,,

blocksolver-0.8.1.dist-info/METADATA

@@ -1,162 +0,0 @@
-Metadata-Version: 2.4
-Name: blocksolver
-Version: 0.8.1
-Summary: Block Quasi-Minimal-Residual sparse linear solver
-Home-page: https://blit.sourceforge.net
-Author: Qianqian Fang
-Author-email: Qianqian Fang <q.fang@neu.edu>
-License: BSD-3-Clause OR LGPL-3.0-or-later OR GPL-3.0-or-later
-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
-Keywords: sparse,linear-algebra,iterative-solver,qmr,fortran,umfpack
-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
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-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"
-Dynamic: author
-Dynamic: home-page
-Dynamic: requires-python
-
-# 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.8.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-blocksolver/__init__.py,sha256=ddfrZdsGFpV3Dqhe-t7U8SqkrjWWcS58XJJQv2BWEzw,1899
-blocksolver/blqmr.py,sha256=n5QXKs4izQGj25uKFIzaXUA4yFfA6v18evte5R25Apk,31765
-blocksolver-0.8.1.dist-info/METADATA,sha256=lqbeHjgwgD3ZeFXUIxTjlWzleIdji4AvneCy9r8js10,4408
-blocksolver-0.8.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-blocksolver-0.8.1.dist-info/top_level.txt,sha256=R5OAf1b8tkdMHqg8VgcfGMg6vbYt25p9JNq2Pk_VlbA,12
-blocksolver-0.8.1.dist-info/RECORD,,