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

pymoto/modules/linalg.py

@@ -9,7 +9,7 @@ import scipy.sparse.linalg as spsla
 
 from pymoto import Signal, Module, DyadCarrier
 from pymoto.solvers import auto_determine_solver
-from pymoto.solvers import matrix_is_hermitian, LDAWrapper
+from pymoto.solvers import matrix_is_sparse, matrix_is_complex, matrix_is_hermitian, LDAWrapper
 
 
 class StaticCondensation(Module):
@@ -251,8 +251,8 @@ class LinSolve(Module):
 
     def _response(self, mat, rhs):
         # Do some detections on the matrix type
-        self.issparse = sps.issparse(mat)  # Check if it is a sparse matrix
-        self.iscomplex = np.iscomplexobj(mat)  # Check if it is a complex-valued matrix
+        self.issparse = matrix_is_sparse(mat)  # Check if it is a sparse matrix
+        self.iscomplex = matrix_is_complex(mat)  # Check if it is a complex-valued matrix
         if not self.iscomplex and self.issymmetric is not None:
             self.ishermitian = self.issymmetric
         if self.ishermitian is None:
@@ -268,7 +268,7 @@ class LinSolve(Module):
         if not isinstance(self.solver, LDAWrapper) and self.use_lda_solver:
             lda_kwargs = dict(hermitian=self.ishermitian, symmetric=self.issymmetric)
             if hasattr(self.solver, 'tol'):
-                lda_kwargs['tol'] = self.solver.tol * 2
+                lda_kwargs['tol'] = self.solver.tol * 5
             self.solver = LDAWrapper(self.solver, **lda_kwargs)
 
         # Update solver with new matrix
@@ -318,9 +318,6 @@ class EigenSolve(Module):
     Mode tracking algorithms can be implemented by the user by providing the argument ``sorting_func``, which is a
     function with arguments (``λ``, ``Q``).
 
-    Todo:
-        Support for sparse matrix
-
     Input Signal(s):
       - ``A`` (`dense matrix`): The system matrix of size ``(n, n)``
       - ``B`` (`dense matrix, optional`): Second system matrix (must be positive-definite) of size ``(n, n)``
@@ -346,12 +343,14 @@ class EigenSolve(Module):
         self.mode = mode
         self.Ainv = None
         self.do_solve = False
+        self.adjoint_solvers_need_update = True
 
     def _response(self, A, *args):
         B = args[0] if len(args) > 0 else None
         if self.is_hermitian is None:
             self.is_hermitian = (matrix_is_hermitian(A) and (B is None or matrix_is_hermitian(B)))
-        self.is_sparse = sps.issparse(A) and (B is None or sps.issparse(B))
+        self.is_sparse = matrix_is_sparse(A) and (B is None or matrix_is_sparse(B))
+        self.adjoint_solvers_need_update = True
 
         # Solve the eigenvalue problem
         if self.is_sparse:
@@ -364,12 +363,20 @@ class EigenSolve(Module):
         W = W[isort]
         Q = Q[:, isort]
 
-        # Normalize the eigenvectors
+        # Normalize the eigenvectors with the following conditions:
+        # 1) Flip sign such that the average (real) value is positive
+        # 2) Normalize the eigenvector v⋅v or v⋅Bv to unity
         for i in range(W.size):
             qi, wi = Q[:, i], W[i]
-            qi *= np.sign(np.real(qi[np.argmax(abs(qi) > 0)]))  # Set first value positive for orientation
             Bqi = qi if B is None else B@qi
-            qi /= np.sqrt(qi@Bqi)  # Normalize
+
+            normval = np.sqrt(qi @ Bqi)
+            sgn = 1 if np.real(np.average(qi)) >= 0 else -1
+            sf = sgn / normval
+            assert np.isfinite(sf)
+            if sf == 0.0:
+                warnings.warn(f"Scaling factor of mode {i} is zero!")
+            qi *= sf
         return W, Q
 
     def _sensitivity(self, dW, dQ):
