structsolve 0.5.0__tar.gz → 0.5.3__tar.gz

{structsolve-0.5.0/structsolve.egg-info → structsolve-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.5.0
+Version: 0.5.3
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -61,7 +61,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.5.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.5.3). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -76,8 +76,17 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.5.0 (2026-10-01)
-    - Configuration-dependent loads and unsymmetric eigenproblems
+* version 0.5.3 (2026-10-06)
+    - Configuration-dependent loads, e.g. follower pressures: the load factor
+      is passed to the callables that accept `inc`, and the arc-length
+      methods use the load vector of the current configuration
+    - Unsymmetric matrices in `lb` (automatic detection), `freq` (residual
+      check, optional symmetric solvers, kinetic criterion) and `solve`
+    - The unsymmetric solvers of `lb` and `freq` use the complex LAPACK
+      drivers of `scipy.linalg.eig`, avoiding crashes of the Python process
+      with Intel MKL 2025.0.0
+    - Linear static analysis with configuration-dependent loads in
+      `Analysis.static(NLgeom=False)`
 * version 0.4.3 (2026-09-17)
     - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
       return buckling loads higher than the critical ones

{structsolve-0.5.0 → structsolve-0.5.3}/README.md

@@ -24,7 +24,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.5.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.5.3). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -39,8 +39,17 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.5.0 (2026-10-01)
-    - Configuration-dependent loads and unsymmetric eigenproblems
+* version 0.5.3 (2026-10-06)
+    - Configuration-dependent loads, e.g. follower pressures: the load factor
+      is passed to the callables that accept `inc`, and the arc-length
+      methods use the load vector of the current configuration
+    - Unsymmetric matrices in `lb` (automatic detection), `freq` (residual
+      check, optional symmetric solvers, kinetic criterion) and `solve`
+    - The unsymmetric solvers of `lb` and `freq` use the complex LAPACK
+      drivers of `scipy.linalg.eig`, avoiding crashes of the Python process
+      with Intel MKL 2025.0.0
+    - Linear static analysis with configuration-dependent loads in
+      `Analysis.static(NLgeom=False)`
 * version 0.4.3 (2026-09-17)
     - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
       return buckling loads higher than the critical ones

{structsolve-0.5.0 → structsolve-0.5.3}/pyproject.toml

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

{structsolve-0.5.0 → structsolve-0.5.3}/structsolve/freq.py

@@ -4,7 +4,7 @@ import numpy as np
 import scipy
 from scipy.sparse import csr_matrix
 from scipy.sparse.linalg import eigs, eigsh, spsolve
-from scipy.linalg import eig, eigh
+from scipy.linalg import eigh
 
 from .logger import msg, warn
 from .sparseutils import remove_null_cols
@@ -193,8 +193,12 @@ def freq(K, M, tol=0, sparse_solver=True,
         # for effiency reasons, solving:
         #    [M]{u} = (-1/lambda2)[K]{u}
         #    [M]{u} = eigval [K]{u}
+        #NOTE complex matrices to call zggev instead of dggev, which crashes
+        #     the process for some matrices with Intel MKL 2025.0.0, see
+        #     linear_buckling._eig_complex
+        from .linear_buckling import _eig_complex
         msg('eig() solver...', level=3, silent=silent)
-        eigvals, peigvecs = eig(a=Meff, b=Keff)
+        eigvals, peigvecs = _eig_complex(a=Meff, b=Keff)
         lambda2 = -1./eigvals
 
     if check_rtol is not None and peigvecs.shape[1]:

{structsolve-0.5.0 → structsolve-0.5.3}/structsolve/linear_buckling.py

@@ -82,17 +82,34 @@ def _is_positive_definite(A):
     return bool(np.all(lu.U.diagonal() > 0))
 
 
+def _lu_solve(lu, b):
+    """``lu.solve(b)`` for a real or complex right-hand side ``b``
+
+    The SuperLU factorization of a real matrix rejects a complex ``b``, whose
+    real and imaginary parts are then solved separately.
+
+    """
+    b = np.asarray(b)
+    if np.iscomplexobj(b):
+        return (lu.solve(np.ascontiguousarray(b.real))
+                + 1j*lu.solve(np.ascontiguousarray(b.imag)))
+    return lu.solve(b)
+
+
 def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
                       check_inertia=True):
     r"""Verify the eigenpairs of `([K] + \lambda [K_G])\{u\} = \{0\}`
 
+    The eigenpairs may be real or complex.
+
     - 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.
-      Only for symmetric matrices, ``check_inertia=True``.
+      Only for symmetric matrices, ``check_inertia=True``, the complex
+      `\lambda` are ignored.
 
     Returns
     -------
@@ -100,6 +117,7 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
         Description of the failed check, ``None`` when all checks passed.
 
     """
