pyMOTO 1.2.1__py3-none-any.whl → 1.4.0__py3-none-any.whl

pymoto/solvers/solvers.py

@@ -0,0 +1,253 @@
+import warnings
+import numpy as np
+from .matrix_checks import matrix_is_hermitian, matrix_is_symmetric, matrix_is_complex
+
+
+class LinearSolver:
+    """ Base class of all linear solvers
+
+    Keyword Args:
+        A (matrix): Optionally provide a matrix, which is used in :method:`update` right away.
+
+    Attributes:
+        defined (bool): Flag if the solver is able to run, e.g. false if some dependent library is not available
+    """
+
+    defined = True
+    _err_msg = ""
+
+    def __init__(self, A=None):
+        if A is not None:
+            self.update(A)
+
+    def update(self, A):
+        """ Updates with a new matrix of the same structure
+
+        Args:
+            A (matrix): The new matrix of size ``(N, N)``
+
+        Returns:
+            self
+        """
+        raise NotImplementedError(f"Solver not implemented {self._err_msg}")
+
+    def solve(self, rhs, x0=None, trans='N'):
+        r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}`
+
+        Args:
+            rhs: Right hand side :math:`\mathbf{b}` of shape ``(N)`` or ``(N, K)`` for multiple right-hand-sides
+            x0 (optional): Initial guess for the solution
+            trans (optional): Option to transpose matrix
+                'N':   A   @ x == rhs   (default)   Normal matrix
+                'T':   A^T @ x == rhs               Transposed matrix
+                'H':   A^H @ x == rhs               Hermitian transposed matrix (conjugate transposed)
+
+        Returns:
+            Solution vector :math:`\mathbf{x}` of same shape as :math:`\mathbf{b}`
+        """
+        raise NotImplementedError(f"Solver not implemented {self._err_msg}")
+
+    @staticmethod
+    def residual(A, x, b, trans='N'):
+        r""" Calculates the (relative) residual of the linear system of equations
+
+        The residual is calculated as
+        :math:`r = \frac{\left| \mathbf{A} \mathbf{x} - \mathbf{b} \right|}{\left| \mathbf{b} \right|}`
+
+        Args:
+            A: The matrix
+            x: Solution vector
+            b: Right-hand side
+            trans (optional): Matrix tranformation (`N` is normal, `T` is transposed, `H` is hermitian transposed)
+
+        Returns:
+            Residual value
+        """
+        assert x.shape == b.shape
+        if trans == 'N':
+            mat = A
+        elif trans == 'T':
+            mat = A.T
+        elif trans == 'H':
+            mat = A.conj().T
+        else:
+            raise TypeError("Only N, T, or H transposition is possible")
+        return np.linalg.norm(mat@x - b, axis=0) / np.linalg.norm(b, axis=0)
+
+
+class LDAWrapper(LinearSolver):
+    r""" Linear dependency aware solver (LDAS)
+
+    This solver uses previous solutions of the system :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` to reduce computational
+    effort. In case the solution :math:`\mathbf{x}` is linearly dependent on the previous solutions, the solution
+    will be nearly free of cost.
+
+    Args:
+        solver: The internal solver to be used
+        tol (optional): Residual tolerance above which the internal solver is used to add a new solution vector.
+        A (optional): The matrix :math:`\mathbf{A}`
+        symmetric (optional): Flag to indicate a symmetric matrix :math:`A=A^T`
+        hermitian (optional): Flag to indicate a Hermitian matrix :math:`A=A^H`
+
+    References:
+    Koppen, S., van der Kolk, M., van den Boom, S., & Langelaar, M. (2022).
+    Efficient computation of states and sensitivities for compound structural optimisation problems using a Linear Dependency Aware Solver (LDAS).
+    Structural and Multidisciplinary Optimization, 65(9), 273.
+    DOI: 10.1007/s00158-022-03378-8
+    """
+    def __init__(self, solver: LinearSolver, tol=1e-7, A=None, symmetric=None, hermitian=None):
+        self.solver = solver
+        self.tol = tol
+        # Storage for solution vectors (solutions of A x = b)
+        self.x_stored = []
+        self.b_stored = []
+        # Storage for adjoint solution vectors (solutions of A^H x = b)
+        self.xadj_stored = []
+        self.badj_stored = []
+        self.A = None
+        self._did_solve = False  # For debugging purposes
+        self._last_rtol = 0.
+        self.hermitian = hermitian
+        self.symmetric = symmetric
+        self.complex = None
+        super().__init__(A)
+
+    def update(self, A):
+        """ Clear the internal stored solution vectors and update the internal ``solver`` """
+        if self.symmetric is None:
+            self.symmetric = matrix_is_symmetric(A)
+
+        if self.hermitian is None:
+            if not matrix_is_complex(A):
+                self.hermitian = self.symmetric
+            self.hermitian = matrix_is_hermitian(A)
+
+        self.A = A
+        self.x_stored.clear()
+        self.b_stored.clear()
+        self.xadj_stored.clear()
+        self.badj_stored.clear()
+        self.solver.update(A)
+
+    def _do_solve_1rhs(self, A, rhs, x_data, b_data, solve_fn, x0=None):
+        dtype = np.result_type(A, rhs)
+        if rhs.ndim == 1:
+            rhs_loc = np.zeros((rhs.size, 1), dtype=dtype)
+            rhs_loc[:, 0] = rhs
+        else:
+            rhs_loc = np.zeros_like(rhs, dtype=dtype)
+            rhs_loc[:] = rhs
+        sol = np.zeros_like(rhs_loc, dtype=dtype)
+
+        # Check linear dependencies in the rhs using modified Gram-Schmidt
+        for (x, b) in zip(x_data, b_data):
+            assert x.ndim == b.ndim == 1
+            assert x.size == b.size == rhs_loc.shape[0]
+            alpha = rhs_loc.T @ b.conj() / (b.conj() @ b)
+
+            rem_rhs = alpha * b[:, None]
+            add_sol = alpha * x[:, None]
+
+            if np.iscomplexobj(rem_rhs) and not np.iscomplexobj(rhs_loc):
+                if np.linalg.norm(np.imag(rem_rhs)) < 1e-10*np.linalg.norm(np.real(rem_rhs)):
+                    rem_rhs = np.real(rem_rhs)
+                else:
+                    warnings.warn('LDAS: Complex vector cannot be subtracted from real rhs')
+                    continue
+
+            if np.iscomplexobj(add_sol) and not np.iscomplexobj(sol):
+                if np.linalg.norm(np.imag(add_sol)) < 1e-10*np.linalg.norm(np.real(add_sol)):
+                    add_sol = np.real(add_sol)
+                else:
+                    warnings.warn('LDAS: Complex vector cannot be added to real solution')
+                    continue
+
+            rhs_loc -= rem_rhs
+            sol += add_sol
+
+        # Check tolerance
+        self._last_rtol = np.ones(rhs_loc.shape[-1]) if len(x_data) == 0 else self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
+        self._did_solve = self._last_rtol > self.tol
+        if np.any(self._did_solve):
+            if x0 is not None:
+                if x0.ndim == 1:
+                    x0_loc = x0.reshape(-1, 1).copy()
+                else:
+                    x0_loc = x0[..., self._did_solve].copy()
+                for x in x_data:
+                    beta = x0_loc.T @ x.conj() / (x.conj() @ x)
+                    x0_loc -= beta * x
+            else:
+                x0_loc = None
+
+            # Calculate a new solution
+            xnew = solve_fn(rhs_loc[..., self._did_solve], x0_loc)
+            self.residual(A, xnew, rhs_loc[..., self._did_solve])
+            sol[..., self._did_solve] += xnew
+
+            # Add to database
+            for i in range(xnew.shape[-1]):
+                # Remove all previous components that are already in the database (orthogonalize)
+                xadd = xnew[..., i]
+                badd = A @ xadd
+                for x, b in zip(x_data, b_data):
+                    beta = badd @ b.conj() / (b.conj() @ b)
+                    badd -= beta * b
+                    xadd -= beta * x
+                bnrm = np.linalg.norm(badd)
+                if not np.isfinite(bnrm) or bnrm == 0:
+                    continue
+                badd /= bnrm
+                xadd /= bnrm
+                x_data.append(xadd)
+                b_data.append(badd)
+
+        if rhs.ndim == 1:
+            return sol.flatten()
+        else:
+            return sol
+
+    def solve(self, rhs, x0=None, trans='N'):
+        r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` by performing a modified
+        Gram-Schmidt over the previously calculated solutions :math:`\mathbf{U}` and corresponding right-hand-sides
+        :math:`\mathbf{F}`. This is used to construct an approximate solution
+        :math:`\tilde{\mathbf{x}} = \sum_k \alpha_k \mathbf{u}_k` in the subspace of :math:`\mathbf{U}`.
+        If the residual of :math:`\mathbf{A} \tilde{\mathbf{x}} = \mathbf{b}` is above the tolerance, a new solution
+        :math:`\mathbf{u}_{k+1}` will be added to the database such that
+        :math:`\mathbf{x} = \tilde{\mathbf{x}}+\mathbf{u}_{k+1}` is the solution to the system
+        :math:`\mathbf{A} \mathbf{x} = \mathbf{b}`.
+
+        The right-hand-side :math:`\mathbf{b}` can be of size ``(N)`` or ``(N, K)``, where ``N`` is the size of matrix
+        :math:`\mathbf{A}` and ``K`` is the number of right-hand sides.
+        """
+        ''' Required    Symm. matrix    Herm. matrix    Any matrix (uses adjoint storage)
+                        A^T = A         A^H = A
+            A x = b
+            A^T x = b   A x = b         A x^* = b^*     A^H x^* = b^*
+            A^H x = b   A x^* = b^*     A x = b         A^H x = b
+            
+            For symmetric or Hermitian matrices, only the normal storage is required. For any other matrix, the `T` and 
+            `H` mode will require the adjoint storage space.
+        '''
+        if trans not in ['N', 'T', 'H']:
+            raise TypeError("Only N, T, or H transposition is possible")
+
+        # Use adjoint storage?
+        adjoint_mode = trans != 'N' and not (self.symmetric or self.hermitian)
+        # Use conjugation?
+        conj_mode = self.symmetric and trans == 'H' or not self.symmetric and trans == 'T'
+
+        storage = 'H' if adjoint_mode else 'N'
+        rhs = rhs.conj() if conj_mode else rhs
+        if storage == 'N':  # Use the normal storage
+            ret = self._do_solve_1rhs(self.A, rhs,
+                                      self.x_stored, self.b_stored,
+                                      lambda b, x_init: self.solver.solve(b, trans='N', x0=x_init),
+                                      x0=x0)
+        elif storage == 'H':  # Use adjoint storage
+            ret = self._do_solve_1rhs(self.A.conj().T, rhs,
+                                      self.xadj_stored, self.badj_stored,
+                                      lambda b, x_init: self.solver.solve(b, trans='H', x0=x_init),
+                                      x0=x0)
+
+        return ret.conj() if conj_mode else ret

