Add CachedFunction support.

For now, only differentiable functions are handled.

Author: Benjamin Chrétien

src/roboptim/core/__init__.py

@@ -180,6 +180,23 @@ def impl_jacobian (self, result, x):
         jacobian (self._fd, result, x)
 
 
+class PyCachedFunction(PyDifferentiableFunction):
+    def __init__ (self, f, size):
+        PyDifferentiableFunction.__init__ \
+            (self, f.inputSize (), f.outputSize (), \
+             self._decodeName (f.name ()))
+        self._cachedFunction = CachedFunction (f._function, size)
+
+    def impl_compute (self, result, x):
+        compute (self._cachedFunction, result, x)
+
+    def impl_gradient (self, result, x, functionId):
+        gradient (self._cachedFunction, result, x, functionId)
+
+    def impl_jacobian (self, result, x):
+        jacobian (self._cachedFunction, result, x)
+
+
 class PyProblem(object):
     def __init__(self, cost):
         self.cost = cost

src/wrap.cc

@@ -437,6 +437,44 @@ namespace roboptim
       }
 
 
+      CachedFunction::CachedFunction (boost::shared_ptr<pyFunction_t> f, size_t cache_size)
+        : function_t (f->inputSize (), f->outputSize (), f->getName ()),
+	  pyFunction_t (f->inputSize (), f->outputSize (), f->getName ()),
+	  cached_f_ (boost::make_shared<cache_t> (f, cache_size))
+      {
+      }
+
+      CachedFunction::~CachedFunction ()
+      {
+      }
+
+      void CachedFunction::impl_compute (result_ref result,
+					 const_argument_ref argument)
+	const
+      {
+	(*cached_f_) (result, argument);
+      }
+
+      void CachedFunction::impl_gradient (gradient_ref gradient,
+					  const_argument_ref argument,
+					  size_type functionId)
+	const
+      {
+	cached_f_->gradient (gradient, argument, functionId);
+      }
+
+      void CachedFunction::impl_jacobian (jacobian_ref jacobian,
+					  const_argument_ref argument)
+	const
+      {
+	cached_f_->jacobian (jacobian, argument);
+      }
+
+      std::ostream& CachedFunction::print (std::ostream& o) const
+      {
+	return cached_f_->print (o);
+      }
+
       FunctionPool::~FunctionPool ()
       {
       }
@@ -472,6 +510,7 @@ using roboptim::core::python::DifferentiableFunction;
 using roboptim::core::python::TwiceDifferentiableFunction;
 using roboptim::core::python::FiniteDifferenceGradient;
 using roboptim::core::python::FunctionPool;
+using roboptim::core::python::CachedFunction;
 
 namespace detail
 {
@@ -1038,6 +1077,50 @@ createFDWrapper (PyObject*, PyObject* args)
   return fdFunctionPy;
 }
 