+    eigvals = np.asarray(eigvals)
     finite = np.isfinite(eigvals)
     if not np.any(finite):
         return 'no finite load multiplier was found'
@@ -117,6 +135,7 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
                 '{2}'.format(residual[i], rtol, lam[i]))
     if not check_inertia:
         return None
+    lam = lam[np.isreal(lam)].real
     positive = lam[lam > 0]
     if positive.size and _is_positive_definite(K):
         s = positive.min()*(1 - min_rel_gap)
@@ -200,20 +219,21 @@ def _real_if_close(mu, eigvecs, rtol=1e-8):
 
     Each eigenvector of an eigenvalue whose imaginary part is below ``rtol``
     of its modulus is rotated in the complex plane to make its largest
-    component real. When all eigenpairs are real, real arrays are returned.
+    component real, and its imaginary part is dropped, as the imaginary part
+    of the eigenvalue. Complex arrays are returned, see
+    :func:`_general_eigenpairs`.
 
     """
-    mu = np.asarray(mu, dtype=complex)
-    eigvecs = np.asarray(eigvecs, dtype=complex)
+    mu = np.array(mu, dtype=complex)
+    eigvecs = np.array(eigvecs, dtype=complex)
     real = np.abs(mu.imag) <= rtol*np.abs(mu)
-    mu = np.where(real, mu.real, mu)
+    mu[real] = mu[real].real
     for i in np.flatnonzero(real):
         v = eigvecs[:, i]
         j = np.argmax(np.abs(v))
         if v[j] != 0:
-            eigvecs[:, i] = v*(abs(v[j])/v[j])
-    if np.all(real):
-        return mu.real, eigvecs.real
+            v = v*(abs(v[j])/v[j])
+        eigvecs[:, i] = v.real
     return mu, eigvecs
 
 
@@ -230,12 +250,61 @@ def _sort_eigenpairs_general(mu, eigvecs):
     return mu[order], eigvecs[:, order]
 
 
+def _general_eigenpairs(mu, eigvecs, k=None):
+    r"""The first ``k`` finite eigenpairs of a general eigenvalue solver
+
+    The eigenvalues with a negligible imaginary part are made real with
+    :func:`_real_if_close`, the finite eigenpairs are sorted with
+    :func:`_sort_eigenpairs_general` and the first ``k`` are kept, all of
+    them with ``k=None``. Real arrays are returned when the kept eigenpairs
+    are real, even when discarded ones, e.g. spurious eigenvalues far from
+    the critical ones, are complex.
+
+    """
+    mu = np.asarray(mu)
+    finite = np.isfinite(mu)
+    mu, eigvecs = _real_if_close(mu[finite], eigvecs[:, finite])
+    mu, eigvecs = _sort_eigenpairs_general(mu, eigvecs)
+    if k is not None:
+        mu = mu[:k]
+        eigvecs = eigvecs[:, :k]
+    if np.all(mu.imag == 0):
+        return mu.real, eigvecs.real
+    return mu, eigvecs
+
+
+def _eig_complex(a, b=None):
+    r"""All eigenpairs of `[a]\{v\} = w [b]\{v\}` with :func:`scipy.linalg.eig`
+
+    The matrices are converted to complex, such that LAPACK ``zgeev`` or
+    ``zggev`` is used instead of ``dgeev`` or ``dggev``. With Intel MKL
+    2025.0.0 the real drivers crash the Python process when computing the
+    eigenvectors of some matrices, with an access violation or a heap
+    corruption that cannot be caught, deterministically for a given matrix,
+    already for 48 x 48 matrices and with any number of threads. The complex
+    drivers are not affected, at about twice the cost of the real ones. The
+    complex eigenvectors of real eigenvalues are made real by
+    :func:`_general_eigenpairs`.
+
+    """
+    a = np.asarray(a, dtype=complex)
+    if b is not None:
+        b = np.asarray(b, dtype=complex)
+    return eig(a=a, b=b)
+
+
 def _eig_condensed(K, KG, k):
     r"""As :func:`_eigh_condensed`, for unsymmetric matrices
 
     The dofs where both the row and the column of ``KG`` are null are
     condensed out with an LU factorization of ``K``, and the condensed
