Merge pull request #31 from fdarricau/non-templated-problem

Remove function-based template arguments for Problem

cf. roboptim/roboptim-core#98

Author: bchretien

.travis.yml

@@ -6,7 +6,7 @@ env:
   global:
   - APT_DEPENDENCIES="doxygen doxygen-latex libltdl-dev libboost-all-dev liblog4cxx10-dev coinor-libipopt-dev libblas-dev liblapack-dev libmumps-seq-dev gfortran"
   - HOMEBREW_DEPENDENCIES="doxygen libtool boost log4cxx ipopt openblas mumps"
-  - GIT_DEPENDENCIES="roboptim/roboptim-core"
+  - GIT_DEPENDENCIES="roboptim/roboptim-core:dev"
   - DEBSIGN_KEYID=5AE5CD75
   - PPA_URI="roboptim/ppa"
   - GH_USERNAME=thomas-moulard
@@ -24,6 +24,7 @@ notifications:
 branches:
   only:
   - master
+  - dev
   - debian
   - travis
   - coverity_scan

include/roboptim/core/plugin/ipopt/ipopt-sparse.hh

@@ -60,16 +60,11 @@ namespace roboptim
   /// to provide hessians in your function's problems.
   class ROBOPTIM_DLLEXPORT IpoptSolverSparse
     : public IpoptSolverCommon<
