tlapack Namespace Reference

Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ). More...

Classes
struct	BandAccess
	Band access. More...
struct	BidiagOpts
	Options struct for bidiag() More...
struct	BlockedBandedCholeskyOpts
	Options struct for pbtrf_with_workspace() More...
struct	BlockedCholeskyOpts
struct	BlockedLDLOpts
	Options struct for hetrf_blocked() More...
struct	EcOpts
	Options for error checking. More...
struct	ErrorCheck
	Descriptor for Exception Handling. More...
struct	FrancisOpts
	Options struct for multishift_qr(). More...
struct	GebrdOpts
	Options struct for gebrd() More...
struct	GehrdOpts
	Options struct for gehrd. More...
struct	GelqfOpts
	Options struct for gelqf. More...
struct	GenHouseholderQOpts
	Options struct for gen_householder_q() More...
struct	GeqlfOpts
	Options struct for gelqf. More...
struct	GeqrfOpts
	Options struct for geqrf. More...
struct	GerqfOpts
	Options struct for gerqf. More...
struct	GesvdOpts
	Options struct for gesvd. More...
struct	GetrfOpts
	Options struct for getrf() More...
struct	GetriOpts
	Options struct for getri() More...
struct	Gghd3Opts
	Options struct for gghd3. More...
struct	HessenbergOpts
	Options struct for hessenberg() More...
struct	HetrfOpts
	Options struct for hetrf() More...
struct	HouseholderLQOpts
	Options struct for householder_lq() More...
struct	HouseholderQLOpts
	Options struct for householder_ql() More...
struct	HouseholderQMulOpts
	Options struct for householder_q_mul() More...
struct	HouseholderQROpts
	Options struct for householder_qr() More...
struct	HouseholderRQOpts
	Options struct for householder_rq() More...
struct	IamaxOpts
	Options for iamax. More...
struct	LegacyBandedMatrix
	Legacy banded matrix. More...
struct	LegacyMatrix
	Legacy matrix. More...
struct	LegacyVector
	Legacy vector. More...
struct	LuMultOpts
	Options struct for lu_mult() More...
struct	MatrixMarket
	MatrixMarket class. More...
struct	mult_llh_Opts
	Options struct for llh_mult() More...
struct	mult_uhu_Opts
	Options struct for mult_uhu() More...
struct	NaNPropagComplex
class	PCG32
	Permuted Congruential Generator. More...
struct	PotrfOpts
	Options struct for potrf() More...
struct	QRIterationOpts
	Options struct for qr_iteration() More...
struct	StrongZero
	Strong zero type. More...
struct	TestUploMatrix
	TestUploMatrix class. More...
struct	TransposeOpts
struct	TrmmBlockedOpts
	Options struct for trmm_blocked_mixed. More...
struct	UngbrOpts
	Options struct for ungbr. More...
struct	UnglqOpts
	Options struct for unglq. More...
struct	UngqlOpts
	Options struct for ungql. More...
struct	UngqOpts
	Options struct for ungq. More...
struct	UngqrOpts
	Options struct for ungqr. More...
struct	UngrqOpts
	Options struct for ungrq. More...
struct	UnmlqOpts
	Options struct for unmlq. More...
struct	UnmqlOpts
	Options struct for unmql. More...
struct	UnmqOpts
	Options struct for unmq. More...
struct	UnmqrOpts
	Options struct for unmqr. More...
struct	UnmrqOpts
	Options struct for unmrq. More...
struct	WorkInfo
	Output information in the workspace query. More...

Typedefs
template<typename... Types>
using	complex_type = typename traits::complex_type_traits< Types..., int >::type
	The common complex type of the list of types.
template<class T >
using	Create = traits::CreateFunctor< T, int >
	Alias for traits::CreateFunctor<,int>.
template<class T , int m, int n = -1>
using	CreateStatic = traits::CreateStaticFunctor< T, m, n, int >
	Alias for traits::CreateStaticFunctor<,int>.
template<class T1 , class... Ts>
using	disable_if_allow_optblas_t = enable_if_t<(!allow_optblas< T1, Ts... >), int >
	Disable if the list of types allows optimized BLAS library.
template<class T1 , class... Ts>
using	enable_if_allow_optblas_t = enable_if_t<(allow_optblas< T1, Ts... >), int >
	Enable if the list of types allows optimized BLAS library.
template<class... matrix_t>
using	matrix_type = typename traits::matrix_type_traits< matrix_t..., int >::type
	Common matrix type deduced from the list of types.
template<typename... Types>
using	real_type = typename traits::real_type_traits< Types..., int >::type
	The common real type of the list of types.
template<typename... Types>
using	scalar_type = typename traits::scalar_type_traits< Types..., int >::type
	The common scalar type of the list of types.
template<class T >
using	size_type = typename traits::size_type_trait< T, int >::type
	Size type of a matrix or vector.
template<class T >
using	type_t = typename traits::entry_type_trait< T, int >::type
	Entry type of a matrix or vector.
template<class... vector_t>
using	vector_type = typename traits::vector_type_traits< vector_t..., int >::type
	Common vector type deduced from the list of types.

Enumerations
enum class	BidiagVariant : char { Level2 = '2' , Blocked = 'B' }
	Variant of the bidiagonal reduction algorithm.
enum class	Diag : char { NonUnit = 'N' , Unit = 'U' }
enum class	Direction : char { Forward = 'F' , Backward = 'B' }
enum class	GenHouseholderQVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to generate the unitary matrix Q from a set of Householder reflectors.
enum class	GetrfVariant : char { Level0 = '0' , Recursive = 'R' }
	Variants of the algorithm to compute the LU factorization.
enum class	GetriVariant : char { UILI = 'D' , UXLI = 'C' }
	Variants of the algorithm to compute the inverse of a matrix. More...
enum class	HessenbergVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to reduce a matrix to upper Hessenberg form.
enum class	HetrfVariant : char { Blocked = 'B' }
	Variants of the algorithm to compute the Bunch-Kaufman factorization.
enum class	HouseholderLQVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to compute the LQ factorization.
enum class	HouseholderQLVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to compute the QL factorization.
enum class	HouseholderQMulVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to multiply by the unitary matrix Q, defined by a set of Householder reflectors.
enum class	HouseholderQRVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to compute the QR factorization.
enum class	HouseholderRQVariant : char { Level2 = '2' , Blocked = 'B' }
	Variants of the algorithm to compute the RQ factorization.
enum class	Layout : char { Strided = 'S' , ColMajor = 'C' , RowMajor = 'R' , Unspecified = 0 }
enum class	Norm : char {   One = '1' , Two = '2' , Inf = 'I' , Fro = 'F' ,   Max = 'M' }
enum class	Op : char { NoTrans = 'N' , Trans = 'T' , ConjTrans = 'C' , Conj = 3 }
enum class	PotrfVariant : char { Blocked = 'B' , Recursive = 'R' , Level2 = '2' , RightLooking }
	Variants of the algorithm to compute the Cholesky factorization.
enum class	QRIterationVariant : char { MultiShift = 'M' , DoubleShift = 'D' }
	Variant of the algorithm that performs QR iterations on an upper Hessenberg matrix.
enum class	Side : char { Left = 'L' , Right = 'R' }
enum class	StoreV : char { Columnwise = 'C' , Rowwise = 'R' }
enum class	Uplo : char {   General = 'G' , Upper = 'U' , Lower = 'L' , UpperHessenberg = 'H' ,   LowerHessenberg = 4 , StrictUpper = 'S' , StrictLower = 6 }

Functions
template<typename T >
constexpr real_type< T >	abs1 (const T &x)
	1-norm absolute value, |Re(x)| + |Im(x)|
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
void	aggressive_early_deflation (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, matrix_t &A, vector_t &s, matrix_t &Z, size_type< matrix_t > &ns, size_type< matrix_t > &nd)
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
void	aggressive_early_deflation (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, matrix_t &A, vector_t &s, matrix_t &Z, size_type< matrix_t > &ns, size_type< matrix_t > &nd, FrancisOpts &opts)
	aggressive_early_deflation accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR alpha_t, TLAPACK_SVECTOR beta_t>
void	aggressive_early_deflation_generalized (bool want_s, bool want_q, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, matrix_t &A, matrix_t &B, alpha_t &alpha, beta_t &beta, matrix_t &Q, matrix_t &Z, size_type< matrix_t > &ns, size_type< matrix_t > &nd, FrancisOpts &opts)
	aggressive_early_deflation_generalized accepts as input an upper Hessenberg pencil (A,B) and performs a unitary similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal subpencil.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_MATRIX work_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
void	aggressive_early_deflation_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, matrix_t &A, vector_t &s, matrix_t &Z, size_type< matrix_t > &ns, size_type< matrix_t > &nd, work_t &work)
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t, enable_if_t< is_complex< type_t< vector_t > >, int > >
void	aggressive_early_deflation_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, matrix_t &A, vector_t &s, matrix_t &Z, size_type< matrix_t > &ns, size_type< matrix_t > &nd, work_t &work, FrancisOpts &opts)
	aggressive_early_deflation accepts as input an upper Hessenberg matrix H and performs an orthogonal similarity transformation designed to detect and deflate fully converged eigenvalues from a trailing principal submatrix. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > >
WorkInfo	aggressive_early_deflation_worksize (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, size_type< matrix_t > nw, const matrix_t &A, const vector_t &s, const matrix_t &Z, const size_type< matrix_t > &ns, const size_type< matrix_t > &nd, const FrancisOpts &opts)
	Worspace query of aggressive_early_deflation().
template<TLAPACK_VECTOR vector_t, disable_if_allow_optblas_t< vector_t > = 0>
auto	asum (vector_t const &x)
	Vector 1-norm: \(\sum_{i=0}^{n-1} |Re(x_i)| + |Im(x_i)|\).
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	axpy (const alpha_t &alpha, const vectorX_t &x, vectorY_t &y)
	Add scaled vector, \(y := \alpha x + y\).
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	bidiag (matrix_t &A, vector_t &tauv, vector_t &tauw, const BidiagOpts &opts={})
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	bidiag_work (matrix_t &A, vector_t &tauv, vector_t &tauw, work_t &work, const BidiagOpts &opts={})
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation: Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	bidiag_worksize (const matrix_t &A, const vector_t &tauv, const vector_t &tauw, const BidiagOpts &opts={})
	Worspace query of bidiag()
template<TLAPACK_REAL real_t>
constexpr real_t	blue_max () noexcept
	Blue's max constant B for the sum of squares.
template<TLAPACK_REAL real_t>
constexpr real_t	blue_min () noexcept
	Blue's min constant b for the sum of squares.
template<TLAPACK_REAL real_t>
constexpr real_t	blue_scalingMax () noexcept
	Blue's scaling constant for numbers bigger than B.
template<TLAPACK_REAL real_t>
constexpr real_t	blue_scalingMin () noexcept
	Blue's scaling constant for numbers smaller than b.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_generalized_similarity_transform (matrix_t &A, matrix_t &Q, matrix_t &Z, matrix_t &B)
	Calculates ||Q'*A*Z - B||.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_generalized_similarity_transform (matrix_t &A, matrix_t &Q, matrix_t &Z, matrix_t &B, matrix_t &res, matrix_t &work)
	Calculates res = Q'*A*Z - B and the frobenius norm of res.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_orthogonality (matrix_t &Q)
	Calculates ||Q'*Q - I||_F if m <= n or ||Q*Q' - I||_F otherwise.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_orthogonality (matrix_t &Q, matrix_t &res)
	Calculates res = Q'*Q - I if m <= n or res = Q*Q' otherwise Also computes the frobenius norm of res.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_similarity_transform (matrix_t &A, matrix_t &Q, matrix_t &B)
	Calculates ||Q'*A*Q - B||.