-    problem is solved with :func:`scipy.linalg.eig`.
+    problem is solved with :func:`scipy.linalg.eig`, through the complex
+    LAPACK driver ``zggev``, see :func:`_eig_complex`. Neither converting to
+    the standard problem `[S]^{-1}[K_{G_{bb}}]` (``dgeev``) nor limiting the
+    threads of BLAS/LAPACK avoids the crash of ``dggev`` with Intel MKL
+    2025.0.0. The ``k`` returned eigenpairs, see :func:`_general_eigenpairs`,
+    are real when they are all real, and complex eigenvectors are
+    back-substituted with the real factorization of `[K_{aa}]`.
 
     """
     KG = csr_matrix(KG)
@@ -259,17 +328,12 @@ def _eig_condensed(K, KG, k):
             j1 = min(j0 + chunk, b.size)
             X = lu.solve(Kab[:, j0:j1].toarray())
             S[:, j0:j1] -= Kba @ X
-    mu, ub = eig(a=KGbb, b=S)
-    finite = np.isfinite(mu)
-    mu, ub = _real_if_close(mu[finite], ub[:, finite])
-    mu, ub = _sort_eigenpairs_general(mu, ub)
-    k = min(k, mu.shape[0])
-    mu = mu[:k]
-    ub = ub[:, :k]
-    eigvecs = np.zeros((K.shape[0], k), dtype=ub.dtype)
+    mu, ub = _eig_complex(a=KGbb, b=S)
+    mu, ub = _general_eigenpairs(mu, ub, k)
+    eigvecs = np.zeros((K.shape[0], mu.shape[0]), dtype=ub.dtype)
     eigvecs[b, :] = ub
     if a.size:
-        eigvecs[a, :] = -lu.solve(np.asarray(Kab @ ub))
+        eigvecs[a, :] = -_lu_solve(lu, np.asarray(Kab @ ub))
     return mu, eigvecs
 
 
@@ -278,20 +342,21 @@ def _eigs_inverse(K, KG, k, tol):
 
     The largest `|\mu|` of `[K]^{-1}[K_G] u = \mu u` are the load
     multipliers `\lambda = -1/\mu` of smallest modulus. ``K`` may be
-    unsymmetric, it is factorized once with SuperLU.
+    unsymmetric, it is factorized once with SuperLU. The operator is real
+    for real matrices, a complex vector is solved with :func:`_lu_solve`.
 
     """
+    K = csc_matrix(K)
     with warnings.catch_warnings():
         warnings.simplefilter("ignore")
-        lu = splu(csc_matrix(K))
+        lu = splu(K)
     KG = csr_matrix(KG)
     n = K.shape[0]
-    OP = LinearOperator((n, n), matvec=lambda x: lu.solve(KG @ x),
-                        dtype=np.result_type(lu.U.dtype, KG.dtype))
+    OP = LinearOperator((n, n), matvec=lambda x: _lu_solve(lu, KG @ x),
+                        dtype=np.result_type(K.dtype, KG.dtype))
     k = min(k, n - 2)
     mu, eigvecs = eigs(OP, k=k, which='LM', tol=tol)
