Detailed Description

Interface to parts of the BLAS library.

Typedefs
using	nda::dcomplex = std::complex<double>
	Alias for std::complex<double> type.

Functions
template<MemoryVector X, MemoryVector Y> requires (have_same_value_type_v<X, Y> and mem::have_compatible_addr_space<X, Y> and is_blas_lapack_v<get_value_t<X>>)
auto	nda::blas::dot (X const &x, Y const &y)
	Interface to the BLAS dot and dotu routine.
template<MemoryVector X, MemoryVector Y> requires (have_same_value_type_v<X, Y> and mem::have_compatible_addr_space<X, Y> and is_blas_lapack_v<get_value_t<X>>)
auto	nda::blas::dotc (X const &x, Y const &y)
	Interface to the BLAS dotc routine.
template<Matrix A, Matrix B, MemoryMatrix C> requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and (MemoryMatrix<B> or is_conj_array_expr<B>) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)
void	nda::blas::gemm (get_value_t< A > alpha, A const &a, B const &b, get_value_t< A > beta, C &&c)
	Interface to the BLAS gemm routine.
template<bool VBATCH = false, Matrix A, Matrix B, MemoryMatrix C> requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and (MemoryMatrix<B> or is_conj_array_expr<B>) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)
void	nda::blas::gemm_batch (get_value_t< A > alpha, std::vector< A > const &va, std::vector< B > const &vb, get_value_t< A > beta, std::vector< C > &vc)
	Implements a batched version of nda::blas::gemm taking vectors of matrices as arguments.
template<ArrayOfRank< 3 > A, ArrayOfRank< 3 > B, MemoryArrayOfRank< 3 > C> requires ((MemoryArrayOfRank<A, 3> or (is_conj_array_expr<A>)) and (MemoryArrayOfRank<B, 3> or (is_conj_array_expr<B>)) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)
void	nda::blas::gemm_batch_strided (get_value_t< A > alpha, A const &a, B const &b, get_value_t< A > beta, C &&c)
	Implements a strided batched version of nda::blas::gemm taking 3-dimensional arrays as arguments.
template<Matrix A, Matrix B, MemoryMatrix C>
void	nda::blas::gemm_generic (typename A::value_type alpha, A const &a, B const &b, typename A::value_type beta, C &&c)
	Generic nda::blas::gemm implementation for types not supported by BLAS/LAPACK.
template<Matrix A, Matrix B, MemoryMatrix C>
void	nda::blas::gemm_vbatch (get_value_t< A > alpha, std::vector< A > const &va, std::vector< B > const &vb, get_value_t< A > beta, std::vector< C > &vc)
	Wrapper of nda::blas::gemm_batch that allows variable sized matrices.
template<Matrix A, MemoryVector X, MemoryVector Y> requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and have_same_value_type_v<A, X, Y> and is_blas_lapack_v<get_value_t<A>>)
void	nda::blas::gemv (get_value_t< A > alpha, A const &a, X const &x, get_value_t< A > beta, Y &&y)
	Interface to the BLAS gemv routine.
template<typename A, typename X, typename Y>
void	nda::blas::gemv_generic (get_value_t< A > alpha, A const &a, X const &x, get_value_t< A > beta, Y &&y)
	Generic nda::blas::gemv implementation for types not supported by BLAS/LAPACK.
template<MemoryVector X, MemoryVector Y, MemoryMatrix M> requires (have_same_value_type_v<X, Y, M> and mem::have_compatible_addr_space<X, Y, M> and is_blas_lapack_v<get_value_t<X>>)
void	nda::blas::ger (get_value_t< X > alpha, X const &x, Y const &y, M &&m)
	Interface to the BLAS ger and geru routine.
template<MemoryArray A> requires (get_rank<A> == 1 or get_rank<A> == 2)
int	nda::blas::get_ld (A const &a)
	Get the leading dimension of an nda::MemoryArray with rank 1 or 2 for LAPACK calls.
