GitLab

Closes #127

Depends on !175

Some more functionality was added with the TypeCasts.hpp file:

* is(...): check if a pointer/reference/unique_ptr can be dynamically
  casted to the derived type
* downcast(...): downcast a pointer/reference/unique_ptr statically to
  the derived type, assumes caller knows that the type is correct.
* downcast_safe(...): downcast a pointer/reference/unique_ptr to the
  derived type, but only if it's possible. If not a nullptr is returned
  for the pointer cases and std::bad_cast is thrown for the reference
  case.

The clang-format test script now relies on clang-format's (now) in-build
functionality to check for wrong formatting instead of actually
performing or committing the formated changes and then reverting them.
From a perceived behaviour standpoint nothing has changed, it should now
only be more convenient to use the script, as it doesn't require a
clean git state anymore.

Further, all formatting and linting scripts run only on the changed
files rather than on the whole codebase. Plus they have some nicer
looking output :^)

OMP tries to recover a sparse signal from a noisy measurement
encoded with a dictionary. This commit adds support for the OMP
algorithm. Therefore, a Dictionary operator, a RepresentationProblem
and the OMP solver are introduced.

The cmakelang package (see https://github.com/cheshirekow/cmake_format)
provides tools for linting and formatting CMake files. This commit
provides a basic infrastructure to make use of it.

First, the necessary formatting style file is added
('.cmake-format.py'). For many cases, the CMake files don't fulfill
these requirements yet, therefore, many linting checks are still
disabled.

Second, scripts and CI stages (only for linting) are added, which are
run alongside clang-format and clang-tidy. Currently, the formatting
job is not run, as the files are not yet formatted correctly.

Future MRs should work on slowly reducing the disabled codes.

Close #90

As found in MR !153, the scope of the caches in the CI were chosen to
large. Therefore it could happen, that sporadically a build job, would
pick a cache from the clang-tidy run, which initializes with the
"Makefile" generator rather than Ninja. This would cause the pipeline to
fail.

Now, the caching is more conservative, there is one cache for each
job-branch combination. This should completely resolve this issue, but
it's also not optimal from a space requirement, but I'd rather use more
disk space on the build server, than have sporadic failures of the CI.

From now on Fermi (GeForce 400) or newer architecture GPU required

CMake presets provide a build-in way to share common build options. This
commit adds a first couple of configurations, which include
configurations for:

  * GCC
  * Clang (with and without libc++)
  * Address and undefined behavior sanitizer
  * Test coverage
  * Couple of CI configurations

CUDA is often installed in either /usr/local/cuda
or /opt/cuda. Therefore, add these paths to the search
path for Cudnn. The paths are now quite similar
to finding Cublas.

  of bounds errors in the second traversal step)
- fix detection of entry/exit direction for non-square-shaped volumes
- add tests for non-square-shaped volumes

set_target_warnings(<target>) adds a set of warnings to a target. elsa
now differentiates between two warning levels: 'base' and 'all'.
Currently, only base will be tested to keep the compability.

From time to time, we can move warnings from the all warnings to the
base warning level and fix some of the warnings.

In CMake 3.18 the (CMAKE_)CUDA_ARCHITECTURES variables were introduced.
CMake uses them to pass the compute capabilities to the CUDA compiler.

Therefore, for CMake versions 3.18 and higher, we rely on this CMake
behaviour and while we still support previous versions, the previous
behaviour is still kept around.

CMAKE_CUDA_ARCHITECTURES is set to 'Auto' by default, which is
equivalent to the previous CUDA_ARCH variables that was used.
Overwriting via the command line is possible for cross compilation of
CUDA code.

The following functions are renamed:
* code-coverage functions (CodeCoverage.cmake)
* Function to determine compue capabilities of cuda
  (ComputeCapabilityCUDA.cmake)
* internal functions in FindLLVM.cmake to _snake_case
* functions to install elsa modules (InstallElsaModule.cmake)
* Consistently call GENERATE_BINDINGS as SNAKE_CASE
* registerComponents to register_module (elsa/CMakeLists.txt)
* AddElsaModule to follow snake_case convention (elsa/CMakeLists.txt)

Also arguments to certain functions are now using lower case, to follow
more conventional standards.

CMake modules are now added via common macro 'AddElsaModule', which
removes a lot of duplicate code.

Also reworked the ml module just a bit to prefer target specific (such
as 'target_compile_definitions' over 'add_definitions').

Files were also formatted to a stricter guideline, which should reduce
some inconsistencies.

adapt style of tests

make clang format happy

make lipschitzConstant std::optional, no unique ptr in jacobi precond

some code-cleanup in the tests, separate build-tests-<module> and run-tests-<module> targets