structsolve 0.7.0__tar.gz → 0.8.0__tar.gz

{structsolve-0.7.0/structsolve.egg-info → structsolve-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.7.0
+Version: 0.8.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -65,7 +65,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.7.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.8.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -80,6 +80,8 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
+* version 0.8.0 (2026-10-14)
+    - Fewer evaluations and factorizations, same solutions: `dR/dlbd` is evaluated together with the tangent stiffness matrix only, Newton-Raphson reuses the factorization of the tangent while it is not updated, the follower linear static analysis factorizes `K0` once, and `lb` estimates its shift and the inertia of `K` once for all its attempts
 * version 0.7.0 (2026-10-13)
     - `calc_fext` may declare the keyword argument `lbd` and then receives the current load factor with the configuration, for prescribed displacements imposed exactly as linear constraints; the solvers use `dR/dlbd` for the arc-length scale, the first Newton-Raphson predictor and the relative convergence criterion. Callables without `lbd` behave as before
 * version 0.6.1 (2026-10-08)

{structsolve-0.7.0 → structsolve-0.8.0}/README.md

@@ -29,7 +29,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.7.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.8.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -44,6 +44,8 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
+* version 0.8.0 (2026-10-14)
+    - Fewer evaluations and factorizations, same solutions: `dR/dlbd` is evaluated together with the tangent stiffness matrix only, Newton-Raphson reuses the factorization of the tangent while it is not updated, the follower linear static analysis factorizes `K0` once, and `lb` estimates its shift and the inertia of `K` once for all its attempts
 * version 0.7.0 (2026-10-13)
     - `calc_fext` may declare the keyword argument `lbd` and then receives the current load factor with the configuration, for prescribed displacements imposed exactly as linear constraints; the solvers use `dR/dlbd` for the arc-length scale, the first Newton-Raphson predictor and the relative convergence criterion. Callables without `lbd` behave as before
 * version 0.6.1 (2026-10-08)

{structsolve-0.7.0 → structsolve-0.8.0}/pyproject.toml

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

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/analysis.py

@@ -2,7 +2,7 @@ from __future__ import absolute_import
 
 import numpy as np
 
-from .static import solve
+from .static import solve, _factorize
 from .logger import msg, warn
 from . import callbacks
 from .newton_raphson import _check_convergence
@@ -302,6 +302,8 @@ class Analysis(object):
         configuration-dependent load, see :meth:`.static`"""
         msg('Configuration-dependent load: load correction iterations',
             level=2, silent=silent)
+        # k0 is factorized once for all the corrections
+        solve_k0 = None
         for iteration in range(1, self.maxNumIter + 1):
             fext = self.calc_fext(inc=1., c=c, silent=True)
             fint = k0 @ c
@@ -313,7 +315,12 @@ class Analysis(object):
                 return c
             if not np.isfinite(Rnorm):
                 break
-            c = c + solve(k0, R, silent=True)
+            if solve_k0 is None:
+                try:
+                    solve_k0 = _factorize(k0)
+                except RuntimeError:
+                    break
+            c = c + solve_k0(R)
         warn('The load correction iterations did not converge, the load may '
              'exceed the critical load of the linearized problem', level=1,
              silent=silent)

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/arc_length.py

@@ -8,12 +8,9 @@ control the arc-length scaling and adaptation.
 
 """
 import numpy as np
-from scipy.sparse import csc_matrix
-from scipy.sparse.linalg import splu
 
 from .logger import msg, warn
-from .static import solve
-from .sparseutils import remove_null_cols
+from .static import solve, _factorize
 from . import callbacks
 from .newton_raphson import (_check_convergence, _check_divergence,
                              _NR_iterations, INC_CUT_FACTOR)
@@ -31,34 +28,6 @@ MIN_GROWTH_FACTOR = 0.5
 MAX_NUM_STEPS = 1000
 
 
-def _factorize(kT):
-    """LU factorization of the tangent stiffness matrix
-
-    Null rows and columns are removed, the corresponding values of the
-    solution are zero.
-
-    Parameters
-    ----------
-    kT : sparse matrix
-        Tangent stiffness matrix.
-
-    Returns
-    -------
-    solve_kT : callable
-        Function that returns the solution ``x`` of ``kT x = b``.
-
-    """
-    kT_red, used_cols = remove_null_cols(kT, silent=True)
-    lu = splu(csc_matrix(kT_red))
-
-    def solve_kT(b):
-        x = np.zeros(b.shape[0], dtype=np.result_type(b, lu.U.dtype))
-        x[used_cols] = lu.solve(b[used_cols])
-        return x
-
-    return solve_kT
-
-
 def _solver_arc_length(an, method, silent=False):
     r"""Arc-length solver
 
@@ -117,12 +86,13 @@ def _solver_arc_length(an, method, silent=False):
     `\{u_{ref}\}` is the linear solution of `\partial R/\partial \lambda`
     at `c = 0`, `\lambda = 0`, since the reference vector may be null, e.g.
     under a prescribed displacement alone; and `\lambda \, \partial
-    R/\partial \lambda`, evaluated at the current iterate before each
-    convergence check, is an additional reference of the relative
-    convergence criterion. The same `\partial R/\partial \lambda` is used
-    in the bordered solution when the tangent stiffness matrix is updated at
-    that iterate; with ``an.modified_NR = True`` it is one call to
-    ``calc_fext`` per iteration.
+    R/\partial \lambda` is an additional reference of the relative
+    convergence criterion. `\partial R/\partial \lambda` is evaluated
+    together with the tangent stiffness matrix, at the same iterate, i.e.
+    once per update of the tangent stiffness matrix, and used in the
+    bordered solution; the last one evaluated is the reference of the next
+    convergence checks. At the converged state it is kept with the tangent
+    stiffness matrix when the step is repeated with a shorter arc length.
 
     The initial arc length corresponds to a load factor increment of
     ``an.initialInc`` along the initial tangent. The convergence and
@@ -194,8 +164,12 @@ def _solver_arc_length(an, method, silent=False):
                 warn('Singular tangent stiffness matrix at the last converged state! Analysis stopped',
                      level=1, silent=silent)
                 break
-        # load vector of the converged configuration, dR/dlbd
-        q_conv = callbacks.calc_load_vector(an, c, fext, lbd)
+            # load vector of the converged configuration, dR/dlbd, kept with
+            # the tangent stiffness matrix when the step is repeated
+            if step_num == 1 and lbd_dependent:
+                q_conv = q0
+            else:
+                q_conv = callbacks.calc_load_vector(an, c, fext, lbd)
         dc_q_conv = solve_kT_conv(q_conv)
         norm_q = np.sqrt(inner(dc_q_conv, 1., dc_q_conv, 1.))
         if arc_length is None:
@@ -218,6 +192,8 @@ def _solver_arc_length(an, method, silent=False):
         Rnorms = []
         solve_kT = solve_kT_conv
         dc_q = dc_q_conv
+        # the last dR/dlbd evaluated, with the tangent stiffness matrix
+        q_iter = q_conv
         iter_kT = 0
         iteration = 0
         while True:
@@ -227,9 +203,6 @@ def _solver_arc_length(an, method, silent=False):
             R = fext_total - fint
             q_ref = None
             if lbd_dependent:
-                # dR/dlbd at the current iterate
-                q_iter = callbacks.calc_load_vector(an, c + dc, fext,
-                                                    lbd + dlbd)
                 q_ref = (lbd + dlbd)*q_iter
             conv, Rnorm, Rrel = _check_convergence(an, R, fint, fext_total,
                                                    fext_ref=dlbd*fext,
@@ -254,6 +227,9 @@ def _solver_arc_length(an, method, silent=False):
                     warn('Singular tangent stiffness matrix', level=2, silent=silent)
                     break
                 if lbd_dependent:
+                    # dR/dlbd at the iterate of the tangent stiffness matrix
+                    q_iter = callbacks.calc_load_vector(an, c + dc, fext,
+                                                        lbd + dlbd)
                     dc_q = solve_kT(q_iter)
                 else:
                     dc_q = solve_kT(callbacks.calc_load_vector(an, c + dc,
@@ -293,8 +269,9 @@ def _solver_arc_length(an, method, silent=False):
         if converged and lbd + dlbd > 1. and lbd < 1.:
             msg('Load factor 1.0 exceeded, correcting to load factor 1.0...', level=1, silent=silent)
             t = (1. - lbd)/dlbd
-            converged, dc1 = _NR_iterations(an, c, t*dc, 1., fext, kT0=None,
-                    silent=silent, lbd_dependent=lbd_dependent)
+            converged, dc1, _ = _NR_iterations(an, c, t*dc, 1., fext,
+                    kT0=None, silent=silent, lbd_dependent=lbd_dependent,
+                    q=q_iter)
             if converged:
                 msg('Converged at load factor 1.00000', level=2, silent=silent)
                 an.cs.append((c + dc1).copy())

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/callbacks.py

@@ -52,7 +52,13 @@ are called exactly as before:
     `\lambda \, \partial R/\partial \lambda`, see
     :func:`.newton_raphson._check_convergence`, since under a prescribed
     displacement alone the reference vector and the reduced internal force
-    vector both vanish at equilibrium.
+    vector both vanish at equilibrium;
+  - ``calc_fext(c=c, lbd=lbd)`` is called at the configurations where the
+    tangent stiffness matrix is updated, right after ``calc_kC`` and
+    ``calc_kG`` at the same ``c`` and load factor, such that the callables
+    may share their computations, and the last `\partial R/\partial
+    \lambda` evaluated is the reference of the convergence checks until the
+    next update.
 
   ``lbd`` is never passed by the linear static analysis,
   ``Analysis.static(NLgeom=False)``.

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/linear_buckling.py

@@ -27,23 +27,11 @@ SHIFT_SEARCH_MAX_GROWTH = 1e10
 PARITY_REL_GAP = 1e-4
 
 
-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.
-
-    """
+def _estimate_mu_max(K, KG, max_iter=50, rel_tol=1e-3):
+    r"""Largest `|\mu|` of ``KG u = mu K u``, estimated by power
+    iterations, see :func:`_estimate_sigma`, or ``None`` when ``K`` is
+    singular, not positive definite, or the linear solution is
+    inaccurate"""
     try:
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -54,7 +42,7 @@ def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
         for i in range(max_iter):
             xKx = x @ Kx
             if not np.isfinite(xKx) or xKx <= 0:
-                return 1.
+                return None
             x = x / np.sqrt(xKx)
             rhs = KG @ x
             y = lu.solve(rhs)
@@ -62,19 +50,45 @@ def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3):
             if i == 0:
                 residual = np.linalg.norm(Ky - rhs)
                 if not residual <= 1e-6 * np.linalg.norm(rhs):