pymoto/{common/solvers_sparse.py → solvers/sparse.py}

@@ -2,7 +2,8 @@ import warnings
 import numpy as np
 import scipy.sparse as sps
 from scipy.sparse import SparseEfficiencyWarning
-from .solvers import matrix_is_hermitian, matrix_is_complex, matrix_is_symmetric, LinearSolver
+from .matrix_checks import matrix_is_hermitian, matrix_is_complex, matrix_is_symmetric
+from .solvers import LinearSolver
 
 # ------------------------------------ Pardiso Solver -----------------------------------
 try:
@@ -126,26 +127,31 @@ class SolverSparsePardiso(LinearSolver):
 
         self._pardiso_solver.factorize(A)
 
-    def solve(self, b):
+    def solve(self, b, x0=None, trans='N'):
         """ solve Ax=b for x
 
         Args:
             A (scipy.sparse.csr.csr_matrix): sparse square CSR matrix , CSC matrix also possible
             b (numpy.ndarray): right-hand side(s), b.shape[0] needs to be the same as A.shape[0]
+            x0 (unused)
+            trans (optional): Indicate which system to solve (Normal, Transposed, or Hermitian transposed)
 
         Returns:
             Solution of the system of linear equations, same shape as input b
         """
-        return self._pardiso_solver.solve(self.A, b)
-
-    def adjoint(self, b):
-        # Cannot use _pardiso_solver.solve because it changes flag 12 internally
-        iparm_prev = self._pardiso_solver.get_iparm(12)
-        self._pardiso_solver.set_iparm(12, int(not iparm_prev))  # Adjoint solver (transpose)
-        b = self._pardiso_solver._check_b(self.A, b)
-        x = self._pardiso_solver._call_pardiso(self.A, b)
-        self._pardiso_solver.set_iparm(12, iparm_prev)  # Revert back to normal solver
-        return x
+        if trans == 'N':
+            return self._pardiso_solver.solve(self.A, b)
+        elif trans == 'T' or trans == 'H':
+            # T and H are the same, because only real matrix is supported
+            # Cannot use _pardiso_solver.solve because it changes flag 12 internally
+            iparm_prev = self._pardiso_solver.get_iparm(12)
+            self._pardiso_solver.set_iparm(12, int(not iparm_prev))  # Adjoint solver (transpose)
+            b = self._pardiso_solver._check_b(self.A, b)
+            x = self._pardiso_solver._call_pardiso(self.A, b)
+            self._pardiso_solver.set_iparm(12, iparm_prev)  # Revert back to normal solver
+            return x
+        else:
+            raise TypeError("Only N, T, or H transposition is possible")
 
     def _print_iparm(self):
         """ Print all iparm settings to console """
