#69 Removed most solvers, replaced by wrappers.

SimPEG/Utils/SolverUtils.py

@@ -2,10 +2,20 @@ import numpy as np
 from matutils import mkvc
 import warnings
 
-def DSolverWrap(fun, factorize=True, destroy = False, checkAccuracy=True, accuracyTol=1e-6):
+def _checkAccuracy(A, b, X, accuracyTol):
+    nrm = np.linalg.norm(mkvc(A*X - b), np.inf)
+    nrm_b = np.linalg.norm(mkvc(b), np.inf)
+    if nrm_b > 0:
+        nrm /= nrm_b
+    if nrm > accuracyTol:
+        msg = '### SolverWarning ###: Accuracy on solve is above tolerance: %e > %e' % (nrm, accuracyTol)
+        print msg
+        warnings.warn(msg, RuntimeWarning)
+
+
+def DSolverWrap(fun, factorize=True, checkAccuracy=True, accuracyTol=1e-6):
 
     def __init__(self, A, **kwargs):
-
         self.A = A.tocsc()
         self.kwargs = kwargs
         if factorize:
@@ -28,27 +38,27 @@ def DSolverWrap(fun, factorize=True, destroy = False, checkAccuracy=True, accura
                     X[:,i] = fun(self.A, b[:,i], **self.kwargs)
 
         if checkAccuracy:
-            nrm = np.linalg.norm(mkvc(self.A*X - b)) / np.linalg.norm(mkvc(b))
-            if nrm > accuracyTol:
-                msg = '### SolverWarning ###: Accuracy on solve is above tolerance: %e > %e' % (nrm, accuracyTol)
-                print msg
-                warnings.warn(msg, RuntimeWarning)
+            _checkAccuracy(self.A, b, X, accuracyTol)
         return X
 
     def clean(self):
-        if destroy == True:
+        if hasattr(self.solver, 'clean'):
             return self.solver.clean()
-        else:
-            return True
 
-    return type(fun.__name__, (object,), {"__init__": __init__, "solve": solve, "clean": clean})
+
+    def __mul__(self, val):
+        if type(val) is np.ndarray:
+            return self.solve(val)
+        raise TypeError('Can only multiply by a numpy array.')
+
+    return type(fun.__name__, (object,), {"__init__": __init__, "solve": solve, "clean": clean, "__mul__": __mul__})
 
 
 
 def ISolverWrap(fun, checkAccuracy=True, accuracyTol=1e-5):
 
     def __init__(self, A, **kwargs):
-        self.A = A.tocsc()
+        self.A = A
         self.kwargs = kwargs
 
     def solve(self, b):
@@ -74,11 +84,12 @@ def ISolverWrap(fun, checkAccuracy=True, accuracyTol=1e-5):
                     X[:,i] = out
 
         if checkAccuracy:
-            nrm = np.linalg.norm(mkvc(self.A*X - b)) / np.linalg.norm(mkvc(b))
-            if nrm > accuracyTol:
-                msg = '### SolverWarning ###: Accuracy on solve is above tolerance: %e > %e' % (nrm, accuracyTol)
-                print msg
-                warnings.warn(msg, RuntimeWarning)
+            _checkAccuracy(self.A, b, X, accuracyTol)
         return X
 
-    return type(fun.__name__, (object,), {"__init__": __init__, "solve": solve})
+    def __mul__(self, val):
+        if type(val) is np.ndarray:
+            return self.solve(val)
+        raise TypeError('Can only multiply by a numpy array.')
+
+    return type(fun.__name__, (object,), {"__init__": __init__, "solve": solve, "__mul__": __mul__})

SimPEG/Utils/TriSolve.f

@@ -1,64 +0,0 @@
-c File TriSolve.f
-       subroutine forward(al, ial, jal, b, nv, n, nRHS, x)
-       double precision al(nv)
-       integer ial(n+1)
-       integer jal(nv)
-       double precision b(n,nRHS)
-       double precision x(n,nRHS)
-       integer nv
-       integer n
-       integer nRHS
-       integer rhs
-cf2py  intent(in) :: al
-cf2py  intent(in) :: ial
-cf2py  intent(in) :: jal
-cf2py  intent(in) :: b
-cf2py  intent(in) :: nv
-cf2py  intent(in) :: n
-cf2py  intent(in) :: nRHS
-cf2py  intent(out) :: x
-       real ( kind = 8 ) t
-
-       do rhs = 1, nRHS
-          do k = 1, n
-             t = b(k,rhs)
-             do j = ial(k)+1, ial(k+1)
-                t = t - al(j) * x(jal(j)+1,rhs)
-             end do
-             x(k,rhs) = t/al(ial(k+1))
-          end do
-       end do
-       end subroutine forward
-
-
-       subroutine backward(au,iau, jau, b, nv, n, nRHS, x)
-       double precision au(nv)
-       integer iau(n+1)
-       integer jau(nv)
-       double precision b(n,nRHS)
-       double precision x(n,nRHS)
-       integer nv
-       integer n
-       integer nRHS
-       integer rhs
-cf2py  intent(in) :: au
-cf2py  intent(in) :: iau
-cf2py  intent(in) :: jau
-cf2py  intent(in) :: b
-cf2py  intent(in) :: nv
-cf2py  intent(in) :: n
-cf2py  intent(in) :: nRHS
-cf2py  intent(out) :: x
-       real ( kind = 8 ) t
-
-       do rhs = 1, nRHS
-          do k = n, 1, -1
-             t = b(k,rhs)
-             do j = iau(k)+1, iau(k+1)
-                t = t - au(j) * x(jau(j)+1,rhs)
-             end do
-             x(k,rhs) = t/au(iau(k)+1)
-          end do
-       end do
-
-       end subroutine backward