structsolve 0.4.1__tar.gz → 0.4.2__tar.gz

{structsolve-0.4.1/structsolve.egg-info → structsolve-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.4.1
+Version: 0.4.2
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -60,7 +60,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.1). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -75,8 +75,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.1 (2026-09-17)
-    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could return buckling loads higher than the critical ones
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

{structsolve-0.4.1 → structsolve-0.4.2}/README.md

@@ -23,7 +23,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.1). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -38,8 +38,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.1 (2026-09-17)
-    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could return buckling loads higher than the critical ones
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

{structsolve-0.4.1 → structsolve-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "structsolve"
-version = "0.4.1"
+version = "0.4.2"
 description = "Structural analysis solvers"
 readme = "README.md"
 license = {text = "BSD-2-Clause"}

structsolve-0.4.2/structsolve/linear_buckling.py

@@ -0,0 +1,357 @@
+import warnings
+
+import numpy as np
+from scipy.sparse import csc_matrix, csr_matrix
+from scipy.sparse.linalg import eigsh, splu
+from scipy.linalg import eigh, LinAlgError
+
+from .logger import msg, warn
+from .sparseutils import remove_null_cols
+
+
+def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
+    r"""Shift of the Cayley mode used by :func:`lb`
+
+    With ``sigma > 0``, ``eigsh(A=KG, M=K, sigma=sigma, mode='cayley',
+    which='SM')`` returns the eigenvalues `\mu` of ``KG u = mu K u`` with the
+    smallest `|(\mu + \sigma)/(\mu - \sigma)|`. This ordering selects the most
+    negative `\mu`, i.e. the lowest positive load multipliers `-1/\mu`, only
+    when `\sigma` is larger than `|\mu|` of these critical eigenvalues.
+    Otherwise the eigenvalues closest to `-\sigma` are returned.
+
+    The largest `|\mu|` is estimated with power iterations on
+    `[K]^{-1}[K_G]`, whose norm ratio in the `[K]`-norm increases towards the
+    largest `|\mu|`, and multiplied by ``safety``. The default shift ``1.`` is
+    returned when ``K`` is singular, not positive definite, or the linear
+    solution is inaccurate.
+
+    """
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(K))
+        x = np.random.RandomState(42).randn(K.shape[0])
+        Kx = K @ x
+        mu_max = 0.
+        for i in range(max_iter):
+            xKx = x @ Kx
+            if not np.isfinite(xKx) or xKx <= 0:
+                return 1.
+            x = x / np.sqrt(xKx)
+            rhs = KG @ x
+            y = lu.solve(rhs)
+            Ky = K @ y
+            if i == 0:
+                residual = np.linalg.norm(Ky - rhs)
+                if not residual <= 1e-6 * np.linalg.norm(rhs):
+                    return 1.
+            # ||y||_K / ||x||_K, with ||x||_K = 1
+            ratio = np.sqrt(abs(y @ Ky))
+            if not np.isfinite(ratio) or ratio == 0:
+                return 1.
+            converged = i > 0 and ratio - mu_max <= rel_tol * ratio
+            mu_max = max(mu_max, ratio)
+            if converged:
+                break
+            x, Kx = y, Ky
+        return safety * mu_max
+    except Exception:
+        return 1.
+
+
+def _is_positive_definite(A):
+    """Tells if the symmetric sparse matrix ``A`` is positive definite
+
+    ``A`` is factorized with a symmetric permutation and without row
+    interchanges. The Gaussian elimination of a positive definite matrix
+    never finds a zero or negative pivot, and by Sylvester's law of inertia
+    any negative pivot means a negative eigenvalue of ``A``.
+
+    """
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(A), permc_spec='MMD_AT_PLUS_A',
+                      diag_pivot_thresh=0., options=dict(SymmetricMode=True))
+    except RuntimeError:
+        # exactly singular
+        return False
+    if not np.array_equal(lu.perm_r, lu.perm_c):
+        # a zero pivot forced a row interchange
+        return False
+    return bool(np.all(lu.U.diagonal() > 0))
+
+
+def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4):
+    r"""Verify the eigenpairs of `([K] + \lambda [K_G])\{u\} = \{0\}`
+
+    - The relative residual
+      `||K u + \lambda K_G u|| / (||K u|| + |\lambda| ||K_G u||)` of every
+      eigenpair with a finite `\lambda` must not be larger than ``rtol``.
+    - No load multiplier is missing below the lowest positive `\lambda_1`
+      of ``eigvals``: when ``K`` is positive definite, `[K] + s [K_G]` with
+      `s = \lambda_1 (1 - min\_rel\_gap)` must also be positive definite.
+
+    Returns
+    -------
+    error : str or None
+        Description of the failed check, ``None`` when all checks passed.
+
+    """
+    finite = np.isfinite(eigvals)
+    if not np.any(finite):
+        return 'no finite load multiplier was found'
+    lam = eigvals[finite]
+    u = eigvecs[:, finite]
+    Ku = K @ u
+    KGu = KG @ u
+    num = np.linalg.norm(Ku + KGu*lam, axis=0)
+    den = np.linalg.norm(Ku, axis=0) + np.abs(lam)*np.linalg.norm(KGu, axis=0)
+    residual = np.full(lam.shape, np.inf)
+    np.divide(num, den, out=residual, where=den > 0)
+    if not np.all(residual <= rtol):
+        i = np.argmax(np.nan_to_num(residual, nan=np.inf))
+        return ('relative residual {0:.2e} > {1:.1e} for the load multiplier '
+                '{2}'.format(residual[i], rtol, lam[i]))
+    positive = lam[lam > 0]
+    if positive.size and _is_positive_definite(K):
+        s = positive.min()*(1 - min_rel_gap)
+        if not _is_positive_definite(K + s*KG):
+            return ('at least one load multiplier lower than {0} is missing'
+                    .format(positive.min()))
+    return None
+
+
+def _sort_eigenpairs(mu, eigvecs):
+    r"""Sort by increasing `\mu`, i.e. the positive `\lambda = -1/\mu` first
+    in increasing order, as returned by :func:`scipy.linalg.eigh`"""
+    order = np.argsort(mu, kind='stable')
+    return mu[order], eigvecs[:, order]
+
+
+def _eigh_condensed(K, KG, k):
+    r"""Dense solution after condensing out the dofs where ``KG`` is null
+
+    With the dofs split in `b`, where `[K_G]` has non-null rows, and `a`,
+    where it does not, the static condensation of the `a` dofs gives:
+
+    .. math::
+
+        ([K_{bb}] - [K_{ba}][K_{aa}]^{-1}[K_{ab}]
+         + \lambda [K_{G_{bb}}])\{u_b\} = \{0\}, \qquad
+        \{u_a\} = -[K_{aa}]^{-1}[K_{ab}]\{u_b\}
+
+    solved with :func:`scipy.linalg.eigh`, which requires a positive
+    definite Schur complement. Returns the ``k`` lowest eigenvalues `\mu` of
+    `K_G u = \mu K u` and the corresponding eigenvectors.
+
+    """
+    active = np.asarray(abs(KG).sum(axis=1)).ravel() > 0
+    b = np.flatnonzero(active)
+    a = np.flatnonzero(~active)
+    if b.size == 0:
+        raise ValueError('KG is a null matrix')
+    K = csr_matrix(K)
+    KGbb = csr_matrix(KG)[b, :][:, b].toarray()
+    S = K[b, :][:, b].toarray()
+    if a.size:
+        Kab = csc_matrix(K[a, :][:, b])
+        Kba = K[b, :][:, a]
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            lu = splu(csc_matrix(K[a, :][:, a]))
+        # solving blocks of right-hand sides with at most ~1e7 entries
+        chunk = max(1, int(1e7) // a.size)
+        for j0 in range(0, b.size, chunk):
+            j1 = min(j0 + chunk, b.size)
+            X = lu.solve(Kab[:, j0:j1].toarray())
+            S[:, j0:j1] -= Kba @ X
+    mu, ub = eigh(a=0.5*(KGbb + KGbb.T), b=0.5*(S + S.T))
+    k = min(k, b.size)
+    ub = ub[:, :k]
+    eigvecs = np.zeros((K.shape[0], k), dtype=ub.dtype)
+    eigvecs[b, :] = ub
+    if a.size:
+        eigvecs[a, :] = -lu.solve(np.asarray(Kab @ ub))
+    return mu[:k], eigvecs
+
+
+def _eigsh_cayley(K, KG, k, tol, silent):
+    """Solution with :func:`scipy.sparse.linalg.eigsh` in Cayley mode"""
+    sigma = _estimate_sigma(K, KG)
+    msg('sigma={0}'.format(sigma), level=4, silent=silent)
+    k = min(k, K.shape[0] - 2)
+    mu, eigvecs = eigsh(A=KG, k=k, which='SM', M=K, tol=tol, sigma=sigma,
+                        mode='cayley')
+    return _sort_eigenpairs(mu, eigvecs)
+
+
+def lb(K, KG, tol=0, sparse_solver=True, silent=False,
+       num_eigvalues=25, num_eigvalues_print=5,
+       skip_null_cols=False, max_dense_size=2000, check_rtol=1e-3):
+    r"""Linear buckling analysis
+
+    Calculates the eigenvalues `\lambda` and eigenvectors `\{u\}` of the
+    eigenvalue problem:
+
+    .. math::
+
+        ([K] + \lambda [K_G])\{u\} = \{0\}
+
+    where `\lambda` is the load multiplier of the load state that generated
+    `[K_G]`. It can also be used for more general eigenvalue analyses, e.g.
+    if ``K`` is the tangent stiffness matrix of a given load state. The null
+    rows and columns of ``K`` are removed from both matrices before solving
+    the eigenvalue problem, unless ``skip_null_cols=True``.
+
+    Parameters
+    ----------
+    K : sparse_matrix
+        Stiffness matrix. Should include all constant terms of the initial
+        stress stiffness matrix, aerodynamic matrix and so forth when
+        applicable.
+    KG : sparse_matrix
+        Initial stress stiffness matrix that multiplies the load multiplier
+        `\lambda` of the eigenvalue problem.
+    tol : float, optional
+        A float tolerance passed to :func:`scipy.sparse.linalg.eigsh`.
+    sparse_solver : bool, optional
+        With ``True``, when ``KG`` has at most ``max_dense_size`` non-null
+        rows, the other dofs (typically the in-plane dofs) are condensed out
+        with a sparse factorization of ``K`` and the condensed problem is
+        solved with :func:`scipy.linalg.eigh`. Otherwise, or when this
+        solution fails, :func:`scipy.sparse.linalg.eigsh` solves the full
+        problem in Cayley mode, with a shift estimated from the matrices.
+        The eigenpairs are verified as described in the Notes, and
+        ``num_eigvalues`` load multipliers are returned.
+        With ``False``, :func:`scipy.linalg.eigh` solves the full problem,
+        returning all load multipliers, and requires a positive definite
+        ``K``.
+    silent : bool, optional
+        A boolean to tell whether the log messages should be printed.
+    num_eigvalues : int, optional
+        Number of load multipliers calculated with the sparse solver, and
+        number of returned eigenvectors.
+    num_eigvalues_print : int, optional
+        Number of eigenvalues to print.
+    skip_null_cols : bool, optional
+        If True, skip the removal of null columns from the matrices.
+        Use only when K is known to be non-singular.
+    max_dense_size : int, optional
+        Maximum number of non-null rows of ``KG`` for which the sparse solver
+        solves the condensed problem with :func:`scipy.linalg.eigh`. Use
+        ``0`` to always use :func:`scipy.sparse.linalg.eigsh`.
+    check_rtol : float, optional
+        Maximum relative residual of the eigenpairs of the sparse solver,
+        see the Notes.
+
+    Returns
+    -------
+    eigvals : ndarray
+        The load multipliers `\lambda`, calculated as ``-1/eigval`` from the
+        eigenvalues ``eigval`` of ``KG u = eigval K u``. The positive load
+        multipliers come first in increasing order, followed by the negative
+        ones, for both solvers.
+    eigvecs : ndarray
+        The `i^{th}` eigenvector is ``eigvecs[:, i]``, with the size of the
+        original matrices. Only ``num_eigvalues`` eigenvectors are returned.
+
+    Raises
+    ------
+    RuntimeError
+        When no eigenpairs of the sparse solver pass the verification.
+
+    Notes
+    -----
+    The eigenpairs of the sparse solver are verified as follows:
+
+    - the relative residual
+      `||K u + \lambda K_G u|| / (||K u|| + |\lambda| ||K_G u||)` of each
+      eigenpair must not be larger than ``check_rtol``;
+    - when ``K`` is positive definite, `[K] + s [K_G]` must also be positive
+      definite for `s` slightly lower than the lowest positive load
+      multiplier found, i.e. no lower load multiplier was missed. The
+      factorization is done with SuperLU, without row interchanges.
+
+    When the condensed dense solution fails the verification,
+    :func:`scipy.sparse.linalg.eigsh` is tried, and a ``RuntimeError`` is
+    raised when it also fails.
+
+    ARPACK, used by :func:`scipy.sparse.linalg.eigsh`, returns wrong
+    eigenpairs at random, without any error, when linked against Intel MKL
+    2024.2.0 to 2025.0.0, e.g. in some Anaconda builds of SciPy: the
+    ``dsteqr`` routine of these MKL versions returns wrong eigenvectors for
+    matrices larger than 32 x 32. MKL 2025.0.1 or newer is not affected.
+
+    """
+    msg('Running linear buckling analysis...', silent=silent)
+
+    msg('Eigenvalue solver... ', level=2, silent=silent)
+
+    size = KG.shape[0]
+    if skip_null_cols:
+        used_cols = None
+    else:
+        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
+    if sparse_solver:
+        K = csr_matrix(K)
+        KG = csr_matrix(KG)
+        num_active = int(np.count_nonzero(abs(KG).sum(axis=1)))
+        solvers = []
+        if num_active <= max_dense_size:
+            solvers.append(('eigh() with condensed dofs',
+                            lambda: _eigh_condensed(K, KG, num_eigvalues)))
+        solvers.append(('eigsh()',
+                        lambda: _eigsh_cayley(K, KG, num_eigvalues, tol,
+                                              silent)))
+        errors = []
+        for name, solver in solvers:
+            msg('{0} solver ({1} of {2} rows of KG are non-null)...'.format(
+                name, num_active, K.shape[0]), level=3, silent=silent)
+            try:
+                eigvals, peigvecs = solver()
+                with np.errstate(divide='ignore'):
+                    error = _check_eigenpairs(K, KG, -1./eigvals, peigvecs,
+                                              check_rtol)
+            except (LinAlgError, RuntimeError, ValueError) as e:
+                error = '{0}: {1}'.format(type(e).__name__, e)
+            if error is None:
+                msg('finished!', level=3, silent=silent)
+                break
+            warn('{0} solver failed: {1}'.format(name, error), level=3,
+                 silent=silent)
+            errors.append('{0} solver: {1}'.format(name, error))
+        else:
+            raise RuntimeError(
+                'Linear buckling analysis failed, no eigenvalue solver passed '
+                'the verification ({0}). When ARPACK is linked against Intel '
+                'MKL 2024.2.0 to 2025.0.0, update MKL to 2025.0.1 or newer. '
+                'Otherwise, try sparse_solver=False or a larger '
+                'max_dense_size.'.format('; '.join(errors)))
+
+    else:
+        K = K.toarray()
+        KG = KG.toarray()
+        msg('eigh() solver...', level=3, silent=silent)
+        eigvals, peigvecs = eigh(a=KG, b=K)
+        msg('finished!', level=3, silent=silent)
+
+    num_eigvecs = min(num_eigvalues, peigvecs.shape[1])
+    if used_cols is not None:
+        eigvecs = np.zeros((size, num_eigvecs), dtype=peigvecs.dtype)
+        eigvecs[used_cols, :] = peigvecs[:, :num_eigvecs]
+    else:
+        eigvecs = peigvecs[:, :num_eigvecs]
+
+    with np.errstate(divide='ignore'):
+        eigvals = -1./eigvals
+
+    msg('finished!', level=2, silent=silent)
+
+    msg('first {0} eigenvalues:'.format(num_eigvalues_print), level=1,
+        silent=silent)
+
+    for eig in eigvals[:num_eigvalues_print]:
+        msg('{0}'.format(eig), level=2, silent=silent)
+
+    return eigvals, eigvecs

{structsolve-0.4.1 → structsolve-0.4.2/structsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.4.1
+Version: 0.4.2
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -60,7 +60,7 @@ Currently these solvers are pretty much compatible with my other repositories
 Citing this library
 ===================
 
-Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.1). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.4.2). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -75,8 +75,18 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.4.1 (2026-09-17)
-    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could return buckling loads higher than the critical ones
+* version 0.4.2 (2026-09-17)
+    - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
+      return buckling loads higher than the critical ones
+    - Fixed wrong buckling loads of the sparse solver of `lb` when SciPy is
+      linked against Intel MKL 2024.2.0 to 2025.0.0 (e.g. Anaconda on
+      Windows), whose `dsteqr` routine breaks ARPACK
+    - `lb` condenses out the dofs where `KG` is null and solves small
+      condensed problems with a dense solver
+    - `lb` verifies the eigenpairs of the sparse solver, raising an error
+      instead of returning wrong results
+    - The sparse solver of `lb` returns the load multipliers sorted as the
+      dense solver
     - Newton-Raphson with full Newton iterations and a relative convergence
       criterion by default, reaching quadratic convergence with exact tangent
       stiffness matrices