-                    return 1.
+                    return None
             # ||y||_K / ||x||_K, with ||x||_K = 1
             ratio = np.sqrt(abs(y @ Ky))
             if not np.isfinite(ratio) or ratio == 0:
-                return 1.
+                return None
             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
+        return mu_max
     except Exception:
+        return None
+
+
+def _estimate_sigma(K, KG, safety=10., max_iter=50, rel_tol=1e-3,
+                   mu_max=False):
+    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. An estimate of :func:`_estimate_mu_max` may be
+    given as ``mu_max``, e.g. to try another ``safety`` factor.
+
+    """
+    if mu_max is False:
+        mu_max = _estimate_mu_max(K, KG, max_iter=max_iter, rel_tol=rel_tol)
+    if mu_max is None:
         return 1.
+    return safety * mu_max
 
 
 def _negative_pivots(A):
@@ -135,7 +149,7 @@ def _lu_solve(lu, b):
 
 
 def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
-                      check_inertia=True):
+                      check_inertia=True, K_positive_definite=None):
     r"""Verify the eigenpairs of `([K] + \lambda [K_G])\{u\} = \{0\}`
 
     The eigenpairs may be real or complex.
@@ -155,6 +169,10 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
       symmetric matrices, ``check_inertia=True``, the complex `\lambda` are
       ignored. Missing negative load multipliers are not detected.
 
