robotic 0.3.4.dev1__cp311-cp311-manylinux2014_x86_64.whl → 0.3.4.dev3__cp311-cp311-manylinux2014_x86_64.whl

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

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,10 +24,10 @@ 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>());
 
   std::shared_ptr<SolverReturn> run();
   bool ministep();

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,20 +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, double muSquaredPenalty=-1., double muLogBarrier=-1.);
+  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 f(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);

robotic/include/rai/Optim/m_EvoStrategies.h

@@ -0,0 +1,113 @@
+#pragma once
+
+#include "NLP.h"
+#include "options.h"
+#include "../Core/util.h"
+
+/*
+
+  Implement:
+ HillClimbing (with fixed exploration; with adaptive exploration)
+ DifferentialHillClimbing (with adaptive exploration distribution on delta)
+ classical model-based optim
+
+ Greedy local search (6:5) Stochastic local search (6:6) Simulated annealing (6:7)
+Random restarts (6:10) Iterated local search (6:11) Variable neighborhood search
+(6:13) Coordinate search (6:14) Pattern search (6:15) Nelder-Mead simplex method
+(6:16) General stochastic search (6:20) Evolutionary algorithms (6:23) Covariance Matrix
+Adaptation (CMAES) (6:24) Estimation of Distribution Algorithms (EDAs) (6:28)
+Model-based optimization (6:31) Implicit filtering (6:34)
+
+Improvement (5:24) Maximal Probability of Improvement
+(5:24) GP-UCB (5:24)
+
+Generic globalization: Iterated Local Optim: check when converged multiply to same local opt
+
+Require bound constraints!
+
+*
+Twiddle
+ */
+
+namespace rai {
+
+//===========================================================================
+
+struct EvolutionStrategy {
+  ScalarFunction f;
+  shared_ptr<OptOptions> opt;
+  arr x;
+  double f_x=1e10;
+  int evals=0, steps=0, rejectedSteps=0, tinySteps=0;
+
+  EvolutionStrategy(ScalarFunction _f, const arr& x_init, shared_ptr<OptOptions> _opt): f(_f), opt(_opt), x(x_init) {}
+
+  //virtuals that define a method
+  virtual arr generateNewSamples() = 0;
+  virtual void update(arr& samples, const arr& values) = 0;
+
+  //generic stepping & looping
+  bool step();
+  shared_ptr<SolverReturn> solve();
+
+  //helper
+  arr select(const arr& samples, const arr& values, uint mu);
+
+};
+
+//===========================================================================
+
+struct CMAES : EvolutionStrategy {
+  unique_ptr<struct CMA_self> self;
+  RAI_PARAM("CMA/", int, lambda, 20)
+  RAI_PARAM("CMA/", double, sigmaInit, .1)
+
+  CMAES(ScalarFunction f, const arr& x_init, shared_ptr<OptOptions> opt = make_shared<OptOptions>());
+  ~CMAES();
+
+  virtual arr generateNewSamples();
+  virtual void update(arr& samples, const arr& values);
+
+  arr getBestEver();
+  arr getCurrentMean();
+};
+
+//===========================================================================
+
+struct ES_mu_plus_lambda : EvolutionStrategy {
+  arr mean;
+  arr elite;
+  RAI_PARAM("ES/", double, sigma, .1)
+  RAI_PARAM("ES/", double, sigmaDecay, .001)
+  RAI_PARAM("ES/", uint, lambda, 20)
+  RAI_PARAM("ES/", uint, mu, 5)
+
+  ES_mu_plus_lambda(ScalarFunction f, const arr& x_init, shared_ptr<OptOptions> opt = make_shared<OptOptions>())
+      : EvolutionStrategy(f, x_init, opt) { mean = x_init; }
+
+  virtual arr generateNewSamples();
+
+  virtual void update(arr& X, const arr& y);
+};
+
+//===========================================================================
+
+struct GaussEDA : EvolutionStrategy {
+  arr mean;
+  arr cov;
+  arr elite;
+  RAI_PARAM("GaussEDA/", double, sigmaInit, .1)
+  RAI_PARAM("GaussEDA/", double, sigma2Min, .001)
+  RAI_PARAM("GaussEDA/", double, beta, .1)
+  RAI_PARAM("ES/", double, sigmaDecay, .001)
+  RAI_PARAM("ES/", uint, lambda, 20)
+  RAI_PARAM("ES/", uint, mu, 5)
+
+  GaussEDA(ScalarFunction f, const arr& x_init, shared_ptr<OptOptions> opt = make_shared<OptOptions>());
+
+  virtual arr generateNewSamples();
+
+  virtual void update(arr& X, const arr& y);
+};
+
+} //namespace

robotic/include/rai/Optim/{gradient.h → m_Gradient.h}

@@ -11,6 +11,8 @@
 #include "options.h"
 #include "../Core/array.h"
 
