Popularity
5.5
Growing
Activity
6.6
-
751
68
86

Code Quality Rank: L1
Programming language: C++
Tags: Math    
Latest version: v1.4.1

Vc alternatives and similar libraries

Based on the "Math" category

  • GLM

    8.5 8.4 L1 Vc VS GLM
    Header-only C++ math library that matches and inter-operates with OpenGL's GLSL math. [MIT]
  • OpenBLAS

    An optimized BLAS library based on GotoBLAS2 1.13 BSD version. [BSD 3-clause] website
  • QuantLib

    7.6 9.3 L1 Vc VS QuantLib
    A free/open-source library for quantitative finance. [Modified BSD] website
  • CGal

    7.2 9.9 L1 Vc VS CGal
    Collection of efficient and reliable geometric algorithms. [LGPL&GPL]
  • Eigen

    A high-level C++ library of template headers for linear algebra, matrix and vector operations, numerical solvers and related algorithms. [MPL2]
  • ceres-solver

    C++ library for modeling and solving large complicated nonlinear least squares problems from google. [BSD]
  • NT2

    5.0 5.6 Vc VS NT2
    A SIMD-optimized numerical template library that provides an interface with MATLAB-like syntax. [Boost]
  • TinyExpr

    4.9 0.0 L4 Vc VS TinyExpr
    tiny recursive descent expression parser, compiler, and evaluation engine for math expressions
  • MIRACL

    4.6 0.0 L1 Vc VS MIRACL
    A Multiprecision Integer and Rational Arithmetic Cryptographic Library. [AGPL]
  • linmath.h

    A lean linear math library, aimed at graphics programming. [WTFPL]
  • LibTomMath

    A free open source portable number theoretic multiple-precision integer library written entirely in C. [PublicDomain & WTFPL] website
  • GMTL

    4.0 0.0 L1 Vc VS GMTL
    Graphics Math Template Library is a collection of tools implementing Graphics primitives in generalized ways. [GPL2]
  • ExprTK

    4.0 3.6 L1 Vc VS ExprTK
    The C++ Mathematical Expression Toolkit Library (ExprTk) is a simple to use, easy to integrate and extremely efficient run-time mathematical expression parser and evaluation engine. [CPL]
  • muparser

    3.2 3.7 L1 Vc VS muparser
    muParser is an extensible high performance math expression parser library written in C++. [MIT]
  • blaze

    high-performance C++ math library for dense and sparse arithmetic. [BSD]
  • Apophenia

    A C library for statistical and scientific computing [GPL2]
  • Boost.Multiprecision

    provides higher-range/precision integer, rational and floating-point types in C++, header-only or with GMP/MPFR/LibTomMath backends. [Boost]
  • safe_numerics

    Replacements to standard numeric types which throw exceptions on errors
  • Wykobi

    A C++ library of efficient, robust and simple to use C++ 2D/3D oriented computational geometry routines. [MIT]
  • cml

    2.0 0.0 L3 Vc VS cml
    free C++ math library for games and graphics. [Boost]
  • Versor

    A (fast) Generic C++ library for Geometric Algebras, including Euclidean, Projective, Conformal, Spacetime (etc).
  • metamath

    metamath is a tiny header-only library. It can be used for symbolic computations on single-variable functions, such as dynamic computations of derivatives.
  • Xerus

    A general purpose library for numerical calculations with higher order tensors, Tensor-Train Decompositions / Matrix Product States and other Tensor Networks
  • GMP

    A C/C++ library for arbitrary precision arithmetic, operating on signed integers, rational numbers, and floating-point numbers. [LGPL3 & GPL2]
  • Armadillo

    A high quality C++ linear algebra library, aiming towards a good balance between speed and ease of use. The syntax (API) is deliberately similar to Matlab. [MPL2]

Do you think we are missing an alternative of Vc or a related project?

Add another 'Math' Library

README

Vc: portable, zero-overhead C++ types for explicitly data-parallel programming

NOTE: This is the development version, implementing https://wg21.link/p0214. For production use consider the latest release or the 1.3 branch. This implementation requires GCC 7.1 or newer. Support for Clang, ICC, and MSVC is available with the 1.3 branch.

Introduction