+    Whether ``K`` is positive definite may be given as
+    ``K_positive_definite``, a boolean or a function returning it, e.g. to
+    verify several solutions with one factorization of ``K``.
+
     Returns
     -------
     error : str or None
@@ -181,7 +199,11 @@ def _check_eigenpairs(K, KG, eigvals, eigvecs, rtol, min_rel_gap=1e-4,
         return None
     lam = lam[np.isreal(lam)].real
     positive = lam[lam > 0]
-    if positive.size and _is_positive_definite(K):
+    if K_positive_definite is None:
+        K_positive_definite = _is_positive_definite
+    if positive.size and (K_positive_definite(K) if
+                          callable(K_positive_definite) else
+                          K_positive_definite):
         s = positive.max()*(1 - min_rel_gap)
         expected = int(np.count_nonzero(positive < s))
         count = _negative_pivots(K + s*KG) if expected else None
@@ -599,15 +621,16 @@ def _eigs_shift_search(K, KG, k, tol, check_rtol, silent):
     return mu, eigvecs
 
 
-def _eigsh_cayley(K, KG, k, tol, silent, safety=10.):
+def _eigsh_cayley(K, KG, k, tol, silent, safety=10., mu_max=False):
     r"""Solution with :func:`scipy.sparse.linalg.eigsh` in Cayley mode
 
     The shift is estimated with :func:`_estimate_sigma` and the given
-    ``safety`` factor. ARPACK's ``ncv`` is chosen by
+    ``safety`` factor, from the estimate ``mu_max`` of
+    :func:`_estimate_mu_max` when given. ARPACK's ``ncv`` is chosen by
     :func:`.arpackutils.capped_eigsh`, which avoids the Intel MKL bug.
 
     """
-    sigma = _estimate_sigma(K, KG, safety=safety)
+    sigma = _estimate_sigma(K, KG, safety=safety, mu_max=mu_max)
     msg('sigma={0}'.format(sigma), level=4, silent=silent)
     k = min(k, K.shape[0] - 2)
     mu, eigvecs = capped_eigsh(A=KG, k=k, M=K, sigma=sigma, which='SM',
@@ -901,16 +924,32 @@ def lb(K, KG, tol=0, sparse_solver=True, silent=False,
         msg('{0} of {1} rows of KG are non-null'.format(num_active,
             K.shape[0]), level=3, silent=silent)
 
+        # the estimate of the shift and the inertia of K are computed once
+        # for all the attempts
+        once = {}
+
+        def mu_max():
+            if 'mu_max' not in once:
+                once['mu_max'] = _estimate_mu_max(K, KG)
+            return once['mu_max']
+
+        def K_positive_definite(K):
+            if 'pd' not in once:
+                once['pd'] = _is_positive_definite(K)
+            return once['pd']
+
         def verify(mu, eigvecs):
             with np.errstate(divide='ignore', invalid='ignore'):
-                return _check_eigenpairs(K, KG, -1./mu, eigvecs, check_rtol)
+                return _check_eigenpairs(K, KG, -1./mu, eigvecs, check_rtol,
+                        K_positive_definite=K_positive_definite)
 
         strategies = [
             ('eigsh() in Cayley mode',
-             lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent)),
+             lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent,
+                                   mu_max=mu_max())),
             ('eigsh() in Cayley mode with a 10 times larger shift',
              lambda: _eigsh_cayley(K, KG, num_eigvalues, tol, silent,
-                                   safety=100.)),
+                                   safety=100., mu_max=mu_max())),
         ]
         dense = ('eigh() with condensed dofs',
                  lambda: _eigh_condensed(K, KG, num_eigvalues))

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/newton_raphson.py

