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

pymoto/modules/linalg.py

@@ -7,10 +7,9 @@ import scipy.linalg as spla  # Dense matrix solvers
 import scipy.sparse as sps
 import scipy.sparse.linalg as spsla
 
-from pymoto import Signal, Module, DyadCarrier, LDAWrapper
-from pymoto import SolverDenseLU, SolverDenseLDL, SolverDenseCholesky, SolverDiagonal, SolverDenseQR
-from pymoto import SolverSparseLU, SolverSparseCholeskyCVXOPT, SolverSparsePardiso, SolverSparseCholeskyScikit
-from pymoto import matrix_is_symmetric, matrix_is_hermitian, matrix_is_diagonal
+from pymoto import Signal, Module, DyadCarrier
+from pymoto.solvers import auto_determine_solver
+from pymoto.solvers import matrix_is_hermitian, LDAWrapper
 
 
 class StaticCondensation(Module):
@@ -172,7 +171,7 @@ class SystemOfEquations(Module):
             adjoint_load += self.Afp * dgdb[self.p, ...]
 
         lam = np.zeros_like(self.x)
-        lamf = -1.0 * self.module_LinSolve.solver.adjoint(adjoint_load)
+        lamf = -1.0 * self.module_LinSolve.solver.solve(adjoint_load, trans='T')
         lam[self.f, ...] = lamf
 
         if dgdb is not None:
@@ -219,105 +218,6 @@ class Inverse(Module):
         return dA if np.iscomplexobj(A) else np.real(dA)
 
 
-# flake8: noqa: C901
-def auto_determine_solver(A, isdiagonal=None, islowertriangular=None, isuppertriangular=None,
-                          ishermitian=None, issymmetric=None, ispositivedefinite=None):
-    """
-    Uses parts of Matlab's scheme https://nl.mathworks.com/help/matlab/ref/mldivide.html
-    :param A: The matrix
-    :param isdiagonal: Manual override for diagonal matrix
-    :param islowertriangular: Override for lower triangular matrix
-    :param isuppertriangular: Override for upper triangular matrix
-    :param ishermitian: Override for hermitian matrix (prevents check)
-    :param issymmetric: Override for symmetric matrix (prevents check). Is the same as hermitian for a real matrix
-    :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
-    issquare = A.shape[0] == A.shape[1]  # Check if the matrix is square
-
-    if not issquare:
-        if issparse:
-            sps.SparseEfficiencyWarning("Only a dense version of QR solver is available")  # TODO
-        return SolverDenseQR()
-
-    # l_bw, u_bw = spla.bandwidth(A) # TODO Get bandwidth (implemented in scipy version > 1.8.0)
-
-    if isdiagonal is None:  # Check if matrix is diagonal
-        # TODO: This could be improved to check other sparse matrix types as well
-        isdiagonal = matrix_is_diagonal(A)
-    if isdiagonal:
-        return SolverDiagonal()
-
-    # Check if the matrix is triangular
-    # TODO Currently only for dense matrices
-    if islowertriangular is None:  # Check if matrix is lower triangular
-        islowertriangular = False if issparse else np.allclose(A, np.tril(A))
-    if islowertriangular:
-        warnings.WarningMessage("Lower triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    if isuppertriangular is None:  # Check if matrix is upper triangular
-        isuppertriangular = False if issparse else np.allclose(A, np.triu(A))
-    if isuppertriangular:
-        warnings.WarningMessage("Upper triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    ispermutedtriangular = False
-    if ispermutedtriangular:
-        warnings.WarningMessage("Permuted triangular solver not implemented",
-                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
-
-    # Check if the matrix is complex-valued
-    iscomplex = np.iscomplexobj(A)
-    if iscomplex:
-        # Detect if the matrix is hermitian and/or symmetric
-        if ishermitian is None:
-            ishermitian = matrix_is_hermitian(A)
-        if issymmetric is None:
-            issymmetric = matrix_is_symmetric(A)
-    else:
-        if ishermitian is None and issymmetric is None:
-            # Detect if the matrix is symmetric
-            issymmetric = matrix_is_symmetric(A)
-            ishermitian = issymmetric
-        elif ishermitian is not None and issymmetric is not None:
-            assert ishermitian == issymmetric, "For real-valued matrices, symmetry and hermitian must be equal"
-        elif ishermitian is None:
-            ishermitian = issymmetric
-        elif issymmetric is None:
-            issymmetric = ishermitian
-
-    if issparse:
-        # Prefer Intel Pardiso solver as it can solve any matrix TODO: Check for complex matrix
-        if SolverSparsePardiso.defined and not iscomplex:
-            # TODO check for positive definiteness?  np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0)
-            return SolverSparsePardiso(symmetric=issymmetric, hermitian=ishermitian, positive_definite=ispositivedefinite)
-
-        if ishermitian:
-            # Check if diagonal is all positive or all negative -> Cholesky
-            if np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0):  # TODO what about the complex case?
-                if SolverSparseCholeskyScikit.defined:
-                    return SolverSparseCholeskyScikit()
-                if SolverSparseCholeskyCVXOPT.defined:
-                    return SolverSparseCholeskyCVXOPT()
-
-        return SolverSparseLU()  # Default to LU, which should be possible for any non-singular square matrix
-
-    else:  # Dense branch
-        if ishermitian:
-            # Check if diagonal is all positive or all negative
-            if np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0):
-                return SolverDenseCholesky()
-            else:
-                return SolverDenseLDL(hermitian=ishermitian)
-        elif issymmetric:
-            return SolverDenseLDL(hermitian=ishermitian)
-        else:
-            # TODO: Detect if the matrix is Hessenberg
-            return SolverDenseLU()
-
-
 class LinSolve(Module):
     r""" Solves linear system of equations :math:`\mathbf{A}\mathbf{x}=\mathbf{b}`
 
