tatooine::lapack Namespace Reference

Enumerations
enum class	sides : char { left = 'L' , right = 'R' , both = 'B' }
enum class	job : char {   no_vec = 'N' , vec = 'V' , update_vec = 'U' , all_vec = 'A' ,   some_vec = 'S' , overwrite_vec = 'O' , compact_vec = 'P' , some_vec_tol = 'C' ,   vec_jacobi = 'J' , workspace = 'W' }
enum class	norm : char {   one = '1' , two = '2' , inf = 'I' , fro = 'F' ,   max = 'M' }
enum class	job_schur : char { eigenvalues = 'E' , schur = 'S' }
enum class	sort { not_sorted = 'N' , sorted = 'S' }
enum class	range { all = 'A' , value = 'V' , index = 'I' }
enum class	vect { q = 'Q' , p = 'P' , none = 'N' , both = 'B' }
enum class	direction { forward = 'F' , backward = 'B' }
enum class	store_v { column_wise = 'C' , row_wise = 'R' }
enum class	matrix_type {   general = 'G' , lower = 'L' , upper = 'U' , hessenberg = 'H' ,   lower_band = 'B' , upper_band = 'Q' , band = 'Z' }
enum class	how_many { all = 'A' , backtransform = 'B' , select = 'S' }
enum class	equed {   none = 'N' , row = 'R' , col = 'C' , both = 'B' ,   yes = 'Y' }
enum class	factored { factored = 'F' , notFactored = 'N' , equilibrate = 'E' }
enum class	sense { none = 'N' , eigenvalues = 'E' , subspace = 'V' , both = 'B' }
enum class	job_cond { eigen_vec = 'E' , left_singular_vec = 'L' , right_singular_vec = 'R' }
enum class	balance { none = 'N' , permute = 'P' , scale = 'S' , both = 'B' }
enum class	order { block = 'B' , entire = 'E' }
enum class	row_col { col = 'C' , row = 'R' }

