robotic 0.3.4__cp312-cp312-manylinux2014_x86_64.whl → 0.3.4.dev2__cp312-cp312-manylinux2014_x86_64.whl

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,94 @@
+#pragma once
+
+#include "NLP.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;
+  arr x;
+  double f_x=1e10;
+  uint steps=0, rejectedSteps=0, tinySteps=0;
+
+  EvolutionStrategy(ScalarFunction _f): f(_f) {}
+
+  virtual arr generateNewSamples() = 0;
+  virtual void update(const arr& samples, const arr& values) = 0;
+
+  bool step();
+
+  shared_ptr<SolverReturn> solve();
+
+  arr select(const arr& samples, const arr& y, 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={});
+  ~CMAES();
+
+  virtual arr generateNewSamples();
+  virtual void update(const arr& samples, const arr& values);
+
+  arr getBestEver();
+  arr getCurrentMean();
+};
+
+//===========================================================================
+
+struct ES_mu_plus_lambda : EvolutionStrategy {
+  arr mean;
+  RAI_PARAM("ES/", double, sigma, .1)
+  RAI_PARAM("ES/", uint, lambda, 20)
+  RAI_PARAM("ES/", uint, mu, 5)
+
+  ES_mu_plus_lambda(ScalarFunction f, const arr& x_init={}) : EvolutionStrategy(f) {}
+
+  virtual arr generateNewSamples(){
+    arr X = replicate(mean, lambda);
+//    for(uint i=0;i<X.d0;i++) X[i] = X[i] % (0.5 + 1.*rand(X.d1));
+    rndGauss(X, sigma, true);
+    return X;
+  }
+
+  virtual void update(const arr& X, const arr& y){
+    arr Y = select(X, y, mu);
+    mean = ::mean(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

@@ -5,19 +5,22 @@
 
 struct LeastSquaredZeroOrder{
   shared_ptr<NLP> P;
+  bool hasLinTerms=false;
 
-  //-- parameters of the inner problem (Lagrangian, unconstrained problem)
-  double sigma=1e-3;
-  double lambda=1e-3;
-  uint steps=0;
+  //-- parameters
+  str method="rank1";
+  double alpha = .5;
+  RAI_PARAM("LSZO/", double, alpha_min, .001)
+  RAI_PARAM("LSZO/", double, damping, 1e-2)
 
-  //-- buffers to avoid re-evaluating points
+  //-- 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;
+
+  uint steps=0, tinySteps=0, rejectedSteps=0;
 
   LeastSquaredZeroOrder(shared_ptr<NLP> P, const arr& x_init={});
 
@@ -25,7 +28,11 @@ struct LeastSquaredZeroOrder{
     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 +41,5 @@ 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);
 };

robotic/include/rai/Optim/m_LocalGreedy.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "NLP.h"
+#include "../Core/util.h"
+
+struct LocalGreedy {
+  RAI_PARAM("LocalGreedy/", double, sigma, .1)
+
+  ScalarFunction f;
+
+
+  //-- buffers to avoid re-evaluating points
+  arr x;               ///< point where P was last evaluated
+  double f_x=0.;
+
+  //-- counters
+  uint steps=0, tinySteps=0, maxSteps=300;
+
+  LocalGreedy(ScalarFunction _f, const arr& x_init={});
+
+  shared_ptr<SolverReturn> solve(){
+    while(!step()){}
+    shared_ptr<SolverReturn> ret = make_shared<SolverReturn>();
+    ret->x = x;
+    ret->f = f_x;
+    ret->feasible=true;
+    return ret;
+  }
+
+  bool step();
+};

robotic/include/rai/Optim/m_NelderMead.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "NLP.h"
+#include "../Core/util.h"
+
+struct NelderMead {
+  ScalarFunction f;
+  arr x;
+  double f_x=0.;
+
+  //-- counters
+  uint steps=0, tinySteps=0, maxSteps=300;
+
+  NelderMead(ScalarFunction _f, const arr& x_init={});
+
+  shared_ptr<SolverReturn> solve();
+};

robotic/include/rai/Optim/{newton.h → m_Newton.h}

@@ -9,24 +9,25 @@
 #pragma once
 
 #include "options.h"
+#include "NLP.h"
 #include "../Core/array.h"
 
-int optNewton(arr& x, ScalarFunction& f, rai::OptOptions opt=DEFAULT_OPTIONS);
+namespace rai {
 
 struct OptNewton {
-  ScalarFunction& f;
+  ScalarFunction f;
+  shared_ptr<rai::OptOptions> opt;
   arr& x;
-  rai::OptOptions opt;
 
   enum StopCriterion { stopNone=0, stopDeltaConverge, stopTinyFSteps, stopTinyXSteps, stopCritEvals, stopStepFailed, stopLineSearchSteps };
 
-  OptNewton(arr& _x, ScalarFunction& _f, const rai::OptOptions& _opt);
+  OptNewton(arr& _x, ScalarFunction _f, std::shared_ptr<OptOptions> _opt = make_shared<OptOptions>());
   ~OptNewton();
   OptNewton& setBounds(const arr& _bounds);
   void reinit(const arr& _x);
 
   StopCriterion step();
-  StopCriterion run(uint maxIt = 1000);
+  shared_ptr<SolverReturn> run(uint maxIt = 1000);
 
  public:
   arr bounds;
@@ -38,3 +39,5 @@ struct OptNewton {
   bool rootFinding=false;
   double timeNewton=0., timeEval=0.;
 };
+
+} //namespace

robotic/include/rai/Optim/options.h

@@ -13,11 +13,11 @@
 namespace rai {
 
 enum OptMethod { M_none=0,
-		 M_gradientDescent, M_rprop, M_LBFGS, M_newton,
-		 M_augmentedLag, M_logBarrier, M_slackGN_logBarrier, M_squaredPenalty, M_singleSquaredPenalty,
+		 M_GradientDescent, M_Rprop, M_LBFGS, M_Newton,
+		 M_AugmentedLag, M_LogBarrier, M_slackGN_logBarrier, M_SquaredPenalty, M_singleSquaredPenalty,
 		 M_slackGN,
 		 M_NLopt, M_Ipopt, M_slackGN_Ipopt, M_Ceres,
-		 M_LSZO};
+		 M_LSZO, M_greedy, M_NelderMead, M_CMA };
 
 
 struct OptOptions {
@@ -45,12 +45,11 @@ struct OptOptions {
   RAI_PARAM("opt/", double, lambdaMax, -1.)
   RAI_PARAM("opt/", double, interiorPadding, 1e-2)
   RAI_PARAM("opt/", bool,   boundedNewton, true)
-  RAI_PARAM_ENUM("opt/", OptMethod, method, M_augmentedLag)
-//  void write(std::ostream& os) const;
+  RAI_PARAM_ENUM("opt/", OptMethod, method, M_AugmentedLag)
+  RAI_PARAM("opt/", bool,   finiteDifference, false)
 };
-//stdOutPipe(OptOptions)
 
-OptOptions& globalOptOptions();
+std::shared_ptr<OptOptions> globalOptOptions();
 
 } //namespace
 

robotic/include/rai/Optim/primalDual.h

@@ -9,10 +9,12 @@
 #pragma once
 
 #include "options.h"
-#include "newton.h"
+#include "m_Newton.h"
 #include "lagrangian.h"
 
-struct PrimalDualProblem : ScalarFunction {
+namespace rai {
+
+struct PrimalDualProblem : NLP_Scalar {
   rai::LagrangianProblem L;
 
   //duality gap parameter (log barrier parameter) of the primal dual equation system
@@ -23,7 +25,7 @@ struct PrimalDualProblem : ScalarFunction {
   double dualityMeasure=1.;
   bool primalFeasible=false;
 
-  PrimalDualProblem(const arr& x, const shared_ptr<NLP>& P, const rai::OptOptions& opt);
+  PrimalDualProblem(const arr& x, const shared_ptr<NLP>& P, std::shared_ptr<OptOptions> opt);
 
   double f(arr& r, arr& R, const arr& x); ///< CORE METHOD: the unconstrained scalar function F
 
@@ -39,10 +41,12 @@ struct OptPrimalDual {
   arr& x;
   PrimalDualProblem PD;
   OptNewton newton;
-  const rai::OptOptions& opt;
+  std::shared_ptr<OptOptions> opt;
   uint its=0;
 
-  OptPrimalDual(arr& x, arr& dual, const shared_ptr<NLP>& P, const rai::OptOptions& opt);
+  OptPrimalDual(arr& x, arr& dual, const shared_ptr<NLP>& P, std::shared_ptr<OptOptions> _opt);
   ~OptPrimalDual();
   uint run(uint maxIt=1000);
 };
+
+} //namespace

robotic/include/rai/Optim/testProblems_Opt.h

@@ -127,15 +127,15 @@ struct NLP_RastriginSOS : NLP {
 
 //===========================================================================
 
-struct NLP_Rastrigin : ScalarFunction {
-  NLP_Rastrigin(uint _dim) { dim=_dim; }
+struct NLP_Rastrigin : NLP_Scalar {
+  NLP_Rastrigin(uint _dim) { dimension=_dim; }
   virtual double f(arr& g, arr& H, const arr& x);
 };
 
 //===========================================================================
 
-struct NLP_Rosenbrock : ScalarFunction {
-  NLP_Rosenbrock(uint _dim) { dim=_dim; }
+struct NLP_Rosenbrock : NLP_Scalar {
+  NLP_Rosenbrock(uint _dim) { dimension=_dim; }
   virtual double f(arr& g, arr& H, const arr& x);
 };
 
@@ -216,7 +216,7 @@ struct ChoiceConstraintFunction : NLP {
   enum WhichConstraint { none=0, wedge2D=1, halfcircle2D, randomLinear, circleLine2D, boundConstrained, boundConstrainedIneq } which;
   uint n;
   arr randomG;
-  shared_ptr<ScalarFunction> f_uc;
+  ScalarFunction f_uc;
   ChoiceConstraintFunction();
 
   void evaluate(arr& phi, arr& J, const arr& x);

robotic/include/rai/Optim/utils.h

@@ -11,27 +11,16 @@
 #include "NLP.h"
 #include "../Core/util.h"
 
-struct Conv_ScalarFunction2NLP : NLP {
-  shared_ptr<ScalarFunction> f;
-  Conv_ScalarFunction2NLP(shared_ptr<ScalarFunction> f);
-  virtual void evaluate(arr& phi, arr& J, const arr& x);
-  virtual void getFHessian(arr& H, const arr& x);
-  virtual void report(ostream& os, int verbose, const char *msg=0){
-    os <<"ScalarFunction of type '" <<rai::niceTypeidName(typeid(*this)) <<"'";
-    if(msg) os <<' ' <<msg;
-    os <<" dimension:" <<f->dim;
-  }
-};
-
-struct Conv_NLP2ScalarProblem : ScalarFunction {
+struct NLP_FiniteDifference : NLP {
   std::shared_ptr<NLP> P;
-  Conv_NLP2ScalarProblem(std::shared_ptr<NLP> _P) : P(_P) { dim = P->dimension; }
-  virtual double f(arr& g, arr& H, const arr& x);
+  NLP_FiniteDifference(std::shared_ptr<NLP> _P) : P(_P) { copySignature(*P); }
+  virtual void evaluate(arr& phi, arr& J, const arr& x0);
+  virtual void report(ostream& os, int verbose, const char *msg=0){ os <<"FiniteDifference version of: "; P->report(os, verbose, msg); }
 };
 
-struct Conv_NLP_SlackLeastSquares : NLP {
+struct NLP_SlackLeastSquares : NLP {
   std::shared_ptr<NLP> P;
-  Conv_NLP_SlackLeastSquares(std::shared_ptr<NLP> _P);
+  NLP_SlackLeastSquares(std::shared_ptr<NLP> _P);
   virtual void evaluate(arr& phi, arr& J, const arr& x);
   virtual void report(ostream& os, int verbose, const char *msg=0){ os <<"SlackLeastSquares of: "; P->report(os, verbose, msg); }
 private:
@@ -54,8 +43,8 @@ struct NLP_LinTransformed : NLP {
 // checks, evaluation
 //
 
-bool checkDirectionalGradient(const ScalarFunction& f, const arr& x, const arr& delta, double tolerance);
-bool checkDirectionalJacobian(const VectorFunction& f, const arr& x, const arr& delta, double tolerance);
+bool checkDirectionalGradient(ScalarFunction f, const arr& x, const arr& delta, double tolerance);
+bool checkDirectionalJacobian(VectorFunction f, const arr& x, const arr& delta, double tolerance);
 
 //===========================================================================
 //
@@ -63,5 +52,5 @@ bool checkDirectionalJacobian(const VectorFunction& f, const arr& x, const arr&
 //
 
 void accumulateInequalities(arr& y, arr& J, const arr& yAll, const arr& JAll);
-void displayFunction(ScalarFunction& f, bool wait=false, double lo=-1.2, double hi=1.2);
+void displayFunction(ScalarFunction f, bool wait=false, double lo=-1.2, double hi=1.2);
 

robotic/version.py

@@ -1 +1 @@
-__version__ = '0.3.4'
+__version__ = '0.3.4.dev2'

{robotic-0.3.4.dist-info → robotic-0.3.4.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotic
-Version: 0.3.4
+Version: 0.3.4.dev2
 Summary: Robotic Control Interface & Manipulation Planning Library
 Home-page: https://github.com/MarcToussaint/robotic/
 Author: Marc Toussaint