@@ -219,17 +225,16 @@ class SolverSparseLU(LinearSolver):
         self.inv = splu(A)
         return self
 
-    def solve(self, rhs):
+    def solve(self, rhs, x0=None, trans='N'):
         r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` by forward and backward
         substitution of :math:`\mathbf{x} = \mathbf{U}^{-1}\mathbf{L}^{-1}\mathbf{b}`.
-        """
-        return self.inv.solve(rhs)
 
-    def adjoint(self, rhs):
-        r""" Solves the linear system of equations :math:`\mathbf{A}^\text{H}\mathbf{x} = \mathbf{b}` by forward and
-        backward substitution of :math:`\mathbf{x} = \mathbf{L}^{-\text{H}}\mathbf{U}^{-\text{H}}\mathbf{b}`.
+        Adjoint system solves the linear system of equations :math:`\mathbf{A}^\text{H}\mathbf{x} = \mathbf{b}` by
+        forward and backward substitution of :math:`\mathbf{x} = \mathbf{L}^{-\text{H}}\mathbf{U}^{-\text{H}}\mathbf{b}`
         """
-        return self.inv.solve(rhs, trans=('H' if self.iscomplex else 'T'))
+        if trans not in ['N', 'T', 'H']:
+            raise TypeError("Only N, T, or H transposition is possible")
+        return self.inv.solve(rhs, trans=trans)
 
 
 # ------------------------------------ Cholesky Solver scikit-sparse -----------------------------------
@@ -281,7 +286,7 @@ class SolverSparseCholeskyScikit(LinearSolver):
 
         return self
 
-    def solve(self, rhs):
+    def solve(self, rhs, x0=None, trans='N'):
         r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` by forward and backward
         substitution of :math:`\mathbf{x} = \mathbf{L}^{-\text{H}}\mathbf{L}^{-1}\mathbf{b}` in case of an
         Hermitian matrix.
