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

robotic/include/rai/Core/arrayDouble.h

@@ -38,9 +38,6 @@ struct Serializable {
 namespace rai {
 
 //struct FileToken;
-struct SparseVector;
-struct SparseMatrix;
-struct RowShifted;
 
 // OLD, TODO: hide -> array.cpp
 extern bool useLapack;
@@ -66,6 +63,7 @@ extern const char* arrayBrackets;
 
 namespace rai {
 
+#if 0
 /** Simple array container to store arbitrary-dimensional arrays (tensors).
   Can buffer more memory than necessary for faster
   resize; enables non-const reference of subarrays; enables fast
@@ -105,7 +103,7 @@ struct ArrayDouble : public Array<double> {
   using Array<double>::elem; //adopt all elem(..) methods
   double& elem(int i, int j); //access that also handles sparse matrices
   using Array<double>::operator(); //adopt all double& operator()(..) methods
-  ArrayDouble operator()(std::pair<int, int> I) const { ArrayDouble z; z.referToRange(*this, I.first, I.second); return z; }
+  ArrayDouble operator()(std::pair<int, int> I) const { ArrayDouble z; z.referToRange(*this, I.first, I.second+1); return z; }
   ArrayDouble operator()(int i, std::pair<int, int> J) const { ArrayDouble z; z.referToRange(*this, i, J.first, J.second); return z; }
   ArrayDouble operator()(int i, int j, std::initializer_list<int> K) const;
   ArrayDouble operator[](int i) const { ArrayDouble z; z.referToDim(*this, i); return z; }
@@ -147,11 +145,10 @@ struct ArrayDouble : public Array<double> {
 
   void write(std::ostream& os=stdCout(), const char* ELEMSEP=nullptr, const char* LINESEP=nullptr, const char* BRACKETS=nullptr, bool dimTag=false, bool binary=false) const;
 };
+#endif
 
 }
 
-typedef rai::ArrayDouble arr;
-
 //===========================================================================
 ///
 /// @name alternative iterators
@@ -287,12 +284,24 @@ 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
 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 {
   virtual double k(const arr& x1, const arr& x2, arr& g1=NoArr, arr& Hx1=NoArr) = 0;
@@ -328,7 +337,7 @@ inline arr zeros(uint d0, uint d1) { return zeros(uintA{d0, d1}); }
 inline arr zeros(uint d0, uint d1, uint d2) { return zeros(uintA{d0, d1, d2}); }
 
 /// return array of c's
-inline arr consts(const double& c, const uintA& d)  {  arr z;  z.resize(d);  z.setUni(c);  return z; }
+inline arr consts(const double& c, const uintA& d)  {  arr z;  z.resize(d);  z.setConst(c);  return z; }
 /// return VECTOR of c's
 inline arr consts(const double& c, uint n) { return consts(c, uintA{n}); }
 /// return matrix of c's
@@ -357,16 +366,15 @@ inline arr randn(uint d0, uint d1) { return randn(uintA{d0, d1}); }
 
 /// return a grid with different lo/hi/steps in each dimension
 arr grid(const arr& lo, const arr& hi, const uintA& steps);
-/// return a grid (1D: range) split in 'steps' steps
-inline arr grid(uint dim, double lo, double hi, uint steps) { arr g;  g.setGrid(dim, lo, hi, steps);  return g; }
 /// return a 1D-grid
-inline arr range(double lo, double hi, uint steps) { arr g;  g.setGrid(1, lo, hi, steps).reshape(-1);  return g; }
+inline arr range(double lo, double hi, uint steps) { return rai::grid(1, lo, hi, steps).reshape(-1); }
 //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) {  arr z;  z.setGrid(1, base, limit, n).reshape(-1);  return z;  }
+inline arr linspace(double base, double limit, uint n) {  return rai::grid(1, base, limit, n).reshape(-1); }
 arr logspace(double base, double limit, uint n);
 
 void normalizeWithJac(arr& y, arr& J, double eps=0.);
@@ -431,11 +439,13 @@ arr reshapeColor(const arr& col, int d0=-1);
 
 void scanArrFile(const char* name);
 
-arr finiteDifferenceGradient(const ScalarFunction& f, const arr& x, arr& Janalytic=NoArr);
-arr finiteDifferenceJacobian(const VectorFunction& f, const arr& _x, arr& Janalytic=NoArr);
-bool checkGradient(const ScalarFunction& f, const arr& x, double tolerance, bool verbose=false);
-bool checkHessian(const 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);
 
@@ -488,10 +498,8 @@ double euclideanDistance(const arr& v, const arr& w);
 double metricDistance(const arr& g, const arr& v, const arr& w);
 
 //min max
-double min(const arr& x);
-double max(const arr& x);
-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);
@@ -501,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);
@@ -510,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);
@@ -612,6 +620,8 @@ inline bool isEmptyShape(const arr& X)   { return X.special && X.special->type==
 inline bool isRowShifted(const arr& X)   { return X.special && X.special->type==SpecialArray::RowShiftedST; }
 inline bool isSparseMatrix(const arr& X) { return X.special && X.special->type==SpecialArray::sparseMatrixST; }
 inline bool isSparseVector(const arr& X) { return X.special && X.special->type==SpecialArray::sparseVectorST; }
+void special_copy(arr& x, const arr& a);
+void special_write(ostream& os, const arr& x);
 
 struct RowShifted : SpecialArray {
   arr& Z;           ///< references the array itself

robotic/include/rai/Core/defines.h

@@ -45,21 +45,22 @@ typedef unsigned int uint;
 //
 
 //using std::cout;
-//using std::cerr;
 //using std::endl;
 using std::ostream;
 using std::istream;
 using std::ofstream;
 using std::ifstream;
 
+namespace rai {
+
+struct String;
+
 //===========================================================================
 //
 // enums
 //
 
-namespace rai {
 enum ArgWord { _left, _right, _sequence, _path, _xAxis, _yAxis, _zAxis, _xNegAxis, _yNegAxis, _zNegAxis };
-}
 
 //===========================================================================
 
@@ -84,9 +85,6 @@ struct Stepper {
 // logging
 //
 
-namespace rai {
-struct String;
-
 /// An object that represents a log file and/or cout logging, together with log levels read from a cfg file
 struct LogObject {
   std::ofstream* fil=0;
@@ -117,12 +115,12 @@ extern LogObject _log;
 const char* errString();
 String& errStringStream();
 
-}
-
 //----- parsing strings in a stream
 struct PARSE { const char* str; PARSE(const char* _str):str(_str) {} };
 std::istream& operator>>(std::istream& is, const PARSE&);
 
+} //namespace
+
 //===========================================================================
 //
 // macros for LOG and CHECK
@@ -177,7 +175,7 @@ std::istream& operator>>(std::istream& is, const PARSE&);
 // macros to define the standard <<and >>operatos for most classes
 //
 
-#define stdInPipe(type)\
+#define stdInPipe(type)							\
   inline std::istream& operator>>(std::istream& is, type& x){ x.read(is); return is; }
 #define stdOutPipe(type)\
   inline std::ostream& operator<<(std::ostream& os, const type& x){ x.write(os); return os; }

robotic/include/rai/Core/graph.h

@@ -25,6 +25,7 @@ struct Graph;
 struct ParseInfo;
 struct RenderingInfo;
 struct GraphEditCallback;
+struct BracketOp;
 typedef Array<Node*> NodeL;
 typedef Array<GraphEditCallback*> GraphEditCallbackL;
 }
@@ -52,7 +53,6 @@ struct Node {
   void swapParent(uint i, Node* p);
 
   //-- get value
-  //get() -> as()
   template<class T> bool is() const { return type==typeid(T); }
   template<class T> T& as() { T* x=getValue<T>(); CHECK(x, "this node '" <<*this <<"' is not of type '" <<typeid(T).name() <<"' but type '" <<type.name() <<"'"); return *x; }
   template<class T> const T& as() const { const T* x=getValue<T>(); CHECK(x, "this node '" <<*this <<"'is not of type '" <<typeid(T).name() <<"' but type '" <<type.name() <<"'"); return *x; }
@@ -60,10 +60,9 @@ struct Node {
 
   template<class T> T* getValue();    ///< query whether node type is equal to (or derived from) T, return the value if so
   template<class T> const T* getValue() const; ///< as above
-  template<class T> std::shared_ptr<T> getPtr() const;  ///< query whether node type is equal to (or derived from) shared_ptr<T>, return the shared_ptr if so
-  template<class T> bool getFromDouble(T& x) const; ///< return value = false means parsing object of type T from the string failed
+  template<class T> bool getFromDouble(T& x) const; ///< return value = false means parsing object of type T from the double failed
   template<class T> bool getFromString(T& x) const; ///< return value = false means parsing object of type T from the string failed
-  template<class T> bool getFromArr(T& x) const; ///< return value = false means parsing object of type T from the string failed
+  template<class T> bool getFromArr(T& x) const; ///< return value = false means parsing object of type T from the arr failed
   bool isBoolAndTrue() const { if(type!=typeid(bool)) return false; return *getValue<bool>() == true; }
   bool isBoolAndFalse() const { if(type!=typeid(bool)) return false; return *getValue<bool>() == false; }
 
@@ -81,12 +80,10 @@ struct Node {
   virtual void copyValue(Node*) {NIY}
   virtual bool hasEqualValue(Node*) {NIY}
   virtual void writeValue(std::ostream& os) const {NIY}
-//  virtual void copyValueInto(void*) const {NIY}
   virtual Node* newClone(Graph& container) const {NIY}
 };
-
-inline std::istream& operator>>(std::istream& is, Node*& x) { HALT("prohibited"); return is; }
 stdOutPipe(Node)
+
 } //namespace
 
 //===========================================================================
@@ -139,9 +136,10 @@ struct Graph : NodeL {
 
   //
   template<class T> Node* set(const char* key, const T& x){ Node* n = findNodeOfType(typeid(T), key); if(n) n->as<T>()=x; else n=add<T>(key, x); return n; }
+  Node* set(Node* _n){ Node* n = findNodeOfType(_n->type, _n->key); if(n) n->copyValue(_n); else n=_n->newClone(*this); return n; }
 
   //-- get nodes
-  Node* operator[](const char* key) const { return findNode(key); } ///< returns nullptr if not found
+  BracketOp operator[](const char* key); ///< returns nullptr if not found
   Node* getNode(const char* key) const { return findNode(key); } ///< returns nullptr if not found
   Node* getEdge(Node* p1, Node* p2) const;
   Node* getEdge(const NodeL& parents) const;
@@ -187,10 +185,10 @@ struct Graph : NodeL {
   Node* readNode(std::istream& is, bool verbose, bool parseInfo); //used only internally..
   void readJson(std::istream& is);
   void writeJson(std::istream& is);
-  void write(std::ostream& os=cout, const char* ELEMSEP=",\n", const char* BRACKETS=0, int indent=-1, bool yamlMode=false, bool binary=false) const;
+  void write(std::ostream& os=cout, const char* ELEMSEP="\n", const char* BRACKETS=0, int indent=-1, bool yamlMode=false, bool binary=false) const;
   void writeDot(std::ostream& os, bool withoutHeader=false, bool defaultEdges=false, int nodesOrEdges=0, int focusIndex=-1, bool subGraphsAsNodes=false);
   void writeHtml(std::ostream& os, std::istream& is);
-  void writeYaml(std::ostream& os);
+  void writeYaml(std::ostream& os, bool classic = false) const;
   void writeParseInfo(std::ostream& os);
 
   void displayDot(Node* highlight=nullptr);
@@ -289,6 +287,21 @@ struct NodeInitializer {
 /// pipe node initializers into a graph (to append nodes)
 inline Graph& operator<<(Graph& G, const NodeInitializer& n) { G.addInit(n); return G; }
 
+//===========================================================================
+
+struct BracketOp {
+  Graph& G;
+  const char* key;
+  Node *n;
+  template<class T> void operator=(const T& x){
+    if(!n) n = G.add<T>(key, x);
+    else n->as<T>() = x;
+  }
+  Node* operator->() { return n; }
+  operator Node*() { return n; }
+  //T& operator->() { return *p; }
+};
+
 //===========================================================================
 //
 // algorithms
@@ -391,10 +404,6 @@ struct Node_typed : Node {
     else os <<value;
   }
 
-//  virtual void copyValueInto(void* value_ptr) const {
-//    *((T*)value_ptr) = value;
-//  }
-
   virtual const std::type_info& getValueType() const {
     return typeid(T);
   }
@@ -428,15 +437,6 @@ template<class T> const T* Node::getValue() const {
   return &typed->value;
 }
 
-template<class T> std::shared_ptr<T> Node::getPtr() const {
-  NIY
-//  std::shared_ptr<T> typed = std::dynamic_pointer_cast<T>(std::shared_ptr<T>(value_ptr));
-  return std::shared_ptr<T>();
-//  const Node_typed<std::shared_ptr<T>>* typed = dynamic_cast<const Node_typed<std::shared_ptr<T>>*>(this);
-//  if(!typed) return nullptr;
-//  return typed->value;
-}
-
 template<class T> bool Node::getFromDouble(T& x) const {
   if(!is<double>()) return false;
   double y = as<double>();
@@ -482,6 +482,10 @@ template<class T> NodeInitializer::NodeInitializer(const char* key, const String
   n = G.add<T>(key, x);
 }
 
+inline BracketOp Graph::operator[](const char* key) {
+  return BracketOp{*this, key, findNode(key)};
+}
+
 template<class T> T& Graph::get(const char* key) const {
   Node* n = findNodeOfType(typeid(T), key);
   if(!n) HALT("no node of type '" <<typeid(T).name() <<"' with key '"<< key<< "' found");

robotic/include/rai/Core/h5.h

@@ -23,6 +23,7 @@ struct H5_Writer {
   H5_Writer(const char* filename);
 
   template<class T> void add(const char* name, const rai::Array<T>& x);
+  void addDict(const char* name, const Graph& dict);
   void addGroup(const char* group);
 };
 
@@ -30,12 +31,13 @@ struct H5_Writer {
 
 struct H5_Reader {
   std::shared_ptr<H5::H5File> file;
-  rai::Graph G;
   int verbose=0;
+  Graph G;
 
   H5_Reader(const char* filename);
   void readAll();
   template<class T> rai::Array<T> read(const char* name, bool ifExists=false);
+  Graph readDict(const char* name, bool ifExists=false);
   bool exists(const char* name);
 };
 

robotic/include/rai/Core/thread.h

@@ -51,7 +51,7 @@ struct CallbackL : rai::Array<Callback<F>*> {
 struct RWLock {
   std::shared_timed_mutex rwLock;
   int rwCount=0;     ///< -1==write locked, positive=numer of readers, 0=unlocked
-  Mutex rwCountMutex;
+  rai::Mutex rwCountMutex;
   RWLock();
   ~RWLock();
   void readLock();   ///< multiple threads may request 'lock for read'
@@ -67,7 +67,7 @@ struct RWLock {
 //
 
 /// This RW lock counts revisions and broadcasts accesses to listeners; who is accessing can be logged; it has a unique name
-struct Var_base : NonCopyable {
+struct Var_base : rai::NonCopyable {
   RWLock rwlock;               ///< rwLock (handled via read/writeAccess)
   uint revision=0;
   rai::String name;            ///< name
@@ -140,7 +140,7 @@ struct Var_data : Var_base {
 
   Var_data(const char* name=0) : Var_base(name), data() {} // default constructor for value always initializes, also primitive types 'bool' or 'int'
   ~Var_data() {
-    if(rwlock.isLocked()) { cerr << "can't destroy a variable when it is currently accessed!" <<endl; exit(1); }
+    if(rwlock.isLocked()) { cout << "can't destroy a variable when it is currently accessed!" <<endl; exit(1); }
   }
 };
 
@@ -227,7 +227,7 @@ template<class T> std::ostream& operator<<(std::ostream& os, Var<T>& x) { x.writ
 /// a basic condition variable
 struct Signaler {
   int status;
-  Mutex statusMutex;
+  rai::Mutex statusMutex;
   std::condition_variable cond;
 
   Signaler(int initialStatus=0);
@@ -240,13 +240,13 @@ struct Signaler {
   void statusLock();   //the user can manually lock/unlock, if he needs locked state access for longer -> use userHasLocked=true below!
   void statusUnlock();
 
-  int  getStatus(Mutex::Token* userHasLocked=0) const;
-  bool waitForSignal(Mutex::Token* userHasLocked=0, double timeout=-1.);
-  bool waitForEvent(std::function<bool()> f, Mutex::Token* userHasLocked=0);
-  bool waitForStatusEq(int i, Mutex::Token* userHasLocked=0, double timeout=-1.);    ///< return value is the state after the waiting
-  int waitForStatusNotEq(int i, Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
-  int waitForStatusGreaterThan(int i, Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
-  int waitForStatusSmallerThan(int i, Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
+  int  getStatus(rai::Mutex::Token* userHasLocked=0) const;
+  bool waitForSignal(rai::Mutex::Token* userHasLocked=0, double timeout=-1.);
+  bool waitForEvent(std::function<bool()> f, rai::Mutex::Token* userHasLocked=0);
+  bool waitForStatusEq(int i, rai::Mutex::Token* userHasLocked=0, double timeout=-1.);    ///< return value is the state after the waiting
+  int waitForStatusNotEq(int i, rai::Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
+  int waitForStatusGreaterThan(int i, rai::Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
+  int waitForStatusSmallerThan(int i, rai::Mutex::Token* userHasLocked=0, double timeout=-1.); ///< return value is the state after the waiting
 };
 
 //===========================================================================
@@ -331,7 +331,7 @@ struct Thread {
   rai::String name;
   std::unique_ptr<std::thread> thread;    ///< the underlying pthread; nullptr iff not opened
   int tid;                    ///< system thread id
-  Mutex stepMutex;              ///< This is set whenever the 'main' is in step (or open, or close) --- use this in all service methods callable from outside!!
+  rai::Mutex stepMutex;              ///< This is set whenever the 'main' is in step (or open, or close) --- use this in all service methods callable from outside!!
   uint step_count;              ///< how often the step was called
   Metronome metronome;          ///< used for beat-looping
   CycleTimer timer;             ///< measure how the time spend per cycle, within step, idle