robotic 0.3.4__cp310-cp310-manylinux2014_x86_64.whl → 0.3.4.dev2__cp310-cp310-manylinux2014_x86_64.whl

robotic/_robotic.pyi

@@ -1301,7 +1301,7 @@ class NLP_Solver:
         """
     def setInitialization(self, arg0: arr) -> NLP_Solver:
         ...
-    def setOptions(self, verbose: int = 1, stopTolerance: float = 0.01, stopFTolerance: float = -1.0, stopGTolerance: float = -1.0, stopEvals: int = 1000, stopInners: int = 1000, stopOuters: int = 1000, stepMax: float = 0.2, damping: float = 1.0, stepInc: float = 1.5, stepDec: float = 0.5, wolfe: float = 0.01, muInit: float = 1.0, muInc: float = 5.0, muMax: float = 10000.0, muLBInit: float = 0.1, muLBDec: float = 0.2, lambdaMax: float = -1.0) -> NLP_Solver:
+    def setOptions(self, verbose: int = 1, stopTolerance: float = 0.01, stopFTolerance: float = -1.0, stopGTolerance: float = -1.0, stopEvals: int = 1000, stopInners: int = 1000, stopOuters: int = 1000, stopLineSteps: int = 10, stopTinySteps: int = 4, stepInit: float = 1.0, stepMin: float = -1.0, stepMax: float = 0.2, stepInc: float = 1.5, stepDec: float = 0.5, damping: float = 1.0, wolfe: float = 0.01, muInit: float = 1.0, muInc: float = 5.0, muMax: float = 10000.0, muLBInit: float = 0.1, muLBDec: float = 0.2, lambdaMax: float = -1.0, interiorPadding: float = 0.01, boundedNewton: bool = True, finiteDifference: bool = False) -> NLP_Solver:
         """
         set solver options
         """
@@ -1457,19 +1457,21 @@ class OptMethod:
     
       none
     
-      gradientDescent
+      GradientDescent
     
-      rprop
+      Rprop
     
       LBFGS
     
-      newton
+      Newton
     
-      augmentedLag
+      AugmentedLag
     
-      squaredPenalty
+      LogBarrier
     
-      logBarrier
+      slackGN_logBarrier
+    
+      SquaredPenalty
     
       singleSquaredPenalty
     
@@ -1479,22 +1481,38 @@ class OptMethod:
     
       Ipopt
     
+      slackGN_Ipopt
+    
       Ceres
+    
+      LSZO
+    
+      greedy
+    
+      NelderMead
+    
+      CMA
     """
+    AugmentedLag: typing.ClassVar[OptMethod]  # value = <OptMethod.AugmentedLag: 5>
+    CMA: typing.ClassVar[OptMethod]  # value = <OptMethod.CMA: 18>
     Ceres: typing.ClassVar[OptMethod]  # value = <OptMethod.Ceres: 14>
+    GradientDescent: typing.ClassVar[OptMethod]  # value = <OptMethod.GradientDescent: 1>
     Ipopt: typing.ClassVar[OptMethod]  # value = <OptMethod.Ipopt: 12>
     LBFGS: typing.ClassVar[OptMethod]  # value = <OptMethod.LBFGS: 3>
+    LSZO: typing.ClassVar[OptMethod]  # value = <OptMethod.LSZO: 15>
+    LogBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.LogBarrier: 6>
     NLopt: typing.ClassVar[OptMethod]  # value = <OptMethod.NLopt: 11>