@@ -290,10 +295,12 @@ class SolverSparseCholeskyScikit(LinearSolver):
         :math:`\mathbf{A}` and ``K`` is the number of right-hand sides.
 
         """
-        return self.inv(rhs)
-
-    def adjoint(self, rhs):
-        return self.solve(rhs)
+        if trans not in ['N', 'T', 'H']:
+            raise TypeError("Only N, T, or H transposition is possible")
+        if trans == 'T':
+            return self.inv(rhs.conj()).conj()
+        else:
+            return self.inv(rhs)
 
 
 # ------------------------------------ Cholesky Solver cvxopt -----------------------------------
@@ -344,15 +351,20 @@ class SolverSparseCholeskyCVXOPT(LinearSolver):
 
         return self
 
-    def solve(self, rhs):
+    def solve(self, rhs, x0=None, trans='N'):
         r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` by forward and backward
         substitution of :math:`\mathbf{x} = \mathbf{L}^{-\text{H}}\mathbf{L}^{-1}\mathbf{b}`. """
+        if trans not in ['N', 'T', 'H']:
+            raise TypeError("Only N, T, or H transposition is possible")
         if rhs.dtype != self._dtype:
             warnings.warn(f"{type(self).__name__}: Type warning: rhs value type ({rhs.dtype}) is converted to {self._dtype}")