template<MemoryArray A> requires (get_rank<A> == 1 or get_rank<A> == 2)
int	nda::blas::get_ncols (A const &a)
	Get the number of columns of an nda::MemoryArray with rank 1 or 2 for BLAS/LAPACK calls.
template<MemoryVector X> requires (is_blas_lapack_v<get_value_t<X>>)
void	nda::blas::scal (get_value_t< X > alpha, X &&x)
	Interface to the BLAS scal routine.

Variables
template<bool conj, bool transpose>
const char	nda::blas::get_op
	Variable template that determines the BLAS matrix operation tag ('N','T','C') based on the given boolean flags for conjugation and transposition.
template<Array A>
static constexpr bool	nda::blas::has_C_layout
	Constexpr variable that is true if the given nda::Array type has a C memory layout.
template<Array A>
static constexpr bool	nda::blas::has_F_layout
	Constexpr variable that is true if the given nda::Array type has a Fortran memory layout.
template<typename A>
static constexpr bool	nda::blas::is_conj_array_expr = false
	Constexpr variable that is true if the given type is a conjugate lazy expression.
template<MemoryArray A>
static constexpr bool	nda::blas::is_conj_array_expr< expr_call< detail::conj_f, A > > = true
	Specialization of nda::blas::is_conj_array_expr for the conjugate lazy expressions.

Function Documentation

◆ dot()

template<MemoryVector X, MemoryVector Y>
requires (have_same_value_type_v<X, Y> and mem::have_compatible_addr_space<X, Y> and is_blas_lapack_v<get_value_t<X>>)

auto nda::blas::dot	(	X const &	x,
		Y const &	y )

#include <nda/blas/dot.hpp>

Interface to the BLAS dot and dotu routine.

This function forms the dot product of two vectors. It calculates

\[ \mathbf{x}^T \mathbf{y} \; . \]

Note: The first argument is never conjugated. Even for complex types. Use nda::blas::dotc for that.

Template Parameters

X	nda::MemoryVector type.
Y	nda::MemoryVector type.

Parameters

x	Input vector \( \mathbf{x} \).
y	Input vector \( \mathbf{y} \).

Returns: Result of \( \mathbf{x}^T \mathbf{y} \).

Definition at line 48 of file dot.hpp.

◆ dotc()

template<MemoryVector X, MemoryVector Y>
requires (have_same_value_type_v<X, Y> and mem::have_compatible_addr_space<X, Y> and is_blas_lapack_v<get_value_t<X>>)

auto nda::blas::dotc	(	X const &	x,
		Y const &	y )

#include <nda/blas/dot.hpp>

Interface to the BLAS dotc routine.

This function forms the dot product of two vectors. It calculates

\[ \mathbf{x}^H \mathbf{y} \; . \]

If the value type of the input vectors is real, it calls nda::blas::dot and returns a real result.

Template Parameters

X	nda::MemoryVector type.
Y	nda::MemoryVector type.

Parameters

x	Input vector \( \mathbf{x} \).
y	Input vector \( \mathbf{y} \).

Returns: Result of \( \mathbf{x}^H \mathbf{y} \).

Definition at line 83 of file dot.hpp.

◆ gemm()

template<Matrix A, Matrix B, MemoryMatrix C>
requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and (MemoryMatrix or is_conj_array_expr) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)

void nda::blas::gemm	(	get_value_t< A >	alpha,
		A const &	a,
		B const &	b,
		get_value_t< A >	beta,
		C &&	c )

#include <nda/blas/gemm.hpp>

Interface to the BLAS gemm routine.

This function performs one of the matrix-matrix operations

\[ \mathbf{C} \leftarrow \alpha \mathrm{op}(\mathbf{A}) \mathrm{op}(\mathbf{B}) + \beta \mathbf{C} \;, \]

where \( \mathrm{op}(\mathbf{X}) \) is one of

