add base kwargs to subclasses

Author: jcapriot

pymatsolver/direct/mumps.py

@@ -7,8 +7,8 @@ class Mumps(Base):
     """
     _transposed = False
 
-    def __init__(self, A, ordering=None, **kwargs):
-        super().__init__(A, **kwargs)
+    def __init__(self, A, ordering=None, is_symmetric=None, is_positive_definite=False, is_hermitian=None, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
+        super().__init__(A, is_symmetric=is_symmetric, is_positive_definite=is_positive_definite, is_hermitian=is_hermitian, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
         if ordering is None:
             ordering = "metis"
         self.ordering = ordering
@@ -19,7 +19,6 @@ def _set_A(self, A):
         self.solver.set_matrix(
             A,
             symmetric=self.is_symmetric,
-            # positive_definite=self.is_positive_definite  # doesn't (yet) support setting positive definiteness
         )
 
     @property

pymatsolver/direct/pardiso.py

@@ -16,8 +16,8 @@ class Pardiso(Base):
 
     _transposed = False
 
-    def __init__(self, A, n_threads=None, **kwargs):
-        super().__init__(A, **kwargs)
+    def __init__(self, A, n_threads=None, is_symmetric=None, is_positive_definite=False, is_hermitian=None, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
+        super().__init__(A, is_symmetric=is_symmetric, is_positive_definite=is_positive_definite, is_hermitian=is_hermitian, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
         self.solver = MKLPardisoSolver(
             self.A,
             matrix_type=self._matrixType(),

pymatsolver/iterative.py

@@ -17,13 +17,13 @@
 class BiCGJacobi(Base):
     """Bicg Solver with Jacobi preconditioner"""
 
-    def __init__(self, A, symmetric=None, maxiter=1000, rtol=1E-6, atol=0.0, **kwargs):
+    def __init__(self, A, symmetric=None, maxiter=1000, rtol=1E-6, atol=0.0, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
         if symmetric is not None:
             warnings.warn(
-                "The symmetric keyword argument is being deprecated and will be removed in pymatsolver 0.7.0",
+                "The symmetric keyword argument is unused and is deprecated. It will be removed in pymatsolver 0.7.0.",
                 DeprecationWarning, stacklevel=2
             )
-        super().__init__(A, **kwargs)
+        super().__init__(A, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
         self._factored = False
         self.maxiter = maxiter
         self.rtol = rtol

pymatsolver/solvers.py

@@ -187,7 +187,7 @@ def solve(self, rhs):
         else:
             if ndim == 2 and rhs.shape[-1] == 1:
                 warnings.warn(
-                    "In the pymatsolver v0.7.0 passing a vector of shape (n, 1) to the solve method "
+                    "In Future pymatsolver v0.4.0, passing a vector of shape (n, 1) to the solve method "
                     "will return an array with shape (n, 1), instead of always returning a flattened array. "
                     "This is to be consistent with numpy.linalg.solve broadcasting.",
                     FutureWarning
@@ -199,7 +199,7 @@ def solve(self, rhs):
                 # switch last two dimensions
                 rhs = np.transpose(rhs, (*range(rhs.ndim-2), -1, -2))
                 in_shape = rhs.shape
-                # Then collapse all other vectors into the last dimension
+                # Then collapse all other vectors into the first dimension
                 rhs = np.reshape(rhs, (-1, in_shape[-1]))
                 # Then reverse the two axes to get the array to end up in fortran order
                 # (which is more common for direct solvers).
@@ -226,7 +226,7 @@ def solve(self, rhs):
     def _solve_single(self, rhs):
         ...
 
-
+    @abstractmethod
     def _solve_multiple(self, rhs):
         ...
 
@@ -263,7 +263,7 @@ def get_attributes(self):
 
 class Diagonal(Base):
 
-    def __init__(self, A, **kwargs):
+    def __init__(self, A, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
         try:
             self._diagonal = np.asarray(A.diagonal())
             if not np.all(self._diagonal):
@@ -275,7 +275,7 @@ def __init__(self, A, **kwargs):
         kwargs.pop("is_hermitian", None)
         is_positive_definite = kwargs.pop("is_positive_definite", None)
         super().__init__(
-            A, is_symmetric=True, is_hermitian=True, **kwargs
+            A, is_symmetric=True, is_hermitian=True, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs
         )
         if is_positive_definite is None:
             if self.is_real:
@@ -294,13 +294,13 @@ def _solve_multiple(self, rhs):
 
 
 class TriangularSolver(Base):
-    def __init__(self, A, lower=True, **kwargs):
+    def __init__(self, A, lower=True, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
         kwargs.pop("is_hermitian", False)
         kwargs.pop("is_symmetric", False)
         if not (sp.issparse(A) and A.format in ['csr','csc']):
             A = sp.csc_matrix(A)
         A.sum_duplicates()
-        super().__init__(A, is_hermitian=False, is_symmetric=False, **kwargs)
+        super().__init__(A, is_hermitian=False, is_symmetric=False, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
         self.lower = lower
 
     @property
@@ -320,23 +320,23 @@ def _solve_multiple(self, rhs):
     _solve_single = _solve_multiple
 
     def transpose(self):
-        transed = super().transpose()
-        transed.lower = not self.lower
-        return transed
+        trans = super().transpose()
+        trans.lower = not self.lower
+        return trans
 
 class Forward(TriangularSolver):
 
-    def __init__(self, A, **kwargs):
+    def __init__(self, A, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
         kwargs.pop("lower", None)
-        super().__init__(A, lower=True, **kwargs)
+        super().__init__(A, lower=True, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
 
 class Backward(TriangularSolver):
 
     _transpose_class = Forward
 
-    def __init__(self, A, **kwargs):
+    def __init__(self, A, check_accuracy=False, check_rtol=1e-6, check_atol=0, accuracy_tol=None, **kwargs):
         kwargs.pop("lower", None)
-        super().__init__(A, lower=False, **kwargs)
+        super().__init__(A, lower=False, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol, **kwargs)
 
 
 Forward._transpose_class = Backward

pymatsolver/wrappers.py

@@ -71,13 +71,11 @@ def WrapDirect(fun, factorize=True, name=None):
     >>> SolverLU = pymatsolver.WrapDirect(splu, factorize=True)
     """
 
