Bootstrap themed components for use in Plotly Dash.

Access dict values as attributes (works recursively).

This library provides ordinary differential equation (ODE) solvers implemented in PyTorch. Backpropagation through ODE solutions is supported using the adjoint method for constant memory cost. For usage of ODE solvers in deep learning applications.

As the solvers are implemented in PyTorch, algorithms in this repository are fully supported to run on the GPU.

Export data as binary VTK files

Python implementation of the Tensor Train (TT) toolbox. It contains several important packages for working with the TT-format in Python. It is able to do TT-interpolation, solve linear systems, eigenproblems, solve dynamical problems. Several computational routines are done in Fortran (which can be used separately), and are wrapped with the f2py tool.

Generates LaTeX source from Python functions.

image and video datasets and models for torch deep learning

The Python Imaging Library adds image processing capabilities to your Python interpreter. This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities. The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.

Example showing how to use starpu for implementing a distributed gemm in C++.

PaRSEC is a generic framework for architecture aware scheduling and management of micro-tasks on distributed many-core heterogeneous architectures.

Chameleon is a dense linear algebra solver relying on sequential task-based algorithms where sub-tasks of the overall algorithms are submitted to a run-time system. Such a system is a layer between the application and the hardware which handles the scheduling and the effective execution of tasks on the processing units. A run-time system such as StarPU is able to manage automatically data transfers between not shared memory area (CPUs-GPUs, distributed nodes).

QUARK (QUeuing And Runtime for Kernels) provides a library that enables the dynamic execution of tasks with data dependencies in a multi-core, multi-socket, shared-memory environment. QUARK infers data dependencies and precedence constraints between tasks from the way that the data is used, and then executes the tasks in an asynchronous, dynamic fashion in order to achieve a high utilization of the available resources.

PaStiX (Parallel Sparse matriX package) is a scientific library that provides a high performance parallel solver for very large sparse linear systems based on direct methods. Numerical algorithms are implemented in single or double precision (real or complex) using LLt, LDLt and LU with static pivoting (for non symmetric matrices having a symmetric pattern). This solver also provides some low-rank compression methods to reduce the memory footprint and/or the time-to-solution.

PaRSEC is a generic framework for architecture aware scheduling and management of micro-tasks on distributed many-core heterogeneous architectures.

Chameleon is a dense linear algebra solver relying on sequential task-based algorithms where sub-tasks of the overall algorithms are submitted to a run-time system. Such a system is a layer between the application and the hardware which handles the scheduling and the effective execution of tasks on the processing units. A run-time system such as StarPU is able to manage automatically data transfers between not shared memory area (CPUs-GPUs, distributed nodes).

DPLASMA is the leading implementation of a dense linear algebra package for distributed, accelerated, heterogeneous systems. It is designed to deliver sustained performance for distributed systems where each node featuring multiple sockets of multicore processors, and if available, accelerators like GPUs or Intel Xeon Phi. DPLASMA achieves this objective through the state of the art PaRSEC runtime, porting the Parallel Linear Algebra Software for Multicore Architectures (PLASMA) algorithms to the distributed memory realm.

Chameleon is a dense linear algebra solver relying on sequential task-based algorithms where sub-tasks of the overall algorithms are submitted to a run-time system. Such a system is a layer between the application and the hardware which handles the scheduling and the effective execution of tasks on the processing units. A run-time system such as StarPU is able to manage automatically data transfers between not shared memory area (CPUs-GPUs, distributed nodes).

ARPACK-NG is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems.

ScalFMM is a C++ library that implements a kernel-independent Fast Multipole Method.

Example showing how to use starpu to implement a distributed regular 2D stencil with communication-avoiding techniques

Mini-chameleon is an educational purpose dense linear algebra solver. As provided, it essentially provides drivers while the actual computational routines remain to be completed. The goal is to implement a dense matrix-matrix product and an LU factorization, first targeting a sequential implementation, followed by an simd version, a shared-memory openmp one, a distributed memory MPI one, an MPI+openmp one and a runtime-based starpu one.

PaStiX (Parallel Sparse matriX package) is a scientific library that provides a high performance parallel solver for very large sparse linear systems based on direct methods. Numerical algorithms are implemented in single or double precision (real or complex) using LLt, LDLt and LU with static pivoting (for non symmetric matrices having a symmetric pattern). This solver also provides some low-rank compression methods to reduce the memory footprint and/or the time-to-solution.

pmtool aims at performing post-mortem analyses of the behavior of StarPU applications. Provide lower bounds on makespan. Study the performance of different schedulers in a simple context. Limitations: ignore communications for the moment; branch comms attempts to remove this limitation.

JUBE helps perform and analyze benchmarks in a systematic way. For each benchmarked application, benchmark data is stored in a format that allows JUBE to deduct the desired information. This data can be parsed by automatic pre- and post-processing scripts that draw information and store it more densely for manual interpretation.