@@ -347,6 +247,7 @@ class LinSolve(Module):
         self.ishermitian = hermitian
         self.issymmetric = symmetric
         self.solver = solver
+        self.u = None  # Solution storage
 
     def _response(self, mat, rhs):
         # Do some detections on the matrix type
@@ -365,19 +266,23 @@ class LinSolve(Module):
         if self.solver is None:
             self.solver = auto_determine_solver(mat, ishermitian=self.ishermitian)
         if not isinstance(self.solver, LDAWrapper) and self.use_lda_solver:
-            self.solver = LDAWrapper(self.solver, hermitian=self.ishermitian, symmetric=self.issymmetric)
+            lda_kwargs = dict(hermitian=self.ishermitian, symmetric=self.issymmetric)
+            if hasattr(self.solver, 'tol'):
+                lda_kwargs['tol'] = self.solver.tol * 2
+            self.solver = LDAWrapper(self.solver, **lda_kwargs)
 
         # Update solver with new matrix
         self.solver.update(mat)
 
         # Solution
-        self.u = self.solver.solve(rhs)
+        self.u = self.solver.solve(rhs, x0=self.u)
 
         return self.u
 
     def _sensitivity(self, dfdv):
         mat, rhs = [s.state for s in self.sig_in]
-        lam = self.solver.adjoint(dfdv.conj()).conj()
+        # lam = self.solver.solve(dfdv.conj(), trans='H').conj()
+        lam = self.solver.solve(dfdv, trans='T')
 
         if self.issparse:
             if self.u.ndim > 1:
@@ -431,13 +336,16 @@ class EigenSolve(Module):
         nmodes: Number of modes to calculate (only for sparse matrices, default = ``0``)
         sigma: Shift value for the eigenvalue problem (only for sparse matrices). Eigenvalues around the shift are
           calculated first (default = ``0.0``)
