robotic 0.3.4__cp38-cp38-manylinux2014_x86_64.whl → 0.3.4.dev2__cp38-cp38-manylinux2014_x86_64.whl

robotic/include/rai/Geo/pairCollision.h

@@ -13,43 +13,18 @@
 
 namespace rai {
 
-/* A class to represent a basic function: distance between two convex (decomposed) meshes
- * The constructor compute the collision geometry, the other methods are mostly readouts
- * The default is distance between two convex meshes
- * Also distance between point (=mesh1) and points (=mesh2)
- * Also distance between point (=mesh1) and decomposed mesh (=mesh2)
- */
-struct PairCollision : NonCopyable {
+struct PairCollision {
   //INPUTS
-  arr mesh1;
-  arr mesh2;
-  const rai::Transformation* t1=0;
-  const rai::Transformation* t2=0;
   double rad1=0., rad2=0.; ///< only kinVector and glDraw account for this; the basic collision geometry (OUTPUTS below) is computed neglecting radii!!
 
   //OUTPUTS
   double distance=0.; ///< negative=penetration
-  arr p1, p2;      ///< witness points on the shapes
-  arr normal;      ///< normal such that "<normal, p1-p2> = distance" is guaranteed (pointing from obj2 to obj1)
-  arr simplex1;    ///< simplex on obj1 defining the collision geometry
-  arr simplex2;    ///< simplex on obj2 defining the collision geometry
-
-//  arr m1, m2, eig1, eig2; ///< output of marginAnalysis: mean and eigenvalues of ALL point on the objs (not only simplex) that define the collision
-
-  arr poly, polyNorm;
-
-  //mesh-to-mesh
-  PairCollision(const arr& mesh1, const arr& mesh2,
-                const rai::Transformation& t1, const rai::Transformation& t2,
-                double rad1=0., double rad2=0.);
-  //sdf-to-sdf
-  PairCollision(ScalarFunction& func1, ScalarFunction& func2, const arr& seed);
-
-  ~PairCollision() {}
-
-  void write(std::ostream& os) const;
+  arr p1, p2;         ///< witness points on the shapes
+  arr normal;         ///< normal such that "<normal, p1-p2> = distance" is guaranteed (pointing from obj2 to obj1)
+  arr simp1, simp2;   ///< simplices on the shapes defining the collision geometry
 
   double getDistance() { return distance-rad1-rad2; }
+  void write(std::ostream& os) const;
 
   // differentiable readout methods (Jp1 and Jx1 are linear and angular Jacobians of mesh1)
   void kinDistance(arr& y, arr& J, const arr& Jp1, const arr& Jp2);
@@ -59,23 +34,52 @@ struct PairCollision : NonCopyable {
   void kinPointP2(arr& y, arr& J, const arr& Jp1, const arr& Jp2, const arr& Jx1, const arr& Jx2);
   void kinCenter(arr& y, arr& J, const arr& Jp1, const arr& Jp2, const arr& Jx1, const arr& Jx2);
 
-  void nearSupportAnalysis(double eps=1e-6); ///< analyses not only closest obj support (the simplex) but all points within a margin
+protected:
+  bool simplexType(uint i, uint j) { return simp1.d0==i && simp2.d0==j; } //helper
+};
+
+//===========================================================================
+
+/* A class to represent a basic function: distance between two convex (decomposed) meshes
+ * The constructor compute the collision geometry, the other methods are mostly readouts
+ * The default is distance between two convex meshes
+ * Also distance between point (=mesh1) and points (=mesh2)
+ * Also distance between point (=mesh1) and decomposed mesh (=mesh2)
+ */
+struct PairCollision_CvxCvx : PairCollision, NonCopyable {
 
- private:
+  //mesh-to-mesh
+  PairCollision_CvxCvx(const arr& pts1, const arr& pts2,
+                    const rai::Transformation& t1, const rai::Transformation& t2,
+                    double rad1=0., double rad2=0.);
+  //sdf-to-sdf -- TODO: own class!
+  PairCollision_CvxCvx(ScalarFunction func1, ScalarFunction func2, const arr& seed);
+
+
+  // void nearSupportAnalysis(double eps=1e-6); ///< analyses not only closest obj support (the simplex) but all points within a margin
+
+private:
   //wrappers of external libs
   enum CCDmethod { _ccdGJKIntersect,  _ccdGJKSeparate, _ccdGJKPenetration, _ccdMPRIntersect, _ccdMPRPenetration };
   void libccd(const arr& m1, const arr& m2, CCDmethod method); //calls ccdMPRPenetration of libccd
-  void GJK_sqrDistance(); //gjk_distance of libGJK
-  bool simplexType(uint i, uint j) { return simplex1.d0==i && simplex2.d0==j; } //helper
+  void GJK_sqrDistance(const arr& pts1, const arr& pts2, const rai::Transformation& t1, const rai::Transformation& t2); //gjk_distance of libGJK
+};
+
+//===========================================================================
+
+struct PairCollision_CvxDecomp : PairCollision, NonCopyable {
+  PairCollision_CvxDecomp(const arr& x, Mesh& mesh,
+                         const rai::Transformation& t1, const rai::Transformation& t2,
+                         double rad1=0., double rad2=0.);
 };
 
 //===========================================================================
 
-struct PclCollision {
+struct PairCollision_PtPcl {
   //OUTPUTS
   arr y, J;
 
-  PclCollision(const arr& x, ANN& ann,
+  PairCollision_PtPcl(const arr& x, ANN& ann,
                const rai::Transformation& t1, const arr& Jp1, const arr& Jx1,
                const rai::Transformation& t2, const arr& Jp2, const arr& Jx2,
                double rad1=0., double rad2=0.,

robotic/include/rai/Geo/signedDistanceFunctions.h

@@ -16,15 +16,17 @@
 // analytic distance functions
 //
 
-struct SDF : ScalarFunction {
+struct SDF {
   SDF(const rai::Transformation& _pose)
-    : pose(_pose) {}
+      : pose(_pose) {}
   ~SDF() {}
   rai::Transformation pose;
   arr lo, up;
   virtual double f(arr& g, arr& H, const arr& x);
   virtual double f_raw(arr& g, arr& H, const arr& x) { NIY; }
 
+  ScalarFunction f_scalar(){ return [this](arr& g, arr& H, const arr& x){ return this->f(g, H, x); }; }
+
   arr eval(const arr& samples);
   floatA evalFloat(const arr& samples);
   floatA evalGrid(uint d0, int d1=-1, int d2=-1);
@@ -108,7 +110,7 @@ struct DensityDisplayData {
 
 struct TensorShape : SDF {
   floatA gridData;
-  shared_ptr<DensityDisplayData> _densityDisplayData;
+  // shared_ptr<DensityDisplayData> _densityDisplayData;
   arr color;
 
   TensorShape(const rai::Transformation& _pose, const floatA& _data, const arr& _lo, const arr& _up)
@@ -157,4 +159,4 @@ struct PCL2Field {
 
 //===========================================================================
 
-shared_ptr<ScalarFunction> DistanceFunction_SSBox();
+ScalarFunction DistanceFunction_SSBox();

robotic/include/rai/KOMO/komo.h

@@ -165,7 +165,7 @@ struct KOMO : rai::NonCopyable {
   void updateAndShiftPrefix(const rai::Configuration& C);
 
   //-- calling a solver
-  std::shared_ptr<SolverReturn> solve(double addInitializationNoise=.01, int splineKnots=-1, const rai::OptOptions& options=DEFAULT_OPTIONS);  ///< run the solver (same as run_prepare(); run(); )
+  std::shared_ptr<SolverReturn> solve(double addInitializationNoise=.01, int splineKnots=-1, const rai::OptOptions& options=*DEFAULT_OPTIONS);  ///< run the solver (same as run_prepare(); run(); )
   void reset();                          ///< reset the dual variables and feature value buffers (always needed when adding/changing objectives before continuing an optimization)
 
   //advanced

robotic/include/rai/Kin/dof_forceExchange.h

@@ -13,7 +13,7 @@
 
 namespace rai {
 
-struct PairCollision;
+struct PairCollision_CvxCvx;
 
 //===========================================================================
 
@@ -26,7 +26,7 @@ struct ForceExchangeDof : Dof, NonCopyable {
   double scale=1.;
   double force_to_torque = 0.;
  private:
-  PairCollision* __coll=0;
+  PairCollision_CvxCvx* __coll=0;
  public:
 
   arr poa; //in world coordinates!
@@ -50,7 +50,7 @@ struct ForceExchangeDof : Dof, NonCopyable {
   virtual void kinForce(arr& y, arr& J) const;
   virtual void kinTorque(arr& y, arr& J) const;
 
-  PairCollision* coll();
+  PairCollision_CvxCvx* coll();
 
   virtual void write(ostream& os) const;
 };

robotic/include/rai/Kin/feature.h

@@ -49,7 +49,7 @@ struct Feature {
 //  Value eval(const FrameL& F) { arr y, J; eval(y, J, F); return Value(y, J); }
   arr eval(const rai::Configuration& C) { return eval(getFrames(C)); }
   uint dim(const FrameL& F) { uint d=dim_phi(F); return applyLinearTrans_dim(d); }
-  fct asFct(const FrameL& F);
+  VectorFunction asFct(const FrameL& F);
 
   virtual const char* typeString() { return rai::niceTypeidName(typeid(*this)); }
   virtual rai::String shortTag(const rai::Configuration& C);

robotic/include/rai/Kin/frame.h

@@ -97,7 +97,7 @@ struct Frame : NonCopyable {
 
   //attachments to the frame
   Joint* joint=nullptr;          ///< this frame is an articulated joint
-  Shape* shape=nullptr;          ///< this frame has a (collision or visual) geometry
+  shared_ptr<Shape> shape;       ///< this frame has a (collision or visual) geometry
   Inertia* inertia=nullptr;      ///< this frame has inertia (is a mass)
   //TODO have a single list of all attached dofs (also joint)
   Array<ForceExchangeDof*> forces;  ///< this frame exchanges forces with other frames
@@ -329,12 +329,12 @@ stdOutPipe(Inertia)
 
 /// a Frame with Shape is a collision or visual object
 struct Shape : NonCopyable {
-  Frame& frame;
-  Enum<ShapeType> _type;
+  Enum<ShapeType> _type = ST_none;
   arr size;
   shared_ptr<Mesh> _mesh;
   shared_ptr<arr> _sscCore;
   double coll_cvxRadius=-1.;
+  int version = 0;
   shared_ptr<SDF> _sdf;
   char cont=0;           ///< are contacts registered (or filtered in the callback)
 
@@ -345,17 +345,14 @@ struct Shape : NonCopyable {
   SDF& sdf() { if(!_sdf) { if(_type==ST_none) _type=ST_sdf; _sdf = make_shared<TensorShape>(); } return *_sdf; }
   double alpha() { arr& C=mesh().C; if(C.N==4 || C.N==2 || (C.nd==2 && C.d1==4)) return C.elem(-1); return 1.; }
 
-  void createMeshes();
-  shared_ptr<ScalarFunction> functional(bool worldCoordinates=true);
-
-  Shape(Frame& f, const Shape* copyShape=nullptr); //new Shape, being added to graph and frame's shape lists
-  virtual ~Shape();
+  void createMeshes(const str& name);
+  shared_ptr<SDF> functional(const rai::Transformation& pose=0);
 
-  bool canCollideWith(const Frame* f) const;
+  bool canCollide(const rai::Frame* f1, const Frame* f2) const;
 
-  void read(const Graph& ats);
-  void write(std::ostream& os) const;
-  void write(Graph& g);
+  void read(Frame& frame);
+  void write(std::ostream& os, const Frame& frame) const;
+  void write(Graph& g, const Frame& frame);
 };
 
 //===========================================================================

robotic/include/rai/Kin/proxy.h

@@ -1,4 +1,4 @@
-/*  ------------------------------------------------------------------
+/*  -------------
     Copyright (c) 2011-2024 Marc Toussaint
     email: toussaint@tu-berlin.de
 

robotic/include/rai/Optim/BayesOpt.h

@@ -11,30 +11,35 @@
 #include "GlobalIterativeNewton.h"
 #include "../Core/array.h"
 
+struct KernelRidgeRegression;
+struct DefaultKernelFunction;
+
+namespace rai {
+
 struct BayesOpt {
-  ScalarFunction& f;
+  ScalarFunction f;
   arr bounds;
 
   arr data_X;
   arr data_y;
 
-  struct KernelRidgeRegression* f_now;
-  struct KernelRidgeRegression* f_smaller;
+  KernelRidgeRegression* f_now;
+  KernelRidgeRegression* f_smaller;
 
   GlobalIterativeNewton alphaMinima_now;
   GlobalIterativeNewton alphaMinima_smaller;
 
-  struct DefaultKernelFunction* kernel_now;
-  struct DefaultKernelFunction* kernel_smaller;
+  DefaultKernelFunction* kernel_now;
+  DefaultKernelFunction* kernel_smaller;
   double lengthScale;
 
   //lengthScale is always relative to hi-lo
-  BayesOpt(ScalarFunction& f, const arr& bounds, rai::OptOptions& opt, double init_lengthScale=1., double prior_var=1.);
+  BayesOpt(ScalarFunction f, const arr& bounds, shared_ptr<OptOptions> opt, double init_lengthScale=1., double prior_var=1.);
   ~BayesOpt();
 
   void step();
   void run(uint maxIt=10);
-  void report(bool display, ScalarFunction& f);
+  void report(bool display, ScalarFunction f);
 
  private:
   void addDataPoint(const arr& x, double y); //and update the regressions
@@ -42,3 +47,5 @@ struct BayesOpt {
   arr pickNextPoint();
   void reduceLengthScale();
 };
+
+} //namespace

robotic/include/rai/Optim/CMA/boundary_transformation.h

@@ -0,0 +1,73 @@
+/*
+ * INTERFACE: the relevant functions are
+ *
+ * * cmaes_boundary_transformation_init(this, l_bound, u_bound, len)
+ * * cmaes_boundary_transformation_exit(this)
+ * * cmaes_boundary_transformation(this, x, y, len)
+ *
+ * implements a smooth mapping double *x -> double *y that guarantees
+ * elements of y to be within specified boundaries. The mapping is piecewise
+ * either linear or quadratic and can achieve values arbitrarily close to and
+ * on the boundaries. The middle of the domain l_bound + (u_bound-l_bound) / 2.0
+ * always maps to itself. Typically, 90% of feasible values (those not close 
+ * to the boundaries) are mapped to themselves, preventing any numerical subtleties. 
+ * Specifically, al, au > 0 are internally chosen offsets. The mapping
+ * [l_bound - al, u_bound + au] <-> [l_bound, u_bound] is monotonous, bijective
+ * and invertible. It is the identity within [l_bound + al, u_bound - au] and 
+ * quadratic for [l_bound - 3*al, l_bound + al] (with l_bound - al -> l_bound)
+ * and for [u_bound - au, u_bound + 3*au] (with u_bound + au -> u_bound).
+ *
+ * The method is robust against very small/large boundary values, say
+ * -1e99 and/or 1e99, to emulated unbounded variables. In this case values
+ * between -1e98 and 1e98 are never changed, i.e. mapped to itself.
+ *
+ */
+
+typedef struct {
+	double const *lower_bounds; /* array of size len_of_bounds */
+	double const *upper_bounds; /* array of size len_of_bounds */
+	unsigned long len_of_bounds; /* in case, last value is recycled */
+	double *al; /* "add"-on to lower boundary preimage, same length as bounds */
+	double *au; /* add-on to upper boundary preimage, same length as bounds */
+} cmaes_boundary_transformation_t;
+
+/* set lower and upper bounds, the values lower_bounds[len_of_bounds - 1] and
+ * upper_bounds[len_of_bounds - 1] are recycled for any element >= len_of_bounds.
+ * If len_of_bounds == 0, no bounds are assumed. If len_of_bounds == 1, the
+ * zero pointer is allowed for lower_bounds or upper_bounds and indicates no
+ * respective bounds. "no bounds" is "emulated" using the very small/large value
+ * of DBL_MAX / -1e2 and DBL_MAX / 1e2, respectively. */
+void cmaes_boundary_transformation_init(cmaes_boundary_transformation_t *,
+		double const *lower_bounds, double const *upper_bounds, unsigned long len_of_bounds);
+
+/* release memory */
+void cmaes_boundary_transformation_exit(cmaes_boundary_transformation_t *);
+
+/* on return, y is guaranteed to have all values within the boundaries.
+ * The caller inputs x and is responsible for having allocated y in that
+ * y[len-1] = x[len-1] is a valid operation.  x==y is valid input, but
+ * will fail together with cmaes when x is an element of the population
+ * returned by cmaes_SamplePopulation (these elements are of type
+ * double const * for a reason).
+ * */
+void cmaes_boundary_transformation(cmaes_boundary_transformation_t *,
+		double const *x, double *y, unsigned long len); /* new value into y */
+
+/* after
+ *   cmaes_boundary_transformation(b,x,y,l) ;
+ * the two consecutive calls
+ *   cmaes_boundary_transformation_inverse(b,y,x,l) ; cmaes_boundary_transformation(b,x,y,l) ;
+ * have no effect on y anymore (but they might change x!).
+ * */
+void cmaes_boundary_transformation_inverse(cmaes_boundary_transformation_t *t,
+		double const *y, double *x, unsigned long len); /* new value into x */
+
+/* used by function cmaes_boundary_transformation. After applying the shift,
+ *   cmaes_boundary_transformation_shift_into_feasible_preimage(b,x,x,l)
+ * the two consecutive calls
+ *   cmaes_boundary_transformation(b,x,y,l) ; cmaes_boundary_transformation_inverse(b,y,x,l) ;
+ * have no effect on x anymore */
+void cmaes_boundary_transformation_shift_into_feasible_preimage(cmaes_boundary_transformation_t *t,
+		double const *x, double *x_shifted, unsigned long len); /* new value into x_shifted */
+
+

robotic/include/rai/Optim/CMA/cmaes.h

@@ -0,0 +1,175 @@
+/* --------------------------------------------------------- */
+/* --- File: cmaes.h ----------- Author: Nikolaus Hansen --- */
+/* ---------------------- last modified: IX 2010         --- */
+/* --------------------------------- by: Nikolaus Hansen --- */
+/* --------------------------------------------------------- */
+/*   
+     CMA-ES for non-linear function minimization. 
+
+     Copyright (C) 1996, 2003-2010  Nikolaus Hansen. 
+     e-mail: nikolaus.hansen (you know what) inria.fr
+      
+     License: see file cmaes.c
+   
+*/
+#ifndef NH_cmaes_h /* only include ones */ 
+#define NH_cmaes_h 
+
+#include <time.h>
+
+typedef struct 
+/* cmaes_random_t 
+ * sets up a pseudo random number generator instance 
+ */
+{
+  /* Variables for Uniform() */
+  long int startseed;
+  long int aktseed;
+  long int aktrand;
+  long int *rgrand;
+  
+  /* Variables for Gauss() */
+  short flgstored;
+  double hold;
+} cmaes_random_t;
+
+typedef struct 
+/* cmaes_timings_t 
+ * time measurement, used to time eigendecomposition 
+ */
+{
+  /* for outside use */
+  double totaltime; /* zeroed by calling re-calling cmaes_timings_start */
+  double totaltotaltime;
+  double tictoctime; 
+  double lasttictoctime;
+  
+  /* local fields */
+  clock_t lastclock;
+  time_t lasttime;
+  clock_t ticclock;
+  time_t tictime;
+  short istic;
+  short isstarted; 
+
+  double lastdiff;
+  double tictoczwischensumme;
+} cmaes_timings_t;
+
+typedef struct 
+/* cmaes_readpara_t
+ * collects all parameters, in particular those that are read from 
+ * a file before to start. This should split in future? 
+ */
+{
+  char * filename;  /* keep record of the file that was taken to read parameters */
+  short flgsupplemented; 
+  
+  /* input parameters */
+  int N; /* problem dimension, must stay constant, should be unsigned or long? */
+  unsigned int seed; 
+  double * xstart; 
+  double * typicalX; 
+  int typicalXcase;
+  double * rgInitialStds;
+  double * rgDiffMinChange; 
+
+  /* termination parameters */
+  double stopMaxFunEvals; 
+  double facmaxeval;
+  double stopMaxIter; 
+  struct { int flg; double val; } stStopFitness; 
+  double stopTolFun;
+  double stopTolFunHist;
+  double stopTolX;
+  double stopTolUpXFactor;
+
+  /* internal evolution strategy parameters */
+  int lambda;          /* -> mu, <- N */
+  int mu;              /* -> weights, (lambda) */
+  double mucov, mueff; /* <- weights */
+  double *weights;     /* <- mu, -> mueff, mucov, ccov */
+  double damps;        /* <- cs, maxeval, lambda */
+  double cs;           /* -> damps, <- N */
+  double ccumcov;      /* <- N */
+  double ccov;         /* <- mucov, <- N */
+  double diagonalCov;  /* number of initial iterations */
+  struct { int flgalways; double modulo; double maxtime; } updateCmode;
+  double facupdateCmode;
+
+  /* supplementary variables */
+
+  char *weigkey; 
+  char resumefile[99];
+  const char **rgsformat;
+  void **rgpadr;
+  const char **rgskeyar;
+  double ***rgp2adr;
+  int n1para, n1outpara;
+  int n2para;
+} cmaes_readpara_t;
+
+typedef struct 
+/* cmaes_t 
+ * CMA-ES "object" 
+ */
+{
+  const char *version;
+  /* char *signalsFilename; */
+  cmaes_readpara_t sp;
+  cmaes_random_t rand; /* random number generator */
+
+  double sigma;  /* step size */
+
+  double *rgxmean;  /* mean x vector, "parent" */
+  double *rgxbestever; 
+  double **rgrgx;   /* range of x-vectors, lambda offspring */
+  int *index;       /* sorting index of sample pop. */
+  double *arFuncValueHist;
+
+  short flgIniphase; /* not really in use anymore */
+  short flgStop; 
+
+  double chiN; 
+  double **C;  /* lower triangular matrix: i>=j for C[i][j] */
+  double **B;  /* matrix with normalize eigenvectors in columns */
+  double *rgD; /* axis lengths */
+
+  double *rgpc;
+  double *rgps;
+  double *rgxold; 
+  double *rgout; 
+  double *rgBDz;   /* for B*D*z */
+  double *rgdTmp;  /* temporary (random) vector used in different places */
+  double *rgFuncValue; 
+  double *publicFitness; /* returned by cmaes_init() */
+
+  double gen; /* Generation number */
+  double countevals;
+  double state; /* 1 == sampled, 2 == not in use anymore, 3 == updated */
+
+  double maxdiagC; /* repeatedly used for output */
+  double mindiagC;
+  double maxEW;
+  double minEW;
+
+  char sOutString[330]; /* 4x80 */
+
+  short flgEigensysIsUptodate;
+  short flgCheckEigen; /* control via cmaes_signals.par */
+  double genOfEigensysUpdate; 
+  cmaes_timings_t eigenTimings;
+ 
+  double dMaxSignifKond; 				     
+  double dLastMinEWgroesserNull;
+
+  short flgresumedone; 
+
+  time_t printtime; 
+  time_t writetime; /* ideally should keep track for each output file */
+  time_t firstwritetime;
+  time_t firstprinttime; 
+
+} cmaes_t; 
+
+#endif 

robotic/include/rai/Optim/CMA/cmaes_interface.h

@@ -0,0 +1,68 @@
+/* --------------------------------------------------------- */
+/* --- File: cmaes_interface.h - Author: Nikolaus Hansen --- */
+/* ---------------------- last modified:  IV 2007        --- */
+/* --------------------------------- by: Nikolaus Hansen --- */
+/* --------------------------------------------------------- */
+/*   
+     CMA-ES for non-linear function minimization. 
+
+     Copyright (C) 1996, 2003, 2007 Nikolaus Hansen. 
+     e-mail: hansen AT lri.fr
+     
+     Documentation: see file docfunctions.txt
+     
+     License: see file cmaes.c
+*/
+#include "cmaes.h"
+
+/* --------------------------------------------------------- */
+/* ------------------ Interface ---------------------------- */
+/* --------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* --- initialization, constructors, destructors --- */
+double * cmaes_init(cmaes_t *, int dimension , double *xstart, 
+		double *stddev, long seed, int lambda, 
+		const char *input_parameter_filename);
+void cmaes_init_para(cmaes_t *, int dimension , double *xstart, 
+		double *stddev, long seed, int lambda, 
+		const char *input_parameter_filename);
+double * cmaes_init_final(cmaes_t *);
+void cmaes_resume_distribution(cmaes_t *evo_ptr, char *filename);
+void cmaes_exit(cmaes_t *);
+
+/* --- core functions --- */
+double * const * cmaes_SamplePopulation(cmaes_t *);
+double *         cmaes_UpdateDistribution(cmaes_t *, 
+					  const double *rgFitnessValues);
+const char *     cmaes_TestForTermination(cmaes_t *);
+
+/* --- additional functions --- */
+double * const * cmaes_ReSampleSingle( cmaes_t *t, int index);
+double const *   cmaes_ReSampleSingle_old(cmaes_t *, double *rgx); 
+double *         cmaes_SampleSingleInto( cmaes_t *t, double *rgx);
+void             cmaes_UpdateEigensystem(cmaes_t *, int flgforce);
+
+/* --- getter functions --- */
+double         cmaes_Get(cmaes_t *, char const *keyword);
+const double * cmaes_GetPtr(cmaes_t *, char const *keyword); /* e.g. "xbestever" */
+double *       cmaes_GetNew( cmaes_t *t, char const *keyword); /* user is responsible to free */
+double *       cmaes_GetInto( cmaes_t *t, char const *keyword, double *mem); /* allocs if mem==NULL, user is responsible to free */
+
+/* --- online control and output --- */
+void           cmaes_ReadSignals(cmaes_t *, char const *filename);
+void           cmaes_WriteToFile(cmaes_t *, const char *szKeyWord,
+                                 const char *output_filename); 
+char *         cmaes_SayHello(cmaes_t *);
+/* --- misc --- */
+double *       cmaes_NewDouble(int n); /* user is responsible to free */
+void           cmaes_FATAL(char const *s1, char const *s2, char const *s3, 
+			   char const *s4);
+
+#ifdef __cplusplus
+} // end extern "C"
+#endif
+

robotic/include/rai/Optim/GlobalIterativeNewton.h

@@ -8,8 +8,10 @@
 
 #pragma once
 
-#include "newton.h"
-#include "gradient.h"
+#include "m_Newton.h"
+#include "m_Gradient.h"
+
+namespace rai {
 
 struct GlobalIterativeNewton {
   arr x;
@@ -21,7 +23,7 @@ struct GlobalIterativeNewton {
   rai::Array<LocalMinimum> localMinima;
   LocalMinimum* best;
 
-  GlobalIterativeNewton(ScalarFunction& f, const arr& bounds, rai::OptOptions& opt);
+  GlobalIterativeNewton(ScalarFunction f, const arr& bounds, std::shared_ptr<OptOptions> opt=make_shared<OptOptions>());
   ~GlobalIterativeNewton();
 
   void step();
@@ -30,3 +32,5 @@ struct GlobalIterativeNewton {
 
   void reOptimizeAllPoints();
 };
+
+} //namespace

robotic/include/rai/Optim/NLP.h

@@ -62,7 +62,8 @@ struct NLP : rai::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);
@@ -80,6 +81,19 @@ struct NLP : rai::NonCopyable {
 
 //===========================================================================
 
+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