@@ -380,7 +387,8 @@ class EigenSolve(Module):
             dA, dB = self._dense_sens(A, B, dW, dQ)
         else:
             if dQ is not None:
-                raise NotImplementedError('Sparse eigenvector sensitivities not implemented')
+                # raise NotImplementedError('Sparse eigenvector sensitivities not implemented')
+                dA, dB = self._sparse_eigvec_sens(A, B, dW, dQ)
             elif dW is not None:
                 dA, dB = self._sparse_eigval_sens(A, B, dW)
 
@@ -389,7 +397,6 @@ class EigenSolve(Module):
         elif len(self.sig_in) == 2:
             return dA, dB
 
-
     def _sparse_eigs(self, A, B=None):
         if self.nmodes is None:
             self.nmodes = 6
@@ -418,8 +425,9 @@ class EigenSolve(Module):
         if self.is_hermitian:
             return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma, mode=self.mode)
         else:
-            # TODO
-            raise NotImplementedError('Non-Hermitian sparse matrix not supported')
+            if self.mode.lower() not in ['normal']:
+                raise NotImplementedError('Only `normal` mode can be selected for non-hermitian matrix')
+            return spsla.eigs(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma)
 
     def _dense_sens(self, A, B, dW, dQ):
         """ Calculates all (eigenvector and eigenvalue) sensitivities for dense matrix """
@@ -460,16 +468,69 @@ class EigenSolve(Module):
             qi = Q[:, i]
             qmq = qi@qi if B is None else qi @ (B @ qi)
             dA_u = (dwi/qmq) * qi
-            if np.isrealobj(A):
-                dA += DyadCarrier([np.real(dA_u), -np.imag(dA_u)], [np.real(qi), np.imag(qi)])
-            else:
-                dA += DyadCarrier(dA_u, qi)
+            dAi = DyadCarrier(dA_u, qi)
+            dA += np.real(dAi) if np.isrealobj(A) else dAi
 
             if dB is not None:
                 dB_u = (wi*dwi/qmq) * qi
-                if np.isrealobj(B):
-                    dB -= DyadCarrier([np.real(dB_u), -np.imag(dB_u)], [np.real(qi), np.imag(qi)])
-                else:
-                    dB -= DyadCarrier(dB_u, qi)
+                dBi = DyadCarrier(dB_u, qi)
+                dB -= np.real(dBi) if np.isrealobj(B) else dBi
+
         return dA, dB
 
+    def _sparse_eigvec_sens(self, A, B, dW, dQ):
+        """ Calculate eigenvector sensitivities for a sparse eigenvalue problem
+        References:
+             Delissen (2022), Topology optimization for dynamic and controlled systems,
+               doi: https://doi.org/10.4233/uuid:c9ed8f61-efe1-4dc8-bb56-e353546cf247
+
+        Args:
+            A: System matrix
+            B: Mass matrix
+            dW: Adjoint eigenvalue sensitivities
+            dQ: Adjoint eigenvector sensitivities
+
+        Returns:
+            dA: Adjoint system matrix sensitivities
+            dB: Adjoint mass matrix sensitivities
+        """
+        if dQ is None:
+            return self._sparse_eigval_sens(A, B, dW)
+        W, Q = [s.state for s in self.sig_out]
+        if dW is not None:
+            dA, dB = self._sparse_eigval_sens(A, B, dW)
+        else:
+            dA, dB = DyadCarrier(), None if B is None else DyadCarrier()
+        for i in range(W.size):
+            phi = Q[:, i]
+            dphi = dQ[:, i]
+            if dphi.min() == dphi.max() == 0.0:
+                continue
+            lam = W[i]
+
+            alpha = - phi @ dphi
+            r = dphi + alpha * B.T @ phi
+
+            # Solve particular solution
+            if self.adjoint_solvers_need_update or self.solvers[i] is None:
+                Z = A - lam * B
+                if not hasattr(self, 'solvers'):
+                    self.solvers = [None for _ in range(W.size)]
+                if self.solvers[i] is None:  # Solver must be able to solve indefinite system
+                    self.solvers[i] = auto_determine_solver(Z, ispositivedefinite=False)
+                if self.adjoint_solvers_need_update:
+                    self.solvers[i].update(Z)
+
+            vp = self.solvers[i].solve(r, trans='T')
+
+            # Calculate total ajoint by adding homogeneous solution
+            c = - vp @ B @ phi
+            v = vp + c * phi
+
+            # Add to mass and stiffness matrix
+            dAi = - DyadCarrier(v, phi)
+            dA += np.real(dAi) if np.isrealobj(A) else dAi
+            if B is not None:
+                dBi = DyadCarrier(alpha / 2 * phi + lam * v, phi)
+                dB += np.real(dBi) if np.isrealobj(B) else dBi
+        return dA, dB