+        mode: Mode of the eigensolver (see documentation of `scipy.sparse.linalg.eigsh` for more info)
     """
-    def _prepare(self, sorting_func=lambda W, Q: np.argsort(W), hermitian=None, nmodes=None, sigma=None):
+    def _prepare(self, sorting_func=lambda W, Q: np.argsort(W), hermitian=None, nmodes=None, sigma=None, mode='normal'):
         self.sorting_fn = sorting_func
         self.is_hermitian = hermitian
         self.nmodes = nmodes
         self.sigma = sigma
+        self.mode = mode
         self.Ainv = None
+        self.do_solve = False
 
     def _response(self, A, *args):
         B = args[0] if len(args) > 0 else None
@@ -462,13 +370,6 @@ class EigenSolve(Module):
             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
-
-            eigvec_nrm = abs(qi@(qi if B is None else B@qi) - 1.0)
-            if eigvec_nrm > 1e-5:
-                warnings.warn(f"Eigenvector {i} normalization error large: |v^T{'B'if len(args)>0 else ''}v|-1 = {eigvec_nrm}")
-            resi_nrm = np.linalg.norm(A@qi - wi*(qi if B is None else B@qi)) / np.linalg.norm(A@qi)
-            if resi_nrm > 1e-5:
-                warnings.warn(f"Eigenvalue {i} residual large: |Av - λ{'B'if len(args)>0 else ''}v|/|Av| = {resi_nrm}")
         return W, Q
 
     def _sensitivity(self, dW, dQ):
@@ -505,12 +406,17 @@ class EigenSolve(Module):
         # Use shift-and-invert, so make inverse operator
         if self.Ainv is None:
             self.Ainv = auto_determine_solver(mat_shifted, ishermitian=self.is_hermitian)
-        self.Ainv.update(mat_shifted)
+            self.do_solve = True
+        if self.sigma != 0:
+            self.do_solve = True
+        if self.do_solve:
+            self.Ainv.update(mat_shifted)
 
-        AinvOp = spsla.LinearOperator(mat_shifted.shape, matvec=self.Ainv.solve, rmatvec=self.Ainv.adjoint)
+        AinvOp = spsla.LinearOperator(mat_shifted.shape, matvec=self.Ainv.solve,
+                                      rmatvec=lambda b: self.Ainv.solve(b, trans='H'))
 
         if self.is_hermitian:
-            return spsla.eigsh(A, M=B, k=self.nmodes, OPinv=AinvOp, sigma=self.sigma)
+            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')

pymoto/modules/scaling.py

@@ -1,12 +1,12 @@
 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.
 
-    Objective scaling (`minval` and `maxval` are both undefined):
-    :math:`y^{(i)} = s \frac{x^{(i)}}{x^{(0)}}`
+    Objective scaling using absolute value or vector norm (`minval` and `maxval` are both undefined):
+    :math:`y^{(i)} = s \frac{x^{(i)}}{||x^{(0)}||}`
 
     For the constraints, the negative null-form convention is used, which means the constraint is :math:`y(x) \leq 0`.
 
@@ -39,7 +39,7 @@ class Scaling(Module):
 
     def _response(self, x):
         if not hasattr(self, 'sf'):
-            self.sf = self.scaling/x
+            self.sf = self.scaling/np.linalg.norm(x)
         if self.minval is not None:
             g = 1 - x/self.minval
         elif self.maxval is not None:

pymoto/routines.py

@@ -1,8 +1,10 @@
+import warnings
 import numpy as np
 from .utils import _parse_to_list, _concatenate_to_array
 from .core_objects import Signal, SignalSlice, Module, Network
 from .common.mma import MMA
 from typing import List, Iterable, Union, Callable
+from scipy.sparse import issparse
 
 
 def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
@@ -20,8 +22,8 @@ def _has_signal_overlap(sig1: List[Signal], sig2: List[Signal]):
 # flake8: noqa: C901
 def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = None,
                       tosig: Union[Signal, Iterable[Signal]] = None,
-                      dx: float = 1e-8, tol: float = 1e-5, random: bool = True, use_df: list = None,
-                      test_fn: Callable = None, keep_zero_structure=True, verbose=True):
+                      dx: float = 1e-8, relative_dx: bool = False, tol: float = 1e-5, random: bool = True,
+                      use_df: list = None, test_fn: Callable = None, keep_zero_structure=True, verbose=True):
     """ Performs a finite difference check on the given Module or Network
 
     Args:
@@ -31,6 +33,7 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
 
     Keyword Args:
         dx: Perturbation size
+        relative_dx: Use a relative perturbation size or not
         tol: Tolerance
         random: Randomize sensitivity data
         use_df: Give pre-defined sensitivity data
@@ -83,15 +86,15 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
     blk.response()
 
     print("Outputs:")
-    if not verbose:
+    if verbose:
+        [print("{}\t{} = {}".format(i, s.tag, s.state)) for i, s in enumerate(outps)]
+    else:
         print(", ".join([s.tag for s in outps]))
 
     # Get analytical response and sensitivities, by looping over all outputs
     for Iout, Sout in enumerate(outps):
         # Obtain the output state
         output = Sout.state
-        if verbose:
-            print("{}\t{} = {}".format(Iout, Sout.tag, output))
 
         # Store the output value
         f0[Iout] = (output.copy() if hasattr(output, "copy") else output)
@@ -153,11 +156,13 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                 if x0 == 0 and keep_zero_structure:
                     it.iternext()
                     continue
-                it[0] += dx
+                sf = np.abs(x0) if (relative_dx and np.abs(x0)!=0) else 1.0  # Scale factor
+                it[0] += dx*sf
                 Sin.state = x
             else:
                 x0 = it[0].item()
