GitLab

This patch adds 3 changes:
- Rely on spdlog::stopwatch instead of the 'raw' standard library clock
- Change the output format a touch to improve readability
- Rename of variables to express intent better

As of version 1.8.0 of spdlog a stopwatch is provided. I thought it
would be nice to justs rely on that one instead of rolling our own (even
if it's not that hard).

The other change is the output format. Instead of printing in the format
'[Timing] [debug] Execution of <caller>: <fn> took <time>ms', I changed
it to '[<caller>] [debug] <fn> took <time>s'. So instead of having a
separate Timing logger, the logger for the class is used. IMO, this
cleans up the log a touch, as my eyes don't have to search in different
columns, but it's minor. Also I use the default output format of the
spdlog::stopwatch, which is in decimal and seconds.

Also I used the change to rename the variables, as it was just a little
off.

Access to a portion of the DataContainer in the form of slices.
Currently, only slicing in the direction of the last dimension are
possible, but this should still be useful for many cases.

The one suprising thing in this implementation, is that the returned
DataContainer, has a descriptor which is of the same dimension as the
original DataContainer but with a "thickness" of 1 in the last
dimension, instead of actually being lower dimensional.

so warnings are swallowed

also install our bundled eigen headers

This is actually mostly exiting because it now supports fmtlib version
8, which is great! Sadly to fully utilize fmt 8.0.0, we need C++20
support. Check the [release
notes](https://github.com/fmtlib/fmt/releases/tag/8.0.0) of fmtlib 8.0.0
to see what awesome things we can do, if we switch to C++20 :^)

When two DataContainers are concatenated, a new one with a
RandomBlocksDescriptor is created, with the two original descriptors
as blocks.

Currently, only concatenation of containers of equal dimension is
allowed.

This commit changes the pipelines to use the newly created docker
registry. The docker registry is running at vmlasser7.in.tum.de with
port 5000. You'll need the credentials and run 'docker login
docker.ciip.in.tum.de:5000' to pull and push images to the registry.

A new variable 'DOCKER_AUTH_CONFIG' is set up in GitLab to manage the
authentication inside of the CI pipeline.

This is a follow up to !142, more tests use the assertion macros with
*_EQ, *_UNARY and such. This commit also fixes many warnings in the
tests with conversions.

Further warnings are fixed in many places such as the CUDA projectors,
the Dictionary operator or the SQS solver. As the last thing, this
commits adds a new overload of isApprox for Expressions.

With this commit, elsa basically without warnings on GCC 11 and Clang 12

Changes to the underlying implementation were necessary to accept
generals ostream and istream instead of the more specialiced ifstream.
This limitation was unnecessary und now EDF::write and EDF::read can be
called with a ostream and istream respectively.

A future MR should add tests using these functions to porperly test the
underlying implementation.

The Timer class now prints timing information only if the Logger is set
to debug level, instead of info level. This reduces noise in the output.
The Timing of execution is not necessarily an useful information all the
time.

An example is the python script introduced in !182, all useful
information regarding conversion and solvers is shadowed by the Timing
information.

Some tests have extraemly long runtime especially in debug builds. This
commit reduces the runtime ~3x on my personal machine, hopefully the
effect is even more pronounced on the CI.

Closes #129

At a couple of places a new unique_ptr was created, then directly
dereferenced and a copy of the underlying VolumeDescriptor returned.
This creates an unnecessray heap allocation. This commits directly casts
the reference of the smart pointer to a VolumeDescriptor and from there
the copy is created.

Remove dynamic_unique_ptr_cast and static_unique_ptr_cast as both is
covered by the downcast functions in TypeCasts.hpp.