\( \mathrm{op}(\mathbf{X}) = \mathbf{X} \),
\( \mathrm{op}(\mathbf{X}) = \mathbf{X}^T \) or
\( \mathrm{op}(\mathbf{X}) = \mathbf{X}^H \).

Here, \( \alpha \) and \( \beta \) are scalars, and \( \mathbf{A} \), \( \mathbf{B} \) are matrices with \( \mathrm{op}(\mathbf{A}) \) is an m-by-k matrix, \( \mathrm{op}(\mathbf{B}) \) is a k-by-n matrix and \( \mathrm{op}(\mathbf{C}) \) is an m-by-n matrix.

Template Parameters

A	nda::Matrix type.
B	nda::Matrix type.
C	nda::MemoryMatrix type.

Parameters

alpha	Input scalar.
a	Input matrix of size m-by-k.
b	Input matrix of size k-by-n.
beta	Input scalar.
c	Input/Output matrix of size m-by-n.

Definition at line 96 of file gemm.hpp.

◆ gemm_batch()

template<bool VBATCH = false, Matrix A, Matrix B, MemoryMatrix C>
requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and (MemoryMatrix or is_conj_array_expr) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)

void nda::blas::gemm_batch	(	get_value_t< A >	alpha,
		std::vector< A > const &	va,
		std::vector< B > const &	vb,
		get_value_t< A >	beta,
		std::vector< C > &	vc )

#include <nda/blas/gemm_batch.hpp>

Implements a batched version of nda::blas::gemm taking vectors of matrices as arguments.

This routine is a batched version of nda::blas::gemm, performing multiple gemm operations in a single call. Each gemm operation performs a matrix-matrix product with general matrices.

Template Parameters

VBATCH	Allow for variable sized matrices.
A	nda::Matrix type.
B	nda::Matrix type.
C	nda::MemoryMatrix type.

Parameters

alpha	Input scalar.
va	std::vector of input matrices.
vb	std::vector of input matrices.
beta	Input scalar.
vc	std::vector of input/output matrices.

Definition at line 58 of file gemm_batch.hpp.

◆ gemm_batch_strided()

template<ArrayOfRank< 3 > A, ArrayOfRank< 3 > B, MemoryArrayOfRank< 3 > C>
requires ((MemoryArrayOfRank<A, 3> or (is_conj_array_expr<A>)) and (MemoryArrayOfRank<B, 3> or (is_conj_array_expr)) and have_same_value_type_v<A, B, C> and is_blas_lapack_v<get_value_t<A>>)

void nda::blas::gemm_batch_strided	(	get_value_t< A >	alpha,
		A const &	a,
		B const &	b,
		get_value_t< A >	beta,
		C &&	c )

#include <nda/blas/gemm_batch.hpp>

Implements a strided batched version of nda::blas::gemm taking 3-dimensional arrays as arguments.

This function is similar to nda::blas::gemm_batch except that it takes 3-dimensional arrays as arguments instead of vectors of matrices. The first dimension of the arrays indexes the matrices to be multiplied.

Template Parameters

A	nda::ArrayOfRank<3> type.
B	nda::ArrayOfRank<3> type.
C	nda::ArrayOfRank<3> type.

Parameters

alpha	Input scalar.
a	3-dimensional input array.
b	3-dimensional input array.
beta	Input scalar.
c	3-dimensional input/output array.

Definition at line 210 of file gemm_batch.hpp.

◆ gemm_generic()

template<Matrix A, Matrix B, MemoryMatrix C>

void nda::blas::gemm_generic	(	typename A::value_type	alpha,
		A const &	a,
		B const &	b,
		typename A::value_type	beta,
		C &&	c )

#include <nda/blas/gemm.hpp>

Generic nda::blas::gemm implementation for types not supported by BLAS/LAPACK.

Template Parameters

A	Some matrix type.
B	Some matrix type.
C	Some matrix type.

Parameters