-                Sin.state = x0 + dx
+                sf = np.abs(x0) if (relative_dx and np.abs(x0) != 0) else 1.0
+                Sin.state = x0 + dx*sf
 
             # Calculate perturbed solution
             blk.response()
@@ -168,7 +173,10 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                 fp = Sout.state
 
                 # Finite difference sensitivity
-                df = (fp - f0[Iout])/dx
+                if issparse(fp):
+                    df = (fp.toarray() - f0[Iout].toarray()) / (dx * sf)
+                else:
+                    df = (fp - f0[Iout])/(dx*sf)
 
                 dgdx_fd = np.real(np.sum(df*df_an[Iout]))
 
@@ -180,7 +188,7 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                 else:
                     dgdx_an = 0.0
 
-                if abs(dgdx_an) < tol:
+                if abs(dgdx_an) == 0:
                     error = abs(dgdx_fd - dgdx_an)
                 else:
                     error = abs(dgdx_fd - dgdx_an)/max(abs(dgdx_fd), abs(dgdx_an))
@@ -207,9 +215,9 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
             if np.iscomplexobj(x0):
                 # Do the perturbation
                 if is_iterable:
-                    it[0] += dx*1j
+                    it[0] += dx*1j*sf
                 else:
-                    Sin.state = x0 + dx*1j
+                    Sin.state = x0 + dx*1j*sf
 
                 # Calculate perturbed solution
                 blk.response()
