TNL is a collection of building blocks that facilitate the development of efficient numerical solvers. It is implemented in C++ using modern programming paradigms in order to provide flexible and user friendly interface. TNL provides native support for modern hardware architectures such as multicore CPUs, GPUs, and distributed systems, which can be managed via a unified interface.

Similarly to the STL, features provided by the TNL can be grouped into several modules:

TODO: Each topic in this list should have a separate page or tutorial.

Core concepts. The main concepts used in TNL are the memory space, which represents the part of memory where given data is allocated, and the execution model, which represents the way how given (typically parallel) algorithm is executed. For example, data can be allocated in the main system memory, in the GPU memory, or using the CUDA Unified Memory which can be accessed from the host as well as from the GPU. On the other hand, algorithms can be executed using either the host CPU or an accelerator (GPU), and for each there are many ways to manage parallel execution. The usage of memory spaces is abstracted with allocators and the execution model is represented by devices. See the Core concepts page for details.
Containers. TNL provides generic containers such as array, multidimensional array or array views, which abstract data management and execution of common operations on different hardware architectures.
Linear algebra. TNL provides generic data structures and algorithms for linear algebra, such as vectors, sparse matrices, Krylov solvers and preconditioners.
- Sparse matrix formats: CSR, Ellpack, Sliced Ellpack, tridiagonal, multidiagonal
- Krylov solvers: CG, BiCGstab, GMRES, CWYGMRES, TFQMR
- Preconditioners: Jacobi, ILU(0) (CPU only), ILUT (CPU only)
Meshes. TNL provides data structures for the representation of structured or unstructured numerical meshes.
Solvers for differential equations. TNL provides a framework for the development of ODE or PDE solvers.
Image processing. TNL provides structures for the representation of image data. Imports and exports from several file formats are provided using external libraries, such as DCMTK for DICOM files, libpng for PNG files, or libjpeg for JPEG files.

Installation

You can either download the stable version or directly clone the git repository via HTTPS:

git clone https://mmg-gitlab.fjfi.cvut.cz/gitlab/tnl/tnl-dev.git

or via SSH:

git clone gitlab@mmg-gitlab.fjfi.cvut.cz:tnl/tnl-dev.git

Since TNL is a header-only library, no installation is necessary to actually use the library. You can just extract the src/TNL subdirectory, for example into ~/.local/include/, and configure your compiler to include headers from this path.

Optionally, you may want to compile and install various tools and examples.

Supported compilers

You need a compiler which supports the C++14 standard, for example GCC 5.0 or later or Clang 3.4 or later. For CUDA support, you also need CUDA 9.0 or later.

Optional components

TNL provides several optional components such as pre-processing and post-processing tools which can be compiled and installed by executing the install script:

./install

CMake 3.12.2 or later is required for the compilation. The script compiles and/or installs the following components into the ~/.local/ directory:

TNL header files from the src/TNL directory.
Various pre-processing and post-processing tools from the src/Tools directory.
Python bindings and scripts from the src/Python directory.
Examples of various numerical solvers from the src/Examples directory.
Benchmarks from the src/Benchmarks directory.
Compiles and executes the unit tests from the src/UnitTests directory.

Individual components can be disabled and the installation prefix can be changed by passing command-line arguments to the install script. Run ./install --help for details.