pymoto/modules/scaling.py

@@ -1,6 +1,7 @@
 from pymoto import Module
 import numpy as np
 
+
 class Scaling(Module):
     r""" Scales (scalar) input for different response functions in optimization (objective / constraints).
     This is useful, for instance, for MMA where the objective must be scaled in a certain way for good convergence.
@@ -25,7 +26,7 @@ class Scaling(Module):
     Keyword Args:
         scaling: Value :math:`s` to scale with
         minval: Minimum value :math:`x_\text{min}` for negative-null-form constraint
-        minval: Maximum value :math:`x_\text{max}` for negative-null-form constraint
+        maxval: Maximum value :math:`x_\text{max}` for negative-null-form constraint
     """
     def _prepare(self, scaling: float = 100.0, minval: float = None, maxval: float = None):
         self.minval = minval

pymoto/routines.py

@@ -10,10 +10,10 @@ from scipy.sparse import issparse
 def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
     for s1 in sig1:
         while isinstance(s1, SignalSlice):
-            s1 = s1.orig_signal
+            s1 = s1.base
         for s2 in sig2:
             while isinstance(s2, SignalSlice):
-                s2 = s2.orig_signal
+                s2 = s2.base
             if s1 == s2:
                 return True
     return False
@@ -102,6 +102,10 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
         # Get the output state shape
         shape = (output.shape if hasattr(output, "shape") else ())
 
+        if output is None:
+            warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+            continue
+
         # Generate a (random) sensitivity for output signal
         if use_df is not None:
             df_an[Iout] = use_df[Iout]
@@ -171,6 +175,9 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
             for Iout, Sout in enumerate(outps):
                 # Obtain perturbed response
                 fp = Sout.state
+                if fp is None:
+                    warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+                    continue
 
                 # Finite difference sensitivity
                 if issparse(fp):
@@ -227,6 +234,10 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                     # Obtain perturbed response
                     fp = Sout.state
 
+                    if fp is None:
+                        warnings.warn(f"Output {Iout} of {Sout.tag} is None")
+                        continue
+
                     # Finite difference sensitivity
                     if issparse(fp):
                         df = (fp.toarray() - f0[Iout].toarray()) / (dx * 1j * sf)

pymoto/solvers/__init__.py

@@ -1,11 +1,11 @@
 from .solvers import LinearSolver, LDAWrapper
-from .matrix_checks import matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian
+from .matrix_checks import matrix_is_sparse, matrix_is_complex, matrix_is_diagonal, matrix_is_symmetric, matrix_is_hermitian
 from .dense import SolverDiagonal, SolverDenseQR, SolverDenseLU, SolverDenseCholesky, SolverDenseLDL
 from .sparse import SolverSparsePardiso, SolverSparseLU, SolverSparseCholeskyScikit, SolverSparseCholeskyCVXOPT
 from .iterative import Preconditioner, CG, DampedJacobi, SOR, ILU, GeometricMultigrid
 from .auto_determine import auto_determine_solver
 