@@ -220,7 +228,10 @@ def finite_difference(blk: Module, fromsig: Union[Signal, Iterable[Signal]] = No
                     fp = Sout.state
 
                     # Finite difference sensitivity
-                    df = (fp - f0[Iout])/(dx*1j)
+                    if issparse(fp):
+                        df = (fp.toarray() - f0[Iout].toarray()) / (dx * 1j * sf)
+                    else:
+                        df = (fp - f0[Iout])/(dx*1j*sf)
                     dgdx_fd = np.imag(np.sum(df*df_an[Iout]))
 
                     if dx_an[Iout][Iin] is not None:
@@ -332,8 +343,9 @@ def minimize_oc(function, variables, objective: Signal,
         function.sensitivity()
         dfdx, _ = _concatenate_to_array(obtain_sensitivities(variables))
         maxdfdx = max(dfdx)
-        if maxdfdx > 0:
-            raise RuntimeError(f"OC only works for negative sensitivities: max(dfdx) = {maxdfdx}")
+        if maxdfdx > 1e-15:
+            warnings.warn(f"OC only works for negative sensitivities: max(dfdx) = {maxdfdx}. Clipping positive values.")
+        dfdx = np.minimum(dfdx, 0)
 
         # Do OC update
         l1, l2 = l1init, l2init
@@ -371,7 +383,12 @@ def minimize_mma(function, variables, responses, **kwargs):
         move: Move limit on relative variable change per iteration
         xmin: Minimum design variable (can be a vector)
         xmax: Maximum design variable (can be a vector)
-        verbosity: 0 - No prints, 1 - Only convergence message, 2 - Convergence and iteration info, 3 - Extended info
+        verbosity: Level of information to print
+          0 - No prints
+          1 - Only convergence message
+          2 - Convergence and iteration info (default)
+          3 - Additional info on variables
+          4 - Additional info on sensitivity information
 
     """
     # Save initial state

pymoto/solvers/__init__.py

@@ -0,0 +1,14 @@
+from .solvers import LinearSolver, LDAWrapper
+from .matrix_checks import 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',
+           'LinearSolver', 'LDAWrapper',
+           'SolverDiagonal', 'SolverDenseQR', 'SolverDenseLU', 'SolverDenseCholesky', 'SolverDenseLDL',
+           'SolverSparsePardiso', 'SolverSparseLU', 'SolverSparseCholeskyScikit', 'SolverSparseCholeskyCVXOPT',
+           'Preconditioner', 'CG', 'DampedJacobi', 'SOR', 'ILU', 'GeometricMultigrid',
+           'auto_determine_solver',
+           ]

pymoto/solvers/auto_determine.py

@@ -0,0 +1,108 @@
+import warnings
+import scipy.sparse as sps
+from inspect import currentframe, getframeinfo
+
+from .dense import *
+from .sparse import *
+from .matrix_checks import *
+
+
+# flake8: noqa: C901
+def auto_determine_solver(A, isdiagonal=None, islowertriangular=None, isuppertriangular=None,
+                          ishermitian=None, issymmetric=None, ispositivedefinite=None):
+    """
+    Uses parts of Matlab's scheme https://nl.mathworks.com/help/matlab/ref/mldivide.html
+    :param A: The matrix
+    :param isdiagonal: Manual override for diagonal matrix
+    :param islowertriangular: Override for lower triangular matrix
+    :param isuppertriangular: Override for upper triangular matrix
+    :param ishermitian: Override for hermitian matrix (prevents check)
+    :param issymmetric: Override for symmetric matrix (prevents check). Is the same as hermitian for a real matrix
+    :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
+    issquare = A.shape[0] == A.shape[1]  # Check if the matrix is square
+
+    if not issquare:
+        if issparse:
+            sps.SparseEfficiencyWarning("Only a dense version of QR solver is available")  # TODO
+        return SolverDenseQR()
+
+    # l_bw, u_bw = spla.bandwidth(A) # TODO Get bandwidth (implemented in scipy version > 1.8.0)
+
+    if isdiagonal is None:  # Check if matrix is diagonal
+        # TODO: This could be improved to check other sparse matrix types as well
+        isdiagonal = matrix_is_diagonal(A)
+    if isdiagonal:
+        return SolverDiagonal()
+
+    # Check if the matrix is triangular
+    # TODO Currently only for dense matrices
+    if islowertriangular is None:  # Check if matrix is lower triangular
+        islowertriangular = False if issparse else np.allclose(A, np.tril(A))
+    if islowertriangular:
+        warnings.WarningMessage("Lower triangular solver not implemented",
+                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
+
+    if isuppertriangular is None:  # Check if matrix is upper triangular
+        isuppertriangular = False if issparse else np.allclose(A, np.triu(A))
+    if isuppertriangular:
+        warnings.WarningMessage("Upper triangular solver not implemented",
+                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
+
+    ispermutedtriangular = False
+    if ispermutedtriangular:
+        warnings.WarningMessage("Permuted triangular solver not implemented",
+                                UserWarning, getframeinfo(currentframe()).filename, getframeinfo(currentframe()).lineno)
+
+    # Check if the matrix is complex-valued
+    iscomplex = np.iscomplexobj(A)
+    if iscomplex:
+        # Detect if the matrix is hermitian and/or symmetric
+        if ishermitian is None:
+            ishermitian = matrix_is_hermitian(A)
+        if issymmetric is None:
+            issymmetric = matrix_is_symmetric(A)
+    else:
+        if ishermitian is None and issymmetric is None:
+            # Detect if the matrix is symmetric
+            issymmetric = matrix_is_symmetric(A)
+            ishermitian = issymmetric
+        elif ishermitian is not None and issymmetric is not None:
+            assert ishermitian == issymmetric, "For real-valued matrices, symmetry and hermitian must be equal"
+        elif ishermitian is None:
+            ishermitian = issymmetric
+        elif issymmetric is None:
+            issymmetric = ishermitian
+
+    if issparse:
+        # Prefer Intel Pardiso solver as it can solve any matrix TODO: Check for complex matrix
+        if SolverSparsePardiso.defined and not iscomplex:
+            # TODO check for positive definiteness?  np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0)
+            return SolverSparsePardiso(symmetric=issymmetric, hermitian=ishermitian, positive_definite=ispositivedefinite)
+
+        if ishermitian:
+            # Check if diagonal is all positive or all negative -> Cholesky
+            if ispositivedefinite is None:
+                ispositivedefinite = np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0)
+            if ispositivedefinite:  # TODO what about the complex case?
+                if SolverSparseCholeskyScikit.defined:
+                    return SolverSparseCholeskyScikit()
+                if SolverSparseCholeskyCVXOPT.defined:
+                    return SolverSparseCholeskyCVXOPT()
+
+        return SolverSparseLU()  # Default to LU, which should be possible for any non-singular square matrix
+
+    else:  # Dense branch
+        if ishermitian:
+            # Check if diagonal is all positive or all negative
+            if np.all(A.diagonal() > 0) or np.all(A.diagonal() < 0):
+                return SolverDenseCholesky()
+            else:
+                return SolverDenseLDL(hermitian=ishermitian)
+        elif issymmetric:
+            return SolverDenseLDL(hermitian=ishermitian)
+        else:
+            # TODO: Detect if the matrix is Hessenberg
+            return SolverDenseLU()