-    __members__: typing.ClassVar[dict[str, OptMethod]]  # value = {'none': <OptMethod.none: 0>, 'gradientDescent': <OptMethod.gradientDescent: 1>, 'rprop': <OptMethod.rprop: 2>, 'LBFGS': <OptMethod.LBFGS: 3>, 'newton': <OptMethod.newton: 4>, 'augmentedLag': <OptMethod.augmentedLag: 5>, 'squaredPenalty': <OptMethod.squaredPenalty: 8>, 'logBarrier': <OptMethod.logBarrier: 6>, 'singleSquaredPenalty': <OptMethod.singleSquaredPenalty: 9>, 'slackGN': <OptMethod.slackGN: 10>, 'NLopt': <OptMethod.NLopt: 11>, 'Ipopt': <OptMethod.Ipopt: 12>, 'Ceres': <OptMethod.Ceres: 14>}
-    augmentedLag: typing.ClassVar[OptMethod]  # value = <OptMethod.augmentedLag: 5>
-    gradientDescent: typing.ClassVar[OptMethod]  # value = <OptMethod.gradientDescent: 1>
-    logBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.logBarrier: 6>
-    newton: typing.ClassVar[OptMethod]  # value = <OptMethod.newton: 4>
+    NelderMead: typing.ClassVar[OptMethod]  # value = <OptMethod.NelderMead: 17>
+    Newton: typing.ClassVar[OptMethod]  # value = <OptMethod.Newton: 4>
+    Rprop: typing.ClassVar[OptMethod]  # value = <OptMethod.Rprop: 2>
+    SquaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.SquaredPenalty: 8>
+    __members__: typing.ClassVar[dict[str, OptMethod]]  # value = {'none': <OptMethod.none: 0>, 'GradientDescent': <OptMethod.GradientDescent: 1>, 'Rprop': <OptMethod.Rprop: 2>, 'LBFGS': <OptMethod.LBFGS: 3>, 'Newton': <OptMethod.Newton: 4>, 'AugmentedLag': <OptMethod.AugmentedLag: 5>, 'LogBarrier': <OptMethod.LogBarrier: 6>, 'slackGN_logBarrier': <OptMethod.slackGN_logBarrier: 7>, 'SquaredPenalty': <OptMethod.SquaredPenalty: 8>, 'singleSquaredPenalty': <OptMethod.singleSquaredPenalty: 9>, 'slackGN': <OptMethod.slackGN: 10>, 'NLopt': <OptMethod.NLopt: 11>, 'Ipopt': <OptMethod.Ipopt: 12>, 'slackGN_Ipopt': <OptMethod.slackGN_Ipopt: 13>, 'Ceres': <OptMethod.Ceres: 14>, 'LSZO': <OptMethod.LSZO: 15>, 'greedy': <OptMethod.greedy: 16>, 'NelderMead': <OptMethod.NelderMead: 17>, 'CMA': <OptMethod.CMA: 18>}
+    greedy: typing.ClassVar[OptMethod]  # value = <OptMethod.greedy: 16>
     none: typing.ClassVar[OptMethod]  # value = <OptMethod.none: 0>
-    rprop: typing.ClassVar[OptMethod]  # value = <OptMethod.rprop: 2>
     singleSquaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.singleSquaredPenalty: 9>
     slackGN: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN: 10>
-    squaredPenalty: typing.ClassVar[OptMethod]  # value = <OptMethod.squaredPenalty: 8>
+    slackGN_Ipopt: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN_Ipopt: 13>
+    slackGN_logBarrier: typing.ClassVar[OptMethod]  # value = <OptMethod.slackGN_logBarrier: 7>
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
         ...

robotic/include/rai/Algo/RidgeRegression.h