-        B = cvxopt.matrix(rhs.astype(self._dtype))
+        if trans == 'T':
+            B = cvxopt.matrix(rhs.conj().astype(self._dtype))
+        else:
+            B = cvxopt.matrix(rhs.astype(self._dtype))
         nrhs = 1 if rhs.ndim == 1 else rhs.shape[1]
+
         cvxopt.cholmod.solve(self.inv, B, nrhs=nrhs)
-        return np.array(B).flatten() if nrhs == 1 else np.array(B)
 
-    def adjoint(self, rhs):
-        return self.solve(rhs)
+        x = np.array(B).flatten() if rhs.ndim == 1 else np.array(B)
+        return x.conj() if trans == 'T' else x

pyMOTO-1.2.1.dist-info/RECORD

@@ -1,24 +0,0 @@
-pymoto/__init__.py,sha256=V3OzqL_4NDy7lzIv_8tvu6s-8qS4bUwczd6XoH75M3s,2196
-pymoto/core_objects.py,sha256=9TjGunvGVwa-LqM2tmE1XlWnqHDscZLeqbKFBZ7ZroU,25111
-pymoto/routines.py,sha256=pMJlEFXa413XbqvbJuw3bZTNGQJ4Al-BRdAy_Es_M2g,14360
-pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=_VWgm0sjMDsan_GiKnwmpJqZcuksgDU6UTdZYMTSi98,15153
-pymoto/common/dyadcarrier.py,sha256=VwLJnOq1omfMX2udG6DMHOkD3AsIB05LTpDY7veYXcc,17136
-pymoto/common/mma.py,sha256=W1Z0h5f3a9BP8nFIlCdahDCIHT4XrcDcDyE6Y1Brq3k,23318
-pymoto/common/solvers.py,sha256=U7XNMSyHhp0fiZ8ASo1guUb-CHGygik7A4lfLOnh07c,8316
-pymoto/common/solvers_dense.py,sha256=vuBUp3y4qJLwmsXbFQ_tEb-7LqqCEemFunTn1z_Qu0U,9901
-pymoto/common/solvers_sparse.py,sha256=QVbGTwGtbhOqRUyg2gHmY-K5haiPbskGA6uj_g-dKz8,15776
-pymoto/modules/assembly.py,sha256=i0zwigijmsJRR3aHZXSIzlDcYMbCWxKW4fe3NqjW8ew,11540
-pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
-pymoto/modules/complex.py,sha256=vwzqRo5W319mVf_RqbB7LpYe7jXruVxa3ZV560Iq39k,4421
-pymoto/modules/filter.py,sha256=8A-dmWSFEqFyQcutjFv__pfgAwszCVZeZgLxuG9hi0g,18840
-pymoto/modules/generic.py,sha256=27EuDMfUtWkkwEqkfbHMCRlHkt6wcV40aUQKfhL2xKI,9783
-pymoto/modules/io.py,sha256=4k5S-YQHKhw_HwmqOoYQWFEzdcL5nMJ5fVD2FJFqpFg,10532
-pymoto/modules/linalg.py,sha256=j8bZfjo5Il_vbdEHr2BhWB3e7OssYVovieoN54zygx8,24266
-pymoto/modules/scaling.py,sha256=hK3sfCoAoseabjqdn5VXe6aGA_fV-MRmMtiv4uIg_I4,2252
-pyMOTO-1.2.1.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.2.1.dist-info/METADATA,sha256=YKmcOzqRFlAObECUODa5oZgcIG9r7GRhjn86x12_8fk,4907
-pyMOTO-1.2.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-pyMOTO-1.2.1.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.2.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.2.1.dist-info/RECORD,,

pymoto/common/solvers.py