Recent generations of CPUs, and GPUs in particular, require data-parallel codes for full efficiency. Data parallelism requires that the same sequence of operations is applied to different input data. CPUs and GPUs can thus reduce the necessary hardware for instruction decoding and scheduling in favor of more arithmetic and logic units, which execute the same instructions synchronously. On CPU architectures this is implemented via SIMD registers and instructions. A single SIMD register can store N values and a single SIMD instruction can execute N operations on those values. On GPU architectures N threads run in perfect sync, fed by a single instruction decoder/scheduler. Each thread has local memory and a given index to calculate the offsets in memory for loads and stores.

Current C++ compilers can do automatic transformation of scalar codes to SIMD instructions (auto-vectorization). However, the compiler must reconstruct an intrinsic property of the algorithm that was lost when the developer wrote a purely scalar implementation in C++. Consequently, C++ compilers cannot vectorize any given code to its most efficient data-parallel variant. Especially larger data-parallel loops, spanning over multiple functions or even translation units, will often not be transformed into efficient SIMD code.

The Vc library provides the missing link. Its types enable explicitly stating data-parallel operations on multiple values. The parallelism is therefore added via the type system. Competing approaches state the parallelism via new control structures and consequently new semantics inside the body of these control structures.

Vc is a free software library to ease explicit vectorization of C++ code. It has an intuitive API and provides portability between different compilers and compiler versions as well as portability between different vector instruction sets. Thus an application written with Vc can be compiled for:

  • AVX and AVX2
  • SSE2 up to SSE4.2 or SSE4a
  • Scalar
  • MIC (only before Vc 2.0)
  • AVX-512 (since Vc 2.0)
  • NEON (in development)
  • NVIDIA GPUs / CUDA (research)

Examples

Scalar Product

Let's start from the code for calculating a 3D scalar product using builtin floats:

using Vec3D = std::array<float, 3>;
float scalar_product(Vec3D a, Vec3D b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

Using Vc, we can easily vectorize the code using the native_simd<float> type:

using Vc::native_simd;
using Vec3D = std::array<native_simd<float>, 3>;
float_v scalar_product(Vec3D a, Vec3D b) {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
}

The above will scale to 1, 4, 8, 16, etc. scalar products calculated in parallel, depending on the target hardware's capabilities.

For comparison, the same vectorization using Intel SSE intrinsics is more verbose and uses prefix notation (i.e. function calls):

using Vec3D = std::array<__m128, 3>;
__m128 scalar_product(Vec3D a, Vec3D b) {
  return _mm_add_ps(_mm_add_ps(_mm_mul_ps(a[0], b[0]), _mm_mul_ps(a[1], b[1])),
                    _mm_mul_ps(a[2], b[2]));
}

The above will neither scale to AVX, MIC, etc. nor is it portable to other SIMD ISAs.

Build Requirements

cmake >= 3.0

C++17 Compiler:

  • GCC >= 7.1

Building and Installing Vc

  • Create a build directory:
$ mkdir build
$ cd build
  • Call cmake; the following options may be interesting:
    • -DCMAKE_INSTALL_PREFIX=<path>: Select a different install prefix. Note that installing is not required (use -I<path to Vc src>) and currently not supported.
    • -DENABLE_UBSAN=ON: Build tests with the “undefined behavior sanitizer” enabled.
    • -DTARGET_ARCHITECTURE=<target>: Select a target architecture, different from the one you are building on.
    • -DUSE_CCACHE=ON: Use ccache (when found) to speed up recurring builds.
$ cmake <srcdir>
  • Build and run tests:
$ make -j8
$ ctest -j8

Documentation

The documentation of the master branch is currently out of date. Please refer to https://wg21.link/p0214 for the specification.

Documentation for older releases is available at:

Publications

Work on integrating the functionality of Vc in the C++ standard library.

Communication

A channel on the freenode IRC network is reserved for discussions on Vc: [##vc on freenode](irc://chat.freenode.net:6667/##vc) ([via SSL](ircs://chat.freenode.net:6697/##vc))

Feel free to use the GitHub issue tracker for questions. Alternatively, there's a mailinglist for users of Vc

License

Vc is released under the terms of the 3-clause BSD license.


*Note that all licence references and agreements mentioned in the Vc README section above are relevant to that project's source code only.