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

robotic/include/rai/{Geo → Algo}/Lewiner/MarchingCubes.h

@@ -158,35 +158,6 @@ public :
   void clean_all  () ;
 
 
-//-----------------------------------------------------------------------------
-// Exportation
-public :
-  /**
-   * PLY exportation of the generated mesh
-   * \param fn  name of the PLY file to create
-   * \param bin if true, the PLY will be written in binary mode
-   */
-  void writePLY( const char *fn, bool bin = false ) ;
-
-  /**
-   * PLY importation of a mesh
-   * \param fn  name of the PLY file to read from
-   */
-  void readPLY( const char *fn ) ;
-
-  /**
-   * VRML / Open Inventor exportation of the generated mesh
-   * \param fn  name of the IV file to create
-   */
-  void writeIV ( const char *fn ) ;
-
-  /**
-   * ISO exportation of the input grid
-   * \param fn  name of the ISO file to create
-   */
-  void writeISO( const char *fn ) ;
-
-
 //-----------------------------------------------------------------------------
 // Algorithm
 public :

robotic/include/rai/Algo/SplineCtrlFeed.h

@@ -40,7 +40,7 @@ struct BSplineCtrlReference : ReferenceFeed {
   //info:
   double getEndTime() { return spline.get()->end(); }
   arr getEndPoint() { return spline.get()->ctrlPoints[-1].copy(); }
-  void eval(arr& x, arr& xDot, arr& xDDot, double t) { spline.get()->eval2(x, xDot, xDDot, t); }
+  void eval(arr& x, arr& xDot, arr& xDDot, double t) { spline.get()->eval3(x, xDot, xDDot, t); }
 
   void report(double ctrlTime);
 };

robotic/include/rai/Algo/marching_cubes.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../Core/array.h"
+
+namespace rai {
+
+std::tuple<arr, uintA> marching_cubes(const floatA& grid_values, const arr& size);
+
+}

robotic/include/rai/Algo/rungeKutta.h

@@ -14,12 +14,12 @@ 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),
 //           double dt);