@@ -8,7 +8,7 @@ and they are shared with the arc-length solvers of
 import numpy as np
 
 from .logger import msg, warn
-from .static import solve
+from .static import solve, _factorize
 from . import callbacks
 
 
@@ -139,7 +139,7 @@ def _check_divergence(an, Rnorm, Rnorms, iteration, silent=False):
 
 
 def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False,
-                   lbd_dependent=False):
+                   lbd_dependent=False, q=None):
     r"""Newton-Raphson iterations at a fixed load factor
 
     Parameters
@@ -161,9 +161,15 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False,
         A boolean to tell whether the log messages should be printed.
     lbd_dependent : bool, optional
         Whether ``calc_fext`` accepts ``lbd``, see :mod:`.callbacks`;
-        ``total*q``, with `\{q\} = \partial R/\partial \lambda` evaluated
-        at the current iterate, is then an additional reference of the
-        relative convergence criterion, see :func:`._check_convergence`.
+        ``total*q``, with `\{q\} = \partial R/\partial \lambda`, is then an
+        additional reference of the relative convergence criterion, see
+        :func:`._check_convergence`. `\{q\}` is evaluated together with the
+        tangent stiffness matrix, at the same iterate, and the last one
+        evaluated is the reference until the next update of the tangent.
+    q : array-like or None, optional
+        The last `\{q\}` evaluated before these iterations, the reference
+        until the first update of the tangent stiffness matrix, used only
+        when ``lbd_dependent=True``.
 
     Returns
     -------
@@ -171,14 +177,18 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False,
         Whether the iterations converged.
     dc : array-like
         Solution increment, such that ``c + dc`` is the solution.
+    q : array-like or None
+        The last `\{q\}` evaluated, ``None`` when ``lbd_dependent=False``.
 
     """
     modified_NR = an.modified_NR
     fext_total = total*fext