{structsolve-0.4.1 → structsolve-0.4.2}/tests/test_linear_buckling.py

@@ -1,4 +1,6 @@
 """Tests for structsolve.linear_buckling: lb()"""
+import os
+
 import numpy as np
 import pytest
 from scipy.sparse import csc_matrix
@@ -41,14 +43,15 @@ def test_lb_dense_solver():
     np.testing.assert_allclose(eigvals[:5], -2.0, rtol=1e-6)
 
 
-def test_lb_sparse_shift_mixed_spectrum():
+@pytest.mark.parametrize('max_dense_size', [0, 2000])
+def test_lb_sparse_shift_mixed_spectrum(max_dense_size):
     """Sparse and dense lb agree when the load multipliers have mixed signs
 
     Regression test: the shift of the sparse solver was a single Rayleigh
     quotient, in which the positive and negative eigenvalues of
     ``KG u = mu K u`` cancel. The shift landed below the critical ``|mu|``
     and eigsh returned the load multipliers near ``1/sigma`` instead of the
-    lowest ones.
+    lowest ones. With ``max_dense_size=0`` eigsh is always used.
     """
     from scipy.sparse import diags
     from structsolve.linear_buckling import _estimate_sigma
@@ -65,13 +68,167 @@ def test_lb_sparse_shift_mixed_spectrum():
     # the shift must bound the largest |mu| of the critical eigenvalues
     assert _estimate_sigma(K, KG) >= np.abs(mu).max()
 