alpha	Input scalar.
a	Input matrix of size m-by-k.
b	Input matrix of size k-by-n.
beta	Input scalar.
c	Input/Output matrix of size m-by-n.

Definition at line 48 of file gemm.hpp.

◆ gemm_vbatch()

template<Matrix A, Matrix B, MemoryMatrix C>

void nda::blas::gemm_vbatch	(	get_value_t< A >	alpha,
		std::vector< A > const &	va,
		std::vector< B > const &	vb,
		get_value_t< A >	beta,
		std::vector< C > &	vc )

#include <nda/blas/gemm_batch.hpp>

Wrapper of nda::blas::gemm_batch that allows variable sized matrices.

Template Parameters

A	nda::Matrix type.
B	nda::Matrix type.
C	nda::MemoryMatrix type.

Parameters

alpha	Input scalar.
va	std::vector of input matrices.
vb	std::vector of input matrices.
beta	Input scalar.
vc	std::vector of input/output matrices.

Definition at line 188 of file gemm_batch.hpp.

◆ gemv()

template<Matrix A, MemoryVector X, MemoryVector Y>
requires ((MemoryMatrix<A> or is_conj_array_expr<A>) and have_same_value_type_v<A, X, Y> and is_blas_lapack_v<get_value_t<A>>)

void nda::blas::gemv	(	get_value_t< A >	alpha,
		A const &	a,
		X const &	x,
		get_value_t< A >	beta,
		Y &&	y )

#include <nda/blas/gemv.hpp>

Interface to the BLAS gemv routine.

This function performs one of the matrix-vector operations

\( \mathbf{y} \leftarrow \alpha \mathbf{A} \mathbf{x} + \beta \mathbf{y} \),
\( \mathbf{y} \leftarrow \alpha \mathbf{A}^T \mathbf{x} + \beta \mathbf{y} \),
\( \mathbf{y} \leftarrow \alpha \mathbf{A}^H \mathbf{x} + \beta \mathbf{y} \),

where \( \alpha \) and \( \beta \) are scalars, \( \mathbf{x} \) and \( \mathbf{y} \) are vectors and \( \mathbf{A} \) is an m-by-n matrix.

Template Parameters

A	nda::Matrix type.
X	nda::MemoryVector type.
Y	nda::MemoryVector type.

Parameters

alpha	Input scalar.
a	Input matrix of size m-by-n.
x	Input vector of size n.
beta	Input scalar.
y	Input/Output vector of size m.

Definition at line 84 of file gemv.hpp.

◆ gemv_generic()

template<typename A, typename X, typename Y>

void nda::blas::gemv_generic	(	get_value_t< A >	alpha,
		A const &	a,
		X const &	x,
		get_value_t< A >	beta,
		Y &&	y )

#include <nda/blas/gemv.hpp>

Generic nda::blas::gemv implementation for types not supported by BLAS/LAPACK.

Template Parameters

A	Some matrix type.
X	Some vector type.
Y	Some vector type.

Parameters

alpha	Input scalar.
a	Input matrix of size m-by-n.
x	Input vector of size n.
beta	Input scalar.
y	Input/Output vector of size m.

Definition at line 46 of file gemv.hpp.

◆ ger()

template<MemoryVector X, MemoryVector Y, MemoryMatrix M>
requires (have_same_value_type_v<X, Y, M> and mem::have_compatible_addr_space<X, Y, M> and is_blas_lapack_v<get_value_t<X>>)

void nda::blas::ger	(	get_value_t< X >	alpha,
		X const &	x,
		Y const &	y,
		M &&	m )

#include <nda/blas/ger.hpp>

Interface to the BLAS ger and geru routine.

This function performs the rank 1 operation

\[ \mathbf{M} \leftarrow \alpha \mathbf{x} \mathbf{y}^T + \mathbf{M} \; , \]

