ENH: use memoization in MINPACK routines

scipy/optimize/minpack.py

@@ -4,7 +4,7 @@
 from numpy import atleast_1d, dot, take, triu, shape, eye, \
                   transpose, zeros, product, greater, array, \
                   all, where, isscalar, asarray, inf, abs
-from optimize import Result
+from optimize import Result, MemoizeFun
 
 error = _minpack.error
 
@@ -183,6 +183,7 @@ def _root_hybr(func, x0, args=(), jac=None, options=None):
     diag      = options.get('diag', None)
 
     full_output = True
+    func = MemoizeFun(func, first_only=True, nskip=1)
     x0 = array(x0, ndmin=1)
     n = len(x0)
     if type(args) != type(()):
@@ -199,6 +200,7 @@ def _root_hybr(func, x0, args=(), jac=None, options=None):
         retval = _minpack._hybrd(func, x0, args, full_output, xtol, maxfev,
                                  ml, mu, epsfcn, factor, diag)
     else:
+        Dfun = MemoizeFun(Dfun, first_only=True, nskip=1)
         _check_func('fsolve', 'fprime', Dfun, x0, args, n, (n,n))
         if (maxfev == 0):
             maxfev = 100*(n + 1)
@@ -348,6 +350,7 @@ def leastsq(func, x0, args=(), Dfun=None, full_output=0,
          params
 
     """
+    func = MemoizeFun(func, first_only=True, nskip=1)
     x0 = array(x0, ndmin=1)
     n = len(x0)
     if type(args) != type(()):
@@ -361,6 +364,7 @@ def leastsq(func, x0, args=(), Dfun=None, full_output=0,
         retval = _minpack._lmdif(func, x0, args, full_output, ftol, xtol,
                 gtol, maxfev, epsfcn, factor, diag)
     else:
+        Dfun = MemoizeFun(Dfun, first_only=True, nskip=1)
         if col_deriv:
             _check_func('leastsq', 'Dfun', Dfun, x0, args, n, (n,m))
         else:

scipy/optimize/optimize.py

@@ -39,11 +39,46 @@
                    'pr_loss': 'Desired error not necessarily achieved due '
                               'to precision loss.'}
 
+
+class MemoizeFun(object):
+    """ Decorator that caches the value of the objective function.
+    If `first_only==True`, only the first point is memoized.
+    If `nskip > 0`, it is assumed that the function is evaluated `nskip`
+    times at the first point, so that the memoized values is used. """
+    def __init__(self, fun, first_only=False, nskip=0):
+        self.fun = fun
+        if hasattr(fun, '__name__'):
+            self.__name__ = fun.__name__
+        self.first_only = first_only
+        self.nskip = nskip
+
+    def __call__(self, x, *args):
+        if hasattr(self, 'calls'):
+            self.calls += 1
+        else:
+            self.calls = 0
+        if self.calls == 0:
+            self.x = numpy.asarray(x).copy()
+            self.f = self.fun(x, *args)
+            return self.f
+        elif self.calls <= self.nskip:
+            return self.f
+        elif self.first_only and self.calls > 1:
+            return self.fun(x, *args)
+        elif numpy.any(x != self.x):
+            self.x = numpy.asarray(x).copy()
+            self.f = self.fun(x, *args)
+            return self.f
+        else:
+            return self.f
+
 class MemoizeJac(object):
     """ Decorator that caches the value gradient of function each time it
     is called. """
     def __init__(self, fun):
         self.fun = fun
+        if hasattr(fun, '__name__'):
+            self.__name__ = fun.__name__
         self.jac = None
         self.x = None