robotic 0.2.9.dev1__cp311-cp311-manylinux2014_x86_64.whl → 0.3.4.dev5__cp311-cp311-manylinux2014_x86_64.whl

robotic/include/rai/LGP/LGP_computers2.h

@@ -0,0 +1,196 @@
+/*  ------------------------------------------------------------------
+    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 "../Search/ComputeNode.h"
+#include "../Search/AStar.h"
+#include "../Logic/folWorld.h"
+#include "../Optim/NLP_GraphSolver.h"
+#include "../PathAlgos/RRT_PathFinder.h"
+#include "LGP_TAMP_Abstraction.h"
+
+namespace rai {
+
+//===========================================================================
+
+struct LGP2_GlobalInfo {
+  RAI_PARAM("LGP/", int, verbose, 1)
+  RAI_PARAM("LGP/", double, skeleton_w0, 1.)
+  RAI_PARAM("LGP/", double, skeleton_wP, 2.)
+  RAI_PARAM("LGP/", double, waypoint_w0, 10.)
+  RAI_PARAM("LGP/", double, waypoint_wP, 2.)
+  RAI_PARAM("LGP/", int, waypointStopEvals, 1000)
+  RAI_PARAM("LGP/", int, rrtStopEvals, 10000)
+  RAI_PARAM("LGP/", double, rrtStepsize, .05)
+  RAI_PARAM("LGP/", double, rrtTolerance, .03)
+  RAI_PARAM("LGP/", double, pathCtrlCosts, 1.)
+  RAI_PARAM("LGP/", int, pathStepsPerPhase, 30)
+  RAI_PARAM("LGP/", double, collScale, 1e1)
+  RAI_PARAM("LGP/", bool, useSequentialWaypointSolver, false)
+};
+
+//===========================================================================
+
+struct LGPComp2_root : ComputeNode {
+  // FOL_World& L;
+  Configuration& C;
+  LGP_TAMP_Abstraction& tamp;
+  // bool useBroadCollisions=false;
+  // StringA explicitCollisions;
+  // StringA explicitLift;
+  // String explicitTerminalSkeleton;
+  // std::shared_ptr<rai::AStar> fol_astar;
+  std::shared_ptr<LGP2_GlobalInfo> info;
+  bool fixedSkeleton=false;
+
+  LGPComp2_root(Configuration& _C, LGP_TAMP_Abstraction& _tamp, const StringA& explicitLift, const String& explicitTerminalSkeleton);
+
+  virtual void untimedCompute() {}
+  virtual int getNumDecisions() { return -1.; }
+//    virtual double effortHeuristic(){ return 11.+10.; }
+  virtual double branchingPenalty_child(int i);
+
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+
+  int verbose() { return info->verbose; }
+};
+
+//===========================================================================
+
+struct LGPComp2_Skeleton : ComputeNode {
+  LGPComp2_root* root=0;
+  int num=0;
+  // Skeleton skeleton;
+  //shared_ptr<SkeletonSolver> sol;
+  // StringA actionSequence;
+  Array<StringA> actionSequence;
+  // Array<Graph*> states;
+  // arr times;
+
+  LGPComp2_Skeleton(LGPComp2_root* _root, int num);
+  // LGPComp2_Skeleton(LGPComp2_root* _root, const Skeleton& _skeleton);
+
+  void createNLPs(const rai::Configuration& C);
+
+  virtual void untimedCompute();
+
+  virtual int getNumDecisions() { return -1.; }
+//    virtual double branchingHeuristic(){ return root->info->waypoint_w0; }
+//    virtual double effortHeuristic(){ return 10.+10.; }
+  virtual double branchingPenalty_child(int i);
+
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+};
+
+//===========================================================================
+
+struct LGPComp2_FactorBounds: ComputeNode {
+  LGPComp2_Skeleton* sket;
+  int seed=0;
+  KOMO komoWaypoints;
+  std::shared_ptr<NLP_Factored> nlp;
+  uint t=0;
+
+  LGPComp2_FactorBounds(LGPComp2_Skeleton* _sket, int rndSeed);
+
+  virtual void untimedCompute();
+//    virtual double effortHeuristic(){ return 10.+1.*(komoWaypoints.T); }
+  virtual int getNumDecisions() { return 1; }
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+};
+
+//===========================================================================
+
+struct LGPComp2_PoseBounds: ComputeNode {
+  LGPComp2_Skeleton* sket;
+  int seed=0;
+  uint t=0;
+
+  LGPComp2_PoseBounds(LGPComp2_Skeleton* _sket, int rndSeed);
+
+  virtual void untimedCompute();
+//    virtual double effortHeuristic(){ return 10.+1.*(sket->states.N); }
+  virtual int getNumDecisions() { return 1; }
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+};
+
+//===========================================================================
+
+struct LGPComp2_Waypoints : ComputeNode {
+  LGPComp2_Skeleton* sket;
+  int seed=0;
+  std::shared_ptr<KOMO> komoWaypoints;
+  NLP_Solver sol;
+  NLP_GraphSolver gsol;
+
+  LGPComp2_Waypoints(LGPComp2_Skeleton* _sket, int rndSeed);
+
+  virtual void untimedCompute();
+//    virtual double effortHeuristic(){ return 10.+1.*(komoWaypoints->T); }
+  virtual int getNumDecisions();
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+};
+
+//===========================================================================
+
+struct LGPComp2_RRTpath : ComputeNode {
+  LGPComp2_Waypoints* ways=0;
+  LGPComp2_RRTpath* prev=0;
+
+  shared_ptr<Configuration> C;
+  uint t;
+  shared_ptr<RRT_PathFinder> rrt;
+  arr q0, qT;
+  arr path;
+
+  LGPComp2_RRTpath(ComputeNode* _par, LGPComp2_Waypoints* _ways, uint _t);
+
+  virtual void untimedCompute();
+//    virtual double effortHeuristic(){ return 10.+1.*(ways->komoWaypoints->T-t-1); }
+
+  virtual int getNumDecisions() { return 1; }
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i);
+};
+
+//===========================================================================
+
+struct LGPComp2_OptimizePath : ComputeNode {
+  LGPComp2_Skeleton* sket=0;
+  LGPComp2_Waypoints* ways=0;
+
+  shared_ptr<KOMO> komoPath;
+  NLP_Solver sol;
+
+  LGPComp2_OptimizePath(LGPComp2_Skeleton* _sket); //compute path from skeleton directly, without waypoints first
+  LGPComp2_OptimizePath(LGPComp2_Waypoints* _ways); //compute path initialized from waypoints
+  LGPComp2_OptimizePath(LGPComp2_RRTpath* _par, LGPComp2_Waypoints* _ways); //compute path initialized from series of RRT solutions
+
+  virtual void untimedCompute();
+//    virtual double effortHeuristic(){ return 0.; }
+
+  virtual double sample() {
+    CHECK(sol.ret, "");
+    CHECK(sol.ret->done, "");
+    if(sol.ret->ineq>1. || sol.ret->eq>4.) return 1e10;
+    return sol.ret->ineq+sol.ret->eq;
+  }
+
+//        if(opt.verbose>0) LOG(0) <<*ret;
+//        if(opt.verbose>1) cout <<komoPath.report(false, true, opt.verbose>2);
+//        if(opt.verbose>0) komoPath.view(opt.verbose>1, STRING("optimized path\n" <<*ret));
+//        //komoPath.checkGradients();
+//        if(opt.verbose>1) komoPath.view_play(opt.verbose>2);
+
+  virtual int getNumDecisions() { return 0; }
+  virtual std::shared_ptr<ComputeNode> createNewChild(int i) { HALT("is terminal"); }
+};
+
+//===========================================================================
+
+}//namespace

robotic/include/rai/LGP/NLP_Descriptor.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../KOMO/komo.h"
+
+rai::Graph getDescriptor(KOMO& komo, int verbose);

robotic/include/rai/Logic/folWorld.h

@@ -129,7 +129,7 @@ struct FOL_World : TreeSearchDomain {
   void addObject(const char* name);
   template<class T> void addValuedFact(const StringA& symbols, const T& x) {
     NodeL parents;
-    for(const String& s:symbols) parents.append(KB[s]);
+    for(const String& s:symbols) parents.append(KB.findNode(s));
     start_state->add<T>(0,  x, parents);
   }
   void addTerminalRule(const char* literals);

robotic/include/rai/Logic/treeSearchDomain.h

@@ -65,7 +65,7 @@ struct TreeSearchDomain {
   virtual const Handle get_stateCopy() = 0;
 
   /// Get the current state
-  virtual void set_state(const Handle& stateCopy) { std::cerr <<"not implemented for world of type " <<typeid(this).name() <<std::endl; exit(-1); }
+  virtual void set_state(const Handle& stateCopy) { std::cout <<"not implemented for world of type " <<typeid(this).name() <<std::endl; exit(-1); }
 
   /// Return whether the current state is a terminal state
   virtual bool is_terminal_state() const = 0;
@@ -81,7 +81,7 @@ struct TreeSearchDomain {
   virtual bool get_info(InfoTag tag) const = 0;
   virtual double get_info_value(InfoTag tag) const = 0;
 
-  virtual void write(std::ostream& os) const { std::cerr <<"NOT OVERLOADED!" <<std::endl; }
+  virtual void write(std::ostream& os) const { std::cout <<"NOT OVERLOADED!" <<std::endl; }
 };
 inline std::ostream& operator<<(std::ostream& os, const TreeSearchDomain& E) { E.write(os); return os; }
 inline std::ostream& operator<<(std::ostream& os, const TreeSearchDomain::SAO& x) { x.write(os); return os; }

robotic/include/rai/Optim/BayesOpt.h

@@ -11,6 +11,11 @@
 #include "GlobalIterativeNewton.h"
 #include "../Core/array.h"
 
+struct KernelRidgeRegression;
+struct DefaultKernelFunction;
+
+namespace rai {
+
 struct BayesOpt {
   ScalarFunction f;
   arr bounds;
@@ -18,23 +23,23 @@ struct BayesOpt {
   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(const 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=true, const ScalarFunction& f=ScalarFunction());
+  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(const 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