+static PyObject*
+createCachedFunction (PyObject*, PyObject* args)
+{
+  typedef CachedFunction cachedDifferentiableFunction_t;
+
+  Function* function = 0;
+  size_t cache_size = 10;
+
+  if (!PyArg_ParseTuple(args, "O&|i", &detail::functionConverter, &function, &cache_size))
+    return 0;
+
+  if (!function)
+    {
+      PyErr_SetString
+	(PyExc_TypeError,
+	 "Failed to retrieve function object");
+      return 0;
+    }
+
+  PyObject* cachedFunctionPy = 0;
+
+  DifferentiableFunction* dfunction =
+    dynamic_cast<DifferentiableFunction*> (function);
+  if (!dfunction)
+    {
+      PyErr_SetString
+	(PyExc_TypeError,
+	 "Failed to retrieve differentiable function object");
+      return 0;
+    }
+
+  boost::shared_ptr<DifferentiableFunction> dfunction_ptr
+    = detail::to_shared_ptr<DifferentiableFunction> (dfunction, PyTuple_GetItem (args, 0));
+  assert (dfunction_ptr);
+
+  cachedDifferentiableFunction_t* cachedFunction
+    = new cachedDifferentiableFunction_t (dfunction_ptr, cache_size);
+
+  cachedFunctionPy = PyCapsule_New (cachedFunction, ROBOPTIM_CORE_FUNCTION_CAPSULE_NAME,
+				    &detail::destructor<cachedDifferentiableFunction_t>);
+
+  return cachedFunctionPy;
+}
+
 static PyObject*
 inputSize (PyObject*, PyObject* args)
 {
@@ -2872,7 +2955,11 @@ static PyMethodDef RobOptimCoreMethods[] =
      METH_VARARGS, "Create a FiniteDifferenceGradient with forward difference."},
     {"FivePointsFiniteDifferenceGradient",
      createFDWrapper<FiniteDifferenceGradient<fivePointsPolicy_t> >,
-     METH_VARARGS, "Create a FiniteDifferenceGradient with the 5-points rule."},
+     METH_VARARGS, "Create a FiniteDifferenceGradient with the 5-point rule."},
+
+    // Filters
+    {"CachedFunction", createCachedFunction, METH_VARARGS,
+     "Create a cached function."},
 
     // Print functions
     {"strFunction", print<Function>, METH_VARARGS,

src/wrap.hh

@@ -5,6 +5,10 @@
 
 #include <boost/variant.hpp>
 #include <boost/mpl/vector.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/make_shared.hpp>
 
 #include <Python.h>
 
@@ -25,6 +29,8 @@
 
 #include <roboptim/core/callback/multiplexer.hh>
 
+#include <roboptim/core/filter/cached-function.hh>
+
 #include <roboptim/core/detail/utility.hh>
 
 
@@ -203,6 +209,41 @@ namespace roboptim
 	}
       };
 
+      class CachedFunction
+	: virtual public ::roboptim::DifferentiableFunction,
+	  public ::roboptim::core::python::DifferentiableFunction
+      {
+      public:
+        typedef ::roboptim::DifferentiableFunction function_t;
+        typedef DifferentiableFunction pyFunction_t;
+
+        typedef ::roboptim::CachedFunction<function_t> cache_t;
+
+        FORWARD_TYPEDEFS_ (cache_t);
+
+        explicit CachedFunction (boost::shared_ptr<pyFunction_t> f, size_t cache_size);
+
+        virtual ~CachedFunction ();
+
+        virtual void impl_compute (result_ref result,
+                                   const_argument_ref argument)
+          const;
+
+        virtual void impl_gradient (gradient_ref gradient,
+                                    const_argument_ref argument,
+                                    size_type functionId)
+          const;
+
+        virtual void impl_jacobian (jacobian_ref jacobian,
+                                    const_argument_ref argument)
+          const;
+
+        virtual std::ostream& print (std::ostream& o) const;
+
+      private:
+	boost::shared_ptr<cache_t> cached_f_;
+      };
+
 
       template <typename S>
       class SolverCallback

tests/CMakeLists.txt