Functions
template<std::floating_point Float>
auto	geev (job JOBVL, job JOBVR, int N, Float *A, int LDA, Float *WR, Float *WI, Float *VL, int LDVL, Float *VR, int LDVR, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	geev (job const JOBVL, job const JOBVR, int N, Float *A, int LDA, Float *WR, Float *WI, Float *VL, int LDVL, Float *VR, int LDVR) -> int
template<std::floating_point Float>
auto	geev (job JOBVL, job JOBVR, int N, Float *A, int LDA, std::complex< Float > *W, Float *VL, int LDVL, Float *VR, int LDVR, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	geev (job const JOBVL, job const JOBVR, int N, Float *A, int LDA, std::complex< Float > *W, Float *VL, int LDVL, Float *VR, int LDVR) -> int
template<std::floating_point Float, size_t N>
auto	geev (tensor< Float, N, N > &A, tensor< std::complex< Float >, N > &W)
template<std::floating_point Float, size_t N>
auto	geev_left (tensor< Float, N, N > &A, tensor< std::complex< Float >, N > &W, tensor< Float, N, N > &VL)
template<std::floating_point Float, size_t N>
auto	geev_right (tensor< Float, N, N > &A, tensor< std::complex< Float >, N > &W, tensor< Float, N, N > &VR)
template<std::floating_point Float, size_t N>
auto	geev (tensor< Float, N, N > &A, tensor< std::complex< Float >, N > &W, tensor< Float, N, N > &VL, tensor< Float, N, N > &VR)
template<std::floating_point Float>
auto	geqrf (int M, int N, Float *A, int LDA, Float *TAU, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	geqrf (int M, int N, Float *A, int LDA, Float *TAU) -> int
template<typename T , size_t M, size_t N>
auto	geqrf (tensor< T, M, N > &A, tensor< T,(M< N) ? M :N > &tau)
template<typename T >
auto	geqrf (tensor< T > &A, tensor< T > &tau)
template<std::floating_point Float>
auto	gesv (int N, int NRHS, Float *A, int LDA, int *IPIV, Float *B, int LDB) -> int
template<typename T , size_t N>
auto	gesv (tensor< T, N, N > &A, tensor< T, N > &b, tensor< int, N > &ipiv)
template<typename T , size_t N, size_t K>
auto	gesv (tensor< T, N, N > &A, tensor< T, N, K > &B, tensor< int, N > &ipiv)
template<typename T >
auto	gesv (tensor< T > &A, tensor< T > &B, tensor< int > &ipiv)
template<std::floating_point Float>
auto	getrf (int M, int N, double *A, int LDA, int *IPIV) -> int
template<typename T , size_t M, size_t N>
auto	getrf (tensor< T, M, N > &A, tensor< int, tatooine::min(M, N)> &p)
template<std::floating_point Float>
auto	lange (norm n, int M, int N, Float *A, int LDA, Float *WORK) -> Float
template<std::floating_point Float>
auto	lange (norm n, int M, int N, Float *A, int LDA) -> Float
template<typename T , size_t M, size_t N>
auto	lange (tensor< T, M, N > &A, norm n)
template<std::floating_point Float>
auto	ormqr (side SIDE, op TRANS, int M, int N, int K, Float *A, int LDA, Float *TAU, Float *C, int LDC, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	ormqr (side SIDE, op TRANS, int M, int N, int K, Float *A, int LDA, Float *TAU, Float *C, int LDC) -> int
template<typename T , size_t K, size_t M>
auto	ormqr (tensor< T, M, K > &A, tensor< T, M > &c, tensor< T, K > &tau, side const s, op trans)
template<typename T , size_t K, size_t M, size_t N>
auto	ormqr (tensor< T, M, K > &A, tensor< T, M, N > &C, tensor< T, K > &tau, side const s, op trans)
template<typename T >
auto	ormqr (tensor< T > &A, tensor< T > &C, tensor< T > &tau, side const s, op trans)
template<std::floating_point Float>
auto	syev (job j, uplo u, int N, Float *A, int LDA, Float *W, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	syev (job j, uplo u, int N, Float *A, int LDA, Float *W) -> int
template<typename Real , size_t N>
auto	syev (job jobz, uplo const u, tensor< Real, N, N > &A, tensor< Real, N > &W)
template<std::floating_point Float>
auto	sysv (uplo u, int N, int NRHS, Float *A, int LDA, int *IPIV, Float *B, int LDB, Float *WORK, int LWORK) -> int
template<std::floating_point Float>
auto	sysv (uplo u, int N, int NRHS, Float *A, int LDA, int *IPIV, Float *B, int LDB) -> int
template<std::floating_point Float, size_t N>
auto	sysv (tensor< Float, N, N > &A, tensor< Float, N > &b, uplo const u)
template<std::floating_point Float>
auto	sysv (tensor< Float > &A, tensor< Float > &B, uplo const u)
template<std::floating_point Float>
auto	trtrs (uplo u, op t, diag d, int N, int NRHS, Float *A, int LDA, Float *B, int LDB) -> int
template<typename T , size_t M, size_t N, size_t NRHS>
auto	trtrs (tensor< T, M, N > &A, tensor< T, M, NRHS > &B, uplo const u, op const t, diag const d)
template<typename T , size_t M, size_t N>
auto	trtrs (tensor< T, M, N > &A, tensor< T, M > &b, uplo const u, op const t, diag const d)
template<typename T >
auto	trtrs (tensor< T > &A, tensor< T > &B, uplo const u, op const t, diag const d)

Enumeration Type Documentation

balance

enum class tatooine::lapack::balance

strong

Enumerator
none
permute
scale
both

direction

enum class tatooine::lapack::direction

strong

Enumerator
forward
backward

equed

enum class tatooine::lapack::equed

strong

Enumerator
none
row
col
both
yes

factored

enum class tatooine::lapack::factored

strong

Enumerator
factored
notFactored
equilibrate

how_many

enum class tatooine::lapack::how_many

strong

Enumerator
all
backtransform
select

job

enum class tatooine::lapack::job : char

strong

Enumerator
no_vec
vec
update_vec
all_vec
some_vec
overwrite_vec
compact_vec
some_vec_tol
vec_jacobi
workspace

job_cond

enum class tatooine::lapack::job_cond

strong

Enumerator
eigen_vec
left_singular_vec
right_singular_vec

job_schur

enum class tatooine::lapack::job_schur : char

strong

Enumerator
eigenvalues
schur

matrix_type

enum class tatooine::lapack::matrix_type

strong

Enumerator
general
lower
upper
hessenberg
lower_band
upper_band
band

norm

enum class tatooine::lapack::norm : char

strong

Enumerator
one
two
inf
fro
max

order

enum class tatooine::lapack::order

strong

Enumerator
block
entire

range

enum class tatooine::lapack::range

strong

Enumerator
all
value
index

row_col

enum class tatooine::lapack::row_col

strong

Enumerator
col
row

sense

enum class tatooine::lapack::sense

strong

Enumerator
none
eigenvalues
subspace
both

sides

enum class tatooine::lapack::sides : char

strong

Enumerator
left
right
both

sort

enum class tatooine::lapack::sort

strong

Enumerator
not_sorted
sorted

store_v

enum class tatooine::lapack::store_v

strong

Enumerator
column_wise
row_wise

vect

enum class tatooine::lapack::vect

strong

Enumerator
q
p
none
both

Function Documentation

geqrf() [1/2]

template<std::floating_point Float>

auto tatooine::lapack::geqrf	(	int	M,
		int	N,
		Float *	A,
		int	LDA,
		Float *	TAU
	)		-> int

geqrf() [2/2]

template<std::floating_point Float>

auto tatooine::lapack::geqrf	(	int	M,
		int	N,
		Float *	A,
		int	LDA,
		Float *	TAU,
		Float *	WORK,
		int	LWORK
	)		-> int

ormqr() [1/2]

template<std::floating_point Float>

auto tatooine::lapack::ormqr	(	side	SIDE,
		op	TRANS,
		int	M,
		int	N,
		int	K,
		Float *	A,
		int	LDA,
		Float *	TAU,
		Float *	C,
		int	LDC
	)		-> int

ormqr() [2/2]

template<std::floating_point Float>

auto tatooine::lapack::ormqr	(	side	SIDE,
		op	TRANS,
		int	M,
		int	N,
		int	K,
		Float *	A,
		int	LDA,
		Float *	TAU,
		Float *	C,
		int	LDC,
		Float *	WORK,
		int	LWORK
	)		-> int

syev() [1/2]

template<std::floating_point Float>

auto tatooine::lapack::syev	(	job	j,
		uplo	u,
		int	N,
		Float *	A,
		int	LDA,
		Float *	W
	)		-> int

syev() [2/2]

template<std::floating_point Float>

auto tatooine::lapack::syev	(	job	j,
		uplo	u,
		int	N,
		Float *	A,
		int	LDA,
		Float *	W,
		Float *	WORK,
		int	LWORK
	)		-> int

trtrs()

template<std::floating_point Float>

auto tatooine::lapack::trtrs	(	uplo	u,
		op	t,
		diag	d,
		int	N,
		int	NRHS,
		Float *	A,
		int	LDA,
		Float *	B,
		int	LDB
	)		-> int