-    mu, eigvecs = _real_if_close(mu, eigvecs)
-    return _sort_eigenpairs_general(mu, eigvecs)
+    return _general_eigenpairs(mu, eigvecs)
 
 
 def _eigsh_cayley(K, KG, k, tol, silent):
@@ -418,7 +483,9 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
     The relative residual of each eigenpair is verified as above, but not
     the inertia, which requires symmetric matrices. Eigenvalues whose
     imaginary part is below ``1e-8`` of their modulus are returned as real,
-    with real eigenvectors.
+    with real eigenvectors. The arrays are real when the returned eigenpairs
+    are real, even if other eigenvalues of the solver are complex. A solver
+    that raises an error is skipped, as one that fails the verification.
 
     ARPACK, used by :func:`scipy.sparse.linalg.eigsh`, returns wrong
     eigenpairs at random, without any error, when linked against Intel MKL
@@ -426,6 +493,13 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
     ``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.
 
+    With Intel MKL 2025.0.0, the real LAPACK drivers ``dgeev`` and ``dggev``
+    of :func:`scipy.linalg.eig` crash the Python process for some matrices
+    when computing the eigenvectors, with any number of threads. The
+    solvers of unsymmetric matrices therefore call :func:`scipy.linalg.eig`
+    with complex matrices, i.e. ``zgeev`` and ``zggev``, which are not
+    affected.
+
     """
     msg('Running linear buckling analysis...', silent=silent)
 
@@ -461,10 +535,10 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
                 name, num_active, K.shape[0]), level=3, silent=silent)
             try:
                 eigvals, peigvecs = solver()
-                with np.errstate(divide='ignore'):
+                with np.errstate(divide='ignore', invalid='ignore'):
                     error = _check_eigenpairs(K, KG, -1./eigvals, peigvecs,
                                               check_rtol)
-            except (LinAlgError, RuntimeError, ValueError) as e:
+            except (LinAlgError, RuntimeError, ValueError, TypeError) as e:
                 error = '{0}: {1}'.format(type(e).__name__, e)
             if error is None:
                 msg('finished!', level=3, silent=silent)
@@ -488,13 +562,18 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
         msg('finished!', level=3, silent=silent)
 
     num_eigvecs = min(num_eigvalues, peigvecs.shape[1])
+    if (np.iscomplexobj(peigvecs)
+            and np.all(np.imag(eigvals[:num_eigvecs]) == 0)):
+        # all eigenvalues are returned by eig(), only the returned
+        # eigenvectors must be real
+        peigvecs = peigvecs[:, :num_eigvecs].real
     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'):
+    with np.errstate(divide='ignore', invalid='ignore'):
         eigvals = -1./eigvals
 
     msg('finished!', level=2, silent=silent)
@@ -514,10 +593,9 @@ def _lb_unsymmetric(K, KG, tol, sparse_solver, silent, num_eigvalues,
     the Notes of :func:`lb`"""
     if not sparse_solver:
         msg('eig() solver...', level=3, silent=silent)
-        mu, eigvecs = eig(a=csr_matrix(KG).toarray(), b=csr_matrix(K).toarray())
-        finite = np.isfinite(mu)
-        mu, eigvecs = _real_if_close(mu[finite], eigvecs[:, finite])
-        mu, eigvecs = _sort_eigenpairs_general(mu, eigvecs)
+        mu, eigvecs = _eig_complex(a=csr_matrix(KG).toarray(),
+                                   b=csr_matrix(K).toarray())
+        mu, eigvecs = _general_eigenpairs(mu, eigvecs)
         msg('finished!', level=3, silent=silent)
         return mu, eigvecs
     K = csr_matrix(K)
@@ -536,10 +614,10 @@ def _lb_unsymmetric(K, KG, tol, sparse_solver, silent, num_eigvalues,
             .format(name, num_active, K.shape[0]), level=3, silent=silent)
         try:
             mu, eigvecs = solver()