+    if not lbd_dependent:
+        q = None
     q_ref = None
     Rnorms = []
     iter_kT = 0
-    kT = None
+    solve_kT = None
     fint = None
 
     iteration = 0
@@ -187,28 +197,37 @@ def _NR_iterations(an, c, dc, total, fext, kT0=None, silent=False,
         if fint is None:
             fint = callbacks.calc_fint(an, c + dc, total)
         R = fext_total - fint
-        if lbd_dependent:
-            q_ref = total*callbacks.calc_load_vector(an, c + dc, fext, total)
+        if q is not None:
+            q_ref = total*q
 
         conv, Rnorm, Rrel = _check_convergence(an, R, fint, fext_total,
                                                q_ref=q_ref)
         msg('Iteration: %d, max(|R|) = %1.3e, relative ||R|| = %1.3e'
             % (iteration, np.abs(R).max(), Rrel), level=2, silent=silent)
         if conv:
-            return True, dc
+            return True, dc, q
         if _check_divergence(an, Rnorm, Rnorms, iteration, silent=silent):
-            return False, dc
-
-        if modified_NR and iteration > 1 and iter_kT < an.compute_every_n:
-            iter_kT += 1
-        elif modified_NR and iteration == 1 and kT0 is not None:
-            kT = kT0
-            iter_kT = 1
-        else:
-            kT = callbacks.calc_kT(an, c + dc, total)
-            iter_kT = 1
-
-        varc = solve(kT, R, silent=True)
+            return False, dc, q
+
+        # the factorization of the tangent stiffness matrix is reused while
+        # the matrix is not updated
+        try:
+            if modified_NR and iteration > 1 and iter_kT < an.compute_every_n:
+                iter_kT += 1
+            elif modified_NR and iteration == 1 and kT0 is not None:
+                solve_kT = _factorize(kT0)
+                iter_kT = 1
+            else:
+                solve_kT = _factorize(callbacks.calc_kT(an, c + dc, total))
+                iter_kT = 1
+                if lbd_dependent:
+                    # dR/dlbd at the iterate of the tangent stiffness matrix
+                    q = callbacks.calc_load_vector(an, c + dc, fext, total)
+        except RuntimeError:
+            warn('Singular tangent stiffness matrix', level=2, silent=silent)
+            return False, dc, q
+
+        varc = solve_kT(R)
 
         eta = 1.
         fint = None
@@ -261,16 +280,19 @@ def _solver_NR(an, silent=False, initialInc=None):
     `\lambda = 0` gives the predictor of the first increment, its linear
     solution `[K_0]^{-1}\{q\}`, instead of the linear solution of the
     reference vector, which is null under a prescribed displacement alone,
-    and `\lambda \|q\|`, with `\{q\}` evaluated at the current iterate
-    before each convergence check, is an additional reference of the
-    relative convergence criterion. With ``an.modified_NR = True`` this is
-    one call to ``calc_fext`` per iteration.
+    and `\lambda \|q\|` is an additional reference of the relative
+    convergence criterion. `\{q\}` is evaluated together with the tangent
+    stiffness matrix, at the same iterate, i.e. ``calc_fext`` is called once
+    per update of the tangent stiffness matrix, and the last `\{q\}`
+    evaluated is the reference of the next convergence checks, also in the
+    next step.
 
     By default full Newton-Raphson is used, i.e. the tangent stiffness matrix
     ``kT = kC + kG`` is rebuilt at every iteration, which gives quadratic
     convergence when ``kT`` is the exact Jacobian of ``fint``. With
     ``an.modified_NR = True`` the tangent stiffness matrix is rebuilt only at
     the first iteration of each step and every ``an.compute_every_n``
+    iterations, and its LU factorization is reused in the other
     iterations.
 
     With ``an.line_search = True``, the full Newton step (``eta = 1``) is tried
@@ -315,7 +337,8 @@ def _solver_NR(an, silent=False, initialInc=None):
     fext = an.calc_fext(inc=1., silent=True)
     kC0 = an.calc_kC(silent=silent)
     q = None
-    if callbacks.is_load_factor_dependent(an):
+    lbd_dependent = callbacks.is_load_factor_dependent(an)
+    if lbd_dependent:
         # dR/dlbd at c = 0 and lbd = 0
         q = callbacks.calc_load_vector(an, np.zeros_like(fext), fext, 0.)
     # predictor of the first step: linear solution scaled by the load factor
@@ -339,12 +362,13 @@ def _solver_NR(an, silent=False, initialInc=None):
         kT0 = None
         if an.modified_NR and step_num == 1 and not an.kT_initial_state:
             kT0 = kC0
-        converged, dc = _NR_iterations(an, c, dc, total, fext, kT0=kT0,
-                                       silent=silent,
-                                       lbd_dependent=q is not None)
+        converged, dc, q_new = _NR_iterations(an, c, dc, total, fext,
+                kT0=kT0, silent=silent, lbd_dependent=lbd_dependent, q=q)
 
         if converged:
             msg('Converged at load factor %1.5f' % total, level=2, silent=silent)
+            # the dR/dlbd of a step that failed is not kept
+            q = q_new
             c = c + dc
             total_last = total
             an.cs.append(c.copy()) #NOTE copy required

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve/static.py

@@ -1,5 +1,6 @@
 import numpy as np
-from scipy.sparse.linalg import spsolve
+from scipy.sparse import csc_matrix
+from scipy.sparse.linalg import spsolve, splu
 
 from .logger import msg
 from .sparseutils import remove_null_cols
@@ -43,6 +44,36 @@ def solve(a, b, silent=False, **kwargs):
     return x
 
 
+def _factorize(kT):
+    """LU factorization of the tangent stiffness matrix
+
+    Null rows and columns are removed, the corresponding values of the
+    solution are zero, as in :func:`.solve`. The factorization is reused by
+    the non-linear solvers while the tangent stiffness matrix is not
+    updated.
+
+    Parameters
+    ----------
+    kT : sparse matrix
+        Tangent stiffness matrix.
+
+    Returns
+    -------
+    solve_kT : callable
+        Function that returns the solution ``x`` of ``kT x = b``.
+
+    """
+    kT_red, used_cols = remove_null_cols(kT, silent=True)
+    lu = splu(csc_matrix(kT_red))
+
+    def solve_kT(b):
+        x = np.zeros(b.shape[0], dtype=np.result_type(b, lu.U.dtype))
+        x[used_cols] = lu.solve(b[used_cols])
+        return x
+
+    return solve_kT
+
+
 def static(K, fext, silent=False):
     r"""Linear static analysis
 

{structsolve-0.7.0 → structsolve-0.8.0/structsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: structsolve
-Version: 0.7.0
+Version: 0.8.0
 Summary: Structural analysis solvers
 Author-email: "Saullo G. P. Castro" <castrosaullo@gmail.com>
 License: BSD-2-Clause
@@ -65,7 +65,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.7.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.8.0). Zenodo. DOI: https://doi.org/10.5281/zenodo.2581212.
 
 
 Documentation
@@ -80,6 +80,8 @@ History
 
 See [CHANGELOG.md](CHANGELOG.md) for the details of each version.
 
+* version 0.8.0 (2026-10-14)
+    - Fewer evaluations and factorizations, same solutions: `dR/dlbd` is evaluated together with the tangent stiffness matrix only, Newton-Raphson reuses the factorization of the tangent while it is not updated, the follower linear static analysis factorizes `K0` once, and `lb` estimates its shift and the inertia of `K` once for all its attempts
 * version 0.7.0 (2026-10-13)
     - `calc_fext` may declare the keyword argument `lbd` and then receives the current load factor with the configuration, for prescribed displacements imposed exactly as linear constraints; the solvers use `dR/dlbd` for the arc-length scale, the first Newton-Raphson predictor and the relative convergence criterion. Callables without `lbd` behave as before
 * version 0.6.1 (2026-10-08)

{structsolve-0.7.0 → structsolve-0.8.0}/structsolve.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ tests/test_linear_buckling.py
 tests/test_linear_buckling_unsymmetric.py
 tests/test_load_factor_dependent_load.py
 tests/test_newton_raphson.py
+tests/test_reuse.py
 tests/test_sparse_first.py
 tests/test_sparseutils.py
 tests/test_static.py

{structsolve-0.7.0 → structsolve-0.8.0}/tests/test_linear_buckling.py

@@ -169,7 +169,7 @@ def test_lb_sparse_raises_when_verification_fails(monkeypatch):
 
     K, KG = load_saved_matrices('plate_ssss_Nxx')
 
-    def wrong_eigsh(K, KG, k, tol, silent, safety=10.):
+    def wrong_eigsh(K, KG, k, tol, silent, safety=10., mu_max=False):
         rng = np.random.RandomState(0)
         return -rng.rand(k), rng.randn(K.shape[0], k)
 

structsolve-0.8.0/tests/test_reuse.py

@@ -0,0 +1,174 @@
+r"""Reuse of evaluations and factorizations by the solvers
+
+- With a ``calc_fext`` that declares ``lbd``, `\partial R/\partial \lambda`
+  is evaluated only together with the tangent stiffness matrix, right after
+  ``calc_kC`` and ``calc_kG`` at the same configuration, see
+  :mod:`structsolve.callbacks`; the solutions are those of the tests of
+  ``test_load_factor_dependent_load.py``.
+- Newton-Raphson factorizes the tangent stiffness matrix once per update.
+- The linear static analysis with a configuration-dependent load factorizes
+  ``K0`` once.
+- :func:`.lb` estimates its shift and the positive definiteness of ``K``
+  once for all its attempts.
+
+"""
+import numpy as np
+import pytest
+from scipy.sparse import csr_matrix
+
+from structsolve import Analysis, lb
+from structsolve import linear_buckling, newton_raphson, analysis
+from test_load_factor_dependent_load import SpringsProblem
+from test_linear_buckling import load_saved_matrices
+
+
+class Recorder(SpringsProblem):
+    r"""The springs, recording the sequence of the calls with ``c``"""
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.events = []
+
+    def calc_fext(self, inc=1., silent=True, c=None, lbd=None):
+        if c is not None:
+            self.events.append(('fext', c.copy(), lbd))
+        return super().calc_fext(inc=inc, silent=silent, c=c, lbd=lbd)
+
+    def calc_kC(self, c=None, NLgeom=False, inc=1., silent=True):
+        if c is not None and NLgeom:
+            self.events.append(('kC', c.copy(), inc))
+        return super().calc_kC(c=c, NLgeom=NLgeom, inc=inc, silent=silent)
+
+    def calc_kG(self, c=None, NLgeom=False, silent=True):
+        if c is not None and NLgeom:
+            self.events.append(('kG', c.copy(), None))
+        return super().calc_kG(c=c, NLgeom=NLgeom, silent=silent)
+
+
+def check_events(pb, origin_calls=1):
+    r"""Every `\partial R/\partial \lambda` but those at the origin follows
+    the tangent stiffness matrix at the same configuration and load factor,
+    and there is at most one per tangent"""
+    ev = pb.events
+    fext = [i for i, e in enumerate(ev) if e[0] == 'fext']
+    tangents = [i for i, e in enumerate(ev) if e[0] == 'kC']
+    assert len(fext) <= len(tangents) + origin_calls
+    for i in fext:
+        _, c, lbd = ev[i]
+        if i < 2 or ev[i - 1][0] != 'kG':
+            assert not np.any(c) and lbd == 0., ev[i]
+            continue
+        assert np.array_equal(ev[i - 1][1], c)
+        assert ev[i - 2][0] == 'kC' and np.array_equal(ev[i - 2][1], c)
+        assert ev[i - 2][2] == lbd
+    return len(fext), len(tangents)
+
+
+def count(monkeypatch, module, name):
+    calls = []
+    func = getattr(module, name)
+
+    def wrapper(*args, **kwargs):
+        calls.append(1)
+        return func(*args, **kwargs)
+
+    monkeypatch.setattr(module, name, wrapper)
+    return calls
+
+
+@pytest.mark.parametrize('method', ['NR', 'arc_length_riks',
+                                    'arc_length_crisfield'])
+@pytest.mark.parametrize('modified_NR', [False, True])
+def test_load_vector_evaluated_with_the_tangent(method, modified_NR):
+    pb = Recorder(d0=-0.3, d1=0.6, F=40.)
+    an = pb.analysis(NL_method=method, initialInc=0.2, relTOL=1e-11,
+                     modified_NR=modified_NR)
+    an.static(NLgeom=True, silent=True)
+    assert np.isclose(an.increments[-1], 1.)
+    for lbd, c_r in zip(an.increments, an.cs):
+        ref = pb.solve_reference(lbd)
+        assert np.allclose(c_r, ref, rtol=1e-8, atol=1e-12), (lbd, c_r, ref)
+    n_fext, n_tangents = check_events(pb)
+    # dR/dlbd at the origin, then at most one per tangent
+    assert n_fext >= 2
+    if method == 'NR':
+        # one per tangent, none at the converged iterates
+        assert n_fext == n_tangents + 1
+
+
+def test_newton_raphson_one_factorization_per_tangent(monkeypatch):
+    factorizations = count(monkeypatch, newton_raphson, '_factorize')
+    for modified_NR in (False, True):
+        del factorizations[:]
+        pb = Recorder(k=(10., 15., 20.), a=(200., 400., 600.), d1=1.)
+        an = pb.analysis(NL_method='NR', initialInc=0.5, relTOL=1e-12,
+                         modified_NR=modified_NR, compute_every_n=3,
+                         kT_initial_state=True)
+        an.static(NLgeom=True, silent=True)
+        assert np.isclose(an.increments[-1], 1.)
+        n_tangents = sum(1 for e in pb.events if e[0] == 'kC')
+        assert len(factorizations) == n_tangents
+        corrections = sum(1 for e in pb.fint_calls) - len(an.increments)
+        if modified_NR:
+            # the factorization is reused between the updates
+            assert len(factorizations) < corrections
+
+
+def test_newton_raphson_singular_tangent_cuts_the_step():
+    """A singular tangent stops the iterations of the step with a warning,
+    the step being repeated with a smaller increment"""
+    pb = SpringsProblem(F=10., d1=0.)
+    calls = []
+
+    def calc_kC(c=None, NLgeom=False, inc=1., silent=True):
+        if c is not None and NLgeom and not calls:
+            calls.append(1)
+            return csr_matrix(np.array([[1., 1.], [1., 1.]]))
+        return pb.calc_kC(c=c, NLgeom=NLgeom, inc=inc, silent=silent)
+
+    an = pb.analysis(initialInc=0.5, relTOL=1e-10)
+    an.calc_kC = calc_kC
+    an.static(NLgeom=True, silent=True)
+    assert calls and np.isclose(an.increments[-1], 1.)
+
+
+def test_linear_static_follower_factorizes_K0_once(monkeypatch):
+    factorizations = count(monkeypatch, analysis, '_factorize')
+    K0 = csr_matrix(np.array([[4., -1., 0.], [-1., 4., -1.], [0., -1., 3.]]))
+    F0 = np.array([1., 0., 2.])
+    B = 0.3*np.array([[0., 1., 0.], [0., 0., 1.], [1., 0., 0.]])
+
+    def calc_fext(inc=1., silent=True, c=None):
+        return inc*(F0 if c is None else F0 + B @ c)
+
+    an = Analysis(calc_fext, None, lambda c=None, NLgeom=False, silent=True:
+                  K0, None)
+    an.relTOL = 1e-12
+    _, cs = an.static(NLgeom=False, silent=True)
+    exact = np.linalg.solve(K0.toarray() - B, F0)
+    assert np.allclose(cs[-1], exact, rtol=1e-10)
+    assert len(factorizations) == 1
+
+
+def test_lb_estimates_once_for_all_attempts(monkeypatch):
+    K, KG = load_saved_matrices('plate_ssss_Nxx')
+    ref, _ = lb(K, KG, silent=True)
+    estimates = count(monkeypatch, linear_buckling, '_estimate_mu_max')
+    inertia = count(monkeypatch, linear_buckling, '_is_positive_definite')
+    eigsh_cayley = linear_buckling._eigsh_cayley
+    attempts = []
+
+    def first_fails(K, KG, k, tol, silent, safety=10., mu_max=False):
+        attempts.append(safety)
+        mu, v = eigsh_cayley(K, KG, k, tol, silent, safety=safety,
+                             mu_max=mu_max)
+        if len(attempts) == 1:
+            # a wrong eigenvector
+            v = v[:, ::-1]
+        return mu, v
+
+    monkeypatch.setattr(linear_buckling, '_eigsh_cayley', first_fails)
+    eigvals, _ = lb(K, KG, silent=True)
+    assert attempts == [10., 100.]
+    assert np.allclose(eigvals[:5], ref[:5], rtol=1e-8)
+    assert len(estimates) == 1
+    assert len(inertia) == 1