@@ -74,7 +74,7 @@ struct KernelRidgeRegression {
   arr evaluate(const arr& X, arr& bayesSigma2=NoArr); ///< returns f(x) and \s^2(x) for a set of points X
 
   double evaluate(const arr& x, arr& df_x, arr& H, double plusSigma, bool onlySigma); ///< returns f(x) + coeff*\sigma(x) and its gradient and Hessian
-  shared_ptr<ScalarFunction> getF(double plusSigma);
+  ScalarFunction getF(double plusSigma);
 };
 
 struct KernelLogisticRegression {

robotic/include/rai/Algo/rungeKutta.h

@@ -14,7 +14,7 @@ namespace rai {
 
 //----- Runge-Kutta
 /// standard Runge-Kutta 4
-void rk4(arr& x, const arr& x0, const fct& f, double dt);
+void rk4(arr& x, const arr& x0, VectorFunction f, double dt);
 /// same for second order diff equation
 //void rk4dd(arr& x1, arr& v1, const arr& x0, const arr& v0,
 //           void (*ddf)(arr& xdd, const arr& x, const arr& v),

robotic/include/rai/Core/array.h

@@ -67,7 +67,7 @@ template<class T> struct Array {
   uint N;   ///< number of elements
   uint nd;  ///< number of dimensions
   uint d0, d1, d2; ///< 0th, 1st, 2nd dim
-  uint* d;  ///< pointer to dimensions (for nd<=3 points to d0)
+  uint* _shape;  ///< pointer to dimensions (for nd<=3 points to d0)
   bool isReference; ///< true if this refers to memory of another array
   uint M;   ///< memory allocated (>=N)
   SpecialArray* special=0; ///< auxiliary data, e.g. if this is a sparse matrics, depends on special type
@@ -95,24 +95,30 @@ template<class T> struct Array {
   Array<T>& operator=(const Array<T>& a);
 
   /// @name iterators
-  struct iterator {
-    using reference = T&;
-    T* p;
-    T& operator()() { return *p; } //access to value by user
-    void operator++() { p++; }
-    reference operator*() { return *p; } //in for(auto& it:array.enumerated())  it is assigned to *iterator
-    friend bool operator!=(const iterator& i, const iterator& j) { return i.p!=j.p; }
-    T& operator->() { return *p; }
-  };
-  struct const_iterator {
-    using reference = const T&;
-    const T* p;
-    const T& operator()() { return *p; } //access to value by user
-    void operator++() { p++; }
-    reference operator*() { return *p; } //in for(auto& it:array.enumerated())  it is assigned to *iterator
-    friend bool operator!=(const const_iterator& i, const const_iterator& j) { return i.p!=j.p; }
-    const T& operator->() { return *p; }
-  };
+  using iterator = T*;
+  using const_iterator = const T*;
+  // struct iterator {
+  //   using reference = T&;
+  //   T* p;
+  //   T& operator()() { return *p; } //access to value by user
+  //   void operator++() { p++; }
+  //   reference operator*() { return *p; } //in for(auto& it:array.enumerated())  it is assigned to *iterator
+  //   friend bool operator!=(const iterator& i, const iterator& j) { return i.p!=j.p; }
+  //   friend long int operator-(const iterator& i, const iterator& j) { return (long int)(i.p-j.p); }
+  //   friend iterator operator+(const iterator& i, int j) { return iterator{i.p+j}; }
+  //   friend iterator operator-(const iterator& i, int j) { return iterator{i.p-j}; }
+  //   friend reference operator*(const iterator& i, int j) { return i.p[j]; }
+  //   T& operator->() { return *p; }
+  // };
+  // struct const_iterator {
+  //   using reference = const T&;
+  //   const T* p;
+  //   const T& operator()() { return *p; } //access to value by user
+  //   void operator++() { p++; }
+  //   reference operator*() { return *p; } //in for(auto& it:array.enumerated())  it is assigned to *iterator
+  //   friend bool operator!=(const const_iterator& i, const const_iterator& j) { return i.p!=j.p; }
+  //   const T& operator->() { return *p; }
+  // };
 
   iterator begin() { return iterator{p}; }
   const_iterator begin() const { return const_iterator{p}; }
@@ -304,7 +310,7 @@ template<class T> struct Array {
   void resizeMEM(uint n, bool copy, int Mforce=-1);
   void reserveMEM(uint Mforce) { resizeMEM(N, true, Mforce); if(!nd) nd=1; }
   void freeMEM();
-  void resetD();
+  void resetShape(uint* dim=0);
 
   /// @name serialization
   uint serial_size();
@@ -447,8 +453,8 @@ template<class T> Array<T> catCol(const rai::Array<T>& a, const rai::Array<T>& b
 namespace rai {
 template<class T, class S> void resizeAs(Array<T>& x, const Array<S>& a) {
   x.nd=a.nd; x.d0=a.d0; x.d1=a.d1; x.d2=a.d2;
-  x.resetD();
-  if(x.nd>3) { x.d=new uint[x.nd];  memmove(x.d, a.d, x.nd*sizeof(uint)); }
+  x.resetShape();
+  if(x.nd>3) { x._shape=new uint[x.nd];  memmove(x._shape, a._shape, x.nd*sizeof(uint)); }
   x.resizeMEM(a.N, false);
 }
 template<class T, class S> void resizeCopyAs(Array<T>& x, const Array<S>& a);
@@ -679,6 +685,8 @@ namespace rai {
 uint product(const uintA& x);
 template<class T> T& min(const Array<T>& x);
 template<class T> T& max(const Array<T>& x);
+template<class T> std::tuple<T&,uint> min_arg(const Array<T>& x);
+template<class T> std::tuple<T&,uint> max_arg(const Array<T>& x);
 uint sum(const uintA& x);
 float sum(const floatA& x);
 template<class T> Array<T> integral(const Array<T>& x);

robotic/include/rai/Core/array.ipp

@@ -41,7 +41,7 @@ template<class T> Array<T>::Array()
     N(0),
     nd(0),
     d0(0), d1(0), d2(0),
-    d(&d0),
+    _shape(&d0),
     isReference(false),
     M(0),
     special(0) {
@@ -72,17 +72,18 @@ template<class T> Array<T>::Array(Array<T>&& a)
     N(a.N),
     nd(a.nd),
     d0(a.d0), d1(a.d1), d2(a.d2),
-    d(&d0),
+    _shape(&d0),
     isReference(a.isReference),
     M(a.M),
     special(a.special) {
   if constexpr(std::is_same_v<T, double>){
     if(a.jac) jac = std::move(a.jac);
   }
-  // CHECK_EQ(a.d, &a.d0, "NIY for larger tensors");
-  if(a.d!=&a.d0) { d=a.d; a.d=&a.d0; }
+  // CHECK_EQ(a.shape, &a.d0, "NIY for larger tensors");
+  if(a._shape!=&a.d0) { _shape=a._shape; a._shape=&a.d0; }
   a.p=NULL;
   a.N=a.nd=a.d0=a.d1=a.d2=0;
+  a.resetShape();
   a.isReference=false;
   a.special=NULL;
 }
@@ -109,7 +110,7 @@ template<class T> Array<T>::~Array() {
   clear();
 #else //faster (leaves members non-zeroed..)
   if(special) { delete special; special=NULL; }
-  if(d!=&d0) { delete[] d; }
+  if(_shape!=&d0) { delete[] _shape; }
   if(M) {
     globalMemoryTotal -= M*sizeT;
     if(memMove==1) free(p); else delete[] p;
@@ -125,57 +126,56 @@ template<class T> Array<T>&  Array<T>::clear() {
 }
 
 /// resize 1D array, discard the previous contents
-template<class T> Array<T>& Array<T>::resize(uint D0) { nd=1; d0=D0; resetD(); resizeMEM(d0, false); return *this; }
+template<class T> Array<T>& Array<T>::resize(uint D0) { nd=1; d0=D0; resetShape(); resizeMEM(d0, false); return *this; }
 
 /// resize but copy the previous contents
-template<class T> Array<T>& Array<T>::resizeCopy(uint D0) { nd=1; d0=D0; resetD(); resizeMEM(d0, true); return *this; }
+template<class T> Array<T>& Array<T>::resizeCopy(uint D0) { nd=1; d0=D0; resetShape(); resizeMEM(d0, true); return *this; }
 
 /// reshape the dimensionality (e.g. from 2D to 1D); throw an error if this actually requires to resize the memory
 template<class T> Array<T>& Array<T>::reshape(int D0) {
   if(D0<0) D0=N;
   CHECK_EQ((int)N, D0, "reshape must preserve total memory size");
-  nd=1; d0=D0; d1=d2=0; resetD();
+  nd=1; d0=D0; d1=d2=0; resetShape();
   return *this;
 }
 
 /// same for 2D ...
-template<class T> Array<T>& Array<T>::resize(uint D0, uint D1) { nd=2; d0=D0; d1=D1; resetD(); resizeMEM(d0*d1, false); return *this; }
+template<class T> Array<T>& Array<T>::resize(uint D0, uint D1) { nd=2; d0=D0; d1=D1; resetShape(); resizeMEM(d0*d1, false); return *this; }
 
 /// ...
-template<class T> Array<T>& Array<T>::resizeCopy(uint D0, uint D1) { nd=2; d0=D0; d1=D1; resetD(); resizeMEM(d0*d1, true); return *this; }
+template<class T> Array<T>& Array<T>::resizeCopy(uint D0, uint D1) { nd=2; d0=D0; d1=D1; resetShape(); resizeMEM(d0*d1, true); return *this; }
 
 /// ...
 template<class T> Array<T>& Array<T>::reshape(int D0, int D1) {
   if(D0<0) D0=N/D1; else if(D1<0) D1=N/D0;
   CHECK_EQ((int)N, D0*D1, "reshape must preserve total memory size");
   nd=2; d0=D0; d1=D1; d2=0;
-  resetD();
+  resetShape();
   return *this;
 }
 
 /// same for 3D ...
-template<class T> Array<T>& Array<T>::resize(uint D0, uint D1, uint D2) { nd=3; d0=D0; d1=D1; d2=D2; resetD(); resizeMEM(d0*d1*d2, false); return *this; }
+template<class T> Array<T>& Array<T>::resize(uint D0, uint D1, uint D2) { nd=3; d0=D0; d1=D1; d2=D2; resetShape(); resizeMEM(d0*d1*d2, false); return *this; }
 
 /// ...
-template<class T> Array<T>& Array<T>::resizeCopy(uint D0, uint D1, uint D2) { nd=3; d0=D0; d1=D1; d2=D2; resetD(); resizeMEM(d0*d1*d2, true); return *this; }
+template<class T> Array<T>& Array<T>::resizeCopy(uint D0, uint D1, uint D2) { nd=3; d0=D0; d1=D1; d2=D2; resetShape(); resizeMEM(d0*d1*d2, true); return *this; }
 
 /// ...
 template<class T> Array<T>& Array<T>::reshape(int D0, int D1, int D2) {
   if(D0<0) D0=N/(D1*D2); else if(D1<0) D1=N/(D0*D2); else if(D2<0) D2=N/(D0*D1);
   CHECK_EQ((int)N, D0*D1*D2, "reshape must preserve total memory size");
   nd=3; d0=D0; d1=D1; d2=D2;
-  resetD();
+  resetShape();
   return *this;
 }
 
 /// resize to multi-dimensional tensor
 template<class T> Array<T>& Array<T>::resize(uint ND, uint* dim) {
-  nd=ND; d0=d1=d2=0; resetD();
-  uint j;
-  for(j=0; j<nd && j<3; j++) {(&d0)[j]=dim[j]; }
-  if(nd>3) { d=new uint[nd];  memmove(d, dim, nd*sizeof(uint)); }
-  uint64_t S;
-  for(S=1, j=0; j<nd; j++) S*=dim[j];
+  nd=ND; d0=d1=d2=0;
+  if(nd>0){ d0=dim[0]; if(nd>1){ d1=dim[1]; if(nd>2){ d2=dim[2]; } } }
+  resetShape(dim);
+  uint64_t S=(nd>0?1:0);
+  for(uint j=0; j<nd; j++) S*=dim[j];
   if(S>=(1ull <<32)) HALT("Array #elements " <<(S>>30) <<"G is >= 2^32");
   resizeMEM((uint)S, false);
   return *this;
@@ -183,12 +183,11 @@ template<class T> Array<T>& Array<T>::resize(uint ND, uint* dim) {
 
 /// resize to multi-dimensional tensor
 template<class T> Array<T>& Array<T>::resizeCopy(uint ND, uint* dim) {
-  nd=ND; d0=d1=d2=0; resetD();
-  uint j;
-  for(j=0; j<nd && j<3; j++) {(&d0)[j]=dim[j]; }
-  if(nd>3) { d=new uint[nd];  memmove(d, dim, nd*sizeof(uint)); }
-  uint64_t S;
-  for(S=1, j=0; j<nd; j++) S*=dim[j];
+  nd=ND; d0=d1=d2=0;
+  if(nd>0){ d0=dim[0]; if(nd>1){ d1=dim[1]; if(nd>2){ d2=dim[2]; } } }
+  resetShape(dim);
+  uint64_t S=(nd>0?1:0);
+  for(uint j=0; j<nd; j++) S*=dim[j];
   if(S>=(1ull <<32)) HALT("Array #elements " <<(S>>30) <<"G is >= 2^32");
   resizeMEM((uint)S, true);
   return *this;
@@ -196,19 +195,10 @@ template<class T> Array<T>& Array<T>::resizeCopy(uint ND, uint* dim) {
 
 /// resize to multi-dimensional tensor
 template<class T> Array<T>& Array<T>::reshape(uint ND, uint* dim) {
-  nd=ND; d0=d1=d2=0; resetD();
-  if(nd>0){
-    d0=dim[0];
-    if(nd>1){
-      d1=dim[1];
-      if(nd>2){
-        d2=dim[2];
-        if(nd>3) { d=new uint[nd];  memmove(d, dim, nd*sizeof(uint)); }
-      }
-    }
-  }
-  //for(uint j=0; j<nd && j<3; j++) {(&d0)[j]=dim[j]; }
-  uint S=(nd>0?1:0);
+  nd=ND; d0=d1=d2=0;
+  if(nd>0){ d0=dim[0]; if(nd>1){ d1=dim[1]; if(nd>2){ d2=dim[2]; } } }
+  resetShape(dim);
+  uint64_t S=(nd>0?1:0);
   for(uint j=0; j<nd; j++) S*=dim[j];
   CHECK_EQ(N, S, "reshape must preserve total memory size");
   return *this;
@@ -229,8 +219,7 @@ template<class T> Array<T>& Array<T>::resizeAs(const Array<T>& a) {
   CHECK(this!=&a, "never do this!!!");
   if(isReference) CHECK_EQ(N, a.N, "resize of a reference (e.g. subarray) is not allowed! (only a resize without changing memory size)");
   nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2;
-  resetD();
-  if(nd>3) { d=new uint[nd];  memmove(d, a.d, nd*sizeof(uint)); }
+  resetShape(a._shape);
   resizeMEM(a.N, false);
   return *this;
 }
@@ -238,8 +227,8 @@ template<class T> Array<T>& Array<T>::resizeAs(const Array<T>& a) {
 /// make it the same size as \c a and copy previous content
 template<class T> Array<T>& Array<T>::resizeCopyAs(const Array<T>& a) {
   CHECK(this!=&a, "never do this!!!");
-  nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2; resetD();
-  if(nd>3) { d=new uint[nd];  memmove(d, a.d, nd*sizeof(uint)); }
+  nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2;
+  resetShape(a._shape);
   resizeMEM(a.N, true);
   return *this;
 }
@@ -247,15 +236,15 @@ template<class T> Array<T>& Array<T>::resizeCopyAs(const Array<T>& a) {
 template<class T> Array<T>& Array<T>::reshapeAs(const Array<T>& a) {
   CHECK(this!=&a, "never do this!!!");
   CHECK_EQ(N, a.N, "reshape must preserve total memory size");
-  nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2; resetD();
-  if(nd>3) { d=new uint[nd];  memmove(d, a.d, nd*sizeof(uint)); }
+  nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2;
+  resetShape(a._shape);
   return *this;
 }
 
 /// return the k-th dimensionality
 template<class T> uint Array<T>::dim(uint k) const {
   CHECK(k<nd, "dimensionality range check error: " <<k <<"!<" <<nd);
-  if(!d && k<3) return (&d0)[k]; else return d[k];
+  if(!_shape && k<3) return (&d0)[k]; else return _shape[k];
 }
 
 #ifdef RAI_CLANG
@@ -363,10 +352,9 @@ template<class T> void Array<T>::freeMEM() {
     M=0;
   }
 #endif
-  if(d && d!=&d0) { delete[] d; d=NULL; }
+  if(_shape!=&d0) { delete[] _shape; _shape=&d0; }
   p=NULL;
   N=nd=d0=d1=d2=0;
-  d=&d0;
   isReference=false;
 }
 
@@ -386,9 +374,13 @@ template<class T> Array<T>& Array<T>::dereference() {
 }
 
 /// reset the dimensionality pointer d to point to &d0
-template<class T> void Array<T>::resetD() {
-  if(d && d!=&d0) { delete[] d; d=NULL; }
-  d=&d0;
+template<class T> void Array<T>::resetShape(uint* dim) {
+  if(_shape!=&d0) { delete[] _shape; _shape=&d0; }
+  if(nd>3) {
+    CHECK(dim, "need shape tuple");
+    _shape=new uint[nd];
+    memmove(_shape, dim, nd*sizeof(uint));
+  }
 }
 
 //***** append, insert & remove
@@ -688,7 +680,7 @@ template<class T> void Array<T>::resizeDim(uint k, uint dk) {
 /// return a uint-Array that contains (acutally refers to) the dimensions of 'this'
 template<class T> Array<uint> Array<T>::dim() const {
   Array<uint> dims;
-  dims.setCarray(d, nd);
+  dims.setCarray(_shape, nd);
   return dims;
 }
 
@@ -1340,8 +1332,8 @@ template<class T> void Array<T>::referToDim(const Array<T>& a, int i) {
   } else if(a.nd>3) {
     uint n=a.N/a.d0;
     referTo(a.p+i*n, n);
-    nd=a.nd-1;  d0=a.d1;  d1=a.d2;  d2=a.d[3];
-    if(nd>3) { d=new uint[nd];  memmove(d, a.d+1, nd*sizeof(uint)); }
+    nd=a.nd-1;  d0=a.d1;  d1=a.d2;  d2=a._shape[3];
+    resetShape(a._shape+1);
   }
 }
 
@@ -1363,14 +1355,14 @@ template<class T> void Array<T>::referToDim(const Array<T>& a, uint i, uint j, u
   CHECK(i<a.d0 && j<a.d1 && k<a.d2, "SubDim range error (" <<i <<"<" <<a.d0 <<", " <<j <<"<" <<a.d1 <<", " <<k <<"<" <<a.d2 << ")");
 
   if(a.nd==4) {
-    referTo(&a(i, j, k), a.d[3]);
+    referTo(&a(i, j, k), a._shape[3]);
   } else if(a.nd==5) {
     NIY;
 //    nd=2; d0=a.d[3]; d1=a.d[4]; d2=0; N=d0*d1;
   } else if(a.nd>5) {
     NIY;
 //    nd=a.nd-3; d0=a.d[3]; d1=a.d[4]; d2=a.d[5]; N=a.N/(a.d0*a.d1*a.d2);
-//    resetD();
+//    resetShape();
 //    if(nd>3) { d=new uint[nd];  memmove(d, a.d+3, nd*sizeof(uint)); }
   }
 //  p=a.p+(i*a.N+(j*a.N+(k*a.N/a.d2))/a.d1)/a.d0;
@@ -1383,6 +1375,7 @@ template<class T> void Array<T>::takeOver(Array<T>& a) {
   freeMEM();
   memMove=a.memMove;
   N=a.N; nd=a.nd; d0=a.d0; d1=a.d1; d2=a.d2;
+  resetShape(a._shape);
   p=a.p; M=a.M;
   special=a.special;
 #if 0 //a remains reference on this
@@ -1391,7 +1384,7 @@ template<class T> void Array<T>::takeOver(Array<T>& a) {
 #else //a is cleared
   a.p=NULL;
   a.M=a.N=a.nd=a.d0=a.d1=a.d2=0;
-  if(a.d && a.d!=&a.d0) { delete[] a.d; a.d=NULL; }
+  a.resetShape();
   a.special=0;
   a.isReference=false;
 #endif
@@ -1611,10 +1604,10 @@ template<class T> void Array<T>::write(std::ostream& os, const char* ELEMSEP, co
         }
       }
     if(nd>3) {
-      CHECK(d && d!=&d0, "");
+      CHECK(_shape && _shape!=&d0, "");
       for(i=0; i<N; i++) {
-        if(i && !(i%d[nd-1])) os <<LINESEP;
-        if(nd>1 && !(i%(d[nd-2]*d[nd-1]))) os <<LINESEP;
+        if(i && !(i%_shape[nd-1])) os <<LINESEP;
+        if(nd>1 && !(i%(_shape[nd-2]*_shape[nd-1]))) os <<LINESEP;
         os <<(i?ELEMSEP:"") <<elem(i);
       }
     }

robotic/include/rai/Core/arrayDouble.h

@@ -284,22 +284,23 @@ arr& getNoArr();
 /// @{
 
 /// a generic vector-valued function \f$f:~x\mapsto y\in\mathbb{R}^d\f$, where return value may have Jacobian attached
-typedef std::function<arr(const arr& x)> fct;
+// typedef std::function<arr(const arr& x)> fct;
 typedef std::function<arr(const arr& x)> VectorFunction;
-
-/// a scalar function \f$f:~x\mapsto y\in\mathbb{R}\f$ with optional gradient and hessian
-struct ScalarFunction {
-  uint dim;
-  virtual double f(arr& g, arr& H, const arr& x) = 0;
-  virtual ~ScalarFunction() {}
-  std::function<double(const arr& x)> cfunc(){ return [this](const arr& x){ return this->f(NoArr, NoArr, x); }; }
-};
-
-struct Conv_cfunc2ScalarFunction : ScalarFunction {
-  std::function<double(arr& g, arr& H, const arr& x)> cfunc;
-  Conv_cfunc2ScalarFunction(std::function<double(arr& g, arr& H, const arr& x)> _cfunc) : cfunc(_cfunc) {}
-  double f(arr& g, arr& H, const arr& x){ return cfunc(g, H, x); }
-};
+typedef std::function<double(arr& g, arr& H, const arr& x)> ScalarFunction;
+
+// /// a scalar function \f$f:~x\mapsto y\in\mathbb{R}\f$ with optional gradient and hessian
+// struct ScalarFunction {
+//   uint dim;
+//   virtual double f(arr& g, arr& H, const arr& x) = 0;
+//   virtual ~ScalarFunction() {}
+//   std::function<double(const arr& x)> cfunc(){ return [this](const arr& x){ return this->f(NoArr, NoArr, x); }; }
+// };
+
+// struct Conv_cfunc2ScalarFunction : ScalarFunction {
+//   std::function<double(arr& g, arr& H, const arr& x)> cfunc;
+//   Conv_cfunc2ScalarFunction(std::function<double(arr& g, arr& H, const arr& x)> _cfunc) : cfunc(_cfunc) {}
+//   double f(arr& g, arr& H, const arr& x){ return cfunc(g, H, x); }
+// };
 
 /// a kernel function
 struct KernelFunction {
@@ -370,6 +371,7 @@ inline arr range(double lo, double hi, uint steps) { return rai::grid(1, lo, hi,
 //inline uintA range(uint n) { uintA r;  r.setStraightPerm(n);  return r; }
 
 arr repmat(const arr& A, uint m, uint n);
+arr match(const arr& A, const uintA& shape);
 
 //inline uintA randperm(uint n) {  uintA z;  z.setRandomPerm(n);  return z; }
 inline arr linspace(double base, double limit, uint n) {  return rai::grid(1, base, limit, n).reshape(-1); }
@@ -437,11 +439,13 @@ arr reshapeColor(const arr& col, int d0=-1);
 
 void scanArrFile(const char* name);
 
-arr finiteDifferenceGradient(ScalarFunction& f, const arr& x, arr& Janalytic=NoArr, double eps=1e-8);
-arr finiteDifferenceJacobian(const VectorFunction& f, const arr& _x, arr& Janalytic=NoArr, double eps=1e-8);
-bool checkGradient(ScalarFunction& f, const arr& x, double tolerance, bool verbose=false);
-bool checkHessian(ScalarFunction& f, const arr& x, double tolerance, bool verbose=false);
-bool checkJacobian(const VectorFunction& f, const arr& x, double tolerance, bool verbose=false, const StringA& featureNames= {});
+arr finiteDifference_gradient(ScalarFunction f, const arr& x0, double y0, double eps=1e-8);
+arr finiteDifference_jacobian(VectorFunction f, const arr& x0, const arr& y0, double eps=1e-8);
+// arr finiteDifferenceGradient(ScalarFunction f, const arr& x, arr& Janalytic=NoArr, double eps=1e-8);
+// arr finiteDifferenceJacobian(VectorFunction f, const arr& _x, arr& Janalytic=NoArr, double eps=1e-8);
+bool checkGradient(ScalarFunction f, const arr& x, double tolerance, bool verbose=false);
+bool checkHessian(ScalarFunction f, const arr& x, double tolerance, bool verbose=false);
+bool checkJacobian(VectorFunction f, const arr& x, double tolerance, bool verbose=false, const StringA& featureNames= {});
 void boundClip(arr& y, const arr& bounds);
 bool boundCheck(const arr& x, const arr& bounds, double eps=1e-3, bool verbose=true);
 
@@ -494,8 +498,8 @@ double euclideanDistance(const arr& v, const arr& w);
 double metricDistance(const arr& g, const arr& v, const arr& w);
 
 //min max
-arr max(const arr& v, uint d);
-arr min(const arr& v, uint d);
+arr max(const arr& v, uint axis);
+arr min(const arr& v, uint axis);
 uint argmin(const arr& x);
 uint argmax(const arr& x);
 void argmax(uint& i, uint& j, const arr& x);
@@ -505,7 +509,7 @@ double absMax(const arr& x);
 double absMin(const arr& x);
 
 double sum(const arr& v);
-arr sum(const arr& v, uint d);
+arr sum(const arr& v, uint axis);
 double sumOfAbs(const arr& v);
 double sumOfPos(const arr& v);
 double sumOfSqr(const arr& v);
@@ -514,9 +518,9 @@ double product(const arr& v);
 
 double trace(const arr& v);
 double var(const arr& v);
-arr mean(const arr& v);
+arr mean(const arr& v, uint axis=0);
 arr covar(const arr& X);
-arr stdDev(const arr& v);
+arr vardiag(const arr& X);
 void clip(const arr& x, double lo, double hi);
 
 void op_transpose(arr& x, const arr& y);

robotic/include/rai/DataGen/shapenetGrasps.h

@@ -2,7 +2,7 @@
 
 #include <Core/util.h>
 #include <Kin/kin.h>
-#include <Kin/kin_physx.h>
+#include <Kin/i_Physx.h>
 
 struct ShapenetGrasps_Options {
   RAI_PARAM("ShapenetGrasps/", int, verbose, 1)

robotic/include/rai/Geo/mesh.h

@@ -44,8 +44,6 @@ struct Mesh {
 
   rai::Transformation glX; ///< transform (only used for drawing! Otherwise use applyOnPoints)  (optional)
 
-  int version = 0;
-
   uint _support_vertex=0;
   bool isArrayFormatted=false;
 
@@ -70,11 +68,11 @@ struct Mesh {
   void setCapsule(double r, double l, uint fineness=2);
   void setSSBox(double x_width, double y_width, double z_height, double r, uint fineness=2);
   void setSSCvx(const arr& core, double r, uint fineness=2);
-  void setImplicitSurface(std::function<double (const arr&)> f, double lo=-10., double up=+10., uint res=100);
+  void setImplicitSurface(ScalarFunction f, double lo=-10., double up=+10., uint res=100);
   void setImplicitSurface(std::function<double(const arr& x)> f, const arr& bounds, uint res);
   void setImplicitSurface(const arr& gridValues, const arr& size);
   void setImplicitSurface(const floatA& gridValues, const arr& size);
-  void setImplicitSurfaceBySphereProjection(ScalarFunction& f, double rad, uint fineness=3);
+  void setImplicitSurfaceBySphereProjection(ScalarFunction f, double rad, uint fineness=3);
   Mesh& setRandom(uint vertices=10);
   void setGrid(uint X, uint Y);