pyMOTO 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

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:
@@ -125,27 +126,33 @@ 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):
+    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 +226,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 +287,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 +296,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 +352,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.3.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-pymoto/__init__.py,sha256=Uy-TOgGg2Ztv2B-HfznVYApXYyvJ3k6a6gm2o3I_5Rg,2232
-pymoto/core_objects.py,sha256=9TjGunvGVwa-LqM2tmE1XlWnqHDscZLeqbKFBZ7ZroU,25111
-pymoto/routines.py,sha256=zcwAlq3ytfjhPJqzvHdvW4nTyzmjdgoVSX5j5vDRExw,14638
-pymoto/utils.py,sha256=YJ-PNLJLc12Yx6TYCrEechS2aaBRx0o4mTM1soeeyz0,1122
-pymoto/common/domain.py,sha256=79BNR3PKOGOJbUZVyKlnQUbctAbHetO3hRV4vPSl17A,15899
-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=0jRSFbfhEQtOW7GPLObXAOQEjC91LeZ9spdK25vD6lA,12953
-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=y9KO7GVnoxpGpJLTMUNZhK4jVUTpWGTnOWI3RBfBeuE,23942
-pymoto/modules/scaling.py,sha256=hK3sfCoAoseabjqdn5VXe6aGA_fV-MRmMtiv4uIg_I4,2252
-pyMOTO-1.3.0.dist-info/LICENSE,sha256=ZXMC2Txpzs-dBwz9Me4_1rQCSVl4P1B27MomNi43F30,1072
-pyMOTO-1.3.0.dist-info/METADATA,sha256=KJvLKj58DMxrc_mJKTy5ZwyU3reFi76MeILIRynh4JY,4907
-pyMOTO-1.3.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-pyMOTO-1.3.0.dist-info/top_level.txt,sha256=EdvAUSmFMaiqhuEZW8jxANMiK-LdPtlmDWL6SfmCdUU,7
-pyMOTO-1.3.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pyMOTO-1.3.0.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)