-    eig_sparse, _ = lb(K, KG, silent=True, num_eigvalues=10)
+    eig_sparse, _ = lb(K, KG, silent=True, num_eigvalues=10,
+                       max_dense_size=max_dense_size)
     eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
     np.testing.assert_allclose(eig_sparse[:4], [1.0, 1.0, 1.1, 1.2],
                                rtol=1e-8)
     np.testing.assert_allclose(eig_sparse[:4], eig_dense[:4], rtol=1e-8)
 
 
+DATA = os.path.join(os.path.dirname(__file__), 'data')
+
+# K and KG of panels models, null rows and columns removed, with the
+# critical load multipliers of the dense solver
+SAVED_MATRICES = [
+    ('plate_ssss_Nxx', [157.5386, 226.3470, 232.5623]),
+    ('cylinder_5panels', [473.1924, 473.1924, 478.6168]),
+]
+
+
+def load_saved_matrices(name):
+    from scipy.sparse import load_npz
+    K = load_npz(os.path.join(DATA, '%s_K.npz' % name)).tocsr()
+    KG = load_npz(os.path.join(DATA, '%s_KG.npz' % name)).tocsr()
+    return K, KG
+
+
+def relative_residuals(K, KG, eigvals, eigvecs):
+    Ku = K @ eigvecs
+    KGu = KG @ eigvecs
+    return (np.linalg.norm(Ku + KGu*eigvals, axis=0)
+            / (np.linalg.norm(Ku, axis=0)
+               + np.abs(eigvals)*np.linalg.norm(KGu, axis=0)))
+
+
+@pytest.mark.parametrize('name, ref', SAVED_MATRICES)
+def test_lb_saved_matrices_sparse_solver(name, ref):
+    """Regression test: ARPACK linked against Intel MKL 2024.2.0 to 2025.0.0
+    returned wrong load multipliers at random, e.g. with the Anaconda builds
+    of SciPy. The default sparse solver condenses out the dofs where KG is
+    null and verifies the eigenpairs"""
+    K, KG = load_saved_matrices(name)
+    eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_dense[:3], ref, rtol=1e-5)
+    for trial in range(3):
+        eigvals, eigvecs = lb(K, KG, silent=True)
+        assert eigvals.shape == (25,)
+        assert eigvecs.shape == (K.shape[0], 25)
+        np.testing.assert_allclose(eigvals, eig_dense[:25], rtol=1e-6)
+        assert np.all(relative_residuals(K, KG, eigvals, eigvecs) < 1e-6)
+
+
+@pytest.mark.parametrize('name, ref', SAVED_MATRICES)
+def test_lb_saved_matrices_eigsh_never_wrong(name, ref):
+    """With max_dense_size=0 only eigsh is used, which either returns the
+    correct load multipliers or raises a RuntimeError, when the eigenpairs
+    returned by ARPACK are wrong"""
+    K, KG = load_saved_matrices(name)
+    for trial in range(3):
+        try:
+            eigvals, eigvecs = lb(K, KG, silent=True, max_dense_size=0)
+        except RuntimeError as e:
+            assert 'verification' in str(e)
+            continue
+        np.testing.assert_allclose(eigvals[:3], ref, rtol=1e-5)
+        assert np.all(eigvals[:-1] <= eigvals[1:])
+
+
+def test_lb_check_eigenpairs():
+    """The verification detects wrong eigenpairs and a missing lowest load
+    multiplier"""
+    from structsolve.linear_buckling import _check_eigenpairs, _eigh_condensed
+
+    K, KG = load_saved_matrices('plate_ssss_Nxx')
+    mu, eigvecs = _eigh_condensed(K, KG, 10)
+    eigvals = -1./mu
+    assert _check_eigenpairs(K, KG, eigvals, eigvecs, 1e-3) is None
+
+    # eigenvectors of other eigenvalues
+    error = _check_eigenpairs(K, KG, eigvals, eigvecs[:, ::-1], 1e-3)
+    assert 'relative residual' in error
+
+    # wrong eigenvalues
+    error = _check_eigenpairs(K, KG, eigvals*1.01, eigvecs, 1e-3)
+    assert 'relative residual' in error
+
+    # lowest load multiplier missing
+    error = _check_eigenpairs(K, KG, eigvals[1:], eigvecs[:, 1:], 1e-3)
+    assert 'missing' in error
+
+    # both equal critical load multipliers missing
+    K, KG = load_saved_matrices('cylinder_5panels')
+    mu, eigvecs = _eigh_condensed(K, KG, 10)
+    eigvals = -1./mu
+    assert _check_eigenpairs(K, KG, eigvals, eigvecs, 1e-3) is None
+    error = _check_eigenpairs(K, KG, eigvals[2:], eigvecs[:, 2:], 1e-3)
+    assert 'missing' in error
+
+
+def test_lb_sparse_raises_when_verification_fails(monkeypatch):
+    """A RuntimeError is raised instead of returning wrong eigenpairs"""
+    import structsolve.linear_buckling as linear_buckling
+
+    K, KG = load_saved_matrices('plate_ssss_Nxx')
+
+    def wrong_eigsh(K, KG, k, tol, silent):
+        rng = np.random.RandomState(0)
+        return -rng.rand(k), rng.randn(K.shape[0], k)
+
+    monkeypatch.setattr(linear_buckling, '_eigsh_cayley', wrong_eigsh)
+    with pytest.raises(RuntimeError, match='verification'):
+        lb(K, KG, silent=True, max_dense_size=0)
+    # the condensed dense solution is used first
+    eigvals, _ = lb(K, KG, silent=True)
+    np.testing.assert_allclose(eigvals[0], 157.5386, rtol=1e-5)
+
+
+@pytest.mark.parametrize('max_dense_size', [0, 2000])
+def test_lb_sparse_sorted_as_dense(max_dense_size):
+    """The sparse solver returns the positive load multipliers first, in
+    increasing order, followed by the negative ones, as the dense solver"""
+    from scipy.sparse import diags
+
+    n = 40
+    k = np.linspace(1., 3., n)
+    rng = np.random.RandomState(1)
+    lambdas = rng.permutation(np.concatenate([np.linspace(1., 20., 5),
+                                              -np.linspace(1., 20., n - 5)]))
+    K = diags(k).tocsr()
+    KG = diags(-k/lambdas).tocsr()
+    eig_sparse, eigvecs = lb(K, KG, silent=True, num_eigvalues=10,
+                             max_dense_size=max_dense_size)
+    eig_dense, _ = lb(K, KG, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_sparse, eig_dense[:10], rtol=1e-8)
+    np.testing.assert_allclose(eig_sparse[:5], np.linspace(1., 20., 5),
+                               rtol=1e-8)
+    assert np.all(eig_sparse[5:] < 0)
+    assert np.all(relative_residuals(K, KG, eig_sparse, eigvecs) < 1e-8)
+
+
+def test_lb_sparse_null_KG_rows_and_null_cols():
+    """Condensed solution with null rows of KG and null rows of K, returning
+    eigenvectors with the size of the original matrices"""
+    from scipy.sparse import random as sprandom, identity, bmat
+
+    n = 60
+    A = sprandom(n, n, density=0.1, random_state=2)
+    K = (A @ A.T + identity(n)).tocsr()
+    B = sprandom(n//3, n//3, density=0.3, random_state=3)
+    KG = bmat([[-(B @ B.T + 0.1*identity(n//3)), None],
+               [None, csc_matrix((n - n//3, n - n//3))]]).tocsr()
+    # adding two null dofs
+    Z = csc_matrix((2, 2))
+    K2 = bmat([[K, None], [None, Z]]).tocsr()
+    KG2 = bmat([[KG, None], [None, Z]]).tocsr()
+    eig_sparse, eigvecs = lb(K2, KG2, silent=True, num_eigvalues=10)
+    eig_dense, _ = lb(K2, KG2, silent=True, sparse_solver=False)
+    np.testing.assert_allclose(eig_sparse, eig_dense[:10], rtol=1e-8)
+    assert eigvecs.shape == (n + 2, 10)
+    assert np.all(eigvecs[n:, :] == 0)
+    assert np.all(relative_residuals(K2, KG2, eig_sparse, eigvecs) < 1e-8)
+
+
 def test_lb_sparse_singular_K():
     """The shift falls back to 1 when K is singular"""
     from structsolve.linear_buckling import _estimate_sigma

structsolve-0.4.1/structsolve/linear_buckling.py

@@ -1,163 +0,0 @@
-import warnings
-
-import numpy as np
-from scipy.sparse import csc_matrix
-from scipy.sparse.linalg import eigsh, splu
-from scipy.linalg import eigh
-
-from .logger import msg, warn
-from .sparseutils import remove_null_cols
-
-
-def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
-    r"""Shift of the Cayley mode used by :func:`lb`
-
-    With ``sigma > 0``, ``eigsh(A=KG, M=K, sigma=sigma, mode='cayley',
-    which='SM')`` returns the eigenvalues `\mu` of ``KG u = mu K u`` with the
-    smallest `|(\mu + \sigma)/(\mu - \sigma)|`. This ordering selects the most
-    negative `\mu`, i.e. the lowest positive load multipliers `-1/\mu`, only
-    when `\sigma` is larger than `|\mu|` of these critical eigenvalues.
-    Otherwise the eigenvalues closest to `-\sigma` are returned.
-
-    The largest `|\mu|` is estimated with power iterations on
-    `[K]^{-1}[K_G]`, whose norm ratio in the `[K]`-norm increases towards the
-    largest `|\mu|`, and multiplied by ``safety``. The default shift ``1.`` is
-    returned when ``K`` is singular, not positive definite, or the linear
-    solution is inaccurate.
-
-    """
-    try:
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            lu = splu(csc_matrix(K))
-        x = np.random.RandomState(42).randn(K.shape[0])
-        Kx = K @ x
-        mu_max = 0.
-        for i in range(max_iter):
-            xKx = x @ Kx
-            if not np.isfinite(xKx) or xKx <= 0:
-                return 1.
-            x = x / np.sqrt(xKx)
-            rhs = KG @ x
-            y = lu.solve(rhs)
-            Ky = K @ y
-            if i == 0:
-                residual = np.linalg.norm(Ky - rhs)
-                if not residual <= 1e-6 * np.linalg.norm(rhs):
-                    return 1.
-            # ||y||_K / ||x||_K, with ||x||_K = 1
-            ratio = np.sqrt(abs(y @ Ky))
-            if not np.isfinite(ratio) or ratio == 0:
-                return 1.
-            converged = i > 0 and ratio - mu_max <= rel_tol * ratio
-            mu_max = max(mu_max, ratio)
-            if converged:
-                break
-            x, Kx = y, Ky
-        return safety * mu_max
-    except Exception:
-        return 1.
-
-def lb(K, KG, tol=0, sparse_solver=True, silent=False,
-       num_eigvalues=25, num_eigvalues_print=5,
-       skip_null_cols=False):
-    r"""Linear buckling analysis
-
-    Calculates the eigenvalues `\lambda` and eigenvectors `\{u\}` of the
-    eigenvalue problem:
-
-    .. math::
-
-        ([K] + \lambda [K_G])\{u\} = \{0\}
-
-    where `\lambda` is the load multiplier of the load state that generated
-    `[K_G]`. It can also be used for more general eigenvalue analyses, e.g.
-    if ``K`` is the tangent stiffness matrix of a given load state. The null
-    rows and columns of ``K`` are removed from both matrices before solving
-    the eigenvalue problem, unless ``skip_null_cols=True``.
-
-    Parameters
-    ----------
-    K : sparse_matrix
-        Stiffness matrix. Should include all constant terms of the initial
-        stress stiffness matrix, aerodynamic matrix and so forth when
-        applicable.
-    KG : sparse_matrix
-        Initial stress stiffness matrix that multiplies the load multiplier
-        `\lambda` of the eigenvalue problem.
-    tol : float, optional
-        A float tolerance passed to the eigenvalue solver.
-    sparse_solver : bool, optional
-        Tells if solver :func:`scipy.sparse.linalg.eigsh` (``True``) or
-        :func:`scipy.linalg.eigh` (``False``) should be used. The sparse
-        solver uses the Cayley mode with a shift estimated from the matrices
-        and calculates ``num_eigvalues`` eigenvalues. The dense solver
-        calculates all eigenvalues and requires a positive definite ``K``.
-    silent : bool, optional
-        A boolean to tell whether the log messages should be printed.
-    num_eigvalues : int, optional
-        Number of calculated eigenvalues with the sparse solver, limited to
-        the size of ``KG`` minus 2, and number of returned eigenvectors.
-    num_eigvalues_print : int, optional
-        Number of eigenvalues to print.
-    skip_null_cols : bool, optional
-        If True, skip the removal of null columns from the matrices.
-        Use only when K is known to be non-singular.
-
-    Returns
-    -------
-    eigvals : ndarray
-        The load multipliers `\lambda`, calculated as ``-1/eigval`` from the
-        eigenvalues ``eigval`` of ``KG u = eigval K u``. The dense solver
-        returns all load multipliers, the positive ones first in increasing
-        order.
-    eigvecs : ndarray
-        The `i^{th}` eigenvector is ``eigvecs[:, i]``, with the size of the
-        original matrices. Only ``num_eigvalues`` eigenvectors are returned.
-
-    """
-    msg('Running linear buckling analysis...', silent=silent)
-
-    msg('Eigenvalue solver... ', level=2, silent=silent)
-
-    k = min(num_eigvalues, KG.shape[0]-2)
-    size = KG.shape[0]
-    if skip_null_cols:
-        used_cols = None
-    else:
-        K, KG, used_cols = remove_null_cols(K, KG, silent=silent)
-    if sparse_solver:
-        mode = 'cayley'
-        sigma = _estimate_sigma(K, KG)
-        msg('eigsh() solver (sigma={0})...'.format(sigma), level=3, silent=silent)
-        eigvals, peigvecs = eigsh(A=KG, k=k,
-                which='SM', M=K, tol=tol, sigma=sigma, mode=mode)
-        msg('finished!', level=3, silent=silent)
-
-    else:
-        K = K.toarray()
-        KG = KG.toarray()
-        msg('eigh() solver...', level=3, silent=silent)
-        eigvals, peigvecs = eigh(a=KG, b=K)
-        msg('finished!', level=3, silent=silent)
-
-    if used_cols is not None:
-        eigvecs = np.zeros((size, num_eigvalues), dtype=peigvecs.dtype)
-        eigvecs[used_cols, :] = peigvecs[:, :num_eigvalues]
-    else:
-        eigvecs = peigvecs[:, :num_eigvalues]
-
-    eigvals = -1./eigvals
-
-    eigvals = eigvals
-    eigvecs = eigvecs
-
-    msg('finished!', level=2, silent=silent)
-
-    msg('first {0} eigenvalues:'.format(num_eigvalues_print), level=1,
-        silent=silent)
-
-    for eig in eigvals[:num_eigvalues_print]:
-        msg('{0}'.format(eig), level=2, silent=silent)
-
-    return eigvals, eigvecs