-void rk4_2ndOrder(arr& x, const arr& x0, const fct& f, double dt);
+arr rk4_2ndOrder(const arr& x0, const std::function<arr (const arr&, const arr&)>& f, double dt);
 
 /** RK with discrete event localization (zero-crossing detection): the
     function sf computes some double-valued indicators. If one of

robotic/include/rai/Algo/spline.h

@@ -29,27 +29,23 @@ struct BSpline {
   arr getBmatrix(const arr& sampleTimes, bool startDuplicates=false, bool endDuplicates=false);
 
   //-- methods concerning ctrl points
-  void setCtrlPoints(const arr& pts, bool addStartDuplicates=true, bool addEndDuplicates=true, const arr& setStartVel=NoArr, const arr& setEndVel=NoArr);
-  void append(const arr& points, const arr& times, bool inside);
+  void setCtrlPoints(const arr& points, bool addStartDuplicates=true, bool addEndDuplicates=true, const arr& setStartVel=NoArr, const arr& setEndVel=NoArr);
 
   //-- convenience user functions
   BSpline& set(uint _degree, const arr& points, const arr& times, const arr& startVel=NoArr, const arr& endVel=NoArr);
+  void overwriteSmooth(const arr& points, const arr& times_rel, double time_cut);
+  void append(const arr& points, const arr& times_rel, bool inside);
   void clear();
   arr& getKnots(){ return knots; }
   arr& getCtrlPoints(){ return ctrlPoints; }
   arr getPoints();
 
-  //-- obsolete
-  // BSpline& set_vel(uint degree, const arr& points, const arr& velocities, const arr& _times);
-
-
   //experimental
   void doubleKnot(uint t);
   void setDoubleKnotVel(int t, const arr& vel);
 
   /// core method to evaluate spline
-  // void eval(arr& x, arr& xDot, arr& xDDot, double t) const;
-  void eval2(arr& x, arr& xDot, arr& xDDot, double t, arr& Jpoints=NoArr, arr& Jtimes=NoArr) const;
+  void eval3(arr& x, arr& xDot, arr& xDDot, double t, arr& Jpoints=NoArr, arr& Jtimes=NoArr) const;
   arr eval(double t, uint derivative=0) const;
   arr eval(const arr& sampleTimes, uint derivative=0) const;
 

robotic/include/rai/Algo/trilinear.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "../Core/array.h"
+
+namespace rai {
+
+template<class T>
+rai::Array<T> trilinear_interpolate(const arr& pts, const rai::Array<T>& grid_values, const arr& grid_res);
+
+} //namespace

robotic/include/rai/Control/CtrlSolver.h

@@ -15,7 +15,7 @@
 
 //===========================================================================
 
-struct CtrlSolver : NonCopyable {
+struct CtrlSolver : rai::NonCopyable {
   KOMO komo;
   double tau;
   double maxVel=1.;

robotic/include/rai/Control/TimingMPC.h

@@ -44,8 +44,8 @@ struct TimingMPC {
 
   uint nPhases() const { return waypoints.d0; }
   bool done() const { return phase>=nPhases(); }
-  arr getWaypoints() const { if(done()) return waypoints[-1].copy().reshape(1, -1); return waypoints({phase, -1}).copy(); }
-  arr getTimes() const { if(done()) return {.1}; return integral(tau({phase, -1})); }
+  arr getWaypoints() const { if(done()) return waypoints[-1].copy().reshape(1, -1); return waypoints({phase,0}).copy(); }
+  arr getTimes() const { if(done()) return {.1}; return integral(tau({phase,0})); }
   arr getVels() const;
 
   bool set_progressedTime(double gap, double tauCutoff=0.);

robotic/include/rai/Core/array.h

@@ -14,6 +14,8 @@
 #include <initializer_list>
 #include <tuple>
 #include <iostream>
+#include <memory>
+#include <vector>
 
 using std::endl;
 
@@ -26,6 +28,8 @@ namespace rai {
 extern const char* arrayElemsep;
 extern const char* arrayLinesep;
 extern const char* arrayBrackets;
+extern int64_t globalMemoryTotal, globalMemoryBound;
+extern bool globalMemoryStrict;
 
 // default sorting methods
 template<class T> bool lower(const T& a, const T& b) { return a<b; }
@@ -42,9 +46,13 @@ template<class T> bool greaterEqual(const T& a, const T& b) { return a>=b; }
 
 namespace rai {
 
+//fwd declarations
 template<class T> struct ArrayModRaw;
 template<class T> struct ArrayModList;
 struct SpecialArray;
+struct SparseVector;
+struct SparseMatrix;
+struct RowShifted;
 
 /** Simple array container to store arbitrary-dimensional arrays (tensors).
   Can buffer more memory than necessary for faster
@@ -59,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
@@ -78,6 +86,7 @@ template<class T> struct Array {
   explicit Array(uint D0, uint D1, uint D2);
   Array(std::initializer_list<T> values);
   Array(std::initializer_list<uint> dim, std::initializer_list<T> values);
+  explicit Array(const T* p, uint size, bool byReference);
   virtual ~Array();
 
   /// @name assignments
@@ -86,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}; }
@@ -132,7 +147,6 @@ template<class T> struct Array {
   Array<T>& resizeAs(const Array<T>& a);
   Array<T>& reshapeAs(const Array<T>& a);
   Array<T>& resizeCopyAs(const Array<T>& a);
-  Array<T>& reshapeFlat();
   Array<T>& dereference();
 
   /// @name dimensionality access
@@ -142,7 +156,7 @@ template<class T> struct Array {
   /// @name initializing/assigning entries
   Array<T>& clear();
   Array<T>& setZero(byte zero=0);
-  void setUni(const T& scalar, int d=-1);
+  void setConst(const T& scalar, int d=-1);
   void setId(int d=-1);
   void setDiag(const T& scalar, int d=-1);
   void setDiag(const Array<T>& vector);
@@ -156,17 +170,16 @@ template<class T> struct Array {
   void setReversePerm(int n=-1);
   void setRandomPerm(int n=-1);
   Array<T>& setCarray(const T* buffer, uint D0);
-  Array<T>& setCarray(const T** buffer, uint D0, uint D1);
+  Array<T>& setCarray(T* const* buffer, uint D0, uint D1);
   Array<T>& referTo(const T* buffer, uint n);
   void referTo(const Array<T>& a);
-  void referToRange(const Array<T>& a, int i_lo, int i_up);
-  void referToRange(const Array<T>& a, int i, int j_lo, int j_up);
-  void referToRange(const Array<T>& a, int i, int j, int k_lo, int k_up);
+  void referToRange(const Array<T>& a, std::pair<int, int> I);
+  void referToRange(const Array<T>& a, int i,  std::pair<int, int> J);
+  void referToRange(const Array<T>& a, int i, int j,  std::pair<int, int> K);
   void referToDim(const Array<T>& a, int i);
   void referToDim(const Array<T>& a, uint i, uint j);
   void referToDim(const Array<T>& a, uint i, uint j, uint k);
   void takeOver(Array<T>& a);  //a is cleared (earlier: becomes a reference to its previously owned memory)
-  Array<T>& setGrid(uint dim, T lo, T hi, uint steps);
 
   /// @name access by reference (direct memory access)
   Array<T> ref() const; //a reference on this
@@ -191,11 +204,11 @@ template<class T> struct Array {
 
   /// @name access by copy
   Array<T> copy() const;
-  Array<T> sub(int i, int I) const;
-  Array<T> sub(int i, int I, int j, int J) const;
-  Array<T> sub(int i, int I, int j, int J, int k, int K) const;
-  Array<T> sub(int i, int I, Array<uint> cols) const;
-  Array<T> sub(Array<uint> elems) const;
+  Array<T> sub(std::pair<int, int> I) const;
+  Array<T> sub(std::pair<int, int> I, std::pair<int, int> J) const;
+  Array<T> sub(std::pair<int, int> I, std::pair<int, int> J, std::pair<int, int> K) const;
+  Array<T> pick(std::pair<int, int> I, Array<uint> cols) const;
+  Array<T> pick(Array<uint> elems) const;
   Array<T> row(uint row_index) const;
   Array<T> rows(uint start_row, uint end_row) const;
   Array<T> col(uint col_index) const;
@@ -225,7 +238,7 @@ template<class T> struct Array {
   void delRows(int i, uint k=1);
   void delColumns(int i, uint k=1);
   void insRows(int i, uint k=1);
-  void insColumns(int i, uint k=1);
+  Array<T>& insColumns(int i, uint k=1);
   void resizeDim(uint k, uint dk);
   void setAppend(const T& x); //? same as if(findValue(x)==-1) append(x)
   void setAppend(const Array<T>& x);
@@ -256,6 +269,22 @@ template<class T> struct Array {
   void permuteRandomly();
   void shift(int offset, bool wrapAround=true);
 
+  /// @name special matrices -- only for double
+  double sparsity();
+  SparseMatrix& sparse();
+  const SparseMatrix& sparse() const;
+  SparseVector& sparseVec();
+  const SparseVector& sparseVec() const;
+  RowShifted& rowShifted();
+  const RowShifted& rowShifted() const;
+
+  /// @name attached Jacobian -- only for double
+  std::unique_ptr<Array<double>> jac=0; ///< optional pointer to Jacobian, to enable autodiff
+  void J_setId();
+  Array<double>& J();
+  Array<double> noJ() const;
+  Array<double> J_reset();
+
   /// @name I/O
   void write(std::ostream& os=std::cout, const char* ELEMSEP=nullptr, const char* LINESEP=nullptr, const char* BRACKETS=nullptr, bool dimTag=false, bool binary=false) const;
   Array<T>& read(std::istream& is);
@@ -281,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();
@@ -299,33 +328,15 @@ template<class T> bool operator==(const Array<T>& v, const Array<T>& w); //equal
 template<class T> Array<byte> operator==(const Array<T>& v, const T& w); //element-wise equal
 template<class T> bool operator!=(const Array<T>& v, const Array<T>& w);
 template<class T> std::istream& operator>>(std::istream& is, Array<T>& x);
-template<class T> Array<T>& operator>>(Array<T>& x, std::istream& is);
 template<class T> std::ostream& operator<<(std::ostream& os, const Array<T>& x);
 
-template<class T> void operator+=(Array<T>& x, const Array<T>& y) {
-  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) {
-  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) {
-  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) {
-  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) {
-  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);
+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; }
 template<class T> Array<T> operator-(const Array<T>& y, const Array<T>& z) { Array<T> x(y); x-=z; return x; }
@@ -360,6 +371,7 @@ template <class T> std::ostream& operator<<(std::ostream& os, const ArrayModList
 /// @name standard types
 /// @{
 
+typedef rai::Array<double> arr;
 typedef rai::Array<uint>   uintA;
 typedef rai::Array<int>    intA;
 typedef rai::Array<char>   charA;
@@ -373,6 +385,8 @@ typedef rai::Array<intA>   intAA;
 typedef rai::Array<uintA>  uintAA;
 
 namespace rai { struct String; }
+typedef rai::Array<rai::String> strA;
+typedef rai::Array<rai::String> strAA;
 typedef rai::Array<rai::String> StringA;
 typedef rai::Array<StringA> StringAA;
 typedef rai::Array<rai::String*> StringL;
@@ -385,7 +399,7 @@ typedef rai::Array<rai::String*> StringL;
 namespace rai {
 
 /// return array of c's
-template<class T> Array<T> consts(const T& c, const uintA& d)  {  Array<T> z;  z.resize(d);  z.setUni(c);  return z; }
+template<class T> Array<T> consts(const T& c, const uintA& d)  {  Array<T> z;  z.resize(d);  z.setConst(c);  return z; }
 /// return VECTOR of c's
 template<class T> Array<T> consts(const T& c, uint n) { return consts(c, uintA{n}); }
 /// return matrix of c's
@@ -410,6 +424,11 @@ template<class T> Array<Array<T>> getArrayArray(const Array<T>& data) {
   return xx;
 }
 
+/** @brief return a `dim'-dimensional grid with `steps' intervals
+  filling the range [lo, hi] in each dimension. Note: returned array is
+  `flat', rather than grid-shaped. */
+template<class T> Array<T> grid(uint dim, T lo, T hi, uint steps);
+
 }
 
 //===========================================================================