@@ -22,6 +22,10 @@ ADD_TEST(solver_callback
 ADD_TEST(finite_differences
   "${TEST_COMMAND}" "${CMAKE_CURRENT_SOURCE_DIR}/finite_differences.py")
 
+# Check cached function support.
+ADD_TEST(cached_function
+  "${TEST_COMMAND}" "${CMAKE_CURRENT_SOURCE_DIR}/cached_function.py")
+
 # Check function pool support.
 ADD_TEST(function_pool
   "${TEST_COMMAND}" "${CMAKE_CURRENT_SOURCE_DIR}/function_pool.py")

tests/cached_function.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from __future__ import \
+    print_function, unicode_literals, absolute_import, division
+
+import unittest
+import roboptim.core
+import numpy, numpy.testing
+import math
+
+class Square (roboptim.core.PyDifferentiableFunction):
+    def __init__ (self):
+        roboptim.core.PyDifferentiableFunction.__init__ \
+            (self, 1, 1, "square function")
+        self.compute_counter = 0
+        self.gradient_counter = 0
+        self.jacobian_counter = 0
+
+    def reset (self):
+        self.compute_counter = 0
+        self.gradient_counter = 0
+        self.jacobian_counter = 0
+
+    def impl_compute (self, result, x):
+        result[0] = x[0] * x[0]
+        self.compute_counter += 1
+
+    def impl_gradient (self, result, x, f_id):
+        result[0] = 2. * x[0]
+        self.gradient_counter += 1
+
+    def impl_jacobian (self, result, x):
+        result[0,0] = 2. * x[0]
+        self.jacobian_counter += 1
+
+class TestFiniteDifferences(unittest.TestCase):
+
+    def test_counters(self):
+
+        square = Square()
+        f = roboptim.core.PyCachedFunction (square, 10)
+
+        x = numpy.array ([4.])
+        res = f (x)
+        numpy.testing.assert_almost_equal (res, [x[0] * x[0]], 5)
+        assert square.compute_counter == 1
+        res2 = f (x)
+        numpy.testing.assert_almost_equal (res2, [x[0] * x[0]], 5)
+        assert square.compute_counter == 1
+
+        grad = f.gradient (x, 0)
+        numpy.testing.assert_almost_equal (grad, [2. * x[0]], 5)
+        assert square.gradient_counter == 1
+        grad2 = f.gradient (x, 0)
+        numpy.testing.assert_almost_equal (grad2, [2. * x[0]], 5)
+        assert square.gradient_counter == 1
+
+        jac = f.jacobian (x)
+        numpy.testing.assert_almost_equal (jac, [[2. * x[0]]], 5)
+        assert square.jacobian_counter == 1
+        jac2 = f.jacobian (x)
+        numpy.testing.assert_almost_equal (jac2, [[2. * x[0]]], 5)
+        assert square.jacobian_counter == 1
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/wrap.py

@@ -178,6 +178,53 @@ def gradient(result, x, functionId):
             roboptim.core.gradient (f, result, x, 0)
             numpy.testing.assert_almost_equal (result, result_fd, 4)
 
+    def test_cached_function(self):
+
+        def compute(result, x):
+            print("compute()")
+            result[0] = x[0] * x[0]
+        def gradient(result, x, functionId):
+            print("gradient()")
+            result[0] = 2 * x[0]
+
+        f = roboptim.core.DifferentiableFunction (1, 1, "x * x")
+        roboptim.core.bindCompute(f, compute)
+        roboptim.core.bindGradient(f, gradient)
+
+        # Cached function
+        cached = roboptim.core.CachedFunction (f, 10)
+
+        # Check computation with sequences.
+        x = [2.,]
+        result = numpy.array([0.,])
+        result2 = numpy.array([0.,])
+        gradient = numpy.array([0.,])
+        gradient2 = numpy.array([0.,])
+
+        roboptim.core.compute (cached, result, x)
+        roboptim.core.compute (cached, result2, x)
+        roboptim.core.gradient (cached, gradient, x, 0)
+        roboptim.core.gradient (cached, gradient2, x, 0)
+
+        self.assertEqual (x, [2.,])
+        self.assertEqual (result, [4.,])
+        self.assertEqual (result2, [4.,])
+        self.assertEqual (gradient, [4.,])
+        self.assertEqual (gradient2, [4.,])
+
+        x = [10.,]
+        roboptim.core.compute (cached, result, x)
+        roboptim.core.compute (cached, result2, x)
+        roboptim.core.gradient (cached, gradient, x, 0)
+        roboptim.core.gradient (cached, gradient2, x, 0)
+
+        self.assertEqual (x, [10.,])
+        self.assertEqual (result, [100.,])
+        self.assertEqual (result2, [100.,])
+        self.assertEqual (gradient, [20.,])
+        self.assertEqual (gradient2, [20.,])
+
+
     def test_function_pool(self):
         data = numpy.zeros(2)