NemoMath

Most important updates:

• Many new built-in Mappings, e.g.
  • Filters that allow temporal smoothing
  • Norm/Metric function
• Mappings now have support for algebraic inversion (within certain limits), e.g.
  

  Mapping<double,double> func = arg<double>() * 2.0 - 1.0;
  Mapping<double,double> inverseFunc = func.inverse();
  

• A new data type TimeSeries, which allows to represent and handle temporal aspects of data
  

  TimeSeries<double,RealVector> series;
  series.append(1.5, RealVector(1.0, 1.0));
  series.append(2.5, RealVector(3.0, 1.0));
  series.insert(2.1, RealVector(2.0, 2.0));
  TimeSeries<double,RealVector> transformed = series.values.map(
      RealMatrix({{0,2},{1,0}}) * arg<RealVector>() 
  );
  

  • See source:/tags/nemomath-0.2.0/nemomath/examples/ExampleTimeSeries.cpp
• All container types (MathVector,Matrix,TimeSeries) provide STL-compliant iterators:
  

  RealVector v(1.0, 3.0, 2.0);
  std::reverse( v.begin(), v.end());
  

• The MacOS/clang platform is now supported

NemoMath is a math-library for robotics and learning... so why don't you just use Eigen 2???

The answer is twofold:

1.: NemoMath takes care of shared ownership issues in robotics/learning applications and systems.¶

Use Eigen (or similar Libs) in something more complex than one method of spaghetti code and you need to think about two questions:

• Who is responsible for deleting an object?
• Who is allowed to modify an object (mutability) and when is a copy necessary?

The first thing that people usually come up with are smart-pointers like boost::shared_ptr. It solves the problem when to delete an object. But, it makes the mutability-issue even worse, since it is not transparent to const-correctness. There is always a danger that some other objects holds a smart pointer on your vector and modifies it. Also, you lose a lot of the original API convenience, such as mathematical operators, which are not directly usable through a smart-pointer.

NemoMath tackles these problem elegantly in the background by using

• Highly efficient intrusive-counters on internal data-objects. Passing a nemo::MathVector is almost as efficient as passing a plain C-pointer.
• Copy-on-write on all Vector and Matrix objects. You can pass them without expensive copying been performed. Once a write-operation takes place, the library takes care of a copy.

Due to these two features, working with nemo::MathVector and nemo::Matrix feels like using simple objects, with which you can do "value-based" programming.
Yet it avoids all the typical overhead. See source:/tags/nemomath-0.1.0/nemomath/examples/ExampleVector.cpp

2.: NemoMath goes far beyond linear algebra.¶

Ultra-flexible Functor API

• Define your own Mappings and combine them flexibly: source:/tags/nemomath-0.1.0/nemomath/examples/ExampleMapping.cpp
• Or just use the operators to express things simply and elegantly: source:/tags/nemomath-0.1.0/nemomath/examples/ExampleMappingArithmetics.cpp

Convenient container data-structures

• Allows flexible interaction with functor objects: source:/tags/nemomath-0.1.0/nemomath/examples/ExampleCollections.cpp
• These data-structures will be STL-compliant in the next version of NemoMath