@@ -435,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);
@@ -526,8 +545,7 @@ template<class T> Array<T> setSectionSorted(const Array<T>& x, const Array<T>& y
   return R;
 }
 
-template<class T>
-void setMinusSorted(Array<T>& x, const Array<T>& y, bool (*comp)(const T& a, const T& b)) {
+template<class T> void setMinusSorted(Array<T>& x, const Array<T>& y, bool (*comp)(const T& a, const T& b)) {
 #if 1
   int i=x.N-1, j=y.N-1;
   if(j<0) return;
@@ -563,6 +581,7 @@ template<class T> uint numberSharedElements(const Array<T>& x, const Array<T>& y
 //
 // special iterators
 
+
 namespace rai {
 
 template<class T>
@@ -665,7 +684,10 @@ template<class T> Array<T>& Array<T>::setNoArr() { special = new SpecialArray(Sp
 
 namespace rai {
 uint product(const uintA& x);
-uint max(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);
@@ -687,6 +709,19 @@ void b64_encode(char* code, int code_len, const char* data, int data_len);
 void b64_decode(char* data, int data_len, const char* code, int code_len);
 }
 
+//===========================================================================
+//
+// conversions
+//
+
+template<class T> rai::Array<T> as_arr(const std::vector<T>& a, bool byReference) {
+  return rai::Array<T>(&a.front(), a.size(), byReference);
+}
+
+template<class T> std::vector<T> as_vector(const rai::Array<T>& a) {
+  return std::vector<T>(a.p, a.p+a.N);
+}
+
 //===========================================================================
 //
 // implementations