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

robotic/_robotic.pyi

@@ -6,7 +6,7 @@ import numpy
 import typing
 from . import DataGen
 from . import test
-__all__ = ['Actions2KOMO_Translator', 'ArgWord', 'BSpline', 'BotOp', 'CameraView', 'CameraViewSensor', 'Config', 'ConfigurationViewer', 'ControlMode', 'DataGen', 'FS', 'Frame', 'JT', 'KOMO', 'KOMO_Objective', 'LGP_Tool', 'NLP', 'NLP_Factory', 'NLP_Sampler', 'NLP_Solver', 'NLP_SolverOptions', 'OT', 'OptBench_Skeleton_Handover', 'OptBench_Skeleton_Pick', 'OptBench_Skeleton_StackAndBalance', 'OptBenchmark_InvKin_Endeff', 'OptMethod', 'Quaternion', 'RRT_PathFinder', 'ST', 'SY', 'Simulation', 'SimulationEngine', 'Skeleton', 'SolverReturn', 'TAMP_Provider', 'compiled', 'default_Actions2KOMO_Translator', 'default_TAMP_Provider', 'depthImage2PointCloud', 'params_add', 'params_clear', 'params_file', 'params_print', 'raiPath', 'setRaiPath', 'test']
+__all__ = ['Actions2KOMO_Translator', 'ArgWord', 'BSpline', 'BotOp', 'CameraView', 'CameraViewSensor', 'Config', 'ConfigurationViewer', 'ControlMode', 'DataGen', 'FS', 'Frame', 'JT', 'KOMO', 'KOMO_Objective', 'LGP_Tool', 'NLP', 'NLP_Factory', 'NLP_Sampler', 'NLP_Solver', 'NLP_SolverOptions', 'OT', 'OptBench_Skeleton_Handover', 'OptBench_Skeleton_Pick', 'OptBench_Skeleton_StackAndBalance', 'OptBenchmark_InvKin_Endeff', 'OptMethod', 'Quaternion', 'RRT_PathFinder', 'ST', 'SY', 'Simulation', 'SimulationEngine', 'Skeleton', 'SolverReturn', 'TAMP_Provider', 'compiled', 'default_Actions2KOMO_Translator', 'default_TAMP_Provider', 'depthImage2PointCloud', 'get_NLP_Problem_names', 'make_NLP_Problem', 'params_add', 'params_clear', 'params_file', 'params_print', 'raiPath', 'rnd_seed', 'rnd_seed_random', 'setRaiPath', 'test']
 class Actions2KOMO_Translator:
     """
     Actions2KOMO_Translator
@@ -103,11 +103,11 @@ class BotOp:
         """
         constructor
         """
-    def attach(self, gripper: ..., obj: ...) -> None:
+    def attach(self, from: ..., to: ...) -> None:
         """
         cheating: attach two objects kinematically
         """
-    def detach(self, obj: ...) -> None:
+    def detach(self, from: ..., to: ...) -> None:
         """
         cheating: detach two previously attached objects
         """
@@ -365,7 +365,7 @@ class Config:
         """
         get the joint state as a numpy vector, optionally only for a subset of joints specified as list of joint names
         """
-    def get_viewer(self, window_title: str = None, offscreen: bool = False) -> ...:
+    def get_viewer(self) -> ConfigurationViewer:
         ...
     def processInertias(self, recomputeInertias: bool = True, transformToDiagInertia: bool = False) -> None:
         """
@@ -401,7 +401,7 @@ class Config:
         """
     def setJointStateSlice(self, arg0: list[float], arg1: int) -> None:
         ...
-    def set_viewer(self, arg0: ...) -> None:
+    def set_viewer(self, arg0: ConfigurationViewer) -> None:
         ...
     def view(self, pause: bool = False, message: str = None) -> int:
         """
@@ -413,7 +413,7 @@ class Config:
         """
     def view_recopyMeshes(self) -> None:
         ...
-    def viewer(self, window_title: str = None, offscreen: bool = False) -> ...:
+    def viewer(self) -> ConfigurationViewer:
         ...
     def watchFile(self, arg0: str) -> None:
         """
@@ -498,6 +498,10 @@ class ConfigurationViewer:
         """
         set the camera pose directly
         """