-            with np.errstate(divide='ignore'):
+            with np.errstate(divide='ignore', invalid='ignore'):
                 error = _check_eigenpairs(K, KG, -1./mu, eigvecs, check_rtol,
                                           check_inertia=False)
-        except (LinAlgError, RuntimeError, ValueError) as e:
+        except (LinAlgError, RuntimeError, ValueError, TypeError) as e:
             error = '{0}: {1}'.format(type(e).__name__, e)
         if error is None:
             msg('finished!', level=3, silent=silent)

{structsolve-0.5.0 → structsolve-0.5.3/structsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.5.0
+Version: 0.5.3
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -61,7 +61,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.5.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
+Saullo G. P. Castro (2026). Structural analysis solvers tailored for semi-analytical models (Version 0.5.3). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -76,8 +76,17 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
-* version 0.5.0 (2026-10-01)
-    - Configuration-dependent loads and unsymmetric eigenproblems
+* version 0.5.3 (2026-10-06)
+    - Configuration-dependent loads, e.g. follower pressures: the load factor
+      is passed to the callables that accept `inc`, and the arc-length
+      methods use the load vector of the current configuration
+    - Unsymmetric matrices in `lb` (automatic detection), `freq` (residual
+      check, optional symmetric solvers, kinetic criterion) and `solve`
+    - The unsymmetric solvers of `lb` and `freq` use the complex LAPACK
+      drivers of `scipy.linalg.eig`, avoiding crashes of the Python process
+      with Intel MKL 2025.0.0
+    - Linear static analysis with configuration-dependent loads in
+      `Analysis.static(NLgeom=False)`
 * version 0.4.3 (2026-09-17)
     - Fixed the eigenvalue shift of the sparse solver of `lb`, which could
       return buckling loads higher than the critical ones

{structsolve-0.5.0 → structsolve-0.5.3}/structsolve.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ tests/test_follower_freq_static.py
 tests/test_follower_loads.py
 tests/test_freq.py
 tests/test_linear_buckling.py
+tests/test_linear_buckling_unsymmetric.py
 tests/test_newton_raphson.py
 tests/test_sparseutils.py
 tests/test_static.py

{structsolve-0.5.0 → structsolve-0.5.3}/tests/test_follower_loads.py

@@ -234,7 +234,13 @@ def test_lb_unsymmetric_complex_pairs():
     assert np.iscomplexobj(eigvals)
     mu = eig(KG, K, right=False)
     ref = -1/mu
-    assert np.allclose(np.sort_complex(eigvals), np.sort_complex(ref))
+    # the complex driver zggev, used by lb(), does not return conjugate
+    # pairs with identical real parts, which changes the order of
+    # np.sort_complex within a pair: nearest reference of each eigenvalue
+    assert eigvals.shape == ref.shape
+    dist = np.abs(eigvals[:, None] - ref[None, :])
+    assert np.all(dist.min(axis=1) <= 1e-8*np.abs(eigvals))
+    assert np.all(dist.min(axis=0) <= 1e-8*np.abs(ref))
     real = np.isreal(eigvals)
     # the real ones come first
     assert not np.any(real[np.argmin(real):]) or np.all(real)

structsolve-0.5.3/tests/test_linear_buckling_unsymmetric.py

@@ -0,0 +1,241 @@
+"""Tests for structsolve.linear_buckling: lb() with unsymmetric matrices"""
+import os
+import subprocess
+import sys
+import textwrap
+
+import numpy as np
+import pytest
+from scipy.linalg import eig
+from scipy.sparse import csr_matrix, diags, random as sprandom, identity
+
+from structsolve import lb
+
+
+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)))
+
+
+def dense_load_multipliers(K, KG):
+    """Finite load multipliers of the full problem with a direct dense eig"""
+    mu = eig(a=np.asarray(KG, dtype=complex), b=np.asarray(K, dtype=complex),
+             right=False)
+    mu = mu[np.isfinite(mu)]
+    # the eigenvalues of the null rows and columns of KG
+    mu = mu[np.abs(mu) > 1e-10*np.abs(mu).max()]
+    return -1./mu
+
+
+def matrices_complex_KG_block():
+    """Dofs 3 to 5 have null rows and columns of KG, which are condensed out,
+    and the KG block has a complex pair of eigenvalues"""
+    n = 6
+    K = np.diag([4., 5., 6., 7., 8., 9.]) + 0.1*(np.eye(n, k=1)
+                                                  + np.eye(n, k=-1))
+    KG = np.zeros((n, n))
+    KG[:3, :3] = [[-1., 0.5, 0.], [-0.5, -1., 0.], [0., 0., -2.]]
+    return K, KG
+
+
+def test_lb_unsymmetric_complex_pair_condensed():
+    """Regression test: a complex eigenpair of the condensed problem, even
+    when not returned, made the back-substitution of the condensed dofs
+    raise a TypeError in the real SuperLU factorization"""
+    K, KG = matrices_complex_KG_block()
+    ref = dense_load_multipliers(K, KG)
+    real = np.abs(ref.imag) <= 1e-8*np.abs(ref)
+    assert np.sum(real) == 1 and np.sum(~real) == 2
+    lam_real = ref[real].real[0]
+    lam_cplx = ref[~real]
+
+    # only the real eigenpair is returned: real arrays
+    eigvals, eigvecs = lb(csr_matrix(K), csr_matrix(KG), num_eigvalues=1,
+                          symmetric=False, silent=True)
+    assert eigvals.dtype == np.float64 and eigvecs.dtype == np.float64
+    assert eigvecs.shape == (6, 1)
+    np.testing.assert_allclose(eigvals, [lam_real], rtol=1e-10)
+    assert np.all(relative_residuals(K, KG, eigvals, eigvecs) < 1e-10)
+
+    # the real eigenpair first, followed by one of the complex pair
+    eigvals, eigvecs = lb(csr_matrix(K), csr_matrix(KG), num_eigvalues=2,
+                          symmetric=False, silent=True)
+    assert eigvals.shape == (2,) and eigvecs.shape == (6, 2)
+    assert np.iscomplexobj(eigvals) and np.iscomplexobj(eigvecs)
+    assert eigvals[0].imag == 0 and np.all(eigvecs[:, 0].imag == 0)
+    np.testing.assert_allclose(eigvals[0].real, lam_real, rtol=1e-10)
+    assert np.min(np.abs(lam_cplx - eigvals[1])) <= 1e-10*abs(eigvals[1])
+    assert np.all(relative_residuals(K, KG, eigvals, eigvecs) < 1e-10)
+
+
+def test_lb_unsymmetric_general_eigenpairs_real_when_kept_real():
+    """The real/complex decision applies to the returned eigenpairs"""
+    from structsolve.linear_buckling import _general_eigenpairs
+
+    mu = np.array([-0.5 + 0.2j, -0.5 - 0.2j, -0.25 + 1e-14j, -0.1, np.inf])
+    v = np.random.RandomState(0).randn(4, 5)*(1 + 1j)
+    m, u = _general_eigenpairs(mu, v, 2)
+    assert m.dtype == np.float64 and u.dtype == np.float64
+    np.testing.assert_allclose(m, [-0.25, -0.1])
+    # rotated eigenvector with a positive largest component
+    r = v[:, 2].real
+    np.testing.assert_allclose(u[:, 0],
+                               np.sqrt(2)*r*np.sign(r[np.argmax(abs(r))]))
+    m, u = _general_eigenpairs(mu, v)
+    assert np.iscomplexobj(m) and m.shape == (4,)
+    np.testing.assert_allclose(m[:2], [-0.25, -0.1])
+    assert np.all(u[:, :2].imag == 0)
+
+
+@pytest.mark.parametrize('max_dense_size', [2000, 0])
+def test_lb_unsymmetric_complex_eigenpairs(max_dense_size):
+    """Genuinely complex eigenpairs, with condensed dofs that receive complex
+    eigenvectors from the back-substitution"""
+    n, nb = 30, 12
+    K = (diags(np.linspace(4., 8., n)) + diags(0.5*np.ones(n - 1), 1)
+         + diags(0.5*np.ones(n - 1), -1)).toarray()
+    rng = np.random.RandomState(4)
+    A = rng.randn(nb, nb)
+    KG = np.zeros((n, n))
+    KG[:nb, :nb] = -np.eye(nb) + 0.5*(A - A.T)
+    ref = dense_load_multipliers(K, KG)
+    assert np.all(np.abs(ref.imag) > 1e-3*np.abs(ref))
+    k = 4
+    eigvals, eigvecs = lb(csr_matrix(K), csr_matrix(KG), num_eigvalues=k,
+                          symmetric=False, silent=True,
+                          max_dense_size=max_dense_size)
+    assert np.iscomplexobj(eigvals) and np.iscomplexobj(eigvecs)
+    assert eigvals.shape == (k,) and eigvecs.shape == (n, k)
+    assert np.all(np.abs(eigvals.imag) > 1e-3*np.abs(eigvals))
+    # the k load multipliers of smallest modulus, by increasing modulus
+    np.testing.assert_allclose(np.abs(eigvals), np.sort(np.abs(ref))[:k],
+                               rtol=1e-8)
+    for lam in eigvals:
+        assert np.min(np.abs(ref - lam)) <= 1e-8*abs(lam)
+    res = relative_residuals(K, KG, eigvals, eigvecs)
+    assert np.all(res < 1e-8)
+    # the condensed dofs are not null
+    assert np.all(np.linalg.norm(eigvecs[nb:, :], axis=0) > 0)
+
+
+def test_lb_check_eigenpairs_real_and_complex():
+    """_check_eigenpairs with check_inertia=False accepts real and complex
+    eigenpairs, and detects wrong ones"""
+    from structsolve.linear_buckling import _check_eigenpairs, _eig_condensed
+
+    K, KG = matrices_complex_KG_block()
+    K = csr_matrix(K)
+    KG = csr_matrix(KG)
+    mu, eigvecs = _eig_condensed(K, KG, 3)
+    assert np.iscomplexobj(mu) and np.iscomplexobj(eigvecs)
+    lam = -1./mu
+    assert _check_eigenpairs(K, KG, lam, eigvecs, 1e-8,
+                             check_inertia=False) is None
+    error = _check_eigenpairs(K, KG, lam, eigvecs[:, ::-1], 1e-8,
+                              check_inertia=False)
+    assert 'relative residual' in error
+    # complex load multipliers are ignored by the inertia check
+    assert _check_eigenpairs(K, KG, lam, eigvecs, 1e-8) is None
+
+    mu, eigvecs = _eig_condensed(K, KG, 1)
+    assert mu.dtype == np.float64 and eigvecs.dtype == np.float64
+    lam = -1./mu
+    assert _check_eigenpairs(K, KG, lam, eigvecs, 1e-8,
+                             check_inertia=False) is None
+    error = _check_eigenpairs(K, KG, lam*1.01, eigvecs, 1e-8,
+                              check_inertia=False)
+    assert 'relative residual' in error
+
+
+@pytest.mark.parametrize('symmetric, solver', [
+    (False, '_eig_condensed'), (True, '_eigh_condensed')])
+def test_lb_solver_type_error_falls_back(monkeypatch, symmetric, solver):
+    """A TypeError of the first solver is recorded and the next solver,
+    eigs() or eigsh(), is used"""
+    import structsolve.linear_buckling as linear_buckling
+
+    n = 40
+    k = np.linspace(1., 3., n)
+    lambdas = np.linspace(1., 20., n)
+    K = diags(k).tocsr()
+    KG = diags(-k/lambdas).tocsr()
+
+    def raise_type_error(*args, **kwargs):
+        raise TypeError('Cannot cast array data from dtype complex128')
+
+    monkeypatch.setattr(linear_buckling, solver, raise_type_error)
+    eigvals, eigvecs = lb(K, KG, silent=True, num_eigvalues=5,
+                          symmetric=symmetric)
+    np.testing.assert_allclose(eigvals, lambdas[:5], rtol=1e-8)
+    assert eigvals.dtype == np.float64 and eigvecs.dtype == np.float64
+    assert np.all(relative_residuals(K, KG, eigvals, eigvecs) < 1e-8)
+
+
+@pytest.mark.parametrize('sparse_solver, max_dense_size',
+                         [(True, 2000), (True, 0), (False, 2000)])
+def test_lb_nearly_symmetric(sparse_solver, max_dense_size):
+    """A symmetric positive definite K with 1e-12 asymmetric noise, forced
+    to the solvers of unsymmetric matrices, gives the load multipliers of
+    the symmetric solver, with real eigenvectors"""
+    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 = np.zeros((n, n))
+    KG[:n//3, :n//3] = -(B @ B.T + 0.1*identity(n//3)).toarray()
+    KG = csr_matrix(KG)
+    noise = sprandom(n, n, density=0.2, random_state=5).toarray()
+    Kn = csr_matrix(K.toarray() + 1e-12*abs(K).max()*noise)
+    assert np.linalg.norm((Kn - Kn.T).toarray()) > 1e-13*abs(K).max()
+
+    ref, _ = lb(K, KG, silent=True, num_eigvalues=10)
+    eigvals, eigvecs = lb(Kn, KG, silent=True, num_eigvalues=10,
+                          symmetric=False, sparse_solver=sparse_solver,
+                          max_dense_size=max_dense_size)
+    if not sparse_solver:
+        # all eigenvalues are returned, also the spurious ones of the null
+        # rows of KG, which may be complex
+        assert np.all(eigvals[:10].imag == 0)
+        eigvals = eigvals[:10].real
+    assert eigvals.dtype == np.float64 and eigvecs.dtype == np.float64
+    assert eigvecs.shape == (n, 10)
+    np.testing.assert_allclose(eigvals, ref, rtol=1e-8)
+    assert np.all(relative_residuals(Kn, KG, eigvals, eigvecs) < 1e-8)
+
+
+def test_eig_complex_mkl_crash_regression():
+    """Regression test: with Intel MKL 2025.0.0, scipy.linalg.eig on these
+    real 48 x 48 matrices (LAPACK dggev) corrupts the heap and the process
+    exits with 0xc0000374, deterministically and with any number of threads.
+    lb() calls the complex driver zggev. Run in a subprocess, which a crash
+    does not take down with the test session"""
+    code = textwrap.dedent("""
+        import numpy as np
+        from scipy.sparse import csr_matrix
+        from structsolve import lb
+        rng = np.random.RandomState(4)
+        KG = rng.randn(48, 48)
+        K = rng.randn(48, 48) + 48*np.eye(48)
+        eigvals, eigvecs = lb(csr_matrix(K), csr_matrix(KG), silent=True,
+                              num_eigvalues=5, symmetric=False)
+        Ku = K @ eigvecs
+        KGu = KG @ eigvecs
+        res = (np.linalg.norm(Ku + KGu*eigvals, axis=0)
+               / (np.linalg.norm(Ku, axis=0)
+                  + np.abs(eigvals)*np.linalg.norm(KGu, axis=0)))
+        assert eigvecs.shape == (48, 5), eigvecs.shape
+        assert np.all(res < 1e-8), res
+        print('ok')
+        """)
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    env = dict(os.environ)
+    env['PYTHONPATH'] = os.pathsep.join(
+        [root] + [p for p in [env.get('PYTHONPATH')] if p])
+    result = subprocess.run([sys.executable, '-c', code], env=env,
+                            capture_output=True, text=True, timeout=300)
+    assert result.returncode == 0, (hex(result.returncode & 0xffffffff),
+                                    result.stderr[-2000:])
+    assert result.stdout.strip().endswith('ok')