Upgraded the derivative() function so it can work on functions with two arguments.

--HG--
extra : convert_revision : svn%3Afdd8eb12-d10e-0410-9acb-85c331704f74/trunk%403921

dlib/optimization/optimization.h

@@ -58,6 +58,33 @@ namespace dlib
             return der;
         }
 
+        template <typename T, typename U>
+        typename U::matrix_type operator()(const T& item, const U& x) const
+        {
+            // U must be some sort of dlib matrix 
+            COMPILE_TIME_ASSERT(is_matrix<U>::value);
+
+            typename U::matrix_type der(x.size());
+            typename U::matrix_type e(x);
+            for (long i = 0; i < x.size(); ++i)
+            {
+                const double old_val = e(i);
+
+                e(i) += eps;
+                const double delta_plus = f(item,e);
+                e(i) = old_val - eps;
+                const double delta_minus = f(item,e);
+
+                der(i) = (delta_plus - delta_minus)/(2*eps);
+
+                // and finally restore the old value of this element
+                e(i) = old_val;
+            }
+
+            return der;
+        }
+        
+
         double operator()(const double& x) const
         {
             return (f(x+eps)-f(x-eps))/(2*eps);

dlib/optimization/optimization_abstract.h

@@ -45,7 +45,11 @@ namespace dlib
     /*!
         requires
             - f == a function that returns a scalar
-            - f must take either double or a dlib::matrix that is a column vector
+            - f must have one of the following forms:
+                - double f(double)
+                - double f(dlib::matrix)  (where the matrix is a column vector)
+                - double f(T, dlib::matrix)  (where the matrix is a column vector.  In 
+                  this case the derivative of f is taken with respect to the second argument.)
             - eps > 0
         ensures
             - returns a function that represents the derivative of the function f.  It