-    def __init__(self, A, **kwargs):
-        pymatsolver_options = {}
-        if (check_accuracy := kwargs.pop('check_accuracy', None)) is not None:
-            pymatsolver_options['check_accuracy'] = check_accuracy
-        if (accuracy_tol := kwargs.pop('accuracy_tol', None)) is not None:
-            pymatsolver_options['accuracy_tol'] = accuracy_tol
-        Base.__init__(self, A, **pymatsolver_options)
+    def __init__(self, A, check_accuracy=False, check_rtol=1E-6, check_atol=0, accuracy_tol=None, **kwargs):
+        Base.__init__(
+            self, A, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol,
+            is_symmetric=False, is_hermitian=False
+        )
         self.kwargs = kwargs
         if factorize:
             self.solver = fun(self.A, **self.kwargs)
@@ -127,7 +125,7 @@ def clean(self):
     )
 
 
-def WrapIterative(fun, check_accuracy=False, accuracy_tol=1e-6, name=None):
+def WrapIterative(fun, check_accuracy=None, accuracy_tol=None, name=None):
     """
     Wraps an iterative Solver.
 
@@ -148,11 +146,16 @@ def WrapIterative(fun, check_accuracy=False, accuracy_tol=1e-6, name=None):
     >>> SolverCG = pymatsolver.WrapIterative(cg)
 
     """
-
-    def __init__(self, A, **kwargs):
-        check_acc = kwargs.pop('check_accuracy', check_accuracy)
-        acc_tol = kwargs.pop('accuracy_tol', accuracy_tol)
-        Base.__init__(self, A, check_accuracy=check_acc, accuracy_tol=acc_tol)
+    if check_accuracy is not None or accuracy_tol is not None:
+        warnings.warn('check_accuracy and accuracy_tol were unused and are now deprecated. They '
+                      'will be removed in pymatsolver v0.4.0. Please pass the keyword arguments `check_rtol` '
+                      'and check_atol directly to the wrapped solver class.', FutureWarning)
+
+    def __init__(self, A, check_accuracy=False, check_rtol=1E-6, check_atol=0, accuracy_tol=None, **kwargs):
+        Base.__init__(
+            self, A, check_accuracy=check_accuracy, check_rtol=check_rtol, check_atol=check_atol, accuracy_tol=accuracy_tol,
+            is_symmetric=False, is_hermitian=False
+        )
         self.kwargs = kwargs
 
     @property