Basic linear algebra algorithms (since C++26)
From cppreference.com
Basic linear algebra algorithms are based on the dense Basic Linear Algebra Subroutines (BLAS) which corresponds to a subset of the BLAS Standard. These algorithms that access the elements of arrays view those elements through std::mdspan
The BLAS algorithms are categorized into three sets of operations called levels, which generally correspond to the degree of the polynomial in the complexities of algorithms:
- BLAS 1: All algorithms with std::mdspan parameters perform a count of std::mdspan array accesses and arithmetic operations that are linear in the maximum product of extents of any std::mdspan parameter. These algorithms contain vector
- BLAS 2: All algorithms have general complexity in quadratic time. These algorithms contain matrix-vector
- BLAS 3: All algorithms have general complexity in cubic time. These algorithms contain matrix-matrix
In-place transformations | |
Defined in header
<linalg> | |
Defined in namespace
std::linalg | |
(C++26)
|
std::mdspan accessor policy whose reference represents the product of a scaling factor that is fixed and its nested std::mdspan accessor's reference (class template) |
(C++26)
|
std::mdspan accessor policy whose reference represents the complex conjugate of its nested std::mdspan accessor's reference (class template) |
(C++26)
|
std::mdspan layout mapping policy that swaps the rightmost two indices, extents, and strides of any unique layout mapping policy (class template) |
(C++26)
|
returns a new read-only std::mdspan computed by the elementwise product of the scaling factor and the corresponding elements of the given std::mdspan
(function template) |
(C++26)
|
returns a new read-only std::mdspan whose elements are the complex conjugates of the corresponding elements of the given std::mdspan (function template) |
(C++26)
|
returns a new std::mdspan representing the transpose of the input matrix by the given std::mdspan (function template) |
(C++26)
|
returns a conjugate transpose view of an object (function template) |
BLAS 1 functions | |
Defined in header
<linalg> | |
Defined in namespace
std::linalg | |
(C++26)
|
generates plane rotation (function template) |
(C++26)
|
applies plane rotation to vectors (function template) |
(C++26)
|
swaps all corresponding elements of matrix or vector (function template) |
(C++26)
|
overwrites matrix or vector with the result of computing the elementwise multiplication by a scalar (function template) |
(C++26)
|
copies elements of one matrix or vector into another (function template) |
(C++26)
|
adds vectors or matrices elementwise (function template) |
(C++26)
|
returns nonconjugated dot product of two vectors (function template) |
(C++26)
|
returns conjugated dot product of two vectors (function template) |
(C++26)
|
returns scaled sum of squares of the vector elements (function template) |
(C++26)
|
returns Euclidean norm of a vector (function template) |
(C++26)
|
returns sum of absolute values of the vector elements (function template) |
(C++26)
|
returns index of maximum absolute value of vector elements (function template) |
(C++26)
|
returns Frobenius norm of a matrix (function template) |
(C++26)
|
returns one norm of a matrix (function template) |
(C++26)
|
returns infinity norm of a matrix (function template) |
BLAS 2 functions | |
Defined in header
<linalg> | |
Defined in namespace
std::linalg | |
(C++26)
|
computes matrix-vector product (function template) |
(C++26)
|
computes symmetric matrix-vector product (function template) |
(C++26)
|
computes Hermitian matrix-vector product (function template) |
(C++26)
|
computes triangular matrix-vector product (function template) |
(C++26)
|
solves a triangular linear system (function template) |
(C++26)
|
performs nonsymmetric nonconjugated rank-1 update of a matrix (function template) |
(C++26)
|
performs nonsymmetric conjugated rank-1 update of a matrix (function template) |
(C++26)
|
performs rank-1 update of a symmetric matrix (function template) |
(C++26)
|
performs rank-1 update of a Hermitian matrix (function template) |
(C++26)
|
performs rank-2 update of a symmetric matrix (function template) |
(C++26)
|
performs rank-2 update of a Hermitian matrix (function template) |
BLAS 3 functions | |
Defined in header
<linalg> | |
Defined in namespace
std::linalg | |
(C++26)
|
computes matrix-matrix product (function template) |
(C++26)
|
computes symmetric matrix-matrix product (function template) |
(C++26)
|
computes Hermitian matrix-matrix product (function template) |
computes triangular matrix-matrix product (function template) |
|
(C++26)
|
performs rank-k update of a symmetric matrix (function template) |
(C++26)
|
performs rank-k update of a Hermitian matrix (function template) |
(C++26)
|
performs rank-2k update of a symmetric matrix (function template) |
(C++26)
|
performs rank-2k update of a Hermitian matrix (function template) |
solves multiple triangular linear systems (function template) |
|
Helper items | |
Defined in header
<linalg> | |
Defined in namespace
std::linalg | |
describe the order of elements in an std::mdspan with linalg::layout_blas_packed layout (tag) |
|
specify whether algorithms and other users of a matrix should access the upper triangle or lower triangle of the matrix (tag) |
|
specify whether algorithms should access diagonal entries of the matrix (tag) |
|
(C++26)
|
std::mdspan layout mapping policy that represents a square matrix that stores only the entries in one triangle, in a packed contiguous format (class template) |
Notes
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_linalg |
202311L |
(C++26) | Basic linear algebra algorithms (BLAS) |
Example
Run this code
#include <cassert> #include <cstddef> #include <execution> #include <linalg> #include <mdspan> #include <numeric> #include <vector> int main() { std::vector<double> x_vec(42); std::ranges::iota(x_vec, 0.0); std::mdspan x(x_vec.data(), x_vec.size()); // x[i] *= 2.0, executed sequentially std::linalg::scale(2.0, x); // x[i] *= 3.0, executed in parallel std::linalg::scale(std::execution::par_unseq, 3.0, x); for (std::size_t i{}; i != x.size(); ++i) assert(x[i] == 6.0 * static_cast<double>(i)); }
External links
1. | BLAS homepage |
2. | BLAS Technical Forum |