+    def setWindow(self, title: str, width: int, height: int) -> None:
+        """
+        set title, width, and height
+        """
     def setupEventHandler(self, blockDefaultHandler: bool) -> None:
         """
         setup callbacks to grab window events and return them with methods below
@@ -842,17 +846,17 @@ class Frame:
         """
         attach a point cloud shape
         """
-    def setPose(self, arg0: arr) -> None:
+    def setPose(self, arg0: arr) -> Frame:
         ...
-    def setPoseByText(self, arg0: str) -> None:
+    def setPoseByText(self, arg0: str) -> Frame:
         ...
     def setPosition(self, arg0: arr) -> Frame:
         ...
     def setQuaternion(self, arg0: arr) -> Frame:
         ...
-    def setRelativePose(self, arg0: arr) -> None:
+    def setRelativePose(self, arg0: arr) -> Frame:
         ...
-    def setRelativePoseByText(self, arg0: str) -> None:
+    def setRelativePoseByText(self, arg0: str) -> Frame:
         ...
     def setRelativePosition(self, arg0: arr) -> Frame:
         ...
@@ -1184,7 +1188,7 @@ class NLP:
         """
     def getBounds(self) -> arr:
         """
-        returns the tuple $(b_{lo},b_{up})$, where both vectors are of same dimensionality of $x$ (or size zero, if there are no bounds)
+        returns a 2xn array with lower and upper bounds as rows (or size zero, if there are no bounds)
         """
     def getDimension(self) -> int:
         """
@@ -1501,6 +1505,7 @@ class OptMethod:
         ...
 class Quaternion:
     """
+    See the Quaternion Lecture Note https://www.user.tu-berlin.de/mtoussai/notes/quaternions.html for details
     """
     @staticmethod
     def _pybind11_conduit_v1_(*args, **kwargs):
@@ -1843,11 +1848,11 @@ class Simulation:
         """
     def addSensor(self, sensorName: str, width: int = 640, height: int = 360, focalLength: float = -1.0, orthoAbsHeight: float = -1.0, zRange: arr = []) -> ...:
         ...
-    def attach(self, gripper: Frame, obj: Frame) -> None:
+    def attach(self, from: Frame, to: Frame) -> None:
         ...
     def depthData2pointCloud(self, arg0: numpy.ndarray[numpy.float32], arg1: list[float]) -> numpy.ndarray[numpy.float64]:
         ...
-    def detach(self, obj: Frame) -> None:
+    def detach(self, from: Frame, to: Frame) -> None:
         ...
     def getGripperWidth(self, gripperFrameName: str) -> float:
         ...
@@ -1892,7 +1897,7 @@ class Simulation:
         """
     def setState(self, frameState: arr, jointState: arr = ..., frameVelocities: arr = ..., jointVelocities: arr = ...) -> None:
         ...
-    def step(self, u_control: arr, tau: float = 0.01, u_mode: ControlMode = ...) -> None:
+    def step(self, u_control: arr = ..., tau: float = 0.01, u_mode: ControlMode = ...) -> None:
         ...
 class SimulationEngine:
     """
@@ -2004,6 +2009,14 @@ def depthImage2PointCloud(depth: numpy.ndarray[numpy.float32], fxycxy: arr) -> a
     """
     return the point cloud from the depth image
     """
+def get_NLP_Problem_names() -> StringA:
+    """
+    return all problem names
+    """
+def make_NLP_Problem(problem_name: ...) -> NLP:
+    """
+    create a benchmark NLP
+    """
 def params_add(*args, **kwargs) -> None:
     """
     add/set parameters
@@ -2024,6 +2037,14 @@ def raiPath(arg0: str) -> ...:
     """
     get a path relative to rai base path
     """
+def rnd_seed(s: int) -> None:
+    """
+    seed rnd with s
+    """
+def rnd_seed_random() -> None:
+    """
+    seed rnd randomly
+    """
 def setRaiPath(arg0: str) -> None:
     """
     redefine the rai (or rai-robotModels) path

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/Core/defines.h

@@ -52,14 +52,16 @@ 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 +86,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 +116,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 +176,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

@@ -53,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; }
@@ -61,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; }
 
@@ -82,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
 
 //===========================================================================
@@ -189,7 +185,7 @@ 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) const;
@@ -408,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);
   }