where \( \alpha \) is a scalar, \( \mathbf{x} \) is an \( m \) element vector, \( \mathbf{y} \) is an \( n \) element vector and \( \mathbf{M} \) is an \( m \times n \) matrix.

Note: The vector \( \mathbf{y} \) is never conjugated. Even for complex types. Use nda::blas::gerc for that.

Template Parameters

X	nda::MemoryVector type.
Y	nda::MemoryVector type.
M	nda::MemoryMatrix type.

Parameters

alpha	Input scalar \( \alpha \).
x	Input vector \( \mathbf{x} \) of size \( m \).
y	Input vector \( \mathbf{y} \) of size \( n \).
m	Input/Output matrix \( \mathbf{M} \) of size \( m \times n \) to which the outer product is added.

Definition at line 55 of file ger.hpp.

◆ get_ld()

template<MemoryArray A>
requires (get_rank<A> == 1 or get_rank<A> == 2)

int nda::blas::get_ld ( A const & a )

#include <nda/blas/tools.hpp>

Get the leading dimension of an nda::MemoryArray with rank 1 or 2 for LAPACK calls.

The leading dimension is the stride between two consecutive columns (rows) of a matrix in Fortran (C) layout. For 1-dimensional arrays, we simply return the size of the array.

Template Parameters

A	nda::MemoryArray type.

Parameters

a	nda::MemoryArray object.

Returns: Leading dimension for BLAS/LAPACK calls.

Definition at line 102 of file tools.hpp.

◆ get_ncols()

template<MemoryArray A>
requires (get_rank<A> == 1 or get_rank<A> == 2)

int nda::blas::get_ncols ( A const & a )

#include <nda/blas/tools.hpp>

Get the number of columns of an nda::MemoryArray with rank 1 or 2 for BLAS/LAPACK calls.

The number of columns corresponds to the extent of the second (first) dimension of a matrix in Fortran (C) layout. For 1-dimensional arrays, we return 1.

Template Parameters

A	nda::MemoryArray type.

Parameters

a	nda::MemoryArray object.

Returns: Number of columns for BLAS/LAPACK calls.

Definition at line 122 of file tools.hpp.

◆ scal()

template<MemoryVector X>
requires (is_blas_lapack_v<get_value_t<X>>)

void nda::blas::scal	(	get_value_t< X >	alpha,
		X &&	x )

#include <nda/blas/scal.hpp>

Interface to the BLAS scal routine.

Scales a vector by a constant. This function calculates \( \mathbf{x} \leftarrow \alpha \mathbf{x} \), where \( \alpha \) is a scalar constant and \( \mathbf{x} \) is a vector.

Template Parameters

X	nda::MemoryVector type.

Parameters

alpha	Input scalar \( \alpha \).
x	Input/Output vector \( \mathbf{x} \) to be scaled.

Definition at line 38 of file scal.hpp.

Variable Documentation

◆ get_op

template<bool conj, bool transpose>

const char nda::blas::get_op

#include <nda/blas/tools.hpp>

Initial value:

= []() {
    static_assert(!(conj and not transpose), "Error in nda::blas::get_op: Cannot use conjugate operation alone in BLAS operations");
    if constexpr (conj and transpose)
      return 'C';
    else if constexpr (transpose)
      return 'T';
    else 
      return 'N';
  }()

Variable template that determines the BLAS matrix operation tag ('N','T','C') based on the given boolean flags for conjugation and transposition.

Template Parameters

conj	Boolean flag for conjugation.
transpose	Boolean flag for transposition.

Definition at line 80 of file tools.hpp.

Detailed Description

Typedefs

Functions

Variables

Function Documentation

◆ dot()

◆ dotc()

◆ gemm()

◆ gemm_batch()

◆ gemm_batch_strided()

◆ gemm_generic()

◆ gemm_vbatch()

◆ gemv()

◆ gemv_generic()

◆ ger()

◆ get_ld()

◆ get_ncols()

◆ scal()

Variable Documentation

◆ get_op