robotic 0.2.6__cp38-cp38-manylinux2014_x86_64.whl → 0.2.8.dev0__cp38-cp38-manylinux2014_x86_64.whl

robotic/include/rai/Optim/SlackGaussNewton.h

@@ -0,0 +1,54 @@
+/*  ------------------------------------------------------------------
+    Copyright (c) 2011-2024 Marc Toussaint
+    email: toussaint@tu-berlin.de
+
+    This code is distributed under the MIT License.
+    Please see <root-path>/LICENSE for details.
+    --------------------------------------------------------------  */
+
+#pragma once
+
+#include "options.h"
+#include "NLP.h"
+#include "../Core/util.h"
+
+//===========================================================================
+
+namespace rai {
+
+struct SlackGaussNewton_Options {
+  RAI_PARAM("sam/", double, tolerance, .01)
+  RAI_PARAM("sam/", double, margin, .0)
+  RAI_PARAM("sam/", int, verbose, 2)
+
+  RAI_PARAM("sam/", int, maxEvals, 50)
+  RAI_PARAM("sam/", double, stepMax, .1)
+  RAI_PARAM("sam/", double, damping, 1e-2)
+};
+
+struct SlackGaussNewton {
+  OptOptions opt;
+  std::shared_ptr<NLP> nlp;
+
+  SlackGaussNewton(const shared_ptr<NLP>& _nlp, const arr& x_init={});
+  SlackGaussNewton& setOptions(const OptOptions& _opt) { opt = _opt; return *this; }
+  std::shared_ptr<SolverReturn> solve();
+
+private:
+  arr x;
+  uint evals=0;
+  uint iters=0;
+  double step();
+
+  struct Eval {
+    arr x;
+    arr phi, J;
+    arr err;
+    arr s, Js;
+    void eval(const arr& _x, SlackGaussNewton& walker);
+  } ev;
+};
+
+//===========================================================================
+
+}

robotic/include/rai/Optim/gradient.h

@@ -50,12 +50,12 @@ struct Rprop {
   unique_ptr<struct sRprop> self;
   Rprop();
   ~Rprop();
-  void init(double initialStepSize=1., double minStepSize=1e-6, double maxStepSize=50.);
+  void init(double initialStepSize=1., double minStepSize=1e-6, double stepMaxSize=50.);
   bool step(arr& x, const ScalarFunction& f);
   uint loop(arr& x, const ScalarFunction& f, double stoppingTolerance=1e-2, double initialStepSize=1., uint maxIterations=1000, int verbose=0);
 };
 
 inline uint optRprop(arr& x, const ScalarFunction& f, rai::OptOptions opt=DEFAULT_OPTIONS) {
-  return Rprop().loop(x, f, opt.stopTolerance, opt.initStep, opt.stopEvals, opt.verbose);
+  return Rprop().loop(x, f, opt.stopTolerance, opt.stepInit, opt.stopEvals, opt.verbose);
 }
 

robotic/include/rai/Optim/opt-ipopt.h

@@ -15,6 +15,6 @@ struct IpoptInterface {
 
   IpoptInterface(const shared_ptr<NLP>& P) : P(P) {}
 
-  arr solve(const arr& x_init=NoArr);
+  shared_ptr<SolverReturn> solve(const arr& x_init=NoArr);
 };
 

robotic/include/rai/Optim/options.h

@@ -23,21 +23,22 @@ struct OptOptions {
   RAI_PARAM("opt/", int,    stopInners, 1000)
   RAI_PARAM("opt/", int,    stopOuters, 1000)
   RAI_PARAM("opt/", int,    stopLineSteps, 10)
-  RAI_PARAM("opt/", int,    stopTinySteps, 10)
-  RAI_PARAM("opt/", double, initStep, 1.)
-  RAI_PARAM("opt/", double, minStep, -1.)
-  RAI_PARAM("opt/", double, maxStep, .2)
-  RAI_PARAM("opt/", double, damping, 1.)
+  RAI_PARAM("opt/", int,    stopTinySteps, 4)
+  RAI_PARAM("opt/", double, stepInit, 1.)
+  RAI_PARAM("opt/", double, stepMin, -1.)
+  RAI_PARAM("opt/", double, stepMax, .2)
   RAI_PARAM("opt/", double, stepInc, 1.5)
   RAI_PARAM("opt/", double, stepDec, .5)
+  RAI_PARAM("opt/", double, damping, 1.)
   RAI_PARAM("opt/", double, wolfe, .01)
-  RAI_PARAM("opt/", bool,   boundedNewton, true)
   RAI_PARAM("opt/", double, muInit, 1.)
   RAI_PARAM("opt/", double, muInc, 5.)
   RAI_PARAM("opt/", double, muMax, 1e4)
   RAI_PARAM("opt/", double, muLBInit, .1)
   RAI_PARAM("opt/", double, muLBDec, .2)
-  RAI_PARAM("opt/", double, maxLambda, -1.)
+  RAI_PARAM("opt/", double, lambdaMax, -1.)
+  RAI_PARAM("opt/", double, interiorPadding, 1e-2)
+  RAI_PARAM("opt/", bool,   boundedNewton, true)
   RAI_PARAM_ENUM("opt/", ConstrainedMethodType, constrainedMethod, augmentedLag)
 //  void write(std::ostream& os) const;
 };

robotic/include/rai/Optim/{benchmarks.h → testProblems_Opt.h}

@@ -83,24 +83,19 @@ struct NLP_RandomLP : NLP {
 
 //===========================================================================
 
-struct ChoiceConstraintFunction : NLP {
-  enum WhichConstraint { none=0, wedge2D=1, halfcircle2D, randomLinear, circleLine2D, boundConstrained, boundConstrainedIneq } which;
-  uint n;
-  arr randomG;
-  ChoiceConstraintFunction();
+struct BoxNLP : NLP {
+  BoxNLP();
+  void evaluate(arr& phi, arr& J, const arr& x);
+};
+
+//===========================================================================
 
+struct ModesNLP : NLP {
+  arr cen;
+  arr radii;
+
+  ModesNLP();
   void evaluate(arr& phi, arr& J, const arr& x);
-  void getFHessian(arr& H, const arr& x);
-//  virtual uint dim_g(){
-//    if(which==randomLinear) return ;
-//    if(which==wedge2D) return n;
-//    if(which==circleLine2D) return 1;
-//    return 2;
-//  }
-//  virtual uint dim_h(){
-//    if(which==circleLine2D) return 1;
-//    return 0;
-//  }
 };
 
 //===========================================================================
@@ -210,3 +205,25 @@ struct NLP_CircleLine : NLP {
   }
 };
 
+//===========================================================================
+
+struct ChoiceConstraintFunction : NLP {
+  enum WhichConstraint { none=0, wedge2D=1, halfcircle2D, randomLinear, circleLine2D, boundConstrained, boundConstrainedIneq } which;
+  uint n;
+  arr randomG;
+  ChoiceConstraintFunction();
+
+  void evaluate(arr& phi, arr& J, const arr& x);
+  void getFHessian(arr& H, const arr& x);
+  //  virtual uint dim_g(){
+  //    if(which==randomLinear) return ;
+  //    if(which==wedge2D) return n;
+  //    if(which==circleLine2D) return 1;
+  //    return 2;
+  //  }
+  //  virtual uint dim_h(){
+  //    if(which==circleLine2D) return 1;
+  //    return 0;
+  //  }
+};
+