@@ -1,236 +0,0 @@
-import numpy as np
-import scipy.sparse as sps
-try:
-    import cvxopt
-    _has_cvxopt = True
-except ImportError:
-    _has_cvxopt = False
-
-
-def is_cvxopt_spmatrix(A):
-    """ Checks if the argument is a cvxopt sparse matrix """
-    return isinstance(A, cvxopt.spmatrix) if _has_cvxopt else False
-
-
-def matrix_is_complex(A):
-    """ Checks if the matrix is complex """
-    if is_cvxopt_spmatrix(A):
-        return A.typecode == 'z'
-    else:
-        return np.iscomplexobj(A)
-
-
-def matrix_is_diagonal(A):
-    """ Checks if the matrix is diagonal"""
-    if sps.issparse(A):
-        if isinstance(A, sps.dia_matrix):
-            return len(A.offsets) == 1 and A.offsets[0] == 0
-        else:
-            return np.allclose((A - sps.spdiags(A.diagonal(), 0, *A.shape)).data, 0.0)
-    elif is_cvxopt_spmatrix(A):
-        return max(abs(A.I - A.J)) == 0
-    else:
-        return np.allclose(A, np.diag(np.diag(A)))
-
-
-def matrix_is_symmetric(A):
-    """ Checks whether a matrix is numerically symmetric """
-    if sps.issparse(A):
-        return np.allclose((A-A.T).data, 0)
-    elif is_cvxopt_spmatrix(A):
-        return np.isclose(max(abs(A-A.T)), 0.0)
-    else:
-        return np.allclose(A, A.T)
-
-
-def matrix_is_hermitian(A):
-    """ Checks whether a matrix is numerically Hermitian """
-    if matrix_is_complex(A):
-        if sps.issparse(A):
-            return np.allclose((A-A.T.conj()).data, 0)
-        elif is_cvxopt_spmatrix(A):
-            return np.isclose(max(abs(A-A.ctrans())), 0.0)
-        else:
-            return np.allclose(A, A.T.conj())
-    else:
-        return matrix_is_symmetric(A)
-
-
-class LinearSolver:
-    """ Base class of all linear solvers
-
-    Keyword Args:
-        A (matrix): Optionally provide a matrix, which is used in :method:`update` right away.
-
-    Attributes:
-        defined (bool): Flag if the solver is able to run, e.g. false if some dependent library is not available
-    """
-
-    defined = True
-    _err_msg = ""
-
-    def __init__(self, A=None):
-        if A is not None:
-            self.update(A)
-
-    def update(self, A):
-        """ Updates with a new matrix of the same structure
-
-        Args:
-            A (matrix): The new matrix of size ``(N, N)``
-
-        Returns:
-            self
-        """
-        raise NotImplementedError(f"Solver not implemented {self._err_msg}")
-
-    def solve(self, rhs):
-        r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}`
-
-        Args:
-            rhs: Right hand side :math:`\mathbf{b}` of shape ``(N)`` or ``(N, K)`` for multiple right-hand-sides
-
-        Returns:
-            Solution vector :math:`\mathbf{x}` of same shape as :math:`\mathbf{b}`
-        """
-        raise NotImplementedError(f"Solver not implemented {self._err_msg}")
-
-    def adjoint(self, rhs):
-        r""" Solves the adjoint linear system of equations
-
-        The system of equations is :math:`\mathbf{A}^\text{H} \mathbf{x} = \mathbf{b}` (conjugate transpose) in case of
-        complex matrix or :math:`\mathbf{A}^\text{T} \mathbf{x} = \mathbf{b}` for a real-valued matrix.
-
-        Args:
-            rhs: Right hand side :math:`\mathbf{b}` of shape ``(N)`` or ``(N, K)`` for multiple right-hand-sides
-
-        Returns:
-            Solution vector :math:`\mathbf{x}` of same shape as :math:`\mathbf{b}`
-        """
-        raise NotImplementedError(f"Solver not implemented {self._err_msg}")
-
-    @staticmethod
-    def residual(A, x, b):
-        r""" Calculates the (relative) residual of the linear system of equations
-
-        The residual is calculated as
-        :math:`r = \frac{\left| \mathbf{A} \mathbf{x} - \mathbf{b} \right|}{\left| \mathbf{b} \right|}`
-
-        Args:
-            A: The matrix
-            x: Solution vector
-            b: Right-hand side
-
-        Returns:
-            Residual value
-        """
-        return np.linalg.norm(A@x - b) / np.linalg.norm(b)
-
-
-class LDAWrapper(LinearSolver):
-    r""" Linear dependency aware solver (LDAS)
-
-    This solver uses previous solutions of the system :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` to reduce computational
-    effort. In case the solution :math:`\mathbf{x}` is linearly dependent on the previous solutions, the solution
-    will be nearly free of cost.
-
-    Args:
-        solver: The internal solver to be used
-        tol (optional): Residual tolerance above which the internal solver is used to add a new solution vector.
-        A (optional): The matrix :math:`\mathbf{A}`
-
-    References:
-
-    Koppen, S., van der Kolk, M., van den Boom, S., & Langelaar, M. (2022).
-    Efficient computation of states and sensitivities for compound structural optimisation problems using a Linear Dependency Aware Solver (LDAS).
-    Structural and Multidisciplinary Optimization, 65(9), 273.
-    DOI: 10.1007/s00158-022-03378-8
-    """
-    def __init__(self, solver: LinearSolver, tol=1e-8, A=None, hermitian=False, symmetric=False):
-        self.solver = solver
-        self.tol = tol
-        self.x_stored = []
-        self.b_stored = []
-        self.xadj_stored = []
-        self.badj_stored = []
-        self.A = None
-        self._did_solve = False  # For debugging purposes
-        self._last_rtol = 0.
-        self.hermitian = hermitian
-        self.symmetric = symmetric
-        super().__init__(A)
-
-    def update(self, A):
-        """ Clear the internal stored solution vectors and update the internal ``solver`` """
-        self.A = A
-        self.x_stored.clear()
-        self.b_stored.clear()
-        self.xadj_stored.clear()
-        self.badj_stored.clear()
-        self.solver.update(A)
-
-    def _do_solve_1rhs(self, A, rhs, x_data, b_data, solve_fn):
-        rhs_loc = rhs.copy()
-        sol = 0
-
-        # Check linear dependencies in the rhs using modified Gram-Schmidt
-        for (x, b) in zip(x_data, b_data):
-            alpha = rhs_loc.conj() @ b / (b.conj() @ b)
-            rhs_loc -= alpha * b
-            sol += alpha * x
-
-        # Check tolerance
-        self._last_rtol = 1.0 if len(x_data) == 0 else self.residual(A, sol, rhs)
-
-        if self._last_rtol > self.tol:
-            # Calculate a new solution
-            xnew = solve_fn(rhs_loc)
-            x_data.append(xnew)
-            b_data.append(rhs_loc)
-            sol += xnew
-            self._did_solve = True
-        else:
-            self._did_solve = False
-
-        return sol
-
-    def _solve_1x(self, b):
-        return self._do_solve_1rhs(self.A, b, self.x_stored, self.b_stored, self.solver.solve)
-
-    def _adjoint_1x(self, b):
-        return self._do_solve_1rhs(self.A.conj().T, b, self.xadj_stored, self.badj_stored, self.solver.adjoint)
-
-    def solve(self, rhs):
-        r""" Solves the linear system of equations :math:`\mathbf{A} \mathbf{x} = \mathbf{b}` by performing a modified
-        Gram-Schmidt over the previously calculated solutions :math:`\mathbf{U}` and corresponding right-hand-sides
-        :math:`\mathbf{F}`. This is used to construct an approximate solution
-        :math:`\tilde{\mathbf{x}} = \sum_k \alpha_k \mathbf{u}_k` in the subspace of :math:`\mathbf{U}`.
-        If the residual of :math:`\mathbf{A} \tilde{\mathbf{x}} = \mathbf{b}` is above the tolerance, a new solution
-        :math:`\mathbf{u}_{k+1}` will be added to the database such that
-        :math:`\mathbf{x} = \tilde{\mathbf{x}}+\mathbf{u}_{k+1}` is the solution to the system
-        :math:`\mathbf{A} \mathbf{x} = \mathbf{b}`.
-
-        The right-hand-side :math:`\mathbf{b}` can be of size ``(N)`` or ``(N, K)``, where ``N`` is the size of matrix
-        :math:`\mathbf{A}` and ``K`` is the number of right-hand sides.
-        """
-        if rhs.ndim == 1:
-            return self._solve_1x(rhs)
-        else:  # Multiple rhs
-            sol = []
-            for i in range(rhs.shape[-1]):
-                sol.append(self._solve_1x(rhs[..., i]))
-            return np.stack(sol, axis=-1)
-
-    def adjoint(self, rhs):
-        if self.hermitian:
-            return self.solve(rhs)
-        elif self.symmetric:
-            return self.solve(rhs.conj()).conj()
-        else:
-            if rhs.ndim == 1:
-                return self._adjoint_1x(rhs)
-            else:  # Multiple rhs
-                sol = []
-                for i in range(rhs.shape[-1]):
-                    sol.append(self._adjoint_1x(rhs[..., i]))
-                return np.stack(sol, axis=-1)