+namespace rai {
+
 //===========================================================================
 //
 // proper (monotone) plain gradient descent with line search
@@ -18,28 +20,24 @@
 
 struct OptGrad {
   arr& x;
-  ScalarFunction& f;
-  rai::OptOptions o;
+  ScalarFunction f;
+  shared_ptr<OptOptions> opt;
 
   enum StopCriterion { stopNone=0, stopCrit1, stopCrit2, stopCritLineSteps, stopCritEvals, stopStepFailed };
-  double fx;
-  arr gx;
+  double f_x;
+  arr g_x;
   double alpha;
   uint it, evals, numTinySteps;
   StopCriterion stopCriterion;
   ofstream fil;
 
-  OptGrad(arr& x, ScalarFunction& f, rai::OptOptions o=DEFAULT_OPTIONS);
+  OptGrad(arr& x, ScalarFunction f, std::shared_ptr<OptOptions> _opt);
   ~OptGrad();
   StopCriterion step();
   StopCriterion run(uint maxIt = 1000);
   void reinit(const arr& _x=NoArr);
 };
 
-inline int optGrad(arr& x, ScalarFunction& f, rai::OptOptions opt=DEFAULT_OPTIONS) {
-  return OptGrad(x, f, opt).run();
-}
-
 //===========================================================================
 //
 // Rprop
@@ -53,11 +51,12 @@ struct Rprop {
   Rprop();
   ~Rprop();
   void init(double initialStepSize=1., double minStepSize=1e-6, double stepMaxSize=50.);
-  bool step(arr& x, ScalarFunction& f);
-  uint loop(arr& x, ScalarFunction& f, double stoppingTolerance=1e-2, double initialStepSize=1., uint maxIterations=1000, int verbose=0);
+  bool step(arr& x, ScalarFunction f);
+  uint loop(arr& x, ScalarFunction f, double stoppingTolerance=1e-2, double initialStepSize=1., uint maxIterations=1000, int verbose=0);
 };
 
-inline uint optRprop(arr& x, ScalarFunction& f, rai::OptOptions opt=DEFAULT_OPTIONS) {
-  return Rprop().loop(x, f, opt.stopTolerance, opt.stepInit, opt.stopEvals, opt.verbose);
+inline uint optRprop(arr& x, ScalarFunction f, shared_ptr<OptOptions> opt) {
+  return Rprop().loop(x, f, opt->stopTolerance, opt->stepInit, opt->stopEvals, opt->verbose);
 }
 
+} //namespace

robotic/include/rai/Optim/m_LBFGS.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "NLP.h"
+#include "options.h"
+
+namespace rai {
+
+struct LBFGS{
+  ScalarFunction f;
+  shared_ptr<rai::OptOptions> opt;
+  arr x;
+
+  LBFGS(ScalarFunction _f, const arr& x_init, std::shared_ptr<OptOptions> _opt);
+
+  std::shared_ptr<SolverReturn> solve();
+
+//private:
+  arr g;
+};
+
+} //namespace

robotic/include/rai/Optim/m_LeastSquaresZeroOrder.h

@@ -1,31 +1,50 @@
 #pragma once
 
 #include "NLP.h"
+#include "options.h"
 #include "../Core/util.h"
 
+namespace rai {
+
 struct LeastSquaredZeroOrder{
   shared_ptr<NLP> P;
+  std::shared_ptr<OptOptions> opt;
+  bool hasLinTerms=false;
 
-  //-- parameters of the inner problem (Lagrangian, unconstrained problem)
-  double sigma=1e-3;
-  double lambda=1e-3;
-  uint steps=0;
-
-  //-- buffers to avoid re-evaluating points
+  //-- parameters
+  str method="rank1";
+  double alpha = .5;
+  RAI_PARAM("LSZO/", double, alpha_min, .001)
+  RAI_PARAM("LSZO/", double, damping, 1e-2)
+  RAI_PARAM("LSZO/", double, noiseRatio, .2)
+  RAI_PARAM("LSZO/", double, noiseAbs, .0)
+  RAI_PARAM("LSZO/", int, maxIters, 500)
+  RAI_PARAM("LSZO/", double, dataRatio, 1.)
+  RAI_PARAM("LSZO/", bool, pruneData, false)
+  RAI_PARAM("LSZO/", bool, covariantNoise, false)
+  RAI_PARAM("LSZO/", double, stepInc, 1.5)
+  RAI_PARAM("LSZO/", double, stepDec, .5)
+
+  //-- state and data
   arr x;               ///< point where P was last evaluated
-  double phi2_x=-1.;
-  arr phi_x, J_x, H_x; ///< features at x
   arr J;
-  arr data_X, data_Phi, data_Phi2;
-  str method="rank1";
+  arr phi_x; //, J_x, H_x; ///< features at x
+  double phi2_x=-1.;
+  arr data_X, data_Phi;
 
-  LeastSquaredZeroOrder(shared_ptr<NLP> P, const arr& x_init={});
+  uint steps=0, tinySteps=0, rejectedSteps=0;
+
+  LeastSquaredZeroOrder(shared_ptr<NLP> P, const arr& x_init, std::shared_ptr<OptOptions> _opt=make_shared<OptOptions>());
 
   shared_ptr<SolverReturn> solve(){
     while(!step()){}
     shared_ptr<SolverReturn> ret = make_shared<SolverReturn>();
     ret->x = x;
-    ret->sos = phi2_x;
+    arr err = P->summarizeErrors(phi_x);
+    ret->f = err(OT_f);
+    ret->sos = err(OT_sos);
+    ret->eq = err(OT_eq);
+    ret->ineq = err(OT_ineq);
     ret->feasible=true;
     return ret;
   }
@@ -34,5 +53,7 @@ struct LeastSquaredZeroOrder{
 
   void updateJ_rank1(arr& J, const arr& x, const arr& x_last, const arr& phi, const arr& phi_last);
 
-  void updateJ_linReg(arr& J, const arr& Xraw, const arr& Y, double lambdaReg=1e-3);
+  void updateJ_linReg(arr& J, const arr& Xraw, const arr& Y);
 };
+
+} //namespace