template<TLAPACK_MATRIX matrix_t>
real_type< type_t< matrix_t > >	check_similarity_transform (matrix_t &A, matrix_t &Q, matrix_t &B, matrix_t &res, matrix_t &work)
	Calculates res = Q'*A*Q - B and the frobenius norm of res.
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel>
constexpr auto	col (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index colIdx) noexcept
template<typename T , class idx_t >
constexpr auto	col (const LegacyMatrix< T, idx_t > &A, size_type< LegacyMatrix< T, idx_t > > colIdx) noexcept
template<typename T , class idx_t >
constexpr auto	col (const LegacyMatrix< T, idx_t, Layout::RowMajor > &A, size_type< LegacyMatrix< T, idx_t, Layout::RowMajor > > colIdx) noexcept
template<class T >
constexpr auto	col (const starpu::Matrix< T > &A, starpu::idx_t colIdx) noexcept
template<class ET , class Exts , class LP , class AP >
constexpr auto	col (const std::experimental::mdspan< ET, Exts, LP, AP > &A, std::size_t colIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel>
constexpr auto	col (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index colIdx) noexcept
template<typename T , class idx_t >
constexpr auto	col (LegacyMatrix< T, idx_t > &A, size_type< LegacyMatrix< T, idx_t > > colIdx) noexcept
template<typename T , class idx_t >
constexpr auto	col (LegacyMatrix< T, idx_t, Layout::RowMajor > &A, size_type< LegacyMatrix< T, idx_t, Layout::RowMajor > > colIdx) noexcept
template<class T >
constexpr auto	col (starpu::Matrix< T > &A, starpu::idx_t colIdx) noexcept
template<class T , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	col (T &A, Eigen::Index colIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	cols (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpec &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpec >
constexpr auto	cols (const LegacyMatrix< T, idx_t, layout > &A, SliceSpec &&cols) noexcept
template<class T , class SliceSpec >
constexpr auto	cols (const starpu::Matrix< T > &A, SliceSpec &&cols) noexcept
template<class ET , class Exts , class LP , class AP , class SliceSpec , std::enable_if_t< isSlice(SliceSpec), int > = 0>
constexpr auto	cols (const std::experimental::mdspan< ET, Exts, LP, AP > &A, SliceSpec &&cols) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpec >
constexpr auto	cols (const TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpec &&slice) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	cols (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpec &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpec >
constexpr auto	cols (LegacyMatrix< T, idx_t, layout > &A, SliceSpec &&cols) noexcept
template<class T , class SliceSpec >
constexpr auto	cols (starpu::Matrix< T > &A, SliceSpec &&cols) noexcept
template<class T , typename SliceSpec , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	cols (T &A, SliceSpec &&cols) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpec >
constexpr auto	cols (TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpec &&slice) noexcept
template<class T >
constexpr T	conj (const starpu::MatrixEntry< T > &x) noexcept
template<typename T , enable_if_t< is_real< T >, int > = 0>
constexpr T	conj (const T &x) noexcept
	Extends std::conj() to real datatypes.
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t>
void	conjtranspose (matrixA_t &A, matrixB_t &B, const TransposeOpts &opts={})
	conjugate transpose a matrix A into a matrix B.
template<TLAPACK_VECTOR vector_t>
void	conjugate (vector_t &x)
	Conjugates a vector.
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	copy (const vectorX_t &x, vectorY_t &y)
	Copy vector, \(y := x\).
template<typename T , class idx_t , Layout layout>
constexpr auto	diag (const LegacyMatrix< T, idx_t, layout > &A, int diagIdx=0) noexcept
template<class T >
constexpr auto	diag (const starpu::Matrix< T > &A, int diagIdx=0)
template<class ET , class Exts , class LP , class AP , std::enable_if_t< LP::template mapping< Exts >::is_always_strided(), bool > = true>
constexpr auto	diag (const std::experimental::mdspan< ET, Exts, LP, AP > &A, int diagIdx=0)
template<typename T , class idx_t , Layout layout>
constexpr auto	diag (LegacyMatrix< T, idx_t, layout > &A, int diagIdx=0) noexcept
template<class T >
constexpr auto	diag (starpu::Matrix< T > &A, int diagIdx=0)
template<class T , typename std::enable_if< traits::internal::is_eigen_matrix< T >, int >::type = 0>
constexpr auto	diag (T &A, int diagIdx=0) noexcept
	Get the Diagonal of an Eigen Matrix.
template<typename real_t >
int	digits () noexcept
	Digits.
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
auto	dot (const vectorX_t &x, const vectorY_t &y)
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
auto	dotu (const vectorX_t &x, const vectorY_t &y)
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	gebd2 (matrix_t &A, vector_t &tauv, vector_t &tauw)
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gebd2_work (matrix_t &A, vector_t &tauv, vector_t &tauw, work_t &work)
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation: Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	gebd2_worksize (const matrix_t &A, const vector_t &tauv, const vector_t &tauw)
	Worspace query of gebd2().
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	gebrd (matrix_t &A, vector_t &tauv, vector_t &tauw, const GebrdOpts &opts={})
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gebrd_work (matrix_t &A, vector_t &tauv, vector_t &tauw, work_t &work, const GebrdOpts &opts={})
	Reduces a general m by n matrix A to an upper real bidiagonal form B by a unitary transformation: Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	gebrd_worksize (const matrix_t &A, const vector_t &tauq, const vector_t &taup, const GebrdOpts &opts={})
	Worspace query of gebrd()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	gehd2 (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau)
	Reduces a general square matrix to upper Hessenberg form.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gehd2_work (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau, work_t &work)
	Reduces a general square matrix to upper Hessenberg form. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	gehd2_worksize (size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau)
	Worspace query of gehd2()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	gehrd (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau, const GehrdOpts &opts={})
	Reduces a general square matrix to upper Hessenberg form.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gehrd_work (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau, work_t &work, const GehrdOpts &opts={})
	Reduces a general square matrix to upper Hessenberg form. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	gehrd_worksize (size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau, const GehrdOpts &opts={})
	Worspace query of gehrd()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	gelq2 (matrix_t &A, vector_t &tauw)
	Computes an LQ factorization of a complex m-by-n matrix A using an unblocked algorithm.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gelq2_work (matrix_t &A, vector_t &tauw, work_t &work)
	Computes an LQ factorization of a complex m-by-n matrix A using an unblocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	gelq2_worksize (const matrix_t &A, const vector_t &tauw)
	Worspace query of gelq2()
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
int	gelqf (A_t &A, tau_t &tau, const GelqfOpts &opts={})
	Computes an LQ factorization of an m-by-n matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, TLAPACK_WORKSPACE work_t>
int	gelqf_work (A_t &A, tau_t &tau, work_t &work, const GelqfOpts &opts={})
	Computes an LQ factorization of an m-by-n matrix A using a blocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
constexpr WorkInfo	gelqf_worksize (const A_t &A, const tau_t &tau, const GelqfOpts &opts={})
	Worspace query of gelqf()
template<TLAPACK_SMATRIX matrix_t>
int	gelqt (matrix_t &A, matrix_t &TT)
	Computes an LQ factorization of a complex m-by-n matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_WORKSPACE work_t>
int	gelqt_work (matrix_t &A, matrix_t &TT, work_t &work)
	Computes an LQ factorization of a complex m-by-n matrix A using a blocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t>
constexpr WorkInfo	gelqt_worksize (const matrix_t &A, const matrix_t &TT)
	Worspace query of gelqt()
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	gemm (Op transA, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	General matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	gemm (Op transA, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	General matrix-matrix multiply:
template<class TA , class TB , class TC , class alpha_t , class beta_t >
void	gemm (Op transA, Op transB, const alpha_t &alpha, const starpu::Matrix< TA > &A, const starpu::Matrix< TB > &B, const beta_t &beta, starpu::Matrix< TC > &C)
	Overload of gemm for starpu::Matrix.
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>>
void	gemmtr (Uplo uplo, Op transA, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	General triangular matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	gemv (Op trans, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	General matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	gemv (Op trans, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	General matrix-vector multiply:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	gen_householder_q (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau, const GenHouseholderQOpts &opts={})
	Generates a matrix Q that is the product of elementary reflectors.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	gen_householder_q_work (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau, work_t &work, const GenHouseholderQOpts &opts={})
	Generates a matrix Q that is the product of elementary reflectors. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	gen_householder_q_worksize (direction_t direction, storage_t storeMode, const matrix_t &A, const vector_t &tau, const GenHouseholderQOpts &opts={})
	Worspace query of gen_householder_q()
template<TLAPACK_MATRIX matrix_t>
int	generalized_schur_move (bool want_q, bool want_z, matrix_t &A, matrix_t &B, matrix_t &Q, matrix_t &Z, size_type< matrix_t > &ifst, size_type< matrix_t > &ilst)
	generalized_schur_move reorders the generalized Schur factorization of a pencil ( S, T ) = Q(A,B)Z**H so that the diagonal elements of (S,T) with row index IFST are moved to row ILST.
template<TLAPACK_CSMATRIX matrix_t, enable_if_t< is_real< type_t< matrix_t > >, bool > = true>
int	generalized_schur_swap (bool want_q, bool want_z, matrix_t &A, matrix_t &B, matrix_t &Q, matrix_t &Z, const size_type< matrix_t > &j0, const size_type< matrix_t > &n1, const size_type< matrix_t > &n2)
	schur_swap, swaps 2 eigenvalues of A.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	geql2 (matrix_t &A, vector_t &tau)
	Computes a QL factorization of a matrix A.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	geql2_work (matrix_t &A, vector_t &tau, work_t &work)
	Computes a QL factorization of a matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	geql2_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of geql2()
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
int	geqlf (A_t &A, tau_t &tau, const GeqlfOpts &opts={})
	Computes an RQ factorization of an m-by-n matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, TLAPACK_WORKSPACE work_t>
int	geqlf_work (A_t &A, tau_t &tau, work_t &work, const GeqlfOpts &opts={})
	Computes an RQ factorization of an m-by-n matrix A using a blocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
constexpr WorkInfo	geqlf_worksize (const A_t &A, const tau_t &tau, const GeqlfOpts &opts={})
	Worspace query of geqlf()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	geqr2 (matrix_t &A, vector_t &tau)
	Computes a QR factorization of a matrix A.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	geqr2_work (matrix_t &A, vector_t &tau, work_t &work)
	Computes a QR factorization of a matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	geqr2_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of geqr2()
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
int	geqrf (A_t &A, tau_t &tau, const GeqrfOpts &opts={})
	Computes a QR factorization of an m-by-n matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, TLAPACK_WORKSPACE work_t>
int	geqrf_work (A_t &A, tau_t &tau, work_t &work, const GeqrfOpts &opts={})
	Computes a QR factorization of an m-by-n matrix A using a blocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
constexpr WorkInfo	geqrf_worksize (const A_t &A, const tau_t &tau, const GeqrfOpts &opts={})
	Worspace query of geqrf()
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	ger (const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	General matrix rank-1 update:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	gerq2 (matrix_t &A, vector_t &tau)
	Computes an RQ factorization of a matrix A.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	gerq2_work (matrix_t &A, vector_t &tau, work_t &work)
	Computes an RQ factorization of a matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	gerq2_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of gerq2()
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
int	gerqf (A_t &A, tau_t &tau, const GerqfOpts &opts={})
	Computes an RQ factorization of an m-by-n matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, TLAPACK_WORKSPACE work_t>
int	gerqf_work (A_t &A, tau_t &tau, work_t &work, const GerqfOpts &opts={})
	Computes an RQ factorization of an m-by-n matrix A using a blocked algorithm. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t>
constexpr WorkInfo	gerqf_worksize (const A_t &A, const tau_t &tau, const GerqfOpts &opts={})
	Worspace query of gerqf()
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	geru (const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	General matrix rank-1 update:
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR r_vector_t>
int	gesvd (bool want_u, bool want_vt, matrix_t &A, r_vector_t &s, matrix_t &U, matrix_t &Vt, const GesvdOpts &opts={})
	Computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real M-by-N matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR piv_t>
int	getrf (matrix_t &A, piv_t &piv, const GetrfOpts &opts={})
	getrf computes an LU factorization of a general m-by-n matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR piv_t>
int	getrf_level0 (matrix_t &A, piv_t &piv)
	getrf computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR piv_t>
int	getrf_recursive (matrix_t &A, piv_t &piv)
	getrf_recursive computes an LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR piv_t>
int	getri (matrix_t &A, const piv_t &piv, const GetriOpts &opts={})
	getri computes inverse of a general n-by-n matrix A
template<TLAPACK_MATRIX matrix_t>
int	getri_uili (matrix_t &A)
	getri_uili calculates the inverse of a general n-by-n matrix A
template<TLAPACK_SMATRIX matrix_t>
int	getri_uxli (matrix_t &A)
	getri computes inverse of a general n-by-n matrix A by solving for X in the following equation
template<TLAPACK_SMATRIX matrix_t, TLAPACK_WORKSPACE work_t>
int	getri_uxli_work (matrix_t &A, work_t &work)
	getri computes inverse of a general n-by-n matrix A by solving for X in the following equation Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t>
constexpr WorkInfo	getri_uxli_worksize (const matrix_t &A)
	Worspace query of getri()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR piv_t, TLAPACK_WORKSPACE work_t>
int	getri_work (matrix_t &A, const piv_t &piv, work_t &work, const GetriOpts &opts={})
	getri computes inverse of a general n-by-n matrix A Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR piv_t>
constexpr WorkInfo	getri_worksize (const matrix_t &A, const piv_t &piv, const GetriOpts &opts={})
	Worspace query of getri()
template<TLAPACK_SMATRIX A_t, TLAPACK_SMATRIX B_t, TLAPACK_SMATRIX Q_t, TLAPACK_SMATRIX Z_t>
int	gghd3 (bool wantq, bool wantz, size_type< A_t > ilo, size_type< A_t > ihi, A_t &A, B_t &B, Q_t &Q, Z_t &Z, const Gghd3Opts &opts={})
	Reduces a pair of real square matrices (A, B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular.
template<TLAPACK_SMATRIX A_t, TLAPACK_SMATRIX B_t, TLAPACK_SMATRIX Q_t, TLAPACK_SMATRIX Z_t>
int	gghrd (bool wantq, bool wantz, size_type< A_t > ilo, size_type< A_t > ihi, A_t &A, B_t &B, Q_t &Q, Z_t &Z)
	Reduces a pair of real square matrices (A, B) to generalized upper Hessenberg form using unitary transformations, where A is a general matrix and B is upper triangular.
template<TLAPACK_MATRIX matrix_t>
bool	hasinf (BandAccess accessType, const matrix_t &A) noexcept
	Returns true if and only if A has an infinite entry.
template<TLAPACK_VECTOR vector_t>
bool	hasinf (const vector_t &x) noexcept
	Returns true if and only if x has an infinite entry.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
bool	hasinf (uplo_t uplo, const matrix_t &A)
	Returns true if and only if A has an infinite entry.
template<TLAPACK_MATRIX matrix_t>
bool	hasnan (BandAccess accessType, const matrix_t &A) noexcept
	Returns true if and only if A has an NaN entry.
template<TLAPACK_VECTOR vector_t>
bool	hasnan (const vector_t &x) noexcept
	Returns true if and only if x has an NaN entry.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
bool	hasnan (uplo_t uplo, const matrix_t &A)
	Returns true if and only if A has an NaN entry.
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	hemm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	hemm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Hermitian matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>>
void	hemm2 (Side side, Uplo uplo, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian matrix-Hermitian matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T > > >
void	hemm2 (Side side, Uplo uplo, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Hermitian matrix-Hermitian matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	hemv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	Hermitian matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	hemv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	Hermitian matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_REAL alpha_t, enable_if_t<(is_real< alpha_t >), int > = 0, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, real_type< T > >, pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	her (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, matrixA_t &A)
	Hermitian matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	her2 (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	Hermitian matrix rank-2 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, real_type< T > > > = 0>
void	her2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	her2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_REAL alpha_t, TLAPACK_REAL beta_t, enable_if_t<(is_real< alpha_t > &&is_real< beta_t >), int > = 0, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, real_type< T > >, pair< beta_t, real_type< T > > > = 0>
void	herk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const beta_t &beta, matrixC_t &C)
	Hermitian rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	herk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, matrixC_t &C)
	Hermitian rank-k update:
template<class TA , class TC , class alpha_t , class beta_t >
void	herk (Uplo uplo, Op trans, const alpha_t &alpha, const starpu::Matrix< TA > &A, const beta_t &beta, starpu::Matrix< TC > &C)
	Overload of herk for starpu::Matrix.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	hessenberg (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau, const HessenbergOpts &opts={})
	Reduces a general square matrix to upper Hessenberg form.
template<TLAPACK_SMATRIX T_t, TLAPACK_SVECTOR CL_t, TLAPACK_SVECTOR SL_t, TLAPACK_SVECTOR CR_t, TLAPACK_SVECTOR SR_t>
void	hessenberg_rq (T_t &T, CL_t &cl, SL_t &sl, CR_t &cr, SR_t &sr)
	Applies a sequence of rotations to an upper triangular matrix T from the left (making it an upper Hessenberg matrix) and reduces that matrix back to upper triangular form using rotations from the right.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	hessenberg_work (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &tau, work_t &work, const HessenbergOpts &opts={})
	Reduces a general square matrix to upper Hessenberg form. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	hessenberg_worksize (size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau, const HessenbergOpts &opts={})
	Workspace query of hessenberg()
template<TLAPACK_SMATRIX A_t, TLAPACK_SVECTOR tau_t, class uplo_t >
int	hetd2 (uplo_t uplo, A_t &A, tau_t &tau)
	Reduce a hermitian matrix to real symmetric tridiagonal form by a unitary similarity transformation: Q**H * A * Q = T.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR ipiv_t, TLAPACK_WORKSPACE work_t>
int	hetf3 (uplo_t uplo, matrix_t &A, ipiv_t &ipiv, work_t &work, const BlockedLDLOpts &opts)
	Computes the partial factorization of a symmetric or Hermitian matrix A using the Bunch-Kaufman diagonal pivoting method with level 3 BLAS operations.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR ipiv_t>
int	hetrf (uplo_t uplo, matrix_t &A, ipiv_t &ipiv, const HetrfOpts &opts={})
	Computes the Bunch-Kaufman factorization of a symmetric or Hermitian matrix A.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR ipiv_t>
int	hetrf_blocked (uplo_t uplo, matrix_t &A, ipiv_t &ipiv)
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR ipiv_t>
int	hetrf_blocked (uplo_t uplo, matrix_t &A, ipiv_t &ipiv, const BlockedLDLOpts &opts)
	Computes the Bunch-Kaufman factorization of a symmetric or Hermitian matrix A.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR ipiv_t, TLAPACK_WORKSPACE work_t>
int	hetrf_blocked_work (uplo_t uplo, matrix_t &A, ipiv_t &ipiv, work_t &work, const BlockedLDLOpts &opts)
	Computes the Bunch-Kaufman factorization of a symmetric or Hermitian matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t>
constexpr WorkInfo	hetrf_blocked_worksize (const matrix_t &A, const BlockedLDLOpts &opts)
	Worspace query of hetrf_blocked()
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR ipiv_t, TLAPACK_WORKSPACE work_t>
int	hetrf_work (uplo_t uplo, matrix_t &A, ipiv_t &ipiv, work_t &work, const HetrfOpts &opts={})
	Computes the Bunch-Kaufman factorization of a symmetric or Hermitian matrix A. Workspace is provided as an argument.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	householder_lq (matrix_t &A, vector_t &tau, const HouseholderLQOpts &opts={})
	Computes a LQ factorization of an m-by-n matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE workspace_t>
int	householder_lq_work (matrix_t &A, vector_t &tau, workspace_t &work, const HouseholderLQOpts &opts={})
	Computes a LQ factorization of an m-by-n matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	householder_lq_worksize (const matrix_t &A, const vector_t &tau, const HouseholderLQOpts &opts={})
	Worspace query of householder_lq()
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	householder_q_mul (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C, const HouseholderQMulOpts &opts={})
	Applies unitary matrix Q to a matrix C.
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	householder_q_mul_work (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C, work_t &work, const HouseholderQMulOpts &opts={})
	Applies unitary matrix Q to a matrix C. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	householder_q_mul_worksize (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, const matrixC_t &C, const HouseholderQMulOpts &opts={})
	Workspace query of householder_q_mul()
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	householder_ql (matrix_t &A, vector_t &tau, const HouseholderQLOpts &opts={})
	Computes a QL factorization of an m-by-n matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	householder_ql_work (matrix_t &A, vector_t &tau, work_t &work, const HouseholderQLOpts &opts={})
	Computes a QL factorization of an m-by-n matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	householder_ql_worksize (const matrix_t &A, const vector_t &tau, const HouseholderQLOpts &opts={})
	Worspace query of householder_ql()
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	householder_qr (matrix_t &A, vector_t &tau, const HouseholderQROpts &opts={})
	Computes a QR factorization of an m-by-n matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE workspace_t>
int	householder_qr_work (matrix_t &A, vector_t &tau, workspace_t &work, const HouseholderQROpts &opts={})
	Computes a QR factorization of an m-by-n matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	householder_qr_worksize (const matrix_t &A, const vector_t &tau, const HouseholderQROpts &opts={})
	Worspace query of householder_qr()
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	householder_rq (matrix_t &A, vector_t &tau, const HouseholderRQOpts &opts={})
	Computes a RQ factorization of an m-by-n matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE workspace_t>
int	householder_rq_work (matrix_t &A, vector_t &tau, workspace_t &work, const HouseholderRQOpts &opts={})
	Computes a RQ factorization of an m-by-n matrix A. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	householder_rq_worksize (const matrix_t &A, const vector_t &tau, const HouseholderRQOpts &opts={})
	Worspace query of householder_rq()
template<TLAPACK_VECTOR vector_t, disable_if_allow_optblas_t< vector_t > = 0>
size_type< vector_t >	iamax (const vector_t &x)
template<TLAPACK_VECTOR vector_t, class abs_f >
size_type< vector_t >	iamax (const vector_t &x, const IamaxOpts< abs_f > &opts)
	Return \(\arg\max_{i=0}^{n-1} |x_i|\).
template<TLAPACK_VECTOR vector_t, class abs_f >
size_type< vector_t >	iamax_ec (const vector_t &x, abs_f absf)
	Return \(\arg\max_{i=0}^{n-1} |x_i|\).
template<TLAPACK_VECTOR vector_t, class abs_f >
size_type< vector_t >	iamax_nc (const vector_t &x, abs_f absf)
	Return \(\arg\max_{i=0}^{n-1} |x_i|\).
template<class T >
constexpr real_type< T >	imag (const starpu::MatrixEntry< T > &x) noexcept
template<typename T , enable_if_t< is_real< T >, int > = 0>
constexpr real_type< T >	imag (const T &x) noexcept
	Extends std::imag() to real datatypes.
template<TLAPACK_MATRIX matrix_t>
auto	infnorm_colmajor (const matrix_t &A)
	Calculates the infinity norm of a column-major matrix.
template<TLAPACK_MATRIX matrix_t, TLAPACK_WORKSPACE work_t>
auto	infnorm_colmajor_work (const matrix_t &A, work_t &work)
	Calculates the infinity norm of a column-major matrix. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t>
constexpr WorkInfo	infnorm_colmajor_worksize (const matrix_t &A)
	Worspace query of infnorm_colmajor()
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
auto	infnorm_hermitian_colmajor (uplo_t uplo, const matrix_t &A)
	Calculates the infinity norm of a column-major hermitian matrix.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t, TLAPACK_WORKSPACE work_t>
auto	infnorm_hermitian_colmajor_work (uplo_t uplo, const matrix_t &A, work_t &work)
	Calculates the infinity norm of a column-major hermitian matrix. Workspace is provided as an argument.
template<class T , TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
constexpr WorkInfo	infnorm_hermitian_colmajor_worksize (uplo_t uplo, const matrix_t &A)
	Worspace query of infnorm_hermitian_colmajor()
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
auto	infnorm_symmetric_colmajor (uplo_t uplo, const matrix_t &A)
	Calculates the infinity norm of a column-major symmetric matrix.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t, TLAPACK_WORKSPACE work_t>
auto	infnorm_symmetric_colmajor_work (uplo_t uplo, const matrix_t &A, work_t &work)
	Calculates the infinity norm of a column-major symmetric matrix. Workspace is provided as an argument.
template<class T , TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
constexpr WorkInfo	infnorm_symmetric_colmajor_worksize (uplo_t uplo, const matrix_t &A)
	Worspace query of infnorm_symmetric_colmajor()
template<TLAPACK_UPLO uplo_t, TLAPACK_DIAG diag_t, TLAPACK_MATRIX matrix_t>
auto	infnorm_triangular_colmajor (uplo_t uplo, diag_t diag, const matrix_t &A)
	Calculates the infinity norm of a column-major triangular matrix.
template<TLAPACK_UPLO uplo_t, TLAPACK_DIAG diag_t, TLAPACK_MATRIX matrix_t, TLAPACK_WORKSPACE work_t>
auto	infnorm_triangular_colmajor_work (uplo_t uplo, diag_t diag, const matrix_t &A, work_t &work)
	Calculates the infinity norm of a column-major triangular matrix. Workspace is provided as an argument.
template<class T , TLAPACK_UPLO uplo_t, TLAPACK_DIAG diag_t, TLAPACK_MATRIX matrix_t>
constexpr WorkInfo	infnorm_triangular_colmajor_worksize (uplo_t uplo, diag_t diag, const matrix_t &A)
	Worspace query of infnorm_triangular_colmajor()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
void	inv_house3 (const matrix_t &A, vector_t &v, type_t< vector_t > &tau)
	Inv_house calculates a reflector to reduce the first column in a 2x3 matrix A from the right to zero.
template<typename T , enable_if_t< is_complex< T >, int > = 0>
constexpr bool	isinf (const T &x) noexcept
	Extends std::isinf() to complex numbers.
template<typename T , enable_if_t< is_complex< T >, int > = 0>
constexpr bool	isnan (const T &x) noexcept
	Extends std::isnan() to complex numbers.
template<TLAPACK_SMATRIX A_t, TLAPACK_VECTOR vector_t, TLAPACK_SMATRIX X_t, TLAPACK_SMATRIX matrixY_t>
int	labrd (A_t &A, vector_t &tauq, vector_t &taup, X_t &X, matrixY_t &Y)
	Reduces the first nb rows and columns of a general m by n matrix A to upper or lower bidiagonal form by an unitary transformation Q**H * A * P, and returns the matrices X and Y which are needed to apply the transformation to the unreduced part of A.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t>
void	lacpy (uplo_t uplo, const matrixA_t &A, matrixB_t &B)
	Copies a matrix from A to B.
template<TLAPACK_REAL real_t, enable_if_t<(is_real< real_t >), int > = 0>
void	ladiv (const real_t &a, const real_t &b, const real_t &c, const real_t &d, real_t &p, real_t &q)
	Performs complex division in real arithmetic.
template<TLAPACK_COMPLEX T, enable_if_t< is_complex< T >, int > = 0>
T	ladiv (const T &x, const T &y)
	Performs complex division in real arithmetic with complex arguments.
template<TLAPACK_SCALAR T>
void	lae2 (T a, T b, T c, T &s1, T &s2)
	Computes the eigenvalues of a real symmetric 2x2 matrix A [ a b ] [ b c ].
template<class d_t , class z_t , class delta_t , class real_t , class idx_t >
int	laed4 (idx_t n, idx_t i, d_t &d, z_t &z, delta_t &delta, real_t rho, real_t &dlam)
	LAED4 used by STEDC.
template<class d_t , class z_t , class delta_t , class real_t , class idx_t >
void	laed5 (idx_t i, d_t &d, z_t &z, delta_t &delta, real_t rho, real_t &dlam)
	LAED5 used by STEDC.
template<class d_t , class z_t , class real_t , class idx_t >
int	laed6 (idx_t kniter, bool &orgati, real_t rho, d_t &d, z_t &z, real_t &finit, real_t &tau)
	LAED6 used by STEDC.
template<TLAPACK_SCALAR T>
void	laev2 (T a, T b, T c, T &s1, T &s2, T &cs, T &sn)
	Computes the eigenvalues and eigenvector of a real symmetric 2x2 matrix A [ a b ] [ b c ] On exit, the decomposition satisfies: [ cs sn ] [ a b ] [ cs -sn ] = [ s1 0 ] [ -sn cs ] [ b c ] [ sn cs ] [ 0 s2 ] where cs*cs + sn*sn = 1.
template<TLAPACK_CSMATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, bool > = true, enable_if_t< is_real< type_t< matrix_t > >, bool > = true>
int	lahqr (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z)
	lahqr computes the eigenvalues and optionally the Schur factorization of an upper Hessenberg matrix, using the double-shift implicit QR algorithm.
template<TLAPACK_SCALAR T>
void	lahqr_eig22 (T a00, T a01, T a10, T a11, complex_type< T > &s1, complex_type< T > &s2)
	Computes the eigenvalues of a 2x2 matrix A.
template<TLAPACK_REAL T>
void	lahqr_schur22 (T &a, T &b, T &c, T &d, complex_type< T > &s1, complex_type< T > &s2, T &cs, T &sn)
	Computes the Schur factorization of a 2x2 matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_real< type_t< matrix_t > >, bool > = true>
int	lahqr_shiftcolumn (const matrix_t &H, vector_t &v, complex_type< type_t< matrix_t > > s1, complex_type< type_t< matrix_t > > s2)
	Given a 2-by-2 or 3-by-3 matrix H, lahqr_shiftcolumn calculates a multiple of the product: (H - s1*I)*(H - s2*I)*e1.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< matrix_t > >, bool > = true>
int	lahqr_shiftcolumn (const matrix_t &H, vector_t &v, type_t< matrix_t > s1, type_t< matrix_t > s2)
	Given a 2-by-2 or 3-by-3 matrix H, lahqr_shiftcolumn calculates a multiple of the product: (H - s1*I)*(H - s2*I)*e1.
template<TLAPACK_CSMATRIX matrix_t, TLAPACK_VECTOR alpha_t, TLAPACK_VECTOR beta_t>
int	lahqz (bool want_s, bool want_q, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, matrix_t &B, alpha_t &alpha, beta_t &beta, matrix_t &Q, matrix_t &Z)
	lahqz computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the single/double-shift implicit QZ algorithm.
template<TLAPACK_MATRIX A_t, TLAPACK_MATRIX B_t, TLAPACK_SCALAR T>
void	lahqz_eig22 (const A_t &A, const B_t &B, complex_type< T > &alpha1, complex_type< T > &alpha2, T &beta1, T &beta2)
	Computes the generalized eigenvalues of a 2x2 pencil (A,B) with B upper triangular.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, bool >
int	lahqz_shiftcolumn (const matrix_t &A, const matrix_t &B, vector_t &v, complex_type< type_t< matrix_t > > s1, complex_type< type_t< matrix_t > > s2, type_t< matrix_t > beta1, type_t< matrix_t > beta2)
	Given a 2-by-2 or 3-by-3 matrix pencil (A,B), lahqz_shiftcolumn calculates a multiple of the product: (beta2*A - s2*B)*B^(-1)*(beta1*A - s1*B)*B^(-1)*e1.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_SMATRIX matrixT_t, TLAPACK_SMATRIX matrixY_t>
int	lahr2 (size_type< matrix_t > k, size_type< matrix_t > nb, matrix_t &A, vector_t &tau, matrixT_t &T, matrixY_t &Y)
	Reduces a general square matrix to upper Hessenberg form.
template<class idx_t , class a_t , class idx1_t >
void	lamrg (idx_t n1, idx_t n2, a_t &a, int dtrd1, int dtrd2, idx1_t &index)
	DLAMRG creates a permutation list to merge the entries of two independently sorted sets into a single set sorted in ascending order.
template<TLAPACK_NORM norm_t, TLAPACK_SMATRIX matrix_t>
auto	lange (norm_t normType, const matrix_t &A)
	Calculates the norm of a matrix.
template<TLAPACK_NORM norm_t, TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
auto	lanhe (norm_t normType, uplo_t uplo, const matrix_t &A)
	Calculates the norm of a hermitian matrix.
template<TLAPACK_NORM norm_t, TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
auto	lansy (norm_t normType, uplo_t uplo, const matrix_t &A)
	Calculates the norm of a symmetric matrix.
template<TLAPACK_NORM norm_t, TLAPACK_UPLO uplo_t, TLAPACK_DIAG diag_t, TLAPACK_SMATRIX matrix_t>
auto	lantr (norm_t normType, uplo_t uplo, diag_t diag, const matrix_t &A)
	Calculates the norm of a symmetric matrix.
template<TLAPACK_REAL TX, TLAPACK_REAL TY, enable_if_t<(is_real< TX > &&is_real< TY >), int > = 0>
real_type< TX, TY >	lapy2 (const TX &x, const TY &y)
	Finds \(\sqrt{x^2+y^2}\), taking care not to cause unnecessary overflow.
template<TLAPACK_REAL TX, TLAPACK_REAL TY, TLAPACK_REAL TZ, enable_if_t<(is_real< TX > &&is_real< TY > &&is_real< TZ >), int > = 0>
real_type< TX, TY, TZ >	lapy3 (const TX &x, const TY &y, const TZ &z)
	Finds \(\sqrt{x^2+y^2+z^2}\), taking care not to cause unnecessary overflow or unnecessary underflow.
template<TLAPACK_SIDE side_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_SVECTOR vector_t, TLAPACK_SCALAR tau_t, TLAPACK_SMATRIX matrix_t, enable_if_t< std::is_convertible_v< direction_t, Direction >, int > = 0>
void	larf (side_t side, direction_t direction, storage_t storeMode, vector_t const &v, const tau_t &tau, matrix_t &C)
	Applies an elementary reflector H to a m-by-n matrix C.
template<TLAPACK_SIDE side_t, TLAPACK_STOREV storage_t, TLAPACK_VECTOR vector_t, TLAPACK_SCALAR tau_t, TLAPACK_VECTOR vectorC0_t, TLAPACK_MATRIX matrixC1_t, enable_if_t< std::is_convertible_v< storage_t, StoreV >, int > = 0>
void	larf (side_t side, storage_t storeMode, vector_t const &x, const tau_t &tau, vectorC0_t &C0, matrixC1_t &C1)
	Applies an elementary reflector defined by tau and v to a m-by-n matrix C decomposed into C0 and C1.
template<TLAPACK_SIDE side_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t, TLAPACK_SCALAR tau_t, TLAPACK_SMATRIX matrix_t, enable_if_t< std::is_convertible_v< direction_t, Direction >, int > = 0>
void	larf_work (side_t side, direction_t direction, storage_t storeMode, vector_t const &v, const tau_t &tau, matrix_t &C, work_t &work)
	Applies an elementary reflector H to a m-by-n matrix C. Workspace is provided as an argument.
template<TLAPACK_SIDE side_t, TLAPACK_STOREV storage_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t, TLAPACK_SCALAR tau_t, TLAPACK_VECTOR vectorC0_t, TLAPACK_MATRIX matrixC1_t, enable_if_t< std::is_convertible_v< storage_t, StoreV >, int > = 0>
void	larf_work (side_t side, storage_t storeMode, vector_t const &x, const tau_t &tau, vectorC0_t &C0, matrixC1_t &C1, work_t &work)
	Applies an elementary reflector defined by tau and v to a m-by-n matrix C decomposed into C0 and C1. Workspace is provided as an argument.
template<class T , TLAPACK_SIDE side_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_SVECTOR vector_t, TLAPACK_SCALAR tau_t, TLAPACK_SMATRIX matrix_t, enable_if_t< std::is_convertible_v< direction_t, Direction >, int > = 0>
constexpr WorkInfo	larf_worksize (side_t side, direction_t direction, storage_t storeMode, vector_t const &v, const tau_t &tau, const matrix_t &C)
	Worspace query of larf().
template<class T , TLAPACK_SIDE side_t, TLAPACK_STOREV storage_t, TLAPACK_VECTOR vector_t, TLAPACK_SCALAR tau_t, TLAPACK_VECTOR vectorC0_t, TLAPACK_MATRIX matrixC1_t, enable_if_t< std::is_convertible_v< storage_t, StoreV >, int > = 0>
constexpr WorkInfo	larf_worksize (side_t side, storage_t storeMode, vector_t const &x, const tau_t &tau, const vectorC0_t &C0, const matrixC1_t &C1)
	Worspace query of larf().
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_MATRIX matrixT_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	larfb (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const matrixT_t &Tmatrix, matrixC_t &C)
	Applies a block reflector \(H\) or its conjugate transpose \(H^H\) to a m-by-n matrix C, from either the left or the right.
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_MATRIX matrixT_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_WORKSPACE work_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	larfb_work (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const matrixT_t &Tmatrix, matrixC_t &C, work_t &work)
	Applies a block reflector \(H\) or its conjugate transpose \(H^H\) to a m-by-n matrix C, from either the left or the right. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrixV_t, TLAPACK_MATRIX matrixT_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	larfb_worksize (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const matrixT_t &Tmatrix, const matrixC_t &C)
	Worspace query of larfb()
template<TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_VECTOR vector_t, enable_if_t< std::is_convertible_v< direction_t, Direction >, int > = 0>
void	larfg (direction_t direction, storage_t storeMode, vector_t &v, type_t< vector_t > &tau)
	Generates a elementary Householder reflection.
template<TLAPACK_STOREV storage_t, TLAPACK_VECTOR vector_t>
void	larfg (storage_t storeMode, type_t< vector_t > &alpha, vector_t &x, type_t< vector_t > &tau)
	Generates a elementary Householder reflection.
template<TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_SMATRIX matrixV_t, TLAPACK_VECTOR vector_t, TLAPACK_SMATRIX matrixT_t>
int	larft (direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixT_t &T)
	Forms the triangular factor T of a block reflector H of order n, which is defined as a product of k elementary reflectors.
template<int idist, TLAPACK_VECTOR vector_t, class iseed_t >
void	larnv (iseed_t &iseed, vector_t &x)
	Returns a vector of n random numbers from a uniform or normal distribution.
template<typename T , enable_if_t< is_same_v< T, real_type< T > >, int > = 0>
void	lartg (const T &a, const T &b, real_type< T > &c, T &s, T &r)
	Construct plane rotation that eliminates b, such that:
template<TLAPACK_MATRIX matrix_t, TLAPACK_REAL a_type, TLAPACK_REAL b_type, enable_if_t<(is_real< a_type > &&is_real< b_type >), int > = 0>
int	lascl (BandAccess accessType, const b_type &b, const a_type &a, matrix_t &A)
	Multiplies a matrix A by the real scalar a/b.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t, TLAPACK_REAL a_type, TLAPACK_REAL b_type, enable_if_t<(is_real< a_type > &&is_real< b_type >), int > = 0>
int	lascl (uplo_t uplo, const b_type &b, const a_type &a, matrix_t &A)
	Multiplies a matrix A by the real scalar a/b.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
void	laset (uplo_t uplo, const type_t< matrix_t > &alpha, const type_t< matrix_t > &beta, matrix_t &A)
	Initializes a matrix to diagonal and off-diagonal values.
template<class idx_t , class d_t >
int	lasrt (char id, idx_t n, d_t &d)
template<TLAPACK_VECTOR vector_t>
void	lassq (const vector_t &x, real_type< type_t< vector_t > > &scale, real_type< type_t< vector_t > > &sumsq)
	Updates a sum of squares represented in scaled form.
template<class abs_f , TLAPACK_VECTOR vector_t>
void	lassq (const vector_t &x, real_type< type_t< vector_t > > &scale, real_type< type_t< vector_t > > &sumsq, abs_f absF)
	Updates a sum of squares represented in scaled form.
template<TLAPACK_MATRIX matrixX_t, TLAPACK_MATRIX matrixT_t, TLAPACK_MATRIX matrixB_t, enable_if_t< is_real< type_t< matrixX_t > > &&is_real< type_t< matrixT_t > > &&is_real< type_t< matrixB_t > >, bool > = true>
int	lasy2 (Op trans_l, Op trans_r, int isign, const matrixT_t &TL, const matrixT_t &TR, const matrixB_t &B, type_t< matrixX_t > &scale, matrixX_t &X, type_t< matrixX_t > &xnorm)
	lasy2 solves the Sylvester matrix equation where the matrices are of order 1 or 2.
template<TLAPACK_SMATRIX matrix_t>
int	lauum_recursive (const Uplo &uplo, matrix_t &C)
	LAUUM is a specific type of inplace HERK.
template<class Derived >
constexpr auto	legacy_matrix (const Eigen::MapBase< Derived, Eigen::ReadOnlyAccessors > &A) noexcept
template<class T , int Rows, int Cols, int Options, int MaxRows, int MaxCols>
constexpr auto	legacy_matrix (const Eigen::Matrix< T, Rows, Cols, Options, MaxRows, MaxCols > &A) noexcept
template<typename T , class idx_t , Layout layout>
constexpr auto	legacy_matrix (const LegacyMatrix< T, idx_t, layout > &A) noexcept
template<class T , class idx_t , class int_t , Direction direction>
constexpr auto	legacy_matrix (const LegacyVector< T, idx_t, int_t, direction > &v) noexcept
template<class ET , class Exts , class LP , class AP , std::enable_if_t< Exts::rank()==2 &&LP::template mapping< Exts >::is_always_strided(), int > = 0>
constexpr auto	legacy_matrix (const std::experimental::mdspan< ET, Exts, LP, AP > &A) noexcept
template<class Derived >
constexpr auto	legacy_vector (const Eigen::MapBase< Derived, Eigen::ReadOnlyAccessors > &A) noexcept
template<class T , int Rows, int Cols, int Options, int MaxRows, int MaxCols>
constexpr auto	legacy_vector (const Eigen::Matrix< T, Rows, Cols, Options, MaxRows, MaxCols > &A) noexcept
template<typename T , class idx_t , typename int_t , Direction direction>
constexpr auto	legacy_vector (const LegacyVector< T, idx_t, int_t, direction > &v) noexcept
template<class ET , class Exts , class LP , class AP , std::enable_if_t< Exts::rank()==1 &&LP::template mapping< Exts >::is_always_strided(), int > = 0>
constexpr auto	legacy_vector (const std::experimental::mdspan< ET, Exts, LP, AP > &A) noexcept
template<typename T , class idx_t >
constexpr auto	lowerband (const LegacyBandedMatrix< T, idx_t > &A) noexcept
template<TLAPACK_SMATRIX matrix_t>
void	lu_mult (matrix_t &A, const LuMultOpts &opts={})
	in-place multiplication of lower triangular matrix L and upper triangular matrix U.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_CVECTOR vector_t>
void	move_bulge (matrix_t &H, vector_t &v, complex_type< type_t< matrix_t > > s1, complex_type< type_t< matrix_t > > s2)
	Given a 4-by-3 matrix H and small order reflector v, move_bulge applies the delayed right update to the last row and calculates a new reflector to move the bulge down.
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t>
void	mult_hehe (Uplo uplo, const alpha_t &alpha, matrixA_t &A, matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Hermitian matrix-Hermitian matrix multiply:
template<TLAPACK_SCALAR alpha_t, TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t, TLAPACK_SMATRIX matrixC_t>
void	mult_hehe (Uplo uplo, const alpha_t &alpha, matrixA_t &A, matrixB_t &B, matrixC_t &C)
	Hermitian matrix-Hermitian matrix multiply:
template<TLAPACK_SMATRIX matrix_t>
void	mult_llh (matrix_t &L, const mult_llh_Opts &opts={})
	in-place multiplication of lower triangular matrix L and upper triangular matrix L^H.
template<TLAPACK_SMATRIX matrix_t>
void	mult_uhu (matrix_t &U, const mult_uhu_Opts &opts={})
	in-place multiplication of upper triangular matrix U and lower triangular matrix U^H.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	multishift_qr (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z)
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	multishift_qr (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z, FrancisOpts &opts)
	multishift_qr computes the eigenvalues and optionally the Schur factorization of an upper Hessenberg matrix, using the multishift implicit QR algorithm with AED.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, bool > = true>
void	multishift_QR_sweep (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, const vector_t &s, matrix_t &Z)
	multishift_QR_sweep performs a single small-bulge multi-shift QR sweep.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t, enable_if_t< is_complex< type_t< vector_t > >, bool > = true>
void	multishift_QR_sweep_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, const vector_t &s, matrix_t &Z, work_t &work)
	multishift_QR_sweep performs a single small-bulge multi-shift QR sweep. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, bool > = true>
constexpr WorkInfo	multishift_QR_sweep_worksize (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &s, const matrix_t &Z)
	Worspace query of multishift_QR_sweep()
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	multishift_qr_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z, work_t &work)
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	multishift_qr_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z, work_t &work, FrancisOpts &opts)
	multishift_qr computes the eigenvalues and optionally the Schur factorization of an upper Hessenberg matrix, using the multishift implicit QR algorithm with AED. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
WorkInfo	multishift_qr_worksize (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &w, const matrix_t &Z, const FrancisOpts &opts)
	Worspace query of multishift_qr()
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
constexpr WorkInfo	multishift_qr_worksize_sweep (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &w, const matrix_t &Z, const FrancisOpts &opts={})
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR alpha_t, TLAPACK_SVECTOR beta_t>
int	multishift_qz (bool want_s, bool want_q, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, matrix_t &B, alpha_t &alpha, beta_t &beta, matrix_t &Q, matrix_t &Z, FrancisOpts &opts)
	multishift_qz computes the eigenvalues of a matrix pair (H,T), where H is an upper Hessenberg matrix and T is upper triangular, using the multishift QZ algorithm with AED.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR alpha_t, TLAPACK_VECTOR beta_t, enable_if_t< is_complex< type_t< alpha_t > >, bool > = true>
void	multishift_QZ_sweep (bool want_t, bool want_q, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, matrix_t &B, const alpha_t &alpha, const beta_t &beta, matrix_t &Q, matrix_t &Z)
	multishift_QR_sweep performs a single small-bulge multi-shift QR sweep.
template<class T >
constexpr auto	ncols (const Eigen::EigenBase< T > &x) noexcept
template<typename T , class idx_t >
constexpr auto	ncols (const LegacyBandedMatrix< T, idx_t > &A) noexcept
template<typename T , class idx_t , Layout layout>
constexpr auto	ncols (const LegacyMatrix< T, idx_t, layout > &A) noexcept
template<class T >
constexpr auto	ncols (const starpu::Matrix< T > &A) noexcept
template<class ET , class Exts , class LP , class AP >
constexpr auto	ncols (const std::experimental::mdspan< ET, Exts, LP, AP > &x)
template<TLAPACK_VECTOR vector_t, disable_if_allow_optblas_t< vector_t > = 0>
auto	nrm2 (const vector_t &x)
template<class T >
constexpr auto	nrows (const Eigen::EigenBase< T > &x) noexcept
template<typename T , class idx_t >
constexpr auto	nrows (const LegacyBandedMatrix< T, idx_t > &A) noexcept
template<typename T , class idx_t , Layout layout>
constexpr auto	nrows (const LegacyMatrix< T, idx_t, layout > &A) noexcept
template<class T >
constexpr auto	nrows (const starpu::Matrix< T > &A) noexcept
template<class ET , class Exts , class LP , class AP >
constexpr auto	nrows (const std::experimental::mdspan< ET, Exts, LP, AP > &x)
std::ostream &	operator<< (std::ostream &out, const Diag v)
std::ostream &	operator<< (std::ostream &out, const Direction v)
std::ostream &	operator<< (std::ostream &out, const Layout v)
std::ostream &	operator<< (std::ostream &out, const Norm v)
std::ostream &	operator<< (std::ostream &out, const Op v)
std::ostream &	operator<< (std::ostream &out, const Side v)
std::ostream &	operator<< (std::ostream &out, const StoreV v)
std::ostream &	operator<< (std::ostream &out, const Uplo v)
template<typename uplo_t , typename matrix_t >
void	pbtrf_with_workspace (uplo_t uplo, matrix_t &A, size_t kd, const BlockedBandedCholeskyOpts &opts={})
	Cholesky factorization of a full, banded, n by n matrix.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, disable_if_allow_optblas_t< matrix_t > = 0>
int	potf2 (uplo_t uplo, matrix_t &A)
	Computes the Cholesky factorization of a Hermitian positive definite matrix A using a level-2 algorithm.
template<class uplo_t , class T >
int	potf2 (uplo_t uplo, starpu::Matrix< T > &A)
	Overload of potf2 for starpu::Matrix.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrix_t>
int	potrf (uplo_t uplo, matrix_t &A, const PotrfOpts &opts={})
	Computes the Cholesky factorization of a Hermitian positive definite matrix A.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
int	potrf2 (uplo_t uplo, matrix_t &A, const EcOpts &opts={})
	Computes the Cholesky factorization of a Hermitian positive definite matrix A using the recursive algorithm.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t, disable_if_allow_optblas_t< matrix_t > = 0>
int	potrf_blocked (uplo_t uplo, matrix_t &A)
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
int	potrf_blocked (uplo_t uplo, matrix_t &A, const BlockedCholeskyOpts &opts)
	Computes the Cholesky factorization of a Hermitian positive definite matrix A using a blocked algorithm.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
int	potrf_rl (uplo_t uplo, matrix_t &A, const BlockedCholeskyOpts &opts={})
	Computes the Cholesky factorization of a Hermitian positive definite matrix A using a blocked algorithm.
template<TLAPACK_SMATRIX matrix_t>
void	potri (Uplo uplo, matrix_t &A)
	Computes the Inverse of a Hermitian positive definite matrix A using recursive algorithms.
template<TLAPACK_UPLO uplo_t, TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t>
int	potrs (uplo_t uplo, const matrixA_t &A, matrixB_t &B)
	Apply the Cholesky factorization to solve a linear system.
Eigen::bfloat16	pow (int base, const Eigen::bfloat16 &exp)
Eigen::half	pow (int base, const Eigen::half &exp)
template<TLAPACK_MATRIX matrix_t>
void	print_matrix (const matrix_t &A)
	Prints a matrix a to std::out.
void	print_matrix_c (const LegacyMatrix< std::complex< float >, size_t, Layout::ColMajor > &A)
void	print_matrix_d (const LegacyMatrix< double, size_t, Layout::ColMajor > &A)
void	print_matrix_r (const LegacyMatrix< float, size_t, Layout::ColMajor > &A)
void	print_matrix_z (const LegacyMatrix< std::complex< double >, size_t, Layout::ColMajor > &A)
void	print_rowmajormatrix_c (const LegacyMatrix< std::complex< float >, size_t, Layout::RowMajor > &A)
void	print_rowmajormatrix_d (const LegacyMatrix< double, size_t, Layout::RowMajor > &A)
void	print_rowmajormatrix_r (const LegacyMatrix< float, size_t, Layout::RowMajor > &A)
void	print_rowmajormatrix_z (const LegacyMatrix< std::complex< double >, size_t, Layout::RowMajor > &A)
template<class d_t , class e_t , enable_if_t< is_same_v< real_type< type_t< d_t > >, real_type< type_t< e_t > > >, int > = 0>
int	pttrf (d_t &D, e_t &E, const EcOpts &opts={})
	Computes the Cholesky factorization of a Hermitian positive definite tridiagonal matrix A.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	qr_iteration (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z, QRIterationOpts &opts)
	Computes the eigenvalues and optionally the Schur factorization of an upper Hessenberg matrix.
template<TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
int	qr_iteration_work (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, vector_t &w, matrix_t &Z, work_t &work, QRIterationOpts &opts)
	Computes the eigenvalues and optionally the Schur factorization of an upper Hessenberg matrix. Workspace is provided as an argument.
template<class T , TLAPACK_MATRIX matrix_t, TLAPACK_VECTOR vector_t, enable_if_t< is_complex< type_t< vector_t > >, int > = 0>
constexpr WorkInfo	qr_iteration_worksize (bool want_t, bool want_z, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &w, const matrix_t &Z, const QRIterationOpts &opts={})
	Worspace query of qr_iteration()
template<class T , class Generator >
T	rand_helper (Generator &gen)
	Helper function to generate random numbers using an uniform distribution in [0,1).
template<class T , class Generator , class Distribution , enable_if_t< is_real< T >, bool > = true>
T	rand_helper (Generator &gen, Distribution &d)
	Helper function to generate random numbers.
template<class T >
constexpr real_type< T >	real (const starpu::MatrixEntry< T > &x) noexcept
template<typename T , enable_if_t< is_real< T >, int > = 0>
constexpr real_type< T >	real (const T &x) noexcept
	Extends std::real() to real datatypes.
template<typename T , class idx_t , Layout layout>
auto	reshape (LegacyMatrix< T, idx_t, layout > &A, size_type< LegacyMatrix< T, idx_t > > m, size_type< LegacyMatrix< T, idx_t > > n)
template<typename T , class idx_t , Layout layout>
auto	reshape (LegacyMatrix< T, idx_t, layout > &A, size_type< LegacyMatrix< T, idx_t > > n)
template<typename T , class idx_t , typename int_t , Direction direction>
auto	reshape (LegacyVector< T, idx_t, int_t, direction > &v, size_type< LegacyMatrix< T, idx_t > > m, size_type< LegacyMatrix< T, idx_t > > n)
template<typename T , class idx_t , typename int_t , Direction direction>
auto	reshape (LegacyVector< T, idx_t, int_t, direction > &v, size_type< LegacyMatrix< T, idx_t > > n)
template<class matrix_t , typename std::enable_if<(traits::is_eigen_type< matrix_t > &&!matrix_t::IsVectorAtCompileTime), int >::type = 0>
auto	reshape (matrix_t &A, Eigen::Index m, Eigen::Index n)
template<class matrix_t , typename std::enable_if<(traits::is_eigen_type< matrix_t > &&!matrix_t::IsVectorAtCompileTime), int >::type = 0>
auto	reshape (matrix_t &A, Eigen::Index n)
template<class ET , class Exts , class LP , class AP , std::enable_if_t<(std::is_same_v< LP, std::experimental::layout_right >||std::is_same_v< LP, std::experimental::layout_left >), int > = 0>
auto	reshape (std::experimental::mdspan< ET, Exts, LP, AP > &A, std::size_t m, std::size_t n)
template<class ET , class Exts , class LP , class AP , std::enable_if_t<(std::is_same_v< LP, std::experimental::layout_right >||std::is_same_v< LP, std::experimental::layout_left >), int > = 0>
auto	reshape (std::experimental::mdspan< ET, Exts, LP, AP > &A, std::size_t n)
template<class ET , class Exts , class AP , std::enable_if_t< Exts::rank()==2, int > = 0>
auto	reshape (std::experimental::mdspan< ET, Exts, std::experimental::layout_stride, AP > &A, std::size_t m, std::size_t n)
template<class ET , class Exts , class AP , std::enable_if_t< Exts::rank()==2, int > = 0>
auto	reshape (std::experimental::mdspan< ET, Exts, std::experimental::layout_stride, AP > &A, std::size_t n)
template<class vector_t , typename std::enable_if<(traits::is_eigen_type< vector_t > &&vector_t::IsVectorAtCompileTime), int >::type = 0>
auto	reshape (vector_t &v, Eigen::Index m, Eigen::Index n)
template<class vector_t , typename std::enable_if<(traits::is_eigen_type< vector_t > &&vector_t::IsVectorAtCompileTime), int >::type = 0>
auto	reshape (vector_t &v, Eigen::Index n)
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_REAL c_type, TLAPACK_SCALAR s_type, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T >, pair< c_type, real_type< T > >, pair< s_type, real_type< T > > > = 0>
void	rot (vectorX_t &x, vectorY_t &y, const c_type &c, const s_type &s)
	Apply plane rotation:
template<TLAPACK_SIDE side_t, TLAPACK_DIRECTION direction_t, TLAPACK_SVECTOR C_t, TLAPACK_SVECTOR S_t, TLAPACK_SMATRIX A_t>
int	rot_sequence (side_t side, direction_t direction, const C_t &c, const S_t &s, A_t &A)
	Applies a sequence of plane rotations to an (m-by-n) matrix.
template<TLAPACK_SIDE side_t, TLAPACK_DIRECTION direction_t, TLAPACK_SMATRIX C_t, TLAPACK_SMATRIX S_t, TLAPACK_SMATRIX A_t>
void	rot_sequence3 (side_t side, direction_t direction, const C_t &C, const S_t &S, A_t &A)
	Applies a sequence of plane rotations to an (m-by-n) matrix.
template<TLAPACK_COMPLEX T, enable_if_t< is_complex< T >, int > = 0, disable_if_allow_optblas_t< T > = 0>
void	rotg (T &a, const T &b, real_type< T > &c, T &s)
	Construct plane rotation that eliminates b, such that:
template<TLAPACK_REAL T, enable_if_t< is_real< T >, int > = 0, disable_if_allow_optblas_t< T > = 0>
void	rotg (T &a, T &b, T &c, T &s)
	Construct plane rotation that eliminates b, such that:
template<int flag, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, enable_if_t<((-2<=flag) &&(flag<=1)), int > = 0, class T = type_t<vectorX_t>, enable_if_t< is_same_v< T, real_type< T > >, int > = 0, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	rotm (vectorX_t &x, vectorY_t &y, const T h[4])
	Apply modified (fast) plane rotation, H:
template<TLAPACK_REAL T, enable_if_t< is_real< T >, int > = 0, disable_if_allow_optblas_t< T > = 0>
int	rotmg (T &d1, T &d2, T &a, const T &b, T h[4])
	Construct modified (fast) plane rotation, H, that eliminates b, such that.
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel>
constexpr auto	row (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index rowIdx) noexcept
template<typename T , class idx_t >
constexpr auto	row (const LegacyMatrix< T, idx_t > &A, size_type< LegacyMatrix< T, idx_t > > rowIdx) noexcept
template<typename T , class idx_t >
constexpr auto	row (const LegacyMatrix< T, idx_t, Layout::RowMajor > &A, size_type< LegacyMatrix< T, idx_t, Layout::RowMajor > > rowIdx) noexcept
template<class T >
constexpr auto	row (const starpu::Matrix< T > &A, starpu::idx_t rowIdx) noexcept
template<class ET , class Exts , class LP , class AP >
constexpr auto	row (const std::experimental::mdspan< ET, Exts, LP, AP > &A, std::size_t rowIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel>
constexpr auto	row (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index rowIdx) noexcept
template<typename T , class idx_t >
constexpr auto	row (LegacyMatrix< T, idx_t > &A, size_type< LegacyMatrix< T, idx_t > > rowIdx) noexcept
template<typename T , class idx_t >
constexpr auto	row (LegacyMatrix< T, idx_t, Layout::RowMajor > &A, size_type< LegacyMatrix< T, idx_t, Layout::RowMajor > > rowIdx) noexcept
template<class T >
constexpr auto	row (starpu::Matrix< T > &A, starpu::idx_t rowIdx) noexcept
template<class T , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	row (T &A, Eigen::Index rowIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	rows (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpec &&rows) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpec >
constexpr auto	rows (const LegacyMatrix< T, idx_t, layout > &A, SliceSpec &&rows) noexcept
template<class T , class SliceSpec >
constexpr auto	rows (const starpu::Matrix< T > &A, SliceSpec &&rows) noexcept
template<class ET , class Exts , class LP , class AP , class SliceSpec , std::enable_if_t< isSlice(SliceSpec), int > = 0>
constexpr auto	rows (const std::experimental::mdspan< ET, Exts, LP, AP > &A, SliceSpec &&rows) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpec >
constexpr auto	rows (const TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpec &&slice) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	rows (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpec &&rows) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpec >
constexpr auto	rows (LegacyMatrix< T, idx_t, layout > &A, SliceSpec &&rows) noexcept
template<class T , class SliceSpec >
constexpr auto	rows (starpu::Matrix< T > &A, SliceSpec &&rows) noexcept
template<class T , typename SliceSpec , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	rows (T &A, SliceSpec &&rows) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpec >
constexpr auto	rows (TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpec &&slice) noexcept
template<TLAPACK_VECTOR vector_t, TLAPACK_REAL alpha_t, enable_if_t< is_real< alpha_t >, int > = 0>
void	rscl (const alpha_t &alpha, vector_t &x)
	Scale vector by the reciprocal of a constant, \(x := x / \alpha\).
template<TLAPACK_REAL real_t>
constexpr real_t	safe_max () noexcept
	Safe Maximum.
template<TLAPACK_REAL real_t>
constexpr real_t	safe_min () noexcept
	Safe Minimum.
template<TLAPACK_VECTOR vector_t, TLAPACK_SCALAR alpha_t, class T = type_t<vector_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< vector_t, T > > = 0>
void	scal (const alpha_t &alpha, vector_t &x)
	Scale vector by constant, \(x := \alpha x\).
template<TLAPACK_MATRIX matrix_t>
int	schur_move (bool want_q, matrix_t &A, matrix_t &Q, size_type< matrix_t > &ifst, size_type< matrix_t > &ilst)
	schur_move reorders the Schur factorization of a matrix S = Q*A*Q**H, so that the diagonal element of S with row index IFST is moved to row ILST.
template<TLAPACK_CSMATRIX matrix_t, enable_if_t< is_real< type_t< matrix_t > >, bool > = true>
int	schur_swap (bool want_q, matrix_t &A, matrix_t &Q, const size_type< matrix_t > &j0, const size_type< matrix_t > &n1, const size_type< matrix_t > &n2)
	schur_swap, swaps 2 eigenvalues of A.
template<typename T , enable_if_t< is_real< T >, int > = 0>
constexpr int	sgn (const T &val)
	Type-safe sgn function.
template<typename T , enable_if_t<!is_complex< T >, bool > = true>
void	singularvalues22 (const T &f, const T &g, const T &h, T &ssmin, T &ssmax)
	Computes the singular value decomposition of a 2-by-2 real triangular matrix.
template<class Derived >
constexpr auto	size (const Eigen::EigenBase< Derived > &x) noexcept
template<class T , int Rows, int Cols, int Options, int MaxRows, int MaxCols, std::enable_if_t<!(traits::internal::isStdComplex< std::decay_t< T > >::value), int > = 0>
constexpr auto	size (const Eigen::Matrix< T, Rows, Cols, Options, MaxRows, MaxCols > &x) noexcept
template<typename T , class idx_t >
constexpr auto	size (const LegacyBandedMatrix< T, idx_t > &A) noexcept
template<typename T , class idx_t , Layout layout>
constexpr auto	size (const LegacyMatrix< T, idx_t, layout > &A) noexcept
template<typename T , class idx_t , typename int_t , Direction direction>
constexpr auto	size (const LegacyVector< T, idx_t, int_t, direction > &x) noexcept
template<class T >
constexpr auto	size (const starpu::Matrix< T > &A) noexcept
template<class ET , class Exts , class LP , class AP >
constexpr auto	size (const std::experimental::mdspan< ET, Exts, LP, AP > &x)
template<class T >
constexpr auto	size (const std::span< T > &x) noexcept
template<class T , class Allocator >
constexpr auto	size (const std::vector< T, Allocator > &x) noexcept
template<class XprType , int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	slice (const Eigen::Block< XprType, 1, BlockCols, InnerPanel > &x, SliceSpec &&range) noexcept
template<class XprType , int BlockRows, bool InnerPanel, typename SliceSpec >
constexpr auto	slice (const Eigen::Block< XprType, BlockRows, 1, InnerPanel > &x, SliceSpec &&range) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpecCol >
constexpr auto	slice (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index rowIdx, SliceSpecCol &&cols) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpecRow >
constexpr auto	slice (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpecRow &&rows, Eigen::Index colIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (const Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecCol >
constexpr auto	slice (const LegacyMatrix< T, idx_t, layout > &A, size_type< LegacyMatrix< T, idx_t, layout > > rowIdx, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecRow >
constexpr auto	slice (const LegacyMatrix< T, idx_t, layout > &A, SliceSpecRow &&rows, size_type< LegacyMatrix< T, idx_t, layout > > colIdx) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (const LegacyMatrix< T, idx_t, layout > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , typename int_t , Direction direction, class SliceSpec >
constexpr auto	slice (const LegacyVector< T, idx_t, int_t, direction > &v, SliceSpec &&rows) noexcept
template<class T , class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (const starpu::Matrix< T > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (const starpu::Matrix< T > &v, SliceSpec &&range) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (const starpu::Matrix< T > &v, SliceSpec &&range, starpu::idx_t colIdx) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (const starpu::Matrix< T > &v, starpu::idx_t rowIdx, SliceSpec &&range) noexcept
template<class ET , class Exts , class LP , class AP , class SliceSpecRow , class SliceSpecCol , std::enable_if_t< isSlice(SliceSpecRow)||isSlice(SliceSpecCol), int > = 0>
constexpr auto	slice (const std::experimental::mdspan< ET, Exts, LP, AP > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<class ET , class Exts , class LP , class AP , class SliceSpec , std::enable_if_t< isSlice(SliceSpec) &&(Exts::rank()==1), int > = 0>
constexpr auto	slice (const std::experimental::mdspan< ET, Exts, LP, AP > &v, SliceSpec &&rows) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (const TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<class vec_t , class SliceSpec , std::enable_if_t< traits::is_stdvector_type< vec_t >, int > = 0>
constexpr auto	slice (const vec_t &v, SliceSpec &&rows) noexcept
template<class XprType , int BlockCols, bool InnerPanel, typename SliceSpec >
constexpr auto	slice (Eigen::Block< XprType, 1, BlockCols, InnerPanel > &x, SliceSpec &&range) noexcept
template<class XprType , int BlockRows, bool InnerPanel, typename SliceSpec >
constexpr auto	slice (Eigen::Block< XprType, BlockRows, 1, InnerPanel > &x, SliceSpec &&range) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpecCol >
constexpr auto	slice (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, Eigen::Index rowIdx, SliceSpecCol &&cols) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, typename SliceSpecRow >
constexpr auto	slice (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpecRow &&rows, Eigen::Index colIdx) noexcept
template<class XprType , int BlockRows, int BlockCols, bool InnerPanel, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (Eigen::Block< XprType, BlockRows, BlockCols, InnerPanel > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecCol >
constexpr auto	slice (LegacyMatrix< T, idx_t, layout > &A, size_type< LegacyMatrix< T, idx_t, layout > > rowIdx, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecRow >
constexpr auto	slice (LegacyMatrix< T, idx_t, layout > &A, SliceSpecRow &&rows, size_type< LegacyMatrix< T, idx_t, layout > > colIdx) noexcept
template<typename T , class idx_t , Layout layout, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (LegacyMatrix< T, idx_t, layout > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<typename T , class idx_t , typename int_t , Direction direction, class SliceSpec >
constexpr auto	slice (LegacyVector< T, idx_t, int_t, direction > &v, SliceSpec &&rows) noexcept
template<class T , class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (starpu::Matrix< T > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (starpu::Matrix< T > &v, SliceSpec &&range) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (starpu::Matrix< T > &v, SliceSpec &&range, starpu::idx_t colIdx) noexcept
template<class T , class SliceSpec >
constexpr auto	slice (starpu::Matrix< T > &v, starpu::idx_t rowIdx, SliceSpec &&range) noexcept
template<class T , typename SliceSpecCol , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	slice (T &A, Eigen::Index rowIdx, SliceSpecCol &&cols) noexcept
template<class T , typename SliceSpecRow , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	slice (T &A, SliceSpecRow &&rows, Eigen::Index colIdx) noexcept
template<class T , class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol) &&traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	slice (T &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
template<class T , typename SliceSpec , typename std::enable_if< traits::is_eigen_type< T > &&!traits::internal::is_eigen_block< T >, int >::type = 0>
constexpr auto	slice (T &x, SliceSpec &&range) noexcept
template<typename T , class idx_t , Uplo uplo, Layout layout, class SliceSpecRow , class SliceSpecCol , typename std::enable_if< isSlice(SliceSpecRow) &&isSlice(SliceSpecCol), int >::type = 0>
constexpr auto	slice (TestUploMatrix< T, idx_t, uplo, layout > &A, SliceSpecRow &&rows, SliceSpecCol &&cols) noexcept
std::complex< Eigen::half >	sqrt (const std::complex< Eigen::half > &z)
template<typename T >
constexpr T	square (const T &x)
template<TLAPACK_SMATRIX matrix_t, class d_t , class e_t , enable_if_t< is_same_v< type_t< d_t >, real_type< type_t< d_t > > >, int > = 0, enable_if_t< is_same_v< type_t< e_t >, real_type< type_t< e_t > > >, int > = 0>
int	steqr (bool want_z, d_t &d, e_t &e, matrix_t &Z)
	STEQR computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix using the implicit QL or QR method.
template<typename T , enable_if_t<!is_complex< T >, bool > = true>
void	svd22 (const T &f, const T &g, const T &h, T &ssmin, T &ssmax, T &csl, T &snl, T &csr, T &snr)
	Computes the singular value decomposition of a 2-by-2 real triangular matrix.
template<class matrix_t , class d_t , class e_t , enable_if_t< is_same_v< type_t< d_t >, real_type< type_t< d_t > > >, int > = 0, enable_if_t< is_same_v< type_t< e_t >, real_type< type_t< e_t > > >, int > = 0>
int	svd_qr (Uplo uplo, bool want_u, bool want_vt, d_t &d, e_t &e, matrix_t &U, matrix_t &Vt)
	Computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real N-by-N (upper or lower) bidiagonal matrix B using the implicit zero-shift QR algorithm.
template<TLAPACK_VECTOR vector_t>
void	swap (vector_t &x, vector_t &y)
	Swap vectors, \(x <=> y\).
template<TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	swap (vectorX_t &x, vectorY_t &y)
	Swap vectors, \(x <=> y\).
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	symm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Symmetric matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	symm (Side side, Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Symmetric matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<vectorY_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T >, pair< beta_t, T > > = 0>
void	symv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, const beta_t &beta, vectorY_t &y)
	Symmetric matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t>
void	symv (Uplo uplo, const alpha_t &alpha, const matrixA_t &A, const vectorX_t &x, vectorY_t &y)
	Symmetric matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	syr (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, matrixA_t &A)
	Symmetric matrix rank-1 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, TLAPACK_VECTOR vectorY_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixA_t>, disable_if_allow_optblas_t< pair< alpha_t, T >, pair< matrixA_t, T >, pair< vectorX_t, T >, pair< vectorY_t, T > > = 0>
void	syr2 (Uplo uplo, const alpha_t &alpha, const vectorX_t &x, const vectorY_t &y, matrixA_t &A)
	Symmetric matrix rank-2 update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	syr2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	syr2k (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixC_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixC_t, T >, pair< alpha_t, T >, pair< beta_t, T > > = 0>
void	syrk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, const beta_t &beta, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t>
void	syrk (Uplo uplo, Op trans, const alpha_t &alpha, const matrixA_t &A, matrixC_t &C)
	Symmetric rank-k update:
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t>
void	transpose (matrixA_t &A, matrixB_t &B, const TransposeOpts &opts={})
	transpose a matrix A into a matrix B.
template<typename T , class idx_t >
constexpr auto	transpose_view (const LegacyMatrix< T, idx_t, Layout::ColMajor > &A) noexcept
template<typename T , class idx_t >
constexpr auto	transpose_view (const LegacyMatrix< T, idx_t, Layout::RowMajor > &A) noexcept
template<class ET , class Exts , class AP >
constexpr auto	transpose_view (const std::experimental::mdspan< ET, Exts, std::experimental::layout_left, AP > &A) noexcept
template<class ET , class Exts , class AP >
constexpr auto	transpose_view (const std::experimental::mdspan< ET, Exts, std::experimental::layout_right, AP > &A) noexcept
template<class ET , class Exts , class AP >
constexpr auto	transpose_view (const std::experimental::mdspan< ET, Exts, std::experimental::layout_stride, AP > &A) noexcept
template<typename T , class idx_t >
constexpr auto	transpose_view (LegacyMatrix< T, idx_t, Layout::ColMajor > &A) noexcept
template<typename T , class idx_t >
constexpr auto	transpose_view (LegacyMatrix< T, idx_t, Layout::RowMajor > &A) noexcept
template<class matrix_t , typename std::enable_if<(traits::is_eigen_type< matrix_t > &&!matrix_t::IsVectorAtCompileTime), int >::type = 0>
constexpr auto	transpose_view (matrix_t &A) noexcept
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>
void	trmm (Side side, Uplo uplo, Op trans, Diag diag, const alpha_t &alpha, const matrixA_t &A, matrixB_t &B)
	Triangular matrix-matrix multiply:
template<TLAPACK_SIDE side_t, TLAPACK_UPLO uplo_t, TLAPACK_OP op_t, TLAPACK_DIAG diag_t, TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixB_t, TLAPACK_WORKSPACE work_t>
void	trmm_blocked_mixed (side_t side, uplo_t uplo, op_t trans, diag_t diag, const scalar_type< type_t< matrixA_t >, type_t< matrixB_t > > &alpha, const matrixA_t &A, matrixB_t &B, work_t &work, const TrmmBlockedOpts &opts={})
	Triangular matrix-matrix multiply using a blocked algorithm.
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_MATRIX matrixC_t, TLAPACK_SCALAR alpha_t, TLAPACK_SCALAR beta_t, class T = type_t<matrixB_t>>
void	trmm_out (Side side, Uplo uplo, Op transA, Diag diag, Op transB, const alpha_t &alpha, const matrixA_t &A, const matrixB_t &B, const beta_t &beta, matrixC_t &C)
	Triangular matrix-matrix multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	trmv (Uplo uplo, Op trans, Diag diag, const matrixA_t &A, vectorX_t &x)
	Triangular matrix-vector multiply:
template<TLAPACK_MATRIX matrixA_t, TLAPACK_MATRIX matrixB_t, TLAPACK_SCALAR alpha_t, class T = type_t<matrixB_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< matrixB_t, T >, pair< alpha_t, T > > = 0>
void	trsm (Side side, Uplo uplo, Op trans, Diag diag, const alpha_t &alpha, const matrixA_t &A, matrixB_t &B)
	Solve the triangular matrix-vector equation.
template<class TA , class TB , class alpha_t >
void	trsm (Side side, Uplo uplo, Op trans, Diag diag, const alpha_t &alpha, const starpu::Matrix< TA > &A, starpu::Matrix< TB > &B)
	Overload of trsm for starpu::Matrix.
template<TLAPACK_MATRIX matrixA_t, TLAPACK_VECTOR vectorX_t, class T = type_t<vectorX_t>, disable_if_allow_optblas_t< pair< matrixA_t, T >, pair< vectorX_t, T > > = 0>
void	trsv (Uplo uplo, Op trans, Diag diag, const matrixA_t &A, vectorX_t &x)
	Solve the triangular matrix-vector equation.
template<TLAPACK_UPLO uplo_t, TLAPACK_SMATRIX matrix_t>
int	trtri_recursive (uplo_t uplo, Diag diag, matrix_t &C, const EcOpts &opts={})
	TRTRI computes the inverse of a triangular matrix in-place Input is a triangular matrix, output is its inverse This is the recursive variant.
template<TLAPACK_SMATRIX matrix_t>
int	ul_mult (matrix_t &A)
	ul_mult computes the matrix product of an upper triangular matrix U and a lower triangular unital matrix L Given input matrix A, nonzero part of L is the subdiagonal of A and on the diagonal of L is assumed to be 1, and the nonzero part of U is diagonal and super-diagonal part of A
template<TLAPACK_REAL real_t>
constexpr real_t	ulp () noexcept
	Unit in the Last Place.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	ung2l (matrix_t &A, const vector_t &tau)
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ung2l_work (matrix_t &A, const vector_t &tau, work_t &work)
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	ung2l_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of ung2l()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	ung2r (matrix_t &A, const vector_t &tau)
	Generates a matrix Q with orthogonal columns.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ung2r_work (matrix_t &A, const vector_t &tau, work_t &work)
	Generates a matrix Q with orthogonal columns.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	ung2r_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of ung2r()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	ungbr_p (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, const UngbrOpts &opts={})
	Generates the unitary matrix P**H determined by gebrd when reducing a matrix A to bidiagonal form: A = Q * B * P**H.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ungbr_p_work (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, work_t &work, const UngbrOpts &opts={})
	Generates the unitary matrix P**H determined by gebrd when reducing a matrix A to bidiagonal form: A = Q * B * P**H. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	ungbr_p_worksize (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, const UngbrOpts &opts={})
	Worspace query of ungbr_p()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	ungbr_q (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, const UngbrOpts &opts={})
	Generates the unitary matrix Q determined by gebrd when reducing a matrix A to bidiagonal form: A = Q * B * P**H.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ungbr_q_work (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, work_t &work, const UngbrOpts &opts={})
	Generates the unitary matrix Q determined by gebrd when reducing a matrix A to bidiagonal form: A = Q * B * P**H. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	ungbr_q_worksize (const size_type< matrix_t > k, matrix_t &A, const vector_t &tau, const UngbrOpts &opts={})
	Worspace query of ungbr_q()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	unghr (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, const vector_t &tau)
	Generates a m-by-n matrix Q with orthogonal columns.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	unghr_work (size_type< matrix_t > ilo, size_type< matrix_t > ihi, matrix_t &A, const vector_t &tau, work_t &work)
	Generates a m-by-n matrix Q with orthogonal columns. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	unghr_worksize (size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau)
	Worspace query of unghr()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	ungl2 (matrix_t &Q, const vector_t &tauw)
	Generates all or part of the unitary matrix Q from an LQ factorization determined by gelq2 (unblocked algorithm).
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ungl2_work (matrix_t &Q, const vector_t &tauw, work_t &work)
	Generates all or part of the unitary matrix Q from an LQ factorization determined by gelq2 (unblocked algorithm).
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	ungl2_worksize (const matrix_t &Q, const vector_t &tauw)
	Worspace query of ungl2()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	unglq (matrix_t &A, const vector_t &tau, const UnglqOpts &opts={})
	Generates all or part of the unitary matrix Q from an LQ factorization determined by gelqf.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	ungq (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau, const UngqOpts &opts={})
	Generates a matrix Q that is the product of elementary reflectors.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	ungq_level2 (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau)
	Generates a matrix Q that is the product of elementary reflectors.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	ungq_level2_work (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau, work_t &work)
	Generates a matrix Q that is the product of elementary reflectors. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	ungq_level2_worksize (direction_t direction, storage_t storeMode, const matrix_t &A, const vector_t &tau)
	Worspace query of ungq_level2()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	ungq_work (direction_t direction, storage_t storeMode, matrix_t &A, const vector_t &tau, work_t &work, const UngqOpts &opts={})
	Generates a matrix Q that is the product of elementary reflectors. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	ungq_worksize (direction_t direction, storage_t storeMode, const matrix_t &A, const vector_t &tau, const UngqOpts &opts={})
	Worspace query of ungq()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	ungql (matrix_t &A, const vector_t &tau, const UngqlOpts &opts={})
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last n columns of a product of k elementary reflectors of order m.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	ungqr (matrix_t &A, const vector_t &tau, const UngqrOpts &opts={})
	Generates a matrix Q with orthogonal columns.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
int	ungr2 (matrix_t &A, const vector_t &tau)
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last m rows of a product of k elementary reflectors of order n.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	ungr2_work (matrix_t &A, const vector_t &tau, work_t &work)
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last m rows of a product of k elementary reflectors of order n.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_VECTOR vector_t>
constexpr WorkInfo	ungr2_worksize (const matrix_t &A, const vector_t &tau)
	Worspace query of ungr2()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	ungrq (matrix_t &A, const vector_t &tau, const UngrqOpts &opts={})
	Generates an m-by-n matrix Q with orthonormal columns, which is defined as the last m rows of a product of k elementary reflectors of order n.
template<TLAPACK_SMATRIX Q_t, TLAPACK_SVECTOR tau_t, class uplo_t >
int	ungtr (uplo_t uplo, Q_t &Q, const tau_t &tau)
	Generates a real orthogonal matrix Q which is defined as the product of k elementary reflectors of order n, as returned by hetrd.
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unm2l (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C)
	Applies unitary matrix Q from an QL factorization to a matrix C.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unm2l_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C)
	Worspace query of unm2l()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unm2r (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C)
	Applies unitary matrix Q to a matrix C.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unm2r_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C)
	Worspace query of unm2r()
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
int	unmhr (Side side, Op trans, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau, matrix_t &C)
	Applies unitary matrix Q to a matrix C.
template<TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t, TLAPACK_WORKSPACE work_t>
int	unmhr_work (Side side, Op trans, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau, matrix_t &C, work_t &work)
	Applies unitary matrix Q to a matrix C. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrix_t, TLAPACK_SVECTOR vector_t>
constexpr WorkInfo	unmhr_worksize (Side side, Op trans, size_type< matrix_t > ilo, size_type< matrix_t > ihi, const matrix_t &A, const vector_t &tau, const matrix_t &C)
	Worspace query of unmhr()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unml2 (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C)
	Applies unitary matrix Q from an LQ factorization to a matrix C.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unml2_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C)
	Worspace query of unml2()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unmlq (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C, const UnmlqOpts &opts={})
	Applies orthogonal matrix op(Q) to a matrix C using a blocked code.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unmlq_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C, const UnmlqOpts &opts={})
	Worspace query of unmlq()
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	unmq (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C, const UnmqOpts &opts={})
	Applies unitary matrix Q to a matrix C.
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
int	unmq_level2 (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C)
	Applies unitary matrix Q to a matrix C.
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	unmq_level2_work (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C, work_t &work)
	Applies unitary matrix Q to a matrix C. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	unmq_level2_worksize (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, const matrixC_t &C)
	Worspace query of unmq_level2()
template<TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t, TLAPACK_WORKSPACE work_t>
int	unmq_work (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, matrixC_t &C, work_t &work, const UnmqOpts &opts={})
	Applies unitary matrix Q to a matrix C. Workspace is provided as an argument.
template<class T , TLAPACK_SMATRIX matrixV_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR vector_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t, TLAPACK_DIRECTION direction_t, TLAPACK_STOREV storage_t>
constexpr WorkInfo	unmq_worksize (side_t side, trans_t trans, direction_t direction, storage_t storeMode, const matrixV_t &V, const vector_t &tau, const matrixC_t &C, const UnmqOpts &opts={})
	Worspace query of unmq()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unmql (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C, const UnmqlOpts &opts={})
	Applies orthogonal matrix op(Q) to a matrix C using a blocked code.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unmql_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C, const UnmqlOpts &opts={})
	Applies unitary matrix Q from an QL factorization to a matrix C.
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unmqr (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C, const UnmqrOpts &opts={})
	Applies orthogonal matrix op(Q) to a matrix C using a blocked code.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unmqr_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C, const UnmqrOpts &opts={})
	Worspace query of unmqr()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unmr2 (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C)
	Applies unitary matrix Q from an RQ factorization to a matrix C.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_VECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unmr2_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C)
	Worspace query of unmr2()
template<TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
int	unmrq (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, matrixC_t &C, const UnmrqOpts &opts={})
	Applies orthogonal matrix op(Q) to a matrix C using a blocked code.
template<class T , TLAPACK_SMATRIX matrixA_t, TLAPACK_SMATRIX matrixC_t, TLAPACK_SVECTOR tau_t, TLAPACK_SIDE side_t, TLAPACK_OP trans_t>
constexpr WorkInfo	unmrq_worksize (side_t side, trans_t trans, const matrixA_t &A, const tau_t &tau, const matrixC_t &C, const UnmrqOpts &opts={})
	Worspace query of unmrq()
template<typename T , class idx_t >
constexpr auto	upperband (const LegacyBandedMatrix< T, idx_t > &A) noexcept
template<TLAPACK_REAL real_t>
constexpr real_t	uroundoff () noexcept
	Unit roundoff.
template<TLAPACK_MATRIX matrix_t>
std::string	visualize_matrix (const matrix_t &A)
	Constructs a json string representing the matrix for use with vscode-debug-visualizer.
std::string	visualize_matrix_c (const LegacyMatrix< std::complex< float >, size_t, Layout::ColMajor > &A)
std::string	visualize_matrix_d (const LegacyMatrix< double, size_t, Layout::ColMajor > &A)
std::string	visualize_matrix_r (const LegacyMatrix< float, size_t, Layout::ColMajor > &A)
template<TLAPACK_MATRIX matrix_t>
std::string	visualize_matrix_table (const matrix_t &A)
	Constructs a json string representing the matrix for use with vscode-debug-visualizer.
template<TLAPACK_MATRIX matrix_t>
std::string	visualize_matrix_text (const matrix_t &A)
	Constructs a json string representing the matrix for use with vscode-debug-visualizer.
std::string	visualize_matrix_z (const LegacyMatrix< std::complex< double >, size_t, Layout::ColMajor > &A)
std::string	visualize_rowmajormatrix_c (const LegacyMatrix< std::complex< float >, size_t, Layout::RowMajor > &A)
std::string	visualize_rowmajormatrix_d (const LegacyMatrix< double, size_t, Layout::RowMajor > &A)
std::string	visualize_rowmajormatrix_r (const LegacyMatrix< float, size_t, Layout::RowMajor > &A)
std::string	visualize_rowmajormatrix_z (const LegacyMatrix< std::complex< double >, size_t, Layout::RowMajor > &A)
template<TLAPACK_VECTOR vector_t>
std::string	visualize_vector (const vector_t &v)
	Constructs a json string representing the vector for use with vscode-debug-visualizer.

Variables
template<class... Ts>
constexpr bool	allow_optblas = traits::allow_optblas_trait<Ts..., int>::value
	True if the list of types allows optimized BLAS library.
constexpr internal::Backward	BACKWARD {}
	Backward direction.
constexpr internal::ColumnwiseStorage	COLUMNWISE_STORAGE {}
	Columnwise storage.
constexpr internal::ConjTranspose	CONJ_TRANS = {}
	conjugate transpose
constexpr internal::Conjugate	CONJUGATE = {}
	non-transpose conjugate
constexpr internal::Forward	FORWARD {}
	Forward direction.
constexpr internal::FrobNorm	FROB_NORM = {}
	Frobenius norm of matrices.
constexpr internal::GeneralAccess	GENERAL = {}
	General access.
constexpr internal::InfNorm	INF_NORM = {}
	infinity norm of matrices
template<typename T >
constexpr bool	is_complex = traits::complex_type_traits<T, int>::is_complex
	True if T is a complex scalar type.
template<typename T >
constexpr bool	is_real = traits::real_type_traits<T, int>::is_real
	True if T is a real scalar type.
template<class array_t >
constexpr Layout	layout = traits::layout_trait<array_t, int>::value
	Layout of a matrix or vector.
constexpr internal::LeftSide	LEFT_SIDE {}
	left side
constexpr internal::LowerHessenberg	LOWER_HESSENBERG = {}
	Lower Hessenberg access.
constexpr internal::LowerTriangle	LOWER_TRIANGLE = {}
	Lower Triangle access.
constexpr internal::MaxNorm	MAX_NORM = {}
	max norm
constexpr ErrorCheck	NO_ERROR_CHECK = {false, false, false}
	Options to disable error checking.
constexpr internal::NoTranspose	NO_TRANS = {}
	no transpose
constexpr internal::NonUnitDiagonal	NON_UNIT_DIAG = {}
	The main diagonal is not assumed to consist of 1's.
constexpr internal::OneNorm	ONE_NORM = {}
	one norm
constexpr internal::RightSide	RIGHT_SIDE {}
	right side
constexpr internal::RowwiseStorage	ROWWISE_STORAGE {}
	Rowwise storage.
constexpr internal::StrictLower	STRICT_LOWER = {}
	Strict Lower Triangle access.
constexpr internal::StrictUpper	STRICT_UPPER = {}
	Strict Upper Triangle access.
constexpr internal::Transpose	TRANSPOSE = {}
	transpose
constexpr internal::TwoNorm	TWO_NORM = {}
	two norm
constexpr internal::UnitDiagonal	UNIT_DIAG = {}
	The main diagonal is assumed to consist of 1's.
constexpr internal::UpperHessenberg	UPPER_HESSENBERG = {}
	Upper Hessenberg access.
constexpr internal::UpperTriangle	UPPER_TRIANGLE = {}
	Upper Triangle access.

Detailed Description

Sort the numbers in D in increasing order (if ID = 'I') or in decreasing order (if ID = 'D' ).

Parameters

[in]	id	ID is CHARACTER*1 = 'I': sort D in increasing order; = 'D': sort D in decreasing order.
[in]	n	N is INTEGER The length of the array D.
[in,out]	d	D is DOUBLE PRECISION array, dimension (N) On entry, the array to be sorted. On exit, D has been sorted into increasing order (D(1) <= ... <= D(N) ) or into decreasing order (D(1) >= ... >= D(N) ), depending on ID.

Returns

= 0: successful exit > 0: if 1, the updating process failed.

Typedef Documentation

Create

template<class T >

using tlapack::Create = typedef traits::CreateFunctor<T, int>

Alias for traits::CreateFunctor<,int>.

Usage:

// matrix_t is a predefined type at this point
 
tlapack::Create<matrix_t> new_matrix; // Creates the functor
 
size_t m = 11;
size_t n = 6;
 
std::vector<float> A_container; // Empty vector
auto A = new_matrix(A_container, m, n); // Initialize A_container if needed

CreateStatic

template<class T , int m, int n = -1>

using tlapack::CreateStatic = typedef traits::CreateStaticFunctor<T, m, n, int>

Alias for traits::CreateStaticFunctor<,int>.

Usage:

// matrix_t and vector_t are predefined types at this point
 
constexpr size_t M = 8;
constexpr size_t N = 6;
tlapack::CreateStatic<matrix_t, M, N> new_MbyN_matrix; // Creates the functor
tlapack::CreateStatic<vector_t, N> new_N_vector; // Creates the functor
 
float A_container[M * N]; // Array of size M * N
auto A = new_MbyN_matrix(A_container);
 
double B_container[N]; // Array of size N
auto B = new_N_vector(B_container);

Enumeration Type Documentation

Diag

enum class tlapack::Diag : char

strong

Enumerator
NonUnit	The main diagonal is not assumed to consist of 1's.
Unit	The main diagonal is assumed to consist of 1's.

Direction

enum class tlapack::Direction : char

strong

Enumerator
Forward	Forward direction.
Backward	Backward direction.

GetriVariant

enum class tlapack::GetriVariant : char

strong

Variants of the algorithm to compute the inverse of a matrix.

Enumerator
UILI	Method D from doi:10.1137/1.9780898718027.
UXLI	Method C from doi:10.1137/1.9780898718027.

Layout

enum class tlapack::Layout : char

strong

Enumerator
Strided	Strided layout. Vectors whose i-th element is at ptr + i*inc, inc is an integer.
ColMajor	Column-major layout. Matrices whose (i,j)-th element is at ptr + i + j*ldim.
RowMajor	Row-major layout. Matrices whose (i,j)-th element is at ptr + i*ldim + j.
Unspecified	Used on all other data structures.

Norm

enum class tlapack::Norm : char

strong

Enumerator
One	one norm
Two	two norm
Inf	infinity norm of matrices
Fro	Frobenius norm of matrices.
Max	max norm

Op

enum class tlapack::Op : char

strong

Enumerator
NoTrans	no transpose
Trans	transpose
ConjTrans	conjugate transpose
Conj	non-transpose conjugate

Side

enum class tlapack::Side : char

strong

Enumerator
Left	left side
Right	right side

StoreV

enum class tlapack::StoreV : char

strong

Enumerator
Columnwise	Columnwise storage.
Rowwise	Rowwise storage.

Uplo

enum class tlapack::Uplo : char

strong

Enumerator
General	0 <= i <= m, 0 <= j <= n.
Upper	0 <= i <= j, 0 <= j <= n.
Lower	0 <= i <= m, 0 <= j <= i.
UpperHessenberg	0 <= i <= j+1, 0 <= j <= n.
LowerHessenberg	0 <= i <= m, 0 <= j <= i+1.
StrictUpper	0 <= i <= j-1, 0 <= j <= n.
StrictLower	0 <= i <= m, 0 <= j <= i-1.

Function Documentation

conj()

template<typename T , enable_if_t< is_real< T >, int > = 0>

constexpr T tlapack::conj ( const T &  x )

constexprnoexcept

Extends std::conj() to real datatypes.

Parameters

[in]

x

Real number

Returns

x

Note

std::conj() is already defined for real numbers in C++. However, the return type is complex<real_t> instead of real_t.

imag()

template<typename T , enable_if_t< is_real< T >, int > = 0>

constexpr real_type< T > tlapack::imag ( const T &  x )

constexprnoexcept

Extends std::imag() to real datatypes.

Parameters

[in]

x

Real number

Returns

0

Note

std::imag() is already defined for real numbers in C++. However, we want a more general definition that works for any real type, not only for the built-in types.

laed4()

template<class d_t , class z_t , class delta_t , class real_t , class idx_t >

int tlapack::laed4	(	idx_t	n,
		idx_t	i,
		d_t &	d,
		z_t &	z,
		delta_t &	delta,
		real_t	rho,
		real_t &	dlam
	)

LAED4 used by STEDC.

Finds a single root of the secular equation.

This subroutine computes the I-th updated eigenvalue of a symmetric rank-one modification to a diagonal matrix whose elements are given in the array d, and that

        D(i) < D(j)  for  i < j

and that RHO > 0. This is arranged by the calling routine, and is no loss in generality. The rank-one modified system is thus

        diag( D )  +  RHO * Z * Z_transpose.

where we assume the Euclidean norm of Z is 1.

The method consists of approximating the rational functions in the secular equation by simpler interpolating rational functions.

Parameters

[in]	n	N is INTEGER The length of all arrays.
[in]	i	I is INTEGER The index of the eigenvalue to be computed. 1 <= I <= N.
[in]	d	D is DOUBLE PRECISION array, dimension (N) The original eigenvalues. It is assumed that they are in order, D(I) < D(J) for I < J.
[in]	z	Z is DOUBLE PRECISION array, dimension (N) The components of the updating vector.
[out]	delta	DELTA is DOUBLE PRECISION array, dimension (N) If N > 2, DELTA contains (D(j) - lambda_I) in its j-th component. If N = 1, then DELTA(1) = 1. If N = 2, see LAED5 for detail. The vector DELTA contains the information necessary to construct the eigenvectors by LAED3 and LAED9.
[in]	rho	RHO is DOUBLE PRECISION The scalar in the symmetric updating formula.
[out]	dlam	DLAM is DOUBLE PRECISION The computed lambda_I, the I-th updated eigenvalue.

Returns

info INFO is INTEGER = 0: successful exit > 0: if INFO = 1, the updating process failed.

Logical variable ORGATI (origin-at-i?) is used for distinguishing whether D(i) or D(i+1) is treated as the origin.

        ORGATI = .true.    origin at i
        ORGATI = .false.   origin at i+1

Logical variable SWTCH3 (switch-for-3-poles?) is for noting if we are working with THREE poles!

MAXIT is the maximum number of iterations allowed for each eigenvalue.

laed5()

template<class d_t , class z_t , class delta_t , class real_t , class idx_t >

void tlapack::laed5	(	idx_t	i,
		d_t &	d,
		z_t &	z,
		delta_t &	delta,
		real_t	rho,
		real_t &	dlam
	)

LAED5 used by STEDC.

Solves the 2-by-2 secular equation.

This subroutine computes the I-th eigenvalue of a symmetric rank-one modification of a 2-by-2 diagonal matrix

        diag( D )  +  RHO * Z * transpose(Z) .

The diagonal elements in the array D are assumed to satisfy

        D(i) < D(j)  for  i < j .

We also assume RHO > 0 and that the Euclidean norm of the vector Z is one.

Parameters

[in]	i	I is INTEGER The index of the eigenvalue to be computed. I = 1 or I = 2.
[in]	d	D is DOUBLE PRECISION array, dimension (2) The original eigenvalues. We assume D(1) < D(2).
[in]	z	Z is DOUBLE PRECISION array, dimension (2) The components of the updating vector.
[out]	delta	DELTA is DOUBLE PRECISION array, dimension (2) The vector DELTA contains the information necessary to construct the eigenvectors.
[in]	rho	RHO is DOUBLE PRECISION The scalar in the symmetric updating formula.
[out]	dlam	DLAM is DOUBLE PRECISION The computed lambda_I, the I-th updated eigenvalue.

laed6()

template<class d_t , class z_t , class real_t , class idx_t >

int tlapack::laed6	(	idx_t	kniter,
		bool &	orgati,
		real_t	rho,
		d_t &	d,
		z_t &	z,
		real_t &	finit,
		real_t &	tau
	)

LAED6 used by STEDC.

Computes one Newton step in solution of the secular equation.

LAED6 computes the positive or negative root (closest to the origin) of z(1) z(2) z(3) f(x) = rho + ------— + -------— + ------— d(1)-x d(2)-x d(3)-x

It is assumed that

if ORGATI = .true. the root is between d(2) and d(3); otherwise it is between d(1) and d(2)

This routine will be called by LAED4 when necessary. In most cases, the root sought is the smallest in magnitude, though it might not be in some extremely rare situations.

Parameters

[in]	kniter	KNITER is INTEGER Refer to LAED4 for its significance.
[in]	orgati	ORGATI is LOGICAL If ORGATI is true, the needed root is between d(2) and d(3); otherwise it is between d(1) and d(2). See LAED4 for further details.
[in]	rho	RHO is DOUBLE PRECISION Refer to the equation f(x) above.
[out]	d	D is DOUBLE PRECISION array, dimension (3) D satisfies d(1) < d(2) < d(3).
[in]	z	Z is DOUBLE PRECISION array, dimension (3) Each of the elements in z must be positive.
[in]	finit	FINIT is DOUBLE PRECISION The value of f at 0. It is more accurate than the one evaluated inside this routine (if someone wants to do so).
[out]	tau	TAU is DOUBLE PRECISION The root of the equation f(x).

Returns

info INFO is INTEGER = 0: successful exit > 0: if INFO = 1, the updating process failed.

lahqz_eig22()

template<TLAPACK_MATRIX A_t, TLAPACK_MATRIX B_t, TLAPACK_SCALAR T>

void tlapack::lahqz_eig22	(	const A_t &	A,
		const B_t &	B,
		complex_type< T > &	alpha1,
		complex_type< T > &	alpha2,
		T &	beta1,
		T &	beta2
	)

Computes the generalized eigenvalues of a 2x2 pencil (A,B) with B upper triangular.

Note: in LAPACK, this function is quite complicated, taking a lot of overflow conditions into account. I still need to translate that functionality.

Parameters

[in]	A	2x2 matrix
[in]	B	2x2 upper triangular matrix
[out]	alpha1	complex number
[out]	alpha2	complex number
[out]	beta1	number
[out]	beta2	number On exit, (alpha1, beta1), (alpha2, beta2) are the generalized eigenvalues of the pencil (A,B)

lamrg()

template<class idx_t , class a_t , class idx1_t >

void tlapack::lamrg	(	idx_t	n1,
		idx_t	n2,
		a_t &	a,
		int	dtrd1,
		int	dtrd2,
		idx1_t &	index
	)

DLAMRG creates a permutation list to merge the entries of two independently sorted sets into a single set sorted in ascending order.

DLAMRG will create a permutation list which will merge the elements of A (which is composed of two independently sorted sets) into a single set which is sorted in ascending order.

Parameters

[in]	n1	N2 is INTEGER
[in]	n2	N2 is INTEGER These arguments contain the respective lengths of the two sorted lists to be merged.
[in]	a	A is DOUBLE PRECISION array, dimension (N1+N2) The first N1 elements of A contain a list of numbers which are sorted in either ascending or descending order. Likewise for the final N2 elements.
[in]	dtrd1	DTRD1 is INTEGER
[in]	dtrd2	DTRD2 is INTEGER These are the strides to be taken through the array A. Allowable strides are 1 and -1. They indicate whether a subset of a is sorted in ascending (DTRDx = 1) or descending (DTRDx = -1) order.
[out]	index	INDEX is INTEGER array, dimension (N1+N2) On exit this array will contain a permutation such that if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be sorted in ascending order.

INDEX is INTEGER array, dimension (N1+N2) On exit this array will contain a permutation such that if B( I ) = A( INDEX( I ) ) for I=1,N1+N2, then B will be sorted in ascending order.

lauum_recursive()

template<TLAPACK_SMATRIX matrix_t>

int tlapack::lauum_recursive	(	const Uplo &	uplo,
		matrix_t &	C
	)

LAUUM is a specific type of inplace HERK.

Given C a triangular matrix (lower or upper), LAUUM computes the Hermitian matrix upper times lower.

If C is lower triangular, then LAUUM computes C^H * C. If C is upper triangular in input, then LAUUM computes C*C^H. The output (symmetric) matrix is stored in place of the input triangular matrix.

This is the recursive variant.

Parameters

[in]	uplo	Uplo::Upper: Upper triangle of C is referenced; the strictly lower triangular part of C is not referenced. Uplo::Lower: Lower triangle of C is referenced; the strictly upper triangular part of C is not referenced.
[in,out]	C	n-by-n (upper of lower) (triangular or symmetric) matrix. On entry, the (upper of lower) part of the n-by-n triangular matrix. On exit, the (upper of lower) part of the n-by-n symmetric matrix C^H * C or C * C^H.

Returns

= 0: successful exit

Todo:

: implement nx to bail out of recursion before 1-by-1 case

print_matrix()

template<TLAPACK_MATRIX matrix_t>

void tlapack::print_matrix

(

const matrix_t &

A

)

Prints a matrix a to std::out.

Parameters

A	m by n matrix

rand_helper() [1/2]

template<class T , class Generator >

T tlapack::rand_helper

(

Generator &

gen

)

Helper function to generate random numbers using an uniform distribution in [0,1).

The type of the uniform distribution is T if real_type<T> is either float, double or long double. Otherwise, the uniform distribution will be defined using the type float.

Parameters

[in,out]

gen

Random number generator.

rand_helper() [2/2]

template<class T , class Generator , class Distribution , enable_if_t< is_real< T >, bool > = true>

T tlapack::rand_helper	(	Generator &	gen,
		Distribution &	d
	)

Helper function to generate random numbers.

Parameters

[in,out]	gen	Random number generator.
[in,out]	d	Random distribution.

real()

template<typename T , enable_if_t< is_real< T >, int > = 0>

constexpr real_type< T > tlapack::real ( const T &  x )

constexprnoexcept

Extends std::real() to real datatypes.

Parameters

[in]

x

Real number

Returns

x

Note

std::real() is already defined for real numbers in C++. However, we want a more general definition that works for any real type, not only for the built-in types.

sgn()

template<typename T , enable_if_t< is_real< T >, int > = 0>

constexpr int tlapack::sgn ( const T &  val )

constexpr

Type-safe sgn function.

See also

Source: https://stackoverflow.com/a/4609795/5253097

visualize_matrix()

template<TLAPACK_MATRIX matrix_t>

std::string tlapack::visualize_matrix

(

const matrix_t &

A

)

Constructs a json string representing the matrix for use with vscode-debug-visualizer.

Returns

String containing JSON representation of A

Parameters

A	m by n matrix

visualize_matrix_table()

template<TLAPACK_MATRIX matrix_t>

std::string tlapack::visualize_matrix_table

(

const matrix_t &

A

)

Constructs a json string representing the matrix for use with vscode-debug-visualizer.

Returns

String containing JSON representation of A

Parameters

A	m by n matrix

visualize_matrix_text()

template<TLAPACK_MATRIX matrix_t>

std::string tlapack::visualize_matrix_text

(

const matrix_t &

A

)

Constructs a json string representing the matrix for use with vscode-debug-visualizer.

Returns

String containing JSON representation of A

Parameters

A	m by n matrix

visualize_vector()

template<TLAPACK_VECTOR vector_t>

std::string tlapack::visualize_vector

(

const vector_t &

v

)

Constructs a json string representing the vector for use with vscode-debug-visualizer.

Returns

String containing JSON representation of v

Parameters

v	size n vector