uni20::mplapack Namespace Reference

Functions
void	eigen (std::size_t n, std::span< float80 > a, std::span< complex160 > values, std::span< complex160 > vectors, bool compute_vectors, Precision p)
	Compute unsorted complex eigenvalues and optional right eigenvectors, destroying a.
void	eigen (std::size_t n, std::span< mpcomplex > a, std::span< mpcomplex > values, std::span< mpcomplex > vectors, bool compute_vectors, Precision p)
	Complex counterpart of the packed general eigensystem.
void	eigen (std::size_t n, std::span< mpreal > a, std::span< mpcomplex > values, std::span< mpcomplex > vectors, bool compute_vectors, Precision p)
	Compute unsorted complex eigenvalues and optional right eigenvectors, destroying a.
void	eigh (std::size_t n, std::span< float80 > a, std::span< float80 > values, bool vectors, char triangle, Precision p)
	Compute ascending eigenvalues and optionally overwrite a with eigenvector columns.
void	eigh (std::size_t n, std::span< mpcomplex > a, std::span< mpreal > values, bool vectors, char triangle, Precision p)
	Hermitian counterpart of the packed real self-adjoint eigensystem.
void	eigh (std::size_t n, std::span< mpreal > a, std::span< mpreal > values, bool vectors, char triangle, Precision p)
	Compute ascending eigenvalues and optionally overwrite a with eigenvector columns.
float80	gecon (std::size_t n, std::span< float80 const > a, float80 const &anorm, char norm, Precision p)
	Estimate reciprocal condition from packed successful LU and the original matrix norm.
mpreal	gecon (std::size_t n, std::span< mpcomplex const > a, mpreal const &anorm, char norm, Precision p)
	Estimate reciprocal condition from packed successful LU and the original matrix norm.
mpreal	gecon (std::size_t n, std::span< mpreal const > a, mpreal const &anorm, char norm, Precision p)
	Estimate reciprocal condition from packed successful LU and the original matrix norm.
std::size_t	gelss (std::size_t m, std::size_t n, std::size_t nrhs, std::span< float80 > a, std::span< float80 > b, std::span< float80 > values, float80 const &cutoff, std::size_t &rank, Precision p)
	Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.
std::size_t	gelss (std::size_t m, std::size_t n, std::size_t nrhs, std::span< mpcomplex > a, std::span< mpcomplex > b, std::span< mpreal > values, mpreal const &cutoff, std::size_t &rank, Precision p)
	Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.
std::size_t	gelss (std::size_t m, std::size_t n, std::size_t nrhs, std::span< mpreal > a, std::span< mpreal > b, std::span< mpreal > values, mpreal const &cutoff, std::size_t &rank, Precision p)
	Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.
void	gemm (std::size_t m, std::size_t n, std::size_t k, complex160 const &alpha, std::span< complex160 const > a, std::span< complex160 const > b, complex160 const &beta, std::span< complex160 > c)
	Complex binary80 counterpart of the packed GEMM adapter.
void	gemm (std::size_t m, std::size_t n, std::size_t k, float80 const &alpha, std::span< float80 const > a, std::span< float80 const > b, float80 const &beta, std::span< float80 > c)
	Packed column-major binary80 GEMM; provider representations stay private.
void	gemm (std::size_t m, std::size_t n, std::size_t k, mpcomplex const &alpha, std::span< mpcomplex const > a, std::span< mpcomplex const > b, mpcomplex const &beta, std::span< mpcomplex > c, Precision p)
	Complex counterpart of the packed real GEMM adapter.
void	gemm (std::size_t m, std::size_t n, std::size_t k, mpreal const &alpha, std::span< mpreal const > a, std::span< mpreal const > b, mpreal const &beta, std::span< mpreal > c, Precision p)
	Multiply packed column-major Uni20 real arrays at explicit precision.
std::size_t	getrf (std::size_t n, std::span< float80 > a, std::vector< std::size_t > &pivots)
	Factor a square binary80 matrix, returning zero or a one-based singular pivot.