@@ -445,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>();

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
@@ -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

robotic/include/rai/Core/util.h

@@ -19,17 +19,19 @@
 #include <climits>
 #include <mutex>
 #include <functional>
+#include <random>
 
 using std::cout;
 using std::cerr;
 using std::endl;
 
+namespace rai {
+
 //===========================================================================
 //
 // standard little methods (this needs cleanup)
 //
 
-namespace rai {
 extern int argc;
 extern char** argv;
 extern std::string startDir;
@@ -121,7 +123,6 @@ const char* niceTypeidName(const std::type_info& type);
 //----- get verbose level
 bool getInteractivity();
 bool getDisableGui();
-}
 
 //===========================================================================
 //
@@ -132,7 +133,6 @@ bool getDisableGui();
 #define STRINGF(format,...) (rai::String().printf(format, __VA_ARGS__))
 #define STREAM(x) (((rai::String&)(rai::String().stream() <<x)).stream())
 
-namespace rai {
 /** @brief String implements the functionalities of an ostream and an
 istream, but also can be send to an ostream or read from an
 istream. It is based on a simple streambuf derived from the
@@ -214,16 +214,13 @@ struct String : public std::iostream {
 
   /// @name I/O
   void write(std::ostream& os) const;
-  uint read(std::istream& is, const char* skipSymbols=nullptr, const char* stopSymbols=nullptr, int eatStopSymbol=-1);
+  uint read(std::istream& is, const char* skipSymbols=0, const char* stopSymbols=0, int eatStopSymbol=-1);
 };
 stdPipes(String)
 
 inline String operator+(const String& a, const char* b) { String s=a; s <<b; return s; }
   //template<class T> String operator+(const String& a, const T& b) { String s=a; s <<b; return s; }
 
-} //namespace
-
-typedef rai::String str;
 
 void setLogLevels(int fileLogLevel=3, int consoleLogLevel=2);
 
@@ -236,26 +233,25 @@ void setLogLevels(int fileLogLevel=3, int consoleLogLevel=2);
 // give names to Enum (for pipe << >> )
 //
 
-namespace rai {
 template<class enum_T>
 struct Enum {
   enum_T x;
   static const char* names [];
   Enum():x((enum_T)-1) {}
   Enum(enum_T y):x(y) {}
-  explicit Enum(const rai::String& str):Enum() { operator=(str); }
+  explicit Enum(const String& str):Enum() { operator=(str); }
   const enum_T& operator=(enum_T y) { x=y; return x; }
   bool operator==(const enum_T& y) const { return x==y; }
   bool operator!=(const enum_T& y) const { return x!=y; }
   operator enum_T() const { return x; }
   void read(std::istream& is) {
-    rai::String str(is);
+    String str(is);
     operator=(str);
   }
   void operator=(const char* str) {
     operator=(STRING(str));
   }
-  void operator=(const rai::String& str) {
+  void operator=(const String& str) {
     bool good=false;
     for(int i=0; names[i]; i++) {
       const char* n = names[i];
@@ -263,14 +259,14 @@ struct Enum {
         if(str==n) { x=(enum_T)(i); good=true; break; }
     }
     if(!good) {
-      rai::String all;
+      String all;
       for(int i=0; names[i]; i++) all <<names[i] <<' ';
       HALT("Enum::read could not find the keyword '" <<str <<"'. Possible Enum keywords: " <<all);
     } else {
       CHECK(str.p && !strcmp(names[x], str.p), "");
     }
   }
-  static bool contains(const rai::String& str) {
+  static bool contains(const String& str) {
     for(int i=0; names[i]; i++) {
       if(str==names[i]) return true;
     }
@@ -287,14 +283,12 @@ struct Enum {
 };
 template<class T> std::istream& operator>>(std::istream& is, Enum<T>& x) { x.read(is); return is; }
 template<class T> std::ostream& operator<<(std::ostream& os, const Enum<T>& x) { x.write(os); return os; }
-}
 
 //===========================================================================
 //
 // parameters
 //
 
-namespace rai {
 //----- parameter grabbing from command line, config file, or default value
 template<class T> T getParameter(const char* tag);
 template<class T> T getParameter(const char* tag, const T& Default);
@@ -331,8 +325,6 @@ template<class T> struct ParameterInitEnum {
   auto& set_##name(type _##name){ name=_##name; return *this; } \
   rai::ParameterInitEnum<type> __init_##name = {name, scope #name, Default};
 
-}
-
 //===========================================================================
 //
 // Testing
@@ -359,15 +351,13 @@ template<class T> struct ParameterInitEnum {
 // FileToken
 //
 
-namespace rai {
-
 /** @brief A ostream/istream wrapper that allows easier initialization of objects, like:
 arr X = FILE("inname");
 X >>FILE("outfile");
 etc
 */
 struct FileToken {
-  rai::String path, name, baseDir;
+  String path, name, baseDir;
   std::shared_ptr<std::ofstream> os;
   std::shared_ptr<std::ifstream> is;
 
@@ -386,9 +376,9 @@ struct FileToken {
   operator std::istream& () { return getIs(); }
   operator std::ostream& () { return getOs(); }
 
-  rai::String autoPath() const;
-  rai::String relPath() const;
-  rai::String fullPath() const;
+  String autoPath() const;
+  String relPath() const;
+  String fullPath() const;
 };
 template<class T> FileToken& operator>>(FileToken& fil, T& x) { fil.getIs() >>x;  return fil; }
 template<class T> std::ostream& operator<<(FileToken& fil, const T& x) { fil.getOs() <<x;  return fil.getOs(); }
@@ -396,7 +386,7 @@ inline std::ostream& operator<<(std::ostream& os, const FileToken& fil) { return
 template<class T> FileToken& operator<<(T& x, FileToken& fil) { fil.getIs() >>x; return fil; }
 template<class T> void operator>>(const T& x, FileToken& fil) { fil.getOs() <<x; }
 inline bool operator==(const FileToken&, const FileToken&) { return false; }
-}
+
 #define FILE(filename) (rai::FileToken(filename)()) //it needs to return a REFERENCE to a local scope object
 
 //===========================================================================
@@ -404,15 +394,17 @@ inline bool operator==(const FileToken&, const FileToken&) { return false; }
 // random number generator
 //
 
-namespace rai {
 /** @brief A random number generator. An global instantiation \c
-  rai::rnd of a \c Rnd object is created. Use this one object to get
+  rnd of a \c Rnd object is created. Use this one object to get
   random numbers.*/
 class Rnd {
  private:
   bool ready;
   int32_t rpoint;     /* Feldindex    */
   int32_t rfield[256];   /* Schieberegisterfeld  */
+public:
+  std::minstd_rand e1;
+  std::random_device r;
 
  public:
   /// ...
@@ -420,52 +412,23 @@ class Rnd {
 
  public:/// @name initialization
   /// initialize with a specific seed
-  uint32_t seed(uint32_t n);
+   void seed(int s){ e1.seed(s); ready=true; }
 
   /// use Parameter<uint>("seed") as seed
-  uint32_t seed();
+  void seed(){ e1.seed(getParameter<uint32_t>("seed", 0)); ready=true; }
 
   /// uses the internal clock to generate a seed
-  uint32_t clockSeed();
+  void seed_random(){ e1.seed(r()); ready=true; }
 
  public:/// @name access
-  /// a initeger random number uniformly distributed in [0, ?]
-  uint32_t num() { if(!ready) seed(); return (uint32_t)rnd250() >>5; }
-  /// same as \c num()
-  uint32_t operator()() { return num(); }
-  /// a initeger random number uniformly distributed in [0, \c i-1]
-  uint32_t num(uint32_t limit) {
-    CHECK(limit, "zero limit in rnd.num()"); return num() % limit;
-  }
-  uint32_t num(int32_t lo, int32_t hi) { return lo+num(hi-lo+1); }
-  /// same as \c num(i)
-  uint32_t operator()(uint32_t i) { return num(i); }
-  uint32_t operator()(int32_t lo, int32_t hi) { return num(lo, hi); }
-  /// a random variable uniformly distributed in [0, 1]
-  double uni() { return ((double)num(1 <<22))/(1 <<22); }
-  /// a random variable uniformly distributed in [\c low, \c high]
-  double uni(double low, double high) { return low+uni()*(high-low); }
-  /// a gaussian random variable with mean zero
-  double gauss();
-  /** @brief a positive integer drawn from a poisson distribution with given
-    \c mean; is case \c mean>100, a (positive) gauss number
-    \c floor(mean+gauss(sqrt(mean))+.5) is returned */
-  uint32_t poisson(double mean);
+  int uni_int(int lo, int up) { if(!ready) seed(); std::uniform_int_distribution<int> dist(lo, up); return dist(e1); }
+  double uni(double lo=0., double up=1.) { if(!ready) seed(); std::uniform_real_distribution<double> dist(lo, up); return dist(e1); }
+  double gauss(double mean=0., double std=1.){ if(!ready) seed(); std::normal_distribution<double> dist(mean, std); return dist(e1); }
 
- private:
-  int32_t rnd250() {
-    rpoint = (rpoint+1) & 255;          // Index erhoehen
-    return rfield[rpoint] =  rfield[(rpoint-250) & 255]
-                             ^ rfield[(rpoint-103) & 255];
-  }
+  uint operator()(uint up) { return uint(uni_int(0, up-1)); }
 
-  void seed250(int32_t seed);
 };
 
-}
-/// The global Rnd object
-extern rai::Rnd rnd;
-
 //===========================================================================
 //
 /// a little inotify wrapper
@@ -475,7 +438,7 @@ struct Inotify {
   int fd, wd;
   char* buffer;
   uint buffer_size;
-  rai::FileToken* fil;
+  FileToken* fil;
   Inotify(const char* filename);
   ~Inotify();
   bool poll(bool block=false, bool verbose=false);
@@ -541,7 +504,6 @@ struct Singleton {
 // just a hook to make things gl drawable
 //
 
-struct OpenGL;
 struct OpenGLDrawOptions {
   bool drawWires=false;
   bool drawColors=true;
@@ -569,22 +531,20 @@ struct CoutToken {
   ~CoutToken() { coutMutex.unlock(); }
   std::ostream& getOs() { return cout; }
 };
-#define COUT (CoutToken().getOs())
+#define COUT (rai::CoutToken().getOs())
 
 //===========================================================================
 //
 // to register a type
 //
 
-namespace rai {
 struct Node;
 struct Graph;
-}
 
 struct Type {
   virtual ~Type() {}
   virtual const std::type_info& typeId() const {NIY}
-  virtual struct rai::Node* readIntoNewNode(struct rai::Graph& container, std::istream&) const {NIY}
+  virtual struct Node* readIntoNewNode(struct Graph& container, std::istream&) const {NIY}
   virtual void* newInstance() const {NIY}
   void write(std::ostream& os) const {  os <<"Type '" <<typeId().name() <<"' ";  }
   void read(std::istream& is) const {NIY}
@@ -606,7 +566,7 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 //
 
  template<class T> T fromFile(const char* filename) {
-   rai::FileToken file(filename);
+   FileToken file(filename);
    T x;
    file.cd_file();
    x.read(file.getIs());
@@ -621,13 +581,21 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 //   return x;
 // }
 
+} //namespace
+
+//===========================================================================
+
+typedef rai::String str;
+extern rai::Rnd rnd;
+std::istream& operator>>(std::istream& is, char* str);
+
 //===========================================================================
 //
-/// running code on init (in cpp files)
+// shared ptrs
 //
 
-#define RUN_ON_INIT_BEGIN(key) struct key##_RUN_ON_INIT{ key##_RUN_ON_INIT(){
-#define RUN_ON_INIT_END(key)   } } key##_RUN_ON_INIT_dummy;
+template<class T> void _delete(T* ptr){}
+template<class T> std::shared_ptr<T> _shared(T& x){ return std::shared_ptr<T>(&x, &_delete<T>); }
 
 //===========================================================================
 //
@@ -637,3 +605,11 @@ inline bool operator==(Type& t1, Type& t2) { return t1.typeId() == t2.typeId();
 void gnuplot(const char* command, bool pause=false, bool persist=false, const char* PDFfile=nullptr);
 void gnuplotClose();
 
+//===========================================================================
+//
+/// running code on init (in cpp files)
+//
+
+#define RUN_ON_INIT_BEGIN(key) struct key##_RUN_ON_INIT{ key##_RUN_ON_INIT(){
+#define RUN_ON_INIT_END(key)   } } key##_RUN_ON_INIT_dummy;
+