-    Solver<DifferentiableSparseFunction,
-	   boost::mpl::vector<LinearSparseFunction,
-			      DifferentiableSparseFunction> > >
+    Solver<EigenMatrixSparse> >
   {
   public:
     /// \brief RobOptim solver type.
-    typedef Solver<
-      DifferentiableSparseFunction,
-      boost::mpl::vector<LinearSparseFunction,
-			 DifferentiableSparseFunction> > solver_t;
+    typedef Solver<EigenMatrixSparse> solver_t;
 
     /// \brief Parent type.
     typedef IpoptSolverCommon<solver_t> parent_t;

include/roboptim/core/plugin/ipopt/ipopt-td.hh

@@ -55,14 +55,11 @@ namespace roboptim
   /// to provide hessians in your function's problems.
   class ROBOPTIM_DLLEXPORT IpoptSolverTd
     : public IpoptSolverCommon<
-    Solver <TwiceDifferentiableFunction,
-	    boost::mpl::vector<LinearFunction, TwiceDifferentiableFunction> > >
+    Solver <EigenMatrixDense> >
   {
   public:
     /// \brief RobOptim solver type.
-    typedef Solver<TwiceDifferentiableFunction,
-      boost::mpl::vector<LinearFunction,
-			 TwiceDifferentiableFunction> > solver_t;
+    typedef Solver<EigenMatrixDense> solver_t;
 
     /// \brief Parent type.
     typedef IpoptSolverCommon<solver_t> parent_t;

include/roboptim/core/plugin/ipopt/ipopt.hh

@@ -58,14 +58,11 @@ namespace roboptim
   /// to provide hessians in your function's problems.
   class ROBOPTIM_DLLEXPORT IpoptSolver
     : public IpoptSolverCommon<
-    Solver<DifferentiableFunction,
-	   boost::mpl::vector<LinearFunction, DifferentiableFunction> > >
+    Solver<EigenMatrixDense> >
   {
   public:
     /// \brief RobOptim solver type.
-    typedef Solver<
-      DifferentiableFunction,
-      boost::mpl::vector<LinearFunction, DifferentiableFunction> > solver_t;
+    typedef Solver<EigenMatrixDense> solver_t;
 
     /// \brief Parent type.
     typedef IpoptSolverCommon<solver_t> parent_t;

src/ipopt-sparse.cc

@@ -34,10 +34,7 @@
 
 namespace roboptim
 {
-  typedef Solver<DifferentiableSparseFunction,
-                 boost::mpl::vector<LinearSparseFunction,
-				    DifferentiableSparseFunction> >
-  ipopt_solver_t;
+  typedef Solver<EigenMatrixSparse> ipopt_solver_t;
 
   template class IpoptSolverCommon<ipopt_solver_t>;
 

src/ipopt-td.cc

@@ -34,10 +34,7 @@
 
 namespace roboptim
 {
-  typedef Solver<TwiceDifferentiableFunction,
-		 boost::mpl::vector<LinearFunction,
-				    TwiceDifferentiableFunction> >
-  solver_ipopt_td_t;
+  typedef Solver<EigenMatrixDense> solver_ipopt_td_t;
 
   template class IpoptSolverCommon<solver_ipopt_td_t>;
 

src/ipopt.cc

@@ -34,9 +34,7 @@
 
 namespace roboptim
 {
-  typedef Solver<DifferentiableFunction,
-		 boost::mpl::vector<LinearFunction, DifferentiableFunction> >
-  ipopt_solver_t;
+  typedef Solver<EigenMatrixDense> ipopt_solver_t;
 
   template class IpoptSolverCommon<ipopt_solver_t>;
 

src/tnlp.cc

@@ -42,7 +42,7 @@ namespace roboptim
     {
       using namespace boost;
 
-      n = static_cast<Index> (solver_.problem ().function ().inputSize ());
+      n = static_cast<Index> (costFunction_->inputSize ());
       m = static_cast<Index> (constraintsOutputSize ());
 
       function_t::vector_t x (n);
@@ -56,18 +56,12 @@ namespace roboptim
 
       // compute number of non zeros elements in jacobian constraint.
       nnz_jac_g = 0;
-      typedef solver_t::problem_t::constraints_t::const_iterator
+      typedef std::vector<differentiableFunctionPtr_t>::const_iterator
 	citer_t;
-      for (citer_t it = solver_.problem ().constraints ().begin ();
-	   it != solver_.problem ().constraints ().end (); ++it)
+      for (citer_t it = differentiableConstraintFunctions_.begin ();
+	   it != differentiableConstraintFunctions_.end (); ++it)
 	{
-	  shared_ptr<solver_t::commonConstraintFunction_t> g;
-	  if (it->which () == LINEAR)
-	    g = get<shared_ptr<linearFunction_t> > (*it);
-	  else
-	    g = get<shared_ptr<nonLinearFunction_t> > (*it);
-
-	  nnz_jac_g += g->jacobian (x).nonZeros ();
+	  nnz_jac_g += (*it)->jacobian (x).nonZeros ();
 	}
 
 
@@ -87,14 +81,14 @@ namespace roboptim
       using namespace boost;
       ROBOPTIM_DEBUG_ONLY
 	(function_t::size_type n_ = static_cast<function_t::size_type> (n));
-      assert (solver_.problem ().function ().inputSize () == n_);
+      assert (costFunction_->inputSize () == n_);
       assert (constraintsOutputSize () == m);
 
       if (!jacobian_)
 	{
-	  jacobian_ = function_t::jacobian_t
-	    (static_cast<function_t::matrix_t::Index> (constraintsOutputSize ()),
-	     solver_.problem ().function ().inputSize ());
+	  jacobian_ = differentiableFunction_t::jacobian_t
+	    (static_cast<differentiableFunction_t::matrix_t::Index> (constraintsOutputSize ()),
+	     costFunction_->inputSize ());
 	  jacobian_->reserve (nele_jac);
 	}
 
@@ -111,15 +105,15 @@ namespace roboptim
 	  // First evaluate the constraints in zero to build the
 	  // constraints jacobian.
 	  int idx = 0;
-	  typedef solver_t::problem_t::constraints_t::const_iterator
+	  typedef std::vector<differentiableFunctionPtr_t>::const_iterator
 	    citer_t;
 	  unsigned constraintId = 0;
 
 	  typedef Eigen::Triplet<double> triplet_t;
 	  std::vector<triplet_t> coefficients;
 
-	  for (citer_t it = solver_.problem ().constraints ().begin ();
-	       it != solver_.problem ().constraints ().end ();
+	  for (citer_t it = differentiableConstraintFunctions_.begin ();
+	       it != differentiableConstraintFunctions_.end ();
 	       ++it, ++constraintId)
 	    {
 	      LOG4CXX_TRACE
@@ -160,23 +154,17 @@ namespace roboptim
 	      else // other use initial guess.
 		x = *(solver_.problem ().startingPoint ());
 
-	      shared_ptr<solver_t::commonConstraintFunction_t> g;
-	      if (it->which () == LINEAR)
-		g = get<shared_ptr<linearFunction_t> > (*it);
-	      else
-		g = get<shared_ptr<nonLinearFunction_t> > (*it);
-
-	      function_t::jacobian_t jacobian = g->jacobian (x);
+	      differentiableFunction_t::jacobian_t jacobian = (*it)->jacobian (x);
 	      for (int k = 0; k < jacobian.outerSize (); ++k)
-		for (function_t::jacobian_t::InnerIterator
+		for (differentiableFunction_t::jacobian_t::InnerIterator
 		       it (jacobian, k); it; ++it)
 		  {
                     const int row = static_cast<int> (idx + it.row ());
                     const int col = static_cast<int> (it.col ());
 		    coefficients.push_back
 		      (triplet_t (row, col, it.value ()));
 		  }
-	      idx += g->outputSize ();
+	      idx += (*it)->outputSize ();
 	    }
 
 	  jacobian_->setFromTriplets
@@ -190,7 +178,7 @@ namespace roboptim
 	  idx = 0;
 
 	  for (int k = 0; k < jacobian_->outerSize (); ++k)
-	    for (function_t::jacobian_t::InnerIterator it (*jacobian_, k);
+	    for (differentiableFunction_t::jacobian_t::InnerIterator it (*jacobian_, k);
 		 it; ++it)
 	      {
 		iRow[idx] = it.row (), jCol[idx] = it.col ();
@@ -208,35 +196,29 @@ namespace roboptim
 
       Eigen::Map<const function_t::vector_t> x_ (x, n);
 
-      typedef solver_t::problem_t::constraints_t::const_iterator
+      typedef std::vector<differentiableFunctionPtr_t>::const_iterator
 	citer_t;
 
       int idx = 0;
       int constraintId = 0;
-      for (citer_t it = solver_.problem ().constraints ().begin ();
-	   it != solver_.problem ().constraints ().end (); ++it)
+      for (citer_t it = differentiableConstraintFunctions_.begin ();
+	   it != differentiableConstraintFunctions_.end (); ++it)
 	{
-	  shared_ptr<solver_t::commonConstraintFunction_t> g;
-	  if (it->which () == LINEAR)
-	    g = get<shared_ptr<linearFunction_t> > (*it);
-	  else
-	    g = get<shared_ptr<nonLinearFunction_t> > (*it);
-
 	  // TODO: use middleRows once Eigen is fixed
 	  // TODO: avoid allocation here (may be solved with
 	  // http://eigen.tuxfamily.org/bz/show_bug.cgi?id=910)
-	  copySparseBlock (*jacobian_, g->jacobian (x_), idx, 0);
-	  idx += g->outputSize ();
+	  copySparseBlock (*jacobian_, (*it)->jacobian (x_), idx, 0);
+	  idx += (*it)->outputSize ();
 
 	  IpoptCheckGradient
-	    (*g, 0, x_,
+	    (*(*it), 0, x_,
 	     constraintId++, solver_);
 	}
 
       // Copy jacobian values from internal sparse matrix.
       idx = 0;
       for (int k = 0; k < jacobian_->outerSize (); ++k)
-	for (function_t::jacobian_t::InnerIterator it (*jacobian_, k);
+	for (differentiableFunction_t::jacobian_t::InnerIterator it (*jacobian_, k);
 	     it; ++it)
 	  {
 	    assert (idx < nele_jac);

src/tnlp.hh

@@ -163,20 +163,56 @@ namespace roboptim
       /// \brief Current state of the solver (used by the callback function).
       solverState_t solverState_;
 
-      /// \brief Cost function type for this problem.
-      typedef typename solver_t::problem_t::function_t function_t;
+      /// \brief Traits of the cost function of this problem
+      typedef typename solver_t::problem_t::function_t::traits_t traits_t;
+
+      /// \brief Function type of this problem
+      typedef GenericFunction<traits_t> function_t;
+
+      /// \brief Differentiable function type of this problem
+      typedef GenericDifferentiableFunction<traits_t> differentiableFunction_t;
+
+      /// \brief Twice Differentiable function type of this problem
+      typedef GenericTwiceDifferentiableFunction<traits_t> twiceDifferentiableFunction_t;
+
+      /// \brief Function pointer type of this problem
+      typedef boost::shared_ptr<const function_t> functionPtr_t;
+
+      /// \brief Differentiable function pointer type of this problem
+      typedef boost::shared_ptr<const differentiableFunction_t> differentiableFunctionPtr_t;
+
+      /// \brief Twice Differentiable function pointer type of this problem
+      typedef boost::shared_ptr<const twiceDifferentiableFunction_t> twiceDifferentiableFunctionPtr_t;
+
+      /// \brief Cost function
+      const function_t* costFunction_;
+
+      /// \brief Differentiable cost function
+      const differentiableFunction_t* differentiableCostFunction_;
+
+      /// \brief Twice Differentiable cost function
+      const twiceDifferentiableFunction_t* twiceDifferentiableCostFunction_;
+
+      /// \brief Constraints
+      std::vector<functionPtr_t> constraintFunctions_;
+
+      /// \brief Differentiable Constraints
+      std::vector<differentiableFunctionPtr_t> differentiableConstraintFunctions_;
+
+      /// \brief Twice Differentiable Constraints
+      std::vector<twiceDifferentiableFunctionPtr_t> twiceDifferentiableConstraintFunctions_;
 
       /// \brief Cost function buffer.
       boost::optional<typename function_t::result_t> cost_;
 
       /// \brief Cost gradient buffer.
-      boost::optional<typename function_t::gradient_t> costGradient_;
+      boost::optional<typename differentiableFunction_t::gradient_t> costGradient_;
 
       /// \brief Constraints buffer.
       boost::optional<typename function_t::result_t> constraints_;
 
       /// \brief Constraints jacobian buffer.
-      boost::optional<typename function_t::matrix_t> jacobian_;
+      boost::optional<typename differentiableFunction_t::matrix_t> jacobian_;
     };
   } // end of namespace detail.
 } // end of namespace roboptim.