robotic 0.2.8.dev4__cp311-cp311-manylinux2014_x86_64.whl → 0.3.4.dev5__cp311-cp311-manylinux2014_x86_64.whl

robotic/include/rai/Optim/NLP.h

@@ -32,7 +32,7 @@ extern ObjectiveTypeA& NoObjectiveTypeA;
  *
  *  Importantly: the Jacobian may be sparse! This allows to implicitly represent structured NLP (in contrast to explicit structure, see below)
  */
-struct NLP : NonCopyable {
+struct NLP : rai::NonCopyable {
   //-- problem signature: needs to be defined in the constructor or a derived class
   uint dimension=0;
   ObjectiveTypeA featureTypes;
@@ -62,7 +62,8 @@ struct NLP : NonCopyable {
 
   //-- utilities
   shared_ptr<NLP> ptr() { return shared_ptr<NLP>(this, [](NLP*) {}); }
-  double eval_scalar(arr& g, arr& H, const arr& x);
+  virtual double eval_scalar(arr& g, arr& H, const arr& x);
+  ScalarFunction f_scalar(){ return [this](arr& g, arr& H, const arr& x){ return this->eval_scalar(g, H, x); }; }
   bool checkJacobian(const arr& x, double tolerance, const StringA& featureNames= {});
   bool checkHessian(const arr& x, double tolerance);
   bool checkBounds(bool strictlyLarger);
@@ -74,10 +75,25 @@ struct NLP : NonCopyable {
     return d;
   }
   arr summarizeErrors(const arr& phi);
+
+  shared_ptr<rai::NonCopyable> obj;
 };
 
 //===========================================================================
 
+struct NLP_Scalar : NLP {
+  arr x, H_x;
+  NLP_Scalar() { featureTypes.resize(1) = OT_f; }
+  virtual double f(arr& g, arr& H, const arr& x) = 0;
+  void evaluate(arr& phi, arr& J, const arr& _x){
+    x = _x;
+    double f_x = f(J, H_x, x);
+    phi.resize(1) = f_x;
+    if(!!J) J.reshape(1, x.N);
+  }
+  void getFHessian(arr& H, const arr& _x) {  CHECK_EQ(_x, x, "");  H = H_x;  }
+};
+
 struct NLP_Factored : NLP {
   //-- problem factorization: needs to be defined in the constructor or a derived class
   uintA variableDimensions; //the size of each variable block
@@ -169,7 +185,7 @@ struct SolverReturn {
   uint evals=0;
   double time=0.;
   bool feasible=false;
-  double sos=-1., f=-1., ineq=-1., eq=-1.;
+  double sos=0., f=0., ineq=0., eq=0.;
   bool done=false;
   void write(ostream& os) const;
 };
@@ -178,11 +194,11 @@ stdOutPipe(SolverReturn)
 //===========================================================================
 // TRIVIAL only header
 
-struct Conv_NLP_TrivialFactoreded : NLP_Factored {
+struct Conv_NLP2TrivialFactoredNLP : NLP_Factored {
   shared_ptr<NLP> P;
   arr x_buffer;
 
-  Conv_NLP_TrivialFactoreded(const shared_ptr<NLP>& P) : P(P) {
+  Conv_NLP2TrivialFactoredNLP(const shared_ptr<NLP>& P) : P(P) {
     copySignature(*P);
     variableDimensions = { dimension };
     featureDimensions = { featureTypes.N };
@@ -197,7 +213,7 @@ struct Conv_NLP_TrivialFactoreded : NLP_Factored {
 
 //===========================================================================
 
-struct Conv_FactoredNLP_BandedNLP : NLP {
+struct Conv_FactoredNLP2BandedNLP : NLP {
   shared_ptr<NLP_Factored> P;
   uint maxBandSize;
   bool sparseNotBanded;
@@ -205,7 +221,7 @@ struct Conv_FactoredNLP_BandedNLP : NLP {
   //buffers
   arrA J_i;
 
-  Conv_FactoredNLP_BandedNLP(const shared_ptr<NLP_Factored>& P, uint _maxBandSize, bool _sparseNotBanded=false);
+  Conv_FactoredNLP2BandedNLP(const shared_ptr<NLP_Factored>& P, uint _maxBandSize, bool _sparseNotBanded=false);
 
   // trivial
   virtual arr  getInitializationSample() { return P->getInitializationSample(); }

robotic/include/rai/Optim/NLP_GraphSolver.h

@@ -10,7 +10,7 @@
 
 #include "NLP_Solver.h"
 
-struct NLP_GraphSolver : NonCopyable {
+struct NLP_GraphSolver : rai::NonCopyable {
   rai::NLP_Solver subSolver;
   arr x, dual;
   std::shared_ptr<NLP_Factored> P;

robotic/include/rai/Optim/NLP_Solver.h

@@ -19,17 +19,17 @@ struct ConstrainedSolver;
 /** User Interface: Meta class to call several different solvers in a unified manner. */
 struct NLP_Solver : NonCopyable {
   arr x, dual; //owner of decision variables, which are passed by reference to lower level solvers
-  rai::OptOptions opt; //owner of options, which are passed by reference to lower level solvers
+  std::shared_ptr<OptOptions> opt; //owner of options, which are passed by reference to lower level solvers
   std::shared_ptr<SolverReturn> ret;
   std::shared_ptr<ConstrainedSolver> optCon;
   std::shared_ptr<NLP_Traced> P;
 
   NLP_Solver();
-  NLP_Solver(const shared_ptr<NLP>& _P, int verbose=-100) { setProblem(_P); if(verbose>-100) opt.verbose=verbose; }
+  NLP_Solver(const shared_ptr<NLP>& _P, int verbose=-100) : NLP_Solver() { setProblem(_P); if(verbose>-100) opt->verbose=verbose; }
 
-  NLP_Solver& setSolver(OptMethod _method) { opt.method=_method; return *this; }
+  NLP_Solver& setSolver(OptMethod _method) { opt->method=_method; return *this; }
   NLP_Solver& setProblem(const shared_ptr<NLP>& _P);
-  NLP_Solver& setOptions(const rai::OptOptions& _opt) { opt = _opt; return *this; }
+  NLP_Solver& setOptions(const rai::OptOptions& _opt) { *opt = _opt; return *this; }
   NLP_Solver& setInitialization(const arr& _x) { x=_x; return *this; }
   NLP_Solver& setWarmstart(const arr& _x, const arr& _dual) { x=_x; dual=_dual; return *this; }
   NLP_Solver& setTracing(bool trace_x, bool trace_costs, bool trace_phi, bool trace_J) { P->setTracing(trace_x, trace_costs, trace_phi, trace_J); return *this; }
@@ -48,7 +48,7 @@ struct NLP_Solver : NonCopyable {
   arr getTrace_evals();
   rai::Graph reportLagrangeGradients(const StringA& featureNames);
   void gnuplot_costs() {
-    FILE("z.opt.trace") <<getTrace_costs();
+    FILE("z.opt.trace") <<getTrace_costs().modRaw();
     gnuplot("plot 'z.opt.trace' us 0:1 t 'f', '' us 0:2 t 'sos', '' us 0:3 t 'ineq', '' us 0:4 t 'eq'");
   }
 };

robotic/include/rai/Optim/constrained.h

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "lagrangian.h"
-#include "newton.h"
+#include "m_Newton.h"
 
 namespace rai {
 
@@ -24,12 +24,12 @@ struct ConstrainedSolver {
   LagrangianProblem L;
   OptNewton newton;
   arr& dual;
-  rai::OptOptions opt;
+  shared_ptr<OptOptions> opt;
   int outer_iters=0, numBadSteps=0;
 
-  ConstrainedSolver(arr& x, arr& dual, const shared_ptr<NLP>& P, const rai::OptOptions& opt=DEFAULT_OPTIONS);
+  ConstrainedSolver(arr& x, arr& dual, const shared_ptr<NLP>& P, shared_ptr<OptOptions> _opt=make_shared<OptOptions>());
 
-  uint run();
+  std::shared_ptr<SolverReturn> run();
   bool ministep();
 //  void reinit();
  private:

robotic/include/rai/Optim/{opt-ceres.h → i_Ceres.h}

@@ -27,12 +27,12 @@ struct CeresInterface {
 
 //===========================================================================
 
-struct Conv_NLP_CeresProblem {
+struct Conv_NLP2Ceres {
   shared_ptr<NLP_Factored> P;
 
   arr x_full, phi_full; //the full linear memory for all decision variables and all features
 
   shared_ptr<ceres::Problem> ceresProblem;
 
-  Conv_NLP_CeresProblem(const shared_ptr<NLP_Factored>& _P);
+  Conv_NLP2Ceres(const shared_ptr<NLP_Factored>& _P);
 };

robotic/include/rai/Optim/{opt-nlopt.h → i_NLopt.h}

@@ -10,6 +10,8 @@
 
 #include "NLP.h"
 
+namespace rai {
+
 struct NLoptInterface {
   shared_ptr<NLP> P;
   arr x, phi_x, J_x;
@@ -28,3 +30,5 @@ struct NLoptInterface {
   static double _g(const std::vector<double>& _x, std::vector<double>& _grad, void* f_data);
   static double _h(const std::vector<double>& _x, std::vector<double>& _grad, void* f_data);
 };
+
+} //namespace

robotic/include/rai/Optim/lagrangian.h

@@ -21,8 +21,9 @@ namespace rai {
 // that can include lagrange terms, penalties, log barriers, and augmented lagrangian terms
 //
 
-struct LagrangianProblem : ScalarFunction, NLP {
+struct LagrangianProblem : NLP {
   shared_ptr<NLP> P;
+  shared_ptr<OptOptions> opt;
 
   //-- parameters of the inner problem (Lagrangian, unconstrained problem)
   double muLB;       ///< log barrier mu
@@ -34,19 +35,20 @@ struct LagrangianProblem : ScalarFunction, NLP {
   arr x;               ///< point where P was last evaluated
   arr phi_x, J_x, H_x; ///< features at x
 
-  LagrangianProblem(const shared_ptr<NLP>& P, const rai::OptOptions& opt);
+  LagrangianProblem(const shared_ptr<NLP>& P, std::shared_ptr<OptOptions> _opt, double muSquaredPenalty=-1., double muLogBarrier=-1.);
 
   virtual void evaluate(arr& phi, arr& J, const arr& x);       //evaluate all features and (optionally) their Jacobians for state x
   virtual void getFHessian(arr& H, const arr& x);              //the Hessian of the sum of all f-features (or Hessian in addition to the Gauss-Newton Hessian of all other features)
   virtual arr  getInitializationSample() { return P->getInitializationSample(); }
+  virtual void report(ostream &os, int verbose, const char *msg){ P->report(os, verbose, msg); }
 
-  double lagrangian(arr& dL, arr& HL, const arr& x); ///< CORE METHOD: the unconstrained scalar function F
+  virtual double eval_scalar(arr& dL, arr& HL, const arr& x); ///< CORE METHOD: the unconstrained scalar function F
 
   rai::Graph reportGradients(const StringA& featureNames);
   void reportMatrix(std::ostream& os);
 
-  void aulaUpdate(const rai::OptOptions& opt, bool anyTimeVariant, double lambdaStepsize=1., double* L_x=nullptr, arr& dL_x=NoArr, arr& HL_x=NoArr);
-  void autoUpdate(const rai::OptOptions& opt, double* L_x=nullptr, arr& dL_x=NoArr, arr& HL_x=NoArr);
+  void aulaUpdate(bool anyTimeVariant, double lambdaStepsize=1., double* L_x=nullptr, arr& dL_x=NoArr, arr& HL_x=NoArr);
+  void autoUpdate(double* L_x=nullptr, arr& dL_x=NoArr, arr& HL_x=NoArr);
 
   //private: used gpenalty function
   double gpenalty(double g);