-__all__ = ['matrix_is_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
+__all__ = ['matrix_is_sparse', 'matrix_is_complex', 'matrix_is_diagonal', 'matrix_is_symmetric', 'matrix_is_hermitian',
            'LinearSolver', 'LDAWrapper',
            'SolverDiagonal', 'SolverDenseQR', 'SolverDenseLU', 'SolverDenseCholesky', 'SolverDenseLDL',
            'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',

pymoto/solvers/auto_determine.py

@@ -21,7 +21,7 @@ def auto_determine_solver(A, isdiagonal=None, islowertriangular=None, isuppertri
     :param ispositivedefinite: Manual override for positive definiteness
     :return: LinearSolver which should be 'best' for the matrix
     """
-    issparse = sps.issparse(A)  # Check if the matrix is sparse
+    issparse = matrix_is_sparse(A)  # Check if the matrix is sparse
     issquare = A.shape[0] == A.shape[1]  # Check if the matrix is square
 
     if not issquare:

pymoto/solvers/iterative.py

@@ -132,7 +132,7 @@ class GeometricMultigrid(Preconditioner):
         assert cycle.lower() in self._available_cycles, f"Cycle ({cycle}) is not available. Options are {self._available_cycles}"
         self.cycle = cycle
         self.inner_level = None if inner_level is None else inner_level
-        self.smoother = DampedJacobi(w=0.5) if smoother is None else None
+        self.smoother = DampedJacobi(w=0.5) if smoother is None else smoother
         self.smooth_steps = smooth_steps
         self.R = None
         self.sub_domain = DomainDefinition(domain.nelx // 2, domain.nely // 2, domain.nelz // 2,
@@ -299,7 +299,7 @@ class CG(LinearSolver):
         self.A = A
         self.preconditioner.update(A)
         if self.verbosity >= 1:
-            print(f"Preconditioner set up in {np.round(time.perf_counter() - tstart,3)}s")
+            print(f"CG Preconditioner set up in {np.round(time.perf_counter() - tstart, 3)}s")
 
     def solve(self, rhs, x0=None, trans='N'):
         if trans == 'N':
@@ -321,10 +321,18 @@ class CG(LinearSolver):
             x = x.reshape((x.size, 1))
 
         r = b - A@x
+        tval = np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)
+        if self.verbosity >= 2:
+            print(f"CG Initial (max) residual = {tval.max()}")
+
+        if tval.max() <= self.tol:
+            if self.verbosity >= 1:
+                print(f"CG Converged in 0 iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
+
+            return x.flatten() if rhs.ndim == 1 else x
+
         z = self.preconditioner.solve(r, trans=trans)
         p = orth(z, normalize=True)
-        if self.verbosity >= 2:
-            print(f"Initial residual = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
 
         for i in range(self.maxit):
             q = A @ p
@@ -333,16 +341,15 @@ class CG(LinearSolver):
             alpha = pq_inv @ (p.conj().T @ r)
 
             x += p @ alpha
-            if i % 50 == 0:  # Explicit restart
+            if i % self.restart == 0:  # Explicit restart
                 r = b - A@x
             else:
                 r -= q @ alpha
 
+            tval = np.linalg.norm(r, axis=0)/np.linalg.norm(b, axis=0)
             if self.verbosity >= 2:
-                print(f"i = {i}, residuals = {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
-
-            tval = np.linalg.norm(r)/np.linalg.norm(b)
-            if tval <= self.tol:
+                print(f"CG i = {i}, residuals = {tval}")
+            if tval.max() <= self.tol:
                 break
 
             z = self.preconditioner.solve(r, trans=trans)
@@ -350,12 +357,9 @@ class CG(LinearSolver):
             beta = -pq_inv @ (q.conj().T @ z)
             p = orth(z + p@beta, normalize=False)
 
-        if tval > self.tol:
-            warnings.warn(f'Maximum iterations ({self.maxit}) reached, with final residual {tval}')
+        if tval.max() > self.tol:
+            warnings.warn(f'CG Maximum iterations ({self.maxit}) reached, with final residuals {tval}')
         elif self.verbosity >= 1:
-            print(f"Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final residuals {np.linalg.norm(r, axis=0) / np.linalg.norm(b, axis=0)}")
+            print(f"CG Converged in {i} iterations and {np.round(time.perf_counter() - tstart, 3)}s, with final (max) residual {tval.max()}")
 
-        if rhs.ndim == 1:
-            return x.flatten()
-        else:
-            return x
+        return x.flatten() if rhs.ndim == 1 else x

pymoto/solvers/matrix_checks.py

@@ -12,6 +12,10 @@ def is_cvxopt_spmatrix(A):
     return isinstance(A, cvxopt.spmatrix) if _has_cvxopt else False
 
 
+def matrix_is_sparse(A):
+    return sps.issparse(A)
+
+
 def matrix_is_complex(A):
     """ Checks if the matrix is complex """
     if is_cvxopt_spmatrix(A):
@@ -22,7 +26,7 @@ def matrix_is_complex(A):
 
 def matrix_is_diagonal(A):
     """ Checks if the matrix is diagonal"""
-    if sps.issparse(A):
+    if matrix_is_sparse(A):
         if isinstance(A, sps.dia_matrix):
             return len(A.offsets) == 1 and A.offsets[0] == 0
         else:
@@ -35,7 +39,7 @@ def matrix_is_diagonal(A):
 
 def matrix_is_symmetric(A):
     """ Checks whether a matrix is numerically symmetric """
-    if sps.issparse(A):
+    if matrix_is_sparse(A):
         return np.allclose((A-A.T).data, 0)
     elif is_cvxopt_spmatrix(A):
         return np.isclose(max(abs(A-A.T)), 0.0)
@@ -46,7 +50,7 @@ def matrix_is_symmetric(A):
 def matrix_is_hermitian(A):
     """ Checks whether a matrix is numerically Hermitian """
     if matrix_is_complex(A):
-        if sps.issparse(A):
+        if matrix_is_sparse(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)

pymoto/solvers/solvers.py

@@ -75,6 +75,17 @@ class LinearSolver:
         return np.linalg.norm(mat@x - b, axis=0) / np.linalg.norm(b, axis=0)
 
 
+def get_diagonal_indices(mat):
+    """ Get the row/column indices for entries in the matrix that are diagonal (has all zeros in its row and column) """
+    assert mat.ndim == 2, "Not a matrix"
+    n = min(*mat.shape)  # Matrix size
+    bmat = mat != 0
+    has_diag = bmat.diagonal()
+    nnz_rows = np.array(bmat.sum(axis=0)).flatten()[:n]
+    nnz_cols = np.array(bmat.sum(axis=1)).flatten()[:n]
+    return np.logical_and(has_diag, nnz_rows <= 1, nnz_cols <= 1)
+
+
 class LDAWrapper(LinearSolver):
     r""" Linear dependency aware solver (LDAS)
 
@@ -105,6 +116,8 @@ class LDAWrapper(LinearSolver):
         self.xadj_stored = []
         self.badj_stored = []
         self.A = None
+        self.diagonal_idx = []
+        self.nondiagonal_idx = slice(None)
         self._did_solve = False  # For debugging purposes
         self._last_rtol = 0.
         self.hermitian = hermitian
@@ -123,6 +136,9 @@ class LDAWrapper(LinearSolver):
             self.hermitian = matrix_is_hermitian(A)
 
         self.A = A
+        diags = get_diagonal_indices(A)
+        self.diagonal_idx = np.argwhere(diags).flatten()
+        self.nondiagonal_idx = np.argwhere(~diags).flatten()
         self.x_stored.clear()
         self.b_stored.clear()
         self.xadj_stored.clear()
@@ -130,6 +146,9 @@ class LDAWrapper(LinearSolver):
         self.solver.update(A)
 
     def _do_solve_1rhs(self, A, rhs, x_data, b_data, solve_fn, x0=None):
+        isel = self.nondiagonal_idx
+        idia = self.diagonal_idx
+
         dtype = np.result_type(A, rhs)
         if rhs.ndim == 1:
             rhs_loc = np.zeros((rhs.size, 1), dtype=dtype)
@@ -139,11 +158,16 @@ class LDAWrapper(LinearSolver):
             rhs_loc[:] = rhs
         sol = np.zeros_like(rhs_loc, dtype=dtype)
 
-        # Check linear dependencies in the rhs using modified Gram-Schmidt
+        # Diagonal part of the matrix
+        sol[idia, ...] = rhs_loc[idia, ...] / A.diagonal()[idia, None]
+        rhs_loc[idia, ...] = 0
+
+        # Non-diagonal part of the matrix
+        # Reconstruct using the database 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)
+            # assert x.size == b.size == rhs_loc.shape[0]
+            alpha = rhs_loc[isel, ...].T @ b.conj() / (b.conj() @ b)
 
             rem_rhs = alpha * b[:, None]
             add_sol = alpha * x[:, None]
@@ -162,34 +186,41 @@ class LDAWrapper(LinearSolver):
                     warnings.warn('LDAS: Complex vector cannot be added to real solution')
                     continue
 
-            rhs_loc -= rem_rhs
-            sol += add_sol
+            rhs_loc[isel, ...] -= rem_rhs
+            sol[isel, ...] += add_sol
+
+        assert np.all(rhs_loc[idia, ...] == 0)
 
         # 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._last_rtol = self.residual(A, sol, rhs if rhs.ndim > 1 else rhs.reshape(-1, 1))
         self._did_solve = self._last_rtol > self.tol
+        # If tolerance too large, use the solver for new values
         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()
+                x0_loc[idia, ...] = 0
                 for x in x_data:
-                    beta = x0_loc.T @ x.conj() / (x.conj() @ x)
-                    x0_loc -= beta * x
+                    beta = x0_loc[isel, ...].T @ x.conj() / (x.conj() @ x)
+                    x0_loc[isel, ...] -= beta * x
             else:
                 x0_loc = None
 
-            # Calculate a new solution
+            # Calculate a new solution (for the vectors that have too high residual)
             xnew = solve_fn(rhs_loc[..., self._did_solve], x0_loc)
-            self.residual(A, xnew, rhs_loc[..., self._did_solve])
-            sol[..., self._did_solve] += xnew
+
+            if isinstance(isel, slice):
+                sol[isel, self._did_solve] += xnew[isel, ...]
+            else:
+                sol[np.ix_(isel, self._did_solve)] += xnew[isel, ...]
 
             # 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
+                xadd = xnew[isel, i]
+                badd = (A @ xnew[..., i])[isel, ...]
                 for x, b in zip(x_data, b_data):
                     beta = badd @ b.conj() / (b.conj() @ b)
                     badd -= beta * b

pymoto/solvers/sparse.py

@@ -126,6 +126,7 @@ class SolverSparsePardiso(LinearSolver):
             self._pardiso_solver = PyPardisoSolver(mtype=self._mtype)
 
         self._pardiso_solver.factorize(A)
+        self._pardiso_solver.set_phase(33)
 
     def solve(self, b, x0=None, trans='N'):
         """ solve Ax=b for x
@@ -139,6 +140,9 @@ class SolverSparsePardiso(LinearSolver):
         Returns:
             Solution of the system of linear equations, same shape as input b
         """
+        if b.dtype != np.float64:  # Only float64 is supported --> this is also done in _check_b, but fails for int8
+            warnings.warn(f"Array b's data type was converted from {b.dtype} to float64")
+            b = b.astype(np.float64)
         if trans == 'N':
             return self._pardiso_solver.solve(self.A, b)
         elif trans == 'T' or trans == 'H':
@@ -199,6 +203,13 @@ class SolverSparsePardiso(LinearSolver):
             if v != 0:
                 print(f"{i+1}: {v} ({k})")  # i+1 because of 1-based numbering
 
+    def __del__(self):
+        try:
+            self._pardiso_solver.free_memory(everything=True)
+        except ImportError:
+            # To prevent ImportError: sys.meta_path is None, Python is likely shutting down
+            pass
+
 
 # ------------------------------------ LU Solver -----------------------------------
 try:

pyMOTO-1.4.0.dist-info/RECORD

@@ -1,29 +0,0 @@
-pymoto/__init__.py,sha256=jsqGNDDpd3Tde1w46C5GqQCuAqfgN3faVjReYMQFiLw,1922
-pymoto/core_objects.py,sha256=mgn5etKHwAOINvu9qqTU89yLs0CDPvxi0anb7q76bNI,24798
-pymoto/routines.py,sha256=KlP6kgY-817i51Z9EotDclaRnOjrSD4SdymD0Rt7yX0,15186
-pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=QJmdRXzexc1KbdLHNP6X6v5whZWtn0f8b4Rv_wlRBT8,18078
-pymoto/common/dyadcarrier.py,sha256=b8Ji8einZ4c0lMDuwxd4ZHwRckb2pkuZtAl4Sbg9q4w,18273
-pymoto/common/mma.py,sha256=sO4PzG2SBeanK82v-Lyw0c29uPmh2q40nXQVt2NCIBU,24838
-pymoto/modules/aggregation.py,sha256=Oi17hIJ6dic4lOPw16zmjbdC72MjB6XK34H80bnbWAI,7580
-pymoto/modules/assembly.py,sha256=UpTzp4KGKVcWruEpNarmNRK5lp6CK82QB-7d4Wk2xTg,18138
-pymoto/modules/autodiff.py,sha256=WAfoAOHBSozf7jbr9gQz9Vw4a_2G9wGJxLMMqUQP0Co,1684
-pymoto/modules/complex.py,sha256=B_Obk-ABdV66lEudZ5s8o6qG9NsmYlBsX-PbWvbphhc,4429
-pymoto/modules/filter.py,sha256=6X9FaQMWYZ_TpHVTFiEibzlmAwmSWbydYM93LFrJ0Wo,25490
-pymoto/modules/generic.py,sha256=YzsGZ8J0oLCORt78Bf2p0v4GuqpWRI77NLoCk7gqidw,10666
-pymoto/modules/io.py,sha256=huqF2A54Tk0f36WRDLaRR7_CdeahmQc25OfvqqQ2hT4,11012
-pymoto/modules/linalg.py,sha256=kvfPTblFXGANWzCxEliTMi8qKxgKiejh2zGp_60iL_Q,19358
-pymoto/modules/scaling.py,sha256=FN6WsqJME-bkJ5nhoKziS_utFCserpRmRDKlJ8F3MEo,2326
-pymoto/solvers/__init__.py,sha256=CuEJMqnZ2QWgj96n4mB18LWonT4D3cq7FgnubrZsxXg,995
-pymoto/solvers/auto_determine.py,sha256=Q4TcTT49SYmPLVG0LMmzOx2Tnly--fLXAQVVYjDzGG0,5130
-pymoto/solvers/dense.py,sha256=9fKPCwNxRKAEk5k1A7fdLrr9ngeVssGlw-sbjWCm4iU,11235
-pymoto/solvers/iterative.py,sha256=CIxJHjGnCaIjXbtO2NxV60yeDpcCbSD6Bp0xR-7vOf0,12944
-pymoto/solvers/matrix_checks.py,sha256=gmq7vwFQaXjH3QG-2bW5LcMJF0abTejzw1vEVXCfLPc,1597
-pymoto/solvers/solvers.py,sha256=RwHjZYYlE3oA0U9k7ukla2gOdmq57rSSJQvHqjaM7JU,10626
-pymoto/solvers/sparse.py,sha256=VtAdscg7USR8oG_RlS21k64J7VQDa5Rk0ByJ9fzvb_0,16621
-pyMOTO-1.4.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.4.0.dist-info/METADATA,sha256=JpafKYREI7mIGlwLQ3v5sFyskvPYPTJBt9u7H-mIhi8,5006
-pyMOTO-1.4.0.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-pyMOTO-1.4.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.4.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.4.0.dist-info/RECORD,,