robotic 0.3.4.dev1__cp312-cp312-manylinux2014_x86_64.whl → 0.3.4.dev3__cp312-cp312-manylinux2014_x86_64.whl

robotic/_robotic.pyi

@@ -236,7 +236,7 @@ class CameraView:
         """
         constructor
         """
-    def computeImageAndDepth(self, config: Config, visualsOnly: bool = True) -> tuple:
+    def computeImageAndDepth(self, config: Config, simulateDepthNoise: bool = False, visualsOnly: bool = True) -> tuple:
         """
         returns image and depth from a camera sensor; the 'config' argument needs to be the same configuration as in the constructor, but in new state
         """
@@ -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: float = -1.0) -> 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):
         ...
@@ -1612,12 +1630,18 @@ class RRT_PathFinder:
         """
         only after setProblem
         """
+    def setOptions(self, verbose: int = 0, stepsize: float = 0.1, subsamples: int = 4, maxIters: int = 5000, p_connect: float = 0.5, collisionTolerance: float = 0.0001, useBroadCollisions: bool = True) -> RRT_PathFinder:
+        """
+        set solver options
+        """
     def setProblem(self, Configuration: Config) -> None:
         ...
     def setStartGoal(self, starts: arr, goals: arr) -> None:
         ...
     def solve(self, verbose: int = 1) -> SolverReturn:
         ...
+    def view(self, pause: bool, message: str = None, play: bool = False) -> None:
+        ...
 class ST:
     """
     Members:
@@ -1921,6 +1945,10 @@ class Simulation:
         ...
     def selectSensor(self, sensorName: str) -> ...:
         ...
+    def setSimulateDepthNoise(self, _setSimulateDepthNoise: bool) -> None:
+        """
+        specify (boolean) on whether to simulate noise
+        """
     def setSplineRef(self, path: arr, times: arr, append: bool = True) -> None:
         """
         set the spline reference to generate motion

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();
@@ -329,6 +335,7 @@ template<class T> void operator+=(Array<T>& x, const T& y);
 template<class T> void operator-=(Array<T>& x, const Array<T>& y);
 template<class T> void operator-=(Array<T>& x, const T& y);
 template<class T> void operator*=(Array<T>& x, const T& y);
+template<class T> void operator/=(Array<T>& x, const T& y);
 
 template<class T> Array<T> operator+(const Array<T>& y, const Array<T>& z) { Array<T> x(y); x+=z; return x; }
 template<class T> Array<T> operator+(const Array<T>& y, T z) {                Array<T> x(y); x+=z; return x; }
@@ -447,8 +454,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 +686,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);
       }
     }
@@ -1951,15 +1944,9 @@ template<class T> void operator+=(Array<T>& x, const Array<T>& y) {
       else x.J() = *y.jac;
     }
   }
-  // CHECK_EQ(x.N, y.N, "update operator on different array dimensions (" <<x.N <<", " <<y.N <<")");
-  // T* xp=x.p, *xstop=xp+x.N;
-  // const T* yp=y.p;
-  // for(; xp!=xstop; xp++, yp++) *xp += *yp;
 }
 template<class T> void operator+=(Array<T>& x, const T& y) {
   UpdateOperator_MS(+=);
-  // T* xp=x.p, *xstop=xp+x.N;
-  // for(; xp!=xstop; xp++) *xp += y;
 }
 template<class T> void operator-=(Array<T>& x, const Array<T>& y) {
   UpdateOperator_MM(-=);
@@ -1969,23 +1956,21 @@ template<class T> void operator-=(Array<T>& x, const Array<T>& y) {
       else x.J() = -(*y.jac);
     }
   }
-  // CHECK_EQ(x.N, y.N, "update operator on different array dimensions (" <<x.N <<", " <<y.N <<")");
-  // T* xp=x.p, *xstop=xp+x.N;
-  // const T* yp=y.p;
-  // for(; xp!=xstop; xp++, yp++) *xp -= *yp;
 }
 template<class T> void operator-=(Array<T>& x, const T& y) {
   UpdateOperator_MS(-=);
-  // T* xp=x.p, *xstop=xp+x.N;
-  // for(; xp!=xstop; xp++) *xp -= y;
 }
 template<class T> void operator*=(Array<T>& x, const T& y) {
   if constexpr(std::is_same_v<T, double>){
     if(x.jac) *x.jac *= y;
   }
   UpdateOperator_MS(*=);
-  // T* xp=x.p, *xstop=xp+x.N;
-  // for(; xp!=xstop; xp++) *xp *= y;
+}
+template<class T> void operator/=(Array<T>& x, const T& y) {
+  if constexpr(std::is_same_v<T, double>){
+    if(x.jac) *x.jac /= y;
+  }
+  UpdateOperator_MS(/=);
 }
 
 #undef UpdateOperator_MM