std::size_t	getrf (std::size_t n, std::span< mpcomplex > a, std::vector< std::size_t > &pivots, Precision p)
	Complex counterpart of the packed real LU factorization adapter.
std::size_t	getrf (std::size_t n, std::span< mpreal > a, std::vector< std::size_t > &pivots, Precision p)
	Factor a packed square matrix, returning zero or a one-based singular pivot.
void	getrs (std::size_t n, std::size_t nrhs, std::span< float80 const > a, std::span< std::size_t const > pivots, std::span< float80 > b)
	Solve from read-only binary80 LU factors and zero-based pivots.
void	getrs (std::size_t n, std::size_t nrhs, std::span< mpcomplex const > a, std::span< std::size_t const > pivots, std::span< mpcomplex > b, Precision p)
	Complex counterpart of the packed real LU solve adapter.
void	getrs (std::size_t n, std::size_t nrhs, std::span< mpreal const > a, std::span< std::size_t const > pivots, std::span< mpreal > b, Precision p)
	Solve from packed LU factors and zero-based pivots, overwriting the RHS array.
void	lq (std::size_t m, std::size_t n, std::span< float80 > a, std::span< float80 > q, std::span< float80 > triangular, Precision p)
	Overwrite m-by-n input work and return Q (k-by-n) and L (m-by-k), k=min(m,n).
void	lq (std::size_t m, std::size_t n, std::span< mpcomplex > a, std::span< mpcomplex > q, std::span< mpcomplex > triangular, Precision p)
	Complex LQ counterpart, with unitary rows in Q.
void	lq (std::size_t m, std::size_t n, std::span< mpreal > a, std::span< mpreal > q, std::span< mpreal > triangular, Precision p)
	Overwrite m-by-n input work and return Q (k-by-n) and L (m-by-k), k=min(m,n).
void	qr (std::size_t m, std::size_t n, std::span< float80 > a, std::span< float80 > q, std::span< float80 > triangular, Precision p)
	Overwrite m-by-n input work and return Q (m-by-k) and R (k-by-n), k=min(m,n).
void	qr (std::size_t m, std::size_t n, std::span< mpcomplex > a, std::span< mpcomplex > q, std::span< mpcomplex > triangular, Precision p)
	Complex QR counterpart, with unitary columns in Q.
void	qr (std::size_t m, std::size_t n, std::span< mpreal > a, std::span< mpreal > q, std::span< mpreal > triangular, Precision p)
	Overwrite m-by-n input work and return Q (m-by-k) and R (k-by-n), k=min(m,n).
void	svd (std::size_t m, std::size_t n, std::span< float80 > a, std::span< float80 > values, std::span< float80 > u, std::span< float80 > vh, char jobu, char jobvt, Precision p)
	Compute descending singular values and requested U/Vh factors, destroying a.
void	svd (std::size_t m, std::size_t n, std::span< mpcomplex > a, std::span< mpreal > values, std::span< mpcomplex > u, std::span< mpcomplex > vh, char jobu, char jobvt, Precision p)
	Complex SVD counterpart; Vh is the conjugate transpose of V.
void	svd (std::size_t m, std::size_t n, std::span< mpreal > a, std::span< mpreal > values, std::span< mpreal > u, std::span< mpreal > vh, char jobu, char jobvt, Precision p)
	Compute descending singular values and requested U/Vh factors, destroying a.

Function Documentation

eigen() [1/3]

void uni20::mplapack::eigen	(	std::size_t	n,
		std::span< float80 >	a,
		std::span< complex160 >	values,
		std::span< complex160 >	vectors,
		bool	compute_vectors,
		Precision	p
	)

Compute unsorted complex eigenvalues and optional right eigenvectors, destroying a.

Real conjugate pairs are unpacked into complex vector columns. The vector span is n-by-n when requested and empty otherwise.

eigen() [2/3]

