Update for new Eigen::Ref API.

Benjamin Chrétien · Benjamin Chrétien · commit 801f2481bca5 · 2015-03-02T18:54:14.000+01:00
diff --git a/src/wrap.cc b/src/wrap.cc
@@ -100,7 +100,7 @@ namespace roboptim
 	  }
       }
 
-      void Function::impl_compute (result_t& result, const argument_t& argument)
+      void Function::impl_compute (result_ref result, const_argument_ref argument)
 	const
       {
         if (!computeCallback_)
@@ -214,14 +214,14 @@ namespace roboptim
       }
 
       void DifferentiableFunction::impl_compute
-      (result_t& result, const argument_t& argument)
+      (result_ref result, const_argument_ref argument)
 	const
       {
         ::roboptim::core::python::Function::impl_compute (result, argument);
       }
 
-      void DifferentiableFunction::impl_gradient (gradient_t& gradient,
-                                                  const argument_t& argument,
+      void DifferentiableFunction::impl_gradient (gradient_ref gradient,
+                                                  const_argument_ref argument,
                                                   size_type functionId)
 	const
       {
@@ -278,8 +278,8 @@ namespace roboptim
 	Py_XDECREF(resultPy);
       }
 
-      void DifferentiableFunction::impl_jacobian (jacobian_t& jacobian,
-                                                  const argument_t& argument)
+      void DifferentiableFunction::impl_jacobian (jacobian_ref jacobian,
+                                                  const_argument_ref argument)
 	const
       {
 	// Jacobian callback not specified, we fallback on parent implementation
@@ -401,22 +401,22 @@ namespace roboptim
       }
 
       void TwiceDifferentiableFunction::impl_compute
-      (result_t& result, const argument_t& argument)
+      (result_ref result, const_argument_ref argument)
 	const
       {
         ::roboptim::core::python::Function::impl_compute (result, argument);
       }
 
       void TwiceDifferentiableFunction::impl_gradient
-      (gradient_t& gradient, const argument_t& argument, size_type functionId)
+      (gradient_ref gradient, const_argument_ref argument, size_type functionId)
 	const
       {
         ::roboptim::core::python::DifferentiableFunction::impl_gradient
           (gradient, argument, functionId);
       }
 
-      void TwiceDifferentiableFunction::impl_hessian (hessian_t& /*hessian*/,
-						      const argument_t& /*argument*/,
+      void TwiceDifferentiableFunction::impl_hessian (hessian_ref /*hessian*/,
+						      const_argument_ref /*argument*/,
 						      size_type /*functionId*/) const
       {
         //FIXME: implement this.
@@ -441,20 +441,20 @@ namespace roboptim
       {
       }
 
-      void FunctionPool::impl_compute (result_t& result, const argument_t& x) const
+      void FunctionPool::impl_compute (result_ref result, const_argument_ref x) const
       {
         pool_.impl_compute (result, x);
       }
 
-      void FunctionPool::impl_gradient (gradient_t& gradient,
-                                        const argument_t& x,
+      void FunctionPool::impl_gradient (gradient_ref gradient,
+                                        const_argument_ref x,
                                         size_type functionId) const
       {
         pool_.impl_gradient (gradient, x, functionId);
       }
 
-      void FunctionPool::impl_jacobian (jacobian_t& jacobian,
-                                        const argument_t& x) const
+      void FunctionPool::impl_jacobian (jacobian_ref jacobian,
+                                        const_argument_ref x) const
       {
         pool_.impl_jacobian (jacobian, x);
       }
@@ -923,7 +923,7 @@ namespace detail
       return PyBool_FromLong (b);
     }
 
-    PyObject* operator () (const roboptim::Function::vector_t& v) const
+    PyObject* operator () (roboptim::Function::const_vector_ref v) const
     {
       npy_intp n = static_cast<npy_intp> (v.size ());
 
diff --git a/src/wrap.hh b/src/wrap.hh
@@ -73,7 +73,7 @@ namespace roboptim
         virtual ~Function ();
 
         virtual void
-	impl_compute (result_t& result, const argument_t& argument) const;
+	impl_compute (result_ref result, const_argument_ref argument) const;
 
         void setComputeCallback (PyObject* callback);
 
@@ -100,16 +100,16 @@ namespace roboptim
 
         size_type outputSize () const;
 
-        virtual void impl_compute (result_t& result, const argument_t& argument)
+        virtual void impl_compute (result_ref result, const_argument_ref argument)
           const;
 
-        virtual void impl_gradient (gradient_t& gradient,
-                                    const argument_t& argument,
+        virtual void impl_gradient (gradient_ref gradient,
+                                    const_argument_ref argument,
                                     size_type functionId)
           const;
 
-        virtual void impl_jacobian (jacobian_t& jacobian,
-                                    const argument_t& argument)
+        virtual void impl_jacobian (jacobian_ref jacobian,
+                                    const_argument_ref argument)
           const;
 
 
@@ -141,18 +141,18 @@ namespace roboptim
 
         virtual ~TwiceDifferentiableFunction ();
 
-        virtual void impl_compute (result_t& result, const argument_t& argument)
+        virtual void impl_compute (result_ref result, const_argument_ref argument)
           const;
 
 
         virtual void impl_gradient
-	(gradient_t& gradient, const argument_t& argument, size_type functionId)
+	(gradient_ref gradient, const_argument_ref argument, size_type functionId)
           const;
 
 
         virtual void
 	impl_hessian (hessian_t& /*hessian*/,
-		      const argument_t& /*argument*/,
+		      const_argument_ref /*argument*/,
 		      size_type /*functionId*/) const;
 
       private:
@@ -187,8 +187,8 @@ namespace roboptim
 
         virtual ~FiniteDifferenceGradient () {}
 
-        virtual void impl_gradient (gradient_t& gradient,
-                                    const argument_t& argument,
+        virtual void impl_gradient (gradient_ref gradient,
+                                    const_argument_ref argument,
                                     size_type functionId)
           const
 	{
@@ -287,14 +287,14 @@ namespace roboptim
 
         virtual ~FunctionPool ();
 
-        virtual void impl_compute (result_t& result, const argument_t& x) const;
+        virtual void impl_compute (result_ref result, const_argument_ref x) const;
 
-        virtual void impl_gradient (gradient_t& gradient,
-                                    const argument_t& x,
+        virtual void impl_gradient (gradient_ref gradient,
+                                    const_argument_ref x,
                                     size_type functionId = 0) const;
 
-        virtual void impl_jacobian (jacobian_t& jacobian,
-                                    const argument_t& x) const;
+        virtual void impl_jacobian (jacobian_ref jacobian,
+                                    const_argument_ref x) const;
 
         virtual std::ostream& print (std::ostream&) const;
 

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ namespace roboptim`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`		`- void Function::impl_compute (result_t& result, const argument_t& argument)`
	`103`	`+ void Function::impl_compute (result_ref result, const_argument_ref argument)`
`104`	`104`	`const`
`105`	`105`	`{`
`106`	`106`	`if (!computeCallback_)`
`@@ -214,14 +214,14 @@ namespace roboptim`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`void DifferentiableFunction::impl_compute`
`217`		`- (result_t& result, const argument_t& argument)`
	`217`	`+ (result_ref result, const_argument_ref argument)`
`218`	`218`	`const`
`219`	`219`	`{`
`220`	`220`	`::roboptim::core::python::Function::impl_compute (result, argument);`
`221`	`221`	`}`
`222`	`222`
`223`		`- void DifferentiableFunction::impl_gradient (gradient_t& gradient,`
`224`		`- const argument_t& argument,`
	`223`	`+ void DifferentiableFunction::impl_gradient (gradient_ref gradient,`
	`224`	`+ const_argument_ref argument,`
`225`	`225`	`size_type functionId)`
`226`	`226`	`const`
`227`	`227`	`{`
`@@ -278,8 +278,8 @@ namespace roboptim`
`278`	`278`	`Py_XDECREF(resultPy);`
`279`	`279`	`}`
`280`	`280`
`281`		`- void DifferentiableFunction::impl_jacobian (jacobian_t& jacobian,`
`282`		`- const argument_t& argument)`
	`281`	`+ void DifferentiableFunction::impl_jacobian (jacobian_ref jacobian,`
	`282`	`+ const_argument_ref argument)`
`283`	`283`	`const`
`284`	`284`	`{`
`285`	`285`	`// Jacobian callback not specified, we fallback on parent implementation`
`@@ -401,22 +401,22 @@ namespace roboptim`
`401`	`401`	`}`
`402`	`402`
`403`	`403`	`void TwiceDifferentiableFunction::impl_compute`
`404`		`- (result_t& result, const argument_t& argument)`
	`404`	`+ (result_ref result, const_argument_ref argument)`
`405`	`405`	`const`
`406`	`406`	`{`
`407`	`407`	`::roboptim::core::python::Function::impl_compute (result, argument);`
`408`	`408`	`}`
`409`	`409`
`410`	`410`	`void TwiceDifferentiableFunction::impl_gradient`
`411`		`- (gradient_t& gradient, const argument_t& argument, size_type functionId)`
	`411`	`+ (gradient_ref gradient, const_argument_ref argument, size_type functionId)`
`412`	`412`	`const`
`413`	`413`	`{`
`414`	`414`	`::roboptim::core::python::DifferentiableFunction::impl_gradient`
`415`	`415`	`(gradient, argument, functionId);`
`416`	`416`	`}`
`417`	`417`
`418`		`- void TwiceDifferentiableFunction::impl_hessian (hessian_t& /hessian/,`
`419`		`- const argument_t& /argument/,`
	`418`	`+ void TwiceDifferentiableFunction::impl_hessian (hessian_ref /hessian/,`
	`419`	`+ const_argument_ref /argument/,`
`420`	`420`	`size_type /functionId/) const`
`421`	`421`	`{`
`422`	`422`	`//FIXME: implement this.`
`@@ -441,20 +441,20 @@ namespace roboptim`
`441`	`441`	`{`
`442`	`442`	`}`
`443`	`443`
`444`		`- void FunctionPool::impl_compute (result_t& result, const argument_t& x) const`
	`444`	`+ void FunctionPool::impl_compute (result_ref result, const_argument_ref x) const`
`445`	`445`	`{`
`446`	`446`	`pool_.impl_compute (result, x);`
`447`	`447`	`}`
`448`	`448`
`449`		`- void FunctionPool::impl_gradient (gradient_t& gradient,`
`450`		`- const argument_t& x,`
	`449`	`+ void FunctionPool::impl_gradient (gradient_ref gradient,`
	`450`	`+ const_argument_ref x,`
`451`	`451`	`size_type functionId) const`
`452`	`452`	`{`
`453`	`453`	`pool_.impl_gradient (gradient, x, functionId);`
`454`	`454`	`}`
`455`	`455`
`456`		`- void FunctionPool::impl_jacobian (jacobian_t& jacobian,`
`457`		`- const argument_t& x) const`
	`456`	`+ void FunctionPool::impl_jacobian (jacobian_ref jacobian,`
	`457`	`+ const_argument_ref x) const`
`458`	`458`	`{`
`459`	`459`	`pool_.impl_jacobian (jacobian, x);`
`460`	`460`	`}`
`@@ -923,7 +923,7 @@ namespace detail`
`923`	`923`	`return PyBool_FromLong (b);`
`924`	`924`	`}`
`925`	`925`
`926`		`- PyObject* operator () (const roboptim::Function::vector_t& v) const`
	`926`	`+ PyObject* operator () (roboptim::Function::const_vector_ref v) const`
`927`	`927`	`{`
`928`	`928`	`npy_intp n = static_cast<npy_intp> (v.size ());`
`929`	`929`