void uni20::mplapack::eigen	(	std::size_t	n,
		std::span< mpcomplex >	a,
		std::span< mpcomplex >	values,
		std::span< mpcomplex >	vectors,
		bool	compute_vectors,
		Precision	p
	)

Complex counterpart of the packed general eigensystem.

eigen() [3/3]

void uni20::mplapack::eigen	(	std::size_t	n,
		std::span< mpreal >	a,
		std::span< mpcomplex >	values,
		std::span< mpcomplex >	vectors,
		bool	compute_vectors,
		Precision	p
	)

Compute unsorted complex eigenvalues and optional right eigenvectors, destroying a.

Real conjugate pairs are unpacked into complex vector columns. The vector span is n-by-n when requested and empty otherwise.

eigh() [1/3]

void uni20::mplapack::eigh	(	std::size_t	n,
		std::span< float80 >	a,
		std::span< float80 >	values,
		bool	vectors,
		char	triangle,
		Precision	p
	)

Compute ascending eigenvalues and optionally overwrite a with eigenvector columns.

The caller supplies an n-by-n matrix and n values. Triangle is 'U' or 'L'.

eigh() [2/3]

void uni20::mplapack::eigh	(	std::size_t	n,
		std::span< mpcomplex >	a,
		std::span< mpreal >	values,
		bool	vectors,
		char	triangle,
		Precision	p
	)

Hermitian counterpart of the packed real self-adjoint eigensystem.

eigh() [3/3]

void uni20::mplapack::eigh	(	std::size_t	n,
		std::span< mpreal >	a,
		std::span< mpreal >	values,
		bool	vectors,
		char	triangle,
		Precision	p
	)

Compute ascending eigenvalues and optionally overwrite a with eigenvector columns.

The caller supplies an n-by-n matrix and n values. Triangle is 'U' or 'L'.

gecon() [1/3]

float80 uni20::mplapack::gecon	(	std::size_t	n,
		std::span< float80 const >	a,
		float80 const &	anorm,
		char	norm,
		Precision	p
	)

Estimate reciprocal condition from packed successful LU and the original matrix norm.

Norm is '1' or 'I'; returns one for an empty matrix. Factors are preserved.

gecon() [2/3]

mpreal uni20::mplapack::gecon	(	std::size_t	n,
		std::span< mpcomplex const >	a,
		mpreal const &	anorm,
		char	norm,
		Precision	p
	)

Estimate reciprocal condition from packed successful LU and the original matrix norm.

Norm is '1' or 'I'; returns one for an empty matrix. Factors are preserved.

gecon() [3/3]

mpreal uni20::mplapack::gecon	(	std::size_t	n,
		std::span< mpreal const >	a,
		mpreal const &	anorm,
		char	norm,
		Precision	p
	)

Estimate reciprocal condition from packed successful LU and the original matrix norm.

Norm is '1' or 'I'; returns one for an empty matrix. Factors are preserved.

gelss() [1/3]

std::size_t uni20::mplapack::gelss	(	std::size_t	m,
		std::size_t	n,
		std::size_t	nrhs,
		std::span< float80 >	a,
		std::span< float80 >	b,
		std::span< float80 >	values,
		float80 const &	cutoff,
		std::size_t &	rank,
		Precision	p
	)

Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.

Returns zero on success or a positive nonconvergence count. Rank and outputs are published only on success. Requires nonzero m and n.

gelss() [2/3]

std::size_t uni20::mplapack::gelss	(	std::size_t	m,
		std::size_t	n,
		std::size_t	nrhs,
		std::span< mpcomplex >	a,
		std::span< mpcomplex >	b,
		std::span< mpreal >	values,
		mpreal const &	cutoff,
		std::size_t &	rank,
		Precision	p
	)

Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.

Returns zero on success or a positive nonconvergence count. Rank and outputs are published only on success. Requires nonzero m and n.

gelss() [3/3]

std::size_t uni20::mplapack::gelss	(	std::size_t	m,
		std::size_t	n,
		std::size_t	nrhs,
		std::span< mpreal >	a,
		std::span< mpreal >	b,
		std::span< mpreal >	values,
		mpreal const &	cutoff,
		std::size_t &	rank,
		Precision	p
	)

Packed GELSS; B has max(m,n) rows, values has min(m,n) entries.

Returns zero on success or a positive nonconvergence count. Rank and outputs are published only on success. Requires nonzero m and n.

gemm() [1/4]

void uni20::mplapack::gemm	(	std::size_t	m,
		std::size_t	n,
		std::size_t	k,
		complex160 const &	alpha,
		std::span< complex160 const >	a,
		std::span< complex160 const >	b,
		complex160 const &	beta,
		std::span< complex160 >	c
	)

Complex binary80 counterpart of the packed GEMM adapter.

gemm() [2/4]

void uni20::mplapack::gemm	(	std::size_t	m,
		std::size_t	n,
		std::size_t	k,
		float80 const &	alpha,
		std::span< float80 const >	a,
		std::span< float80 const >	b,
		float80 const &	beta,
		std::span< float80 >	c
	)

Packed column-major binary80 GEMM; provider representations stay private.

Sizes must match the dimensions. Zero coefficients preserve BLAS no-read semantics. Conversion preserves the native x87 value exactly.

gemm() [3/4]

void uni20::mplapack::gemm	(	std::size_t	m,
		std::size_t	n,
		std::size_t	k,
		mpcomplex const &	alpha,
		std::span< mpcomplex const >	a,
		std::span< mpcomplex const >	b,
		mpcomplex const &	beta,
		std::span< mpcomplex >	c,
		Precision	p
	)

Complex counterpart of the packed real GEMM adapter.

gemm() [4/4]

void uni20::mplapack::gemm	(	std::size_t	m,
		std::size_t	n,
		std::size_t	k,
		mpreal const &	alpha,
		std::span< mpreal const >	a,
		std::span< mpreal const >	b,
		mpreal const &	beta,
		std::span< mpreal >	c,
		Precision	p
	)

Multiply packed column-major Uni20 real arrays at explicit precision.

Provider objects and ambient precision are confined to the implementation. The call never suspends or hands off work. Array sizes must match the dimensions.

getrf() [1/3]

std::size_t uni20::mplapack::getrf	(	std::size_t	n,
		std::span< float80 >	a,
		std::vector< std::size_t > &	pivots
	)

Factor a square binary80 matrix, returning zero or a one-based singular pivot.

Pivot output is a zero-based row-swap sequence; a is overwritten.

getrf() [2/3]

std::size_t uni20::mplapack::getrf	(	std::size_t	n,
		std::span< mpcomplex >	a,
		std::vector< std::size_t > &	pivots,
		Precision	p
	)

Complex counterpart of the packed real LU factorization adapter.

getrf() [3/3]

std::size_t uni20::mplapack::getrf	(	std::size_t	n,
		std::span< mpreal >	a,
		std::vector< std::size_t > &	pivots,
		Precision	p
	)

Factor a packed square matrix, returning zero or a one-based singular pivot.

Pivot vectors contain zero-based row indices and are reusable by GETRS at the same precision. The coefficient array is overwritten with LU data.

getrs() [1/3]

void uni20::mplapack::getrs	(	std::size_t	n,
		std::size_t	nrhs,
		std::span< float80 const >	a,
		std::span< std::size_t const >	pivots,
		std::span< float80 >	b
	)

Solve from read-only binary80 LU factors and zero-based pivots.

getrs() [2/3]

void uni20::mplapack::getrs	(	std::size_t	n,
		std::size_t	nrhs,
		std::span< mpcomplex const >	a,
		std::span< std::size_t const >	pivots,
		std::span< mpcomplex >	b,
		Precision	p
	)

Complex counterpart of the packed real LU solve adapter.

getrs() [3/3]

void uni20::mplapack::getrs	(	std::size_t	n,
		std::size_t	nrhs,
		std::span< mpreal const >	a,
		std::span< std::size_t const >	pivots,
		std::span< mpreal >	b,
		Precision	p
	)

Solve from packed LU factors and zero-based pivots, overwriting the RHS array.

lq() [1/3]

void uni20::mplapack::lq	(	std::size_t	m,
		std::size_t	n,
		std::span< float80 >	a,
		std::span< float80 >	q,
		std::span< float80 >	triangular,
		Precision	p
	)

Overwrite m-by-n input work and return Q (k-by-n) and L (m-by-k), k=min(m,n).

lq() [2/3]

void uni20::mplapack::lq	(	std::size_t	m,
		std::size_t	n,
		std::span< mpcomplex >	a,
		std::span< mpcomplex >	q,
		std::span< mpcomplex >	triangular,
		Precision	p
	)

Complex LQ counterpart, with unitary rows in Q.

lq() [3/3]

void uni20::mplapack::lq	(	std::size_t	m,
		std::size_t	n,
		std::span< mpreal >	a,
		std::span< mpreal >	q,
		std::span< mpreal >	triangular,
		Precision	p
	)

Overwrite m-by-n input work and return Q (k-by-n) and L (m-by-k), k=min(m,n).

qr() [1/3]

void uni20::mplapack::qr	(	std::size_t	m,
		std::size_t	n,
		std::span< float80 >	a,
		std::span< float80 >	q,
		std::span< float80 >	triangular,
		Precision	p
	)

Overwrite m-by-n input work and return Q (m-by-k) and R (k-by-n), k=min(m,n).

qr() [2/3]

void uni20::mplapack::qr	(	std::size_t	m,
		std::size_t	n,
		std::span< mpcomplex >	a,
		std::span< mpcomplex >	q,
		std::span< mpcomplex >	triangular,
		Precision	p
	)

Complex QR counterpart, with unitary columns in Q.

qr() [3/3]

void uni20::mplapack::qr	(	std::size_t	m,
		std::size_t	n,
		std::span< mpreal >	a,
		std::span< mpreal >	q,
		std::span< mpreal >	triangular,
		Precision	p
	)

Overwrite m-by-n input work and return Q (m-by-k) and R (k-by-n), k=min(m,n).

svd() [1/3]

void uni20::mplapack::svd	(	std::size_t	m,
		std::size_t	n,
		std::span< float80 >	a,
		std::span< float80 >	values,
		std::span< float80 >	u,
		std::span< float80 >	vh,
		char	jobu,
		char	jobvt,
		Precision	p
	)

Compute descending singular values and requested U/Vh factors, destroying a.

Jobs are 'A' (full), 'S' (reduced), 'N' (omitted) or 'O' (overwrite a). At most one factor may overwrite a. An omitted or overwritten factor has an empty span; other spans must have their exact logical sizes.

svd() [2/3]

void uni20::mplapack::svd	(	std::size_t	m,
		std::size_t	n,
		std::span< mpcomplex >	a,
		std::span< mpreal >	values,
		std::span< mpcomplex >	u,
		std::span< mpcomplex >	vh,
		char	jobu,
		char	jobvt,
		Precision	p
	)

Complex SVD counterpart; Vh is the conjugate transpose of V.

svd() [3/3]

void uni20::mplapack::svd	(	std::size_t	m,
		std::size_t	n,
		std::span< mpreal >	a,
		std::span< mpreal >	values,
		std::span< mpreal >	u,
		std::span< mpreal >	vh,
		char	jobu,
		char	jobvt,
		Precision	p
	)

Compute descending singular values and requested U/Vh factors, destroying a.

Jobs are 'A' (full), 'S' (reduced), 'N' (omitted) or 'O' (overwrite a). At most one factor may overwrite a. An omitted or overwritten factor has an empty span; other spans must have their exact logical sizes.