slate Namespace Reference

SLATE's top-level namespace. More...

Namespaces
namespace	device
	GPU device implementations of kernels.
namespace	func
	A set of functions useful in SLATE's "lambda" constructors.
namespace	impl
	Namespace used for target implementations.
namespace	internal
	Namespace used for SLATE internal implementation.
namespace	work
	Namespace used for SLATE actual work implementation.

Classes
class	BandMatrix
	General banded, non-symmetric, m-by-n, distributed, tiled matrices. More...
class	BaseBandMatrix
	Base class for all SLATE distributed, tiled banded storage matrices. More...
class	BaseMatrix
	Base class for all SLATE distributed, tiled matrices. More...
class	BaseTrapezoidMatrix
	Base class for all SLATE distributed, tiled trapezoidal storage matrices. More...
class	BaseTriangularBandMatrix
	Triangular banded, n-by-n, distributed, tiled matrices. More...
class	Debug
	Slate::Debug - helper class used for debugging during development. More...
class	Exception
	Base class for SLATE exceptions. More...
class	FalseConditionException
	Exception class for slate_assert(). More...
class	HermitianBandMatrix
	Hermitian banded, n-by-n, distributed, tiled matrices. More...
class	HermitianMatrix
	Hermitian, n-by-n, distributed, tiled matrices. More...
struct	is_complex
	True if T is std::complex<T2> for some type T2. More...
class	LockGuard
	Constructor acquires lock; destructor releases lock. More...
class	Matrix
	General non-symmetric, m-by-n, distributed, tiled matrices. More...
class	MatrixStorage
	Slate::MatrixStorage class Used to store the map of distributed tiles. More...
class	Memory
	Allocates workspace blocks for host and GPU devices. More...
class	mpi_type
	Gives mpi_type based on actual scalar_t. More...
class	MpiException
	Exception class for slate_mpi_call(). More...
class	NotImplemented
	Exception class for slate_not_implemented(). More...
class	OmpSetMaxActiveLevels
	Constructor ensures that OpenMP max-active-levels-var ICV has a minimum value; destructor resets original value. More...
class	OptionValue
	Values for options to pass to SLATE routines. More...
class	SymmetricMatrix
	Symmetric, n-by-n, distributed, tiled matrices. More...
class	Tile
	Tile holding an mb-by-nb matrix, with leading dimension (stride). More...
class	Timer
	Simple class around wall-clock timer; currently uses MPI_Wtime. More...
class	TrapezoidMatrix
	Trapezoid, n-by-n, distributed, tiled matrices. More...
class	TriangularBandMatrix
	Triangular banded, n-by-n, distributed, tiled matrices. More...
class	TriangularMatrix
	Triangular, n-by-n, distributed, tiled matrices. More...
class	TrueConditionException
	Exception class for slate_error_if(). More...

Typedefs
typedef short	MOSI_State
template<typename scalar_t >
using	TriangularFactors = std::vector< Matrix< scalar_t > >
using	Options = std::map< Option, OptionValue >
using	Value = OptionValue
using	Pivots = std::vector< std::vector< Pivot > >
template<bool B, class T = void>
using	enable_if_t = typename std::enable_if< B, T >::type
using	llong = long long

Enumerations
enum class	Target : char {   Target::Host = 'H' , Target::HostTask = 'T' , Target::HostNest = 'N' , Target::HostBatch = 'B' ,   Target::Devices = 'D' }
	Location and method of computation. More...
enum class	MethodTrsm : char {   Auto = '*' , A = 'A' , B = 'B' , TrsmA = 'A' ,   TrsmB = 'B' }
	Algorithm to use for triangular solve (trsm). More...
enum class	MethodGemm : char {   Auto = '*' , A = 'A' , C = 'C' , GemmA = 'A' ,   GemmC = 'C' }
	Algorithm to use for general matrix multiply (gemm). More...
enum class	MethodHemm : char {   Auto = '*' , A = 'A' , C = 'C' , HemmA = 'A' ,   HemmC = 'C' }
	Algorithm to use for Hermitian matrix multiply (hemm). More...
enum class	MethodCholQR : char {   Auto = '*' , GemmA = 'A' , GemmC = 'C' , HerkA = 'R' ,   HerkC = 'K' }
	Algorithm to use for Cholesky QR. More...
enum class	MethodGels : char {   Auto = '*' , QR = 'Q' , CholQR = 'C' , Geqrf = 'Q' ,   Cholqr = 'C' }
	Algorithm to use for least squares (gels). More...
enum class	MethodLU : char {   Auto = '*' , PartialPiv = 'P' , CALU = 'C' , NoPiv = 'N' ,   RBT = 'R' , BEAM = 'B' }
	Algorithm to use for LU factorization and solve. More...
enum class	MethodEig : char {   Auto = '*' , QR = 'Q' , DC = 'D' , Bisection = 'B' ,   MRRR = 'M' }
	Algorithm to use for eigenvalues (eig). More...
enum class	MethodSVD : char { Auto = '*' , QR = 'Q' , DC = 'D' , Bisection = 'B' }
	Algorithm to use for singular value decomposition (SVD). More...
enum class	Option : char {   Option::ChunkSize , Option::Lookahead , Option::BlockSize , Option::InnerBlocking ,   Option::MaxPanelThreads , Option::Tolerance , Option::Target , Option::HoldLocalWorkspace ,   Option::Depth , Option::MaxIterations , Option::UseFallbackSolver , Option::PivotThreshold ,   Option::PrintVerbose = 50 , Option::PrintEdgeItems , Option::PrintWidth , Option::PrintPrecision ,   Option::MethodCholQR = 60 , Option::MethodEig , Option::MethodGels , Option::MethodGemm ,   Option::MethodHemm , Option::MethodLU , Option::MethodTrsm , Option::MethodSVD }
	Keys for options to pass to SLATE routines. More...
enum class	LayoutConvert : char { LayoutConvert::ColMajor = 'C' , LayoutConvert::RowMajor = 'R' , LayoutConvert::None = 'N' }
	To convert matrix between column-major and row-major. More...
enum class	NormScope : char { NormScope::Columns = 'C' , NormScope::Rows = 'R' , NormScope::Matrix = 'M' }
	Whether computing matrix norm, column norms, or row norms. More...
enum class	GridOrder : char { GridOrder::Col = 'C' , GridOrder::Row = 'R' , GridOrder::Unknown = 'U' }
	Order to map MPI processes to tile grid. More...
enum	MOSI { Modified = 0x100 , OnHold = 0x1000 , Shared = 0x010 , Invalid = 0x001 }
	A tile state in the MOSI coherency protocol. More...
enum class	TileKind : char { TileKind::Workspace = 'w' , TileKind::SlateOwned = 'o' , TileKind::UserOwned = 'u' }
	Whether a tile is workspace or origin (local non-workspace), and who owns (allocated, deallocates) the data. More...
enum	Fields { Field_Kind = 0x01 , Field_MOSI = 0x02 , Field_Layout = 0x04 , Field_Buffer = 0x08 }
enum class	Origin : char { Host = 'H' , ScaLAPACK = 'S' , Devices = 'D' }

Functions
template<typename scalar_t >
void	swap (BandMatrix< scalar_t > &A, BandMatrix< scalar_t > &B)
	Swap contents of band matrices A and B.
template<typename scalar_t >
void	swap (BaseBandMatrix< scalar_t > &A, BaseBandMatrix< scalar_t > &B)
	Swap contents of band matrices A and B.
template<typename scalar_t >
void	swap (BaseMatrix< scalar_t > &A, BaseMatrix< scalar_t > &B)
	Swap contents of matrices A and B.
template<typename scalar_t >
void	swap (BaseTrapezoidMatrix< scalar_t > &A, BaseTrapezoidMatrix< scalar_t > &B)
	Swap contents of matrices A and B.
template<typename scalar_t >
void	swap (BaseTriangularBandMatrix< scalar_t > &A, BaseTriangularBandMatrix< scalar_t > &B)
	Swap contents of band matrices A and B.
const char *	to_c_string (MethodTrsm value)
std::string	to_string (MethodTrsm value)
void	from_string (std::string const &str, MethodTrsm *val)
const char *	to_c_string (MethodGemm value)
std::string	to_string (MethodGemm value)
void	from_string (std::string const &str, MethodGemm *val)
const char *	to_c_string (MethodHemm value)
std::string	to_string (MethodHemm value)
void	from_string (std::string const &str, MethodHemm *val)
const char *	to_c_string (MethodCholQR value)
std::string	to_string (MethodCholQR value)
void	from_string (std::string const &str, MethodCholQR *val)
const char *	to_c_string (MethodGels value)
std::string	to_string (MethodGels value)
void	from_string (std::string const &str, MethodGels *val)
const char *	to_c_string (MethodLU value)
std::string	to_string (MethodLU value)
void	from_string (std::string const &str, MethodLU *val)
const char *	to_c_string (MethodEig value)
std::string	to_string (MethodEig value)
void	from_string (std::string const &str, MethodEig *val)
const char *	to_c_string (MethodSVD value)
std::string	to_string (MethodSVD value)
void	from_string (std::string const &str, MethodSVD *val)
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::Matrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Sigma, slate::Options const &opts=slate::Options())
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::BaseTrapezoidMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Sigma, slate::Options const &opts=slate::Options())
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Sigma, slate::Options const &opts=slate::Options())
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::Matrix< scalar_t > &A, slate::Options const &opts=slate::Options())
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::BaseTrapezoidMatrix< scalar_t > &A, slate::Options const &opts=slate::Options())
template<typename scalar_t >
void	generate_matrix (MatgenParams &params, slate::HermitianMatrix< scalar_t > &A, slate::Options const &opts=slate::Options())
void	generate_matrix_usage ()
template<typename scalar_t >
void	swap (HermitianBandMatrix< scalar_t > &A, HermitianBandMatrix< scalar_t > &B)
	Swap contents of Hermitian band matrices A and B.
template<typename scalar_t >
void	swap (HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B)
	Swaps contents of matrices A and B.
template<typename real_t >
real_t	max_nan (real_t x, real_t y)
	max that propagates nan consistently:
template<typename scalar_t >
scalar_t	sqr (scalar_t x)
	Square of number.
template<typename real_t >
real_t	sign (real_t val)
	Sign (signum) function.
template<typename real_t >
void	combine_sumsq (real_t &scale1, real_t &sumsq1, real_t scale2, real_t sumsq2)
	Adds two scaled, sum-of-squares representations.
template<typename real_t >
void	add_sumsq (real_t &scale, real_t &sumsq, real_t absx)
	Adds new value to scaled, sum-of-squares representation.
template<typename T >
constexpr T	ceildiv (T x, T y)
template<typename T >
constexpr T	roundup (T x, T y)
float	cabs1 (float x)
double	cabs1 (double x)
float	cabs1 (std::complex< float > x)
double	cabs1 (std::complex< double > x)
int64_t	local2global (int64_t local, int64_t nb, int iproc, int isrcproc, int nprocs)
int64_t	global2local (int64_t global, int64_t nb, int nprocs)
int64_t	num_local_rows_cols (int64_t n, int64_t nb, int iproc, int isrcproc, int nprocs)
	Computes the number of rows or cols of a distributed matrix owned by the process iproc.
template<typename scalar_t >
void	swap (Matrix< scalar_t > &A, Matrix< scalar_t > &B)
	Swap contents of matrices A and B.
template<typename real_t , enable_if_t< std::is_floating_point< real_t >::value > * = nullptr>
int	snprintf_value (char *buf, size_t buf_len, int width, int precision, real_t value)
	Print real value to a buffer buf of length buf_len.
template<typename integer_t , enable_if_t< std::is_integral< integer_t >::value > * = nullptr>
int	snprintf_value (char *buf, size_t buf_len, int width, int precision, integer_t value)
	Overload to print integer values.
template<typename real_t >
int	snprintf_value (char *buf, size_t buf_len, int width, int precision, std::complex< real_t > value)
	Overload to print complex values as " <real> + <imag>i".
template<typename scalar_t >
void	print (const char *label, Tile< scalar_t > &A, blas::Queue &queue, Options const &opts)
	Print a SLATE tile, on either CPU or GPU.
template<typename scalar_t >
void	print (const char *label, Matrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed matrix.
template<typename scalar_t >
void	print (const char *label, BandMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed band matrix.
template<typename scalar_t >
void	print (const char *label, BaseTriangularBandMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed BaseTriangular (triangular, symmetric, and Hermitian) band matrix.
template<typename scalar_t >
void	print (const char *label, HermitianMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed Hermitian matrix.
template<typename scalar_t >
void	print (const char *label, SymmetricMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed symmetric matrix.
template<typename scalar_t >
void	print (const char *label, TrapezoidMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed trapezoid matrix.
template<typename scalar_t >
void	print (const char *label, TriangularMatrix< scalar_t > &A, Options const &opts)
	Print a SLATE distributed triangular matrix.
template<typename scalar_t >
void	print (const char *label, int64_t n, scalar_t const *x, int64_t incx, Options const &opts)
	Print a vector.
template<typename scalar_type >
void	print (const char *label, std::vector< scalar_type > const &x, Options const &opts)
	Print a vector.
template<typename scalar_t >
void	multiply (scalar_t alpha, BandMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, Matrix< scalar_t > &A, HermitianBandMatrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, Matrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	multiply (scalar_t alpha, Matrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	triangular_multiply (scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	triangular_multiply (scalar_t alpha, Matrix< scalar_t > &A, TriangularMatrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	triangular_solve (scalar_t alpha, TriangularBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	triangular_solve (scalar_t alpha, Matrix< scalar_t > &A, TriangularBandMatrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	triangular_solve (scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	triangular_solve (scalar_t alpha, Matrix< scalar_t > &A, TriangularMatrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	rank_k_update (blas::real_type< scalar_t > alpha, Matrix< scalar_t > &A, blas::real_type< scalar_t > beta, HermitianMatrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	rank_k_update (scalar_t alpha, Matrix< scalar_t > &A, scalar_t beta, SymmetricMatrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	rank_2k_update (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, blas::real_type< scalar_t > beta, HermitianMatrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	rank_2k_update (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, SymmetricMatrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	lu_solve (BandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
int64_t	lu_solve (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
int64_t	lu_solve_nopiv (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	lu_factor (BandMatrix< scalar_t > &A, Pivots &pivots, Options const &opts=Options())
template<typename scalar_t >
int64_t	lu_factor (Matrix< scalar_t > &A, Pivots &pivots, Options const &opts=Options())
template<typename scalar_t >
int64_t	lu_factor_nopiv (Matrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
void	lu_solve_using_factor (BandMatrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	lu_solve_using_factor (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	lu_solve_using_factor_nopiv (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	lu_inverse_using_factor (Matrix< scalar_t > &A, Pivots &pivots, Options const &opts=Options())
template<typename scalar_t >
void	lu_inverse_using_factor_out_of_place (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &A_inverse, Options const &opts=Options())
template<typename scalar_t >
blas::real_type< scalar_t >	lu_rcondest_using_factor (Norm in_norm, Matrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts=Options())
template<typename scalar_t >
void	chol_solve (HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
int64_t	chol_solve (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
int64_t	chol_solve (SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
int64_t	chol_factor (HermitianBandMatrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
int64_t	chol_factor (HermitianMatrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
int64_t	chol_factor (SymmetricMatrix< scalar_t > &A, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	chol_solve_using_factor (HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	chol_solve_using_factor (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	chol_solve_using_factor (SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	chol_inverse_using_factor (HermitianMatrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
blas::real_type< scalar_t >	chol_rcondest_using_factor (Norm in_norm, HermitianMatrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts=Options())
template<typename scalar_t >
int64_t	indefinite_solve (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
int64_t	indefinite_solve (SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
int64_t	indefinite_factor (HermitianMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Options const &opts=Options())
template<typename scalar_t >
int64_t	indefinite_factor (SymmetricMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	indefinite_solve_using_factor (HermitianMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	indefinite_solve_using_factor (SymmetricMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	least_squares_solve (Matrix< scalar_t > &A, Matrix< scalar_t > &BX, Options const &opts=Options())
template<typename scalar_t >
void	qr_factor (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Options const &opts=Options())
template<typename scalar_t >
void	qr_multiply_by_q (Side side, Op op, Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	lq_factor (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Options const &opts=Options())
template<typename scalar_t >
void	lq_multiply_by_q (Side side, Op op, Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
blas::real_type< scalar_t >	triangular_rcondest (Norm in_norm, TriangularMatrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts=Options())
template<typename scalar_t >
void	eig_vals (HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
template<typename scalar_t >
void	eig (HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
	Without Z, compute only eigenvalues. Same as eig_vals.
template<typename scalar_t >
void	eig (HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options())
	With Z, compute eigenvalues & eigenvectors.
template<typename scalar_t >
void	eig_vals (SymmetricMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	eig (SymmetricMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	Without Z, compute only eigenvalues. Same as eig_vals.
template<typename scalar_t >
void	eig (SymmetricMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	With Z, compute eigenvalues & eigenvectors.
template<typename scalar_t >
void	eig_vals (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
template<typename scalar_t >
void	eig (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
	Without Z, compute only eigenvalues. Same as eig_vals.
template<typename scalar_t >
void	eig (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options())
	With Z, compute eigenvalues & eigenvectors.
template<typename scalar_t >
void	eig_vals (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	eig (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	Without Z, compute only eigenvalues. Same as eig_vals.
template<typename scalar_t >
void	eig (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	With Z, compute eigenvalues & eigenvectors.
int	version ()
const char *	id ()
template<typename scalar_t >
void	add (scalar_t alpha, Matrix< scalar_t > &A, scalar_t beta, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel general matrix-matrix addition.
template<typename scalar_t >
void	add (scalar_t alpha, BaseTrapezoidMatrix< scalar_t > &A, scalar_t beta, BaseTrapezoidMatrix< scalar_t > &B, Options const &opts)
	Distributed parallel matrix-matrix addition.
template<typename src_matrix_type , typename dst_matrix_type >
void	copy (src_matrix_type &A, dst_matrix_type &B, Options const &opts)
	Copy and precision conversion.
template<typename scalar_t >
void	scale (blas::real_type< scalar_t > numer, blas::real_type< scalar_t > denom, Matrix< scalar_t > &A, Options const &opts)
	Scale matrix entries by the real scalar numer/denom.
template<typename scalar_t >
void	scale (blas::real_type< scalar_t > value, Matrix< scalar_t > &A, Options const &opts=Options())
	General matrix, version with denom = 1.0.
template<typename scalar_t >
void	scale (blas::real_type< scalar_t > numer, blas::real_type< scalar_t > denom, BaseTrapezoidMatrix< scalar_t > &A, Options const &opts)
	Scale matrix entries by the real scalar numer/denom.
template<typename scalar_t >
void	scale (blas::real_type< scalar_t > value, BaseTrapezoidMatrix< scalar_t > &A, Options const &opts=Options())
	BaseTrapezoid matrix, version with denom = 1.0.
template<typename scalar_t , typename scalar_t2 >
void	scale_row_col (Equed equed, std::vector< scalar_t2 > const &R, std::vector< scalar_t2 > const &C, Matrix< scalar_t > &A, Options const &opts)
	Apply row or column scaling, or both, to a Matrix.
template<typename scalar_t >
void	set (scalar_t offdiag_value, scalar_t diag_value, Matrix< scalar_t > &A, Options const &opts)
	Set matrix entries.
template<typename scalar_t >
void	set (scalar_t value, Matrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
void	set (scalar_t offdiag_value, scalar_t diag_value, BaseTrapezoidMatrix< scalar_t > &A, Options const &opts)
	Set matrix entries.
template<typename scalar_t >
void	set (scalar_t value, BaseTrapezoidMatrix< scalar_t > &A, Options const &opts=Options())
template<typename scalar_t >
void	set (std::function< scalar_t(int64_t i, int64_t j) > const &value, Matrix< scalar_t > &A, Options const &opts)
	Set matrix entries.
template<typename scalar_t >
void	set (std::function< scalar_t(int64_t i, int64_t j) > const &value, BaseTrapezoidMatrix< scalar_t > &A, Options const &opts)
	Set matrix entries.
template<typename scalar_t >
void	gerbt (Matrix< scalar_t > &U_in, Matrix< scalar_t > &A, Matrix< scalar_t > &V)
	Applies a 2-sided RBT to the given matrix.
template<typename scalar_t >
void	gerbt (Matrix< scalar_t > &Uin, Matrix< scalar_t > &B)
	Applies a 1-sided RBT to the given matrix on the left.
template<typename scalar_t >
void	gbmm (scalar_t alpha, BandMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel general matrix-matrix multiplication.
template<typename scalar_t >
void	gemm (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel general matrix-matrix multiplication.
template<typename scalar_t >
void	gemmA (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel general matrix-matrix multiplication.
template<typename scalar_t >
void	gemmC (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel general matrix-matrix multiplication.
template<typename scalar_t >
void	hbmm (Side side, scalar_t alpha, HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian banded matrix-matrix multiplication.
template<typename scalar_t >
void	hemm (Side side, scalar_t alpha, HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian matrix-matrix multiplication.
template<typename scalar_t >
void	hemm (Side side, scalar_t alpha, SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	hemmA (Side side, scalar_t alpha, HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian matrix-matrix multiplication.
template<typename scalar_t >
void	hemmC (Side side, scalar_t alpha, HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian matrix-matrix multiplication.
template<typename scalar_t >
void	symm (Side side, scalar_t alpha, SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel symmetric matrix-matrix multiplication.
template<typename scalar_t >
void	symm (Side side, scalar_t alpha, HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, Matrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	trmm (Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	tbsm (Side side, scalar_t alpha, TriangularBandMatrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	tbsm (Side side, scalar_t alpha, TriangularBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular band matrix-matrix solve.
template<typename scalar_t >
void	trsm (Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	trsmA (Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	trsmB (Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	trtri (TriangularMatrix< scalar_t > &A, Options const &opts)
	Distributed parallel inverse of a triangular matrix.
template<typename scalar_t >
void	trtrm (TriangularMatrix< scalar_t > &A, Options const &opts)
	Distributed parallel inverse of a triangular matrix.
template<typename scalar_t >
void	herk (blas::real_type< scalar_t > alpha, Matrix< scalar_t > &A, blas::real_type< scalar_t > beta, HermitianMatrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian rank k update.
template<typename scalar_t >
void	herk (blas::real_type< scalar_t > alpha, Matrix< scalar_t > &A, blas::real_type< scalar_t > beta, SymmetricMatrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	syrk (scalar_t alpha, Matrix< scalar_t > &A, scalar_t beta, SymmetricMatrix< scalar_t > &C, Options const &opts)
	Distributed parallel symmetric rank k update.
template<typename scalar_t >
void	syrk (scalar_t alpha, Matrix< scalar_t > &A, scalar_t beta, HermitianMatrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	her2k (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, blas::real_type< scalar_t > beta, HermitianMatrix< scalar_t > &C, Options const &opts)
	Distributed parallel Hermitian rank 2k update.
template<typename scalar_t >
void	her2k (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, blas::real_type< scalar_t > beta, SymmetricMatrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	redistribute (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Redistribute a matrix A from one distribution into matrix B with another distribution.
template<typename scalar_t >
void	syr2k (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, SymmetricMatrix< scalar_t > &C, Options const &opts)
	Distributed parallel symmetric rank 2k update.
template<typename scalar_t >
void	syr2k (scalar_t alpha, Matrix< scalar_t > &A, Matrix< scalar_t > &B, scalar_t beta, HermitianMatrix< scalar_t > &C, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename matrix_type >
blas::real_type< typename matrix_type::value_type >	norm (Norm in_norm, matrix_type &A, Options const &opts)
	Distributed parallel general matrix norm.
template<typename scalar_t >
blas::real_type< scalar_t >	norm (Norm trnorm, TriangularMatrix< scalar_t > &A, Options const &opts=Options())
template<typename matrix_type >
void	colNorms (Norm in_norm, matrix_type &A, blas::real_type< typename matrix_type::value_type > *values, Options const &opts)
	Distributed parallel matrix norm.
template<typename scalar_t >
int64_t	gbsv (BandMatrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel band LU factorization and solve.
template<typename scalar_t >
int64_t	gesv (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel LU factorization and solve.
template<typename scalar_t >
int64_t	gesv_nopiv (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel LU factorization and solve.
template<typename scalar_t >
int64_t	gesv_mixed (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Matrix< scalar_t > &X, int &iter, Options const &opts=Options())
template<typename scalar_hi , typename scalar_lo >
int64_t	gesv_mixed (Matrix< scalar_hi > &A, Pivots &pivots, Matrix< scalar_hi > &B, Matrix< scalar_hi > &X, int &iter, Options const &opts)
	Distributed parallel iterative-refinement LU factorization and solve.
template<typename scalar_t >
int64_t	gesv_mixed_gmres (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Matrix< scalar_t > &X, int &iter, Options const &opts=Options())
template<typename scalar_hi , typename scalar_lo >
int64_t	gesv_mixed_gmres (Matrix< scalar_hi > &A, Pivots &pivots, Matrix< scalar_hi > &B, Matrix< scalar_hi > &X, int &iter, Options const &opts)
	Distributed parallel GMRES-IR LU factorization and solve.
template<typename scalar_t >
void	gesv_rbt (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Matrix< scalar_t > &X, int &iter, Options const &opts)
	Distributed parallel LU factorization and solve.
template<typename scalar_t >
int64_t	gbtrf (BandMatrix< scalar_t > &A, Pivots &pivots, Options const &opts)
	Distributed parallel band LU factorization.
template<typename scalar_t >
int64_t	getrf (Matrix< scalar_t > &A, Pivots &pivots, Options const &opts)
	Distributed parallel LU factorization.
template<typename scalar_t >
int64_t	getrf_nopiv (Matrix< scalar_t > &A, Options const &opts)
	Distributed parallel LU factorization without pivoting.
template<typename scalar_t >
int64_t	getrf_tntpiv (Matrix< scalar_t > &A, Pivots &pivots, Options const &opts)
	Distributed parallel LU factorization.
template<typename scalar_t >
void	gbtrs (BandMatrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel band LU solve.
template<typename scalar_t >
void	getrs (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel LU solve.
template<typename scalar_t >
void	getrs_nopiv (Matrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options())
template<typename scalar_t >
void	getri (Matrix< scalar_t > &A, Pivots &pivots, Options const &opts)
	Distributed parallel LU inversion.
template<typename scalar_t >
void	getri (Matrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel LU inversion (out-of-place version).
template<typename scalar_t >
int64_t	pbsv (HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Cholesky factorization and solve.
template<typename scalar_t >
int64_t	posv (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Cholesky factorization and solve.
template<typename scalar_t >
int64_t	posv (SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
int64_t	posv_mixed (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Matrix< scalar_t > &X, int &iter, Options const &opts=Options())
template<typename scalar_hi , typename scalar_lo >
int64_t	posv_mixed (HermitianMatrix< scalar_hi > &A, Matrix< scalar_hi > &B, Matrix< scalar_hi > &X, int &iter, Options const &opts)
	Distributed parallel iterative-refinement Cholesky factorization and solve.
template<typename scalar_t >
int64_t	posv_mixed_gmres (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Matrix< scalar_t > &X, int &iter, Options const &opts=Options())
template<typename scalar_hi , typename scalar_lo >
int64_t	posv_mixed_gmres (HermitianMatrix< scalar_hi > &A, Matrix< scalar_hi > &B, Matrix< scalar_hi > &X, int &iter, Options const &opts)
	Distributed parallel GMRES-IR Cholesky factorization and solve.
template<typename scalar_t >
int64_t	pbtrf (HermitianBandMatrix< scalar_t > &A, Options const &opts)
	Distributed parallel band Cholesky factorization.
template<typename scalar_t >
int64_t	potrf (HermitianMatrix< scalar_t > &A, Options const &opts)
	Distributed parallel Cholesky factorization.
template<typename scalar_t >
int64_t	potrf (SymmetricMatrix< scalar_t > &A, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	pbtrs (HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Cholesky solve.
template<typename scalar_t >
void	potrs (HermitianMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Cholesky solve.
template<typename scalar_t >
void	potrs (SymmetricMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	potri (HermitianMatrix< scalar_t > &A, Options const &opts)
	Distributed parallel Cholesky inversion.
template<typename scalar_t >
int64_t	hesv (HermitianMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Hermitian indefinite \(LTL^T\) factorization and solve.
template<typename scalar_t >
int64_t	sysv (SymmetricMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
int64_t	hetrf (HermitianMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Options const &opts)
	Distributed parallel Hermitian indefinite \(LTL^T\) factorization.
template<typename scalar_t >
int64_t	sytrf (SymmetricMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &H, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	hetrs (HermitianMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel Hermitian indefinite \(LTL^T\) solve.
template<typename scalar_t >
void	sytrs (SymmetricMatrix< scalar_t > &A, Pivots &pivots, BandMatrix< scalar_t > &T, Pivots &pivots2, Matrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	gels_qr (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Matrix< scalar_t > &BX, Options const &opts)
	Distributed parallel least squares solve via QR or LQ factorization.
template<typename scalar_t >
void	gels_cholqr (Matrix< scalar_t > &A, Matrix< scalar_t > &R, Matrix< scalar_t > &BX, Options const &opts)
	Distributed parallel least squares solve via CholeskyQR factorization.
template<typename scalar_t >
void	gels (Matrix< scalar_t > &A, Matrix< scalar_t > &BX, Options const &opts)
	Distributed parallel least squares solve via QR or LQ factorization.
template<typename scalar_t >
void	geqrf (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Options const &opts)
	Distributed parallel QR factorization.
template<typename scalar_t >
void	unmqr (Side side, Op op, Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel multiply by \(Q\) from QR factorization.
template<typename scalar_t >
void	cholqr (Matrix< scalar_t > &A, Matrix< scalar_t > &R, Options const &opts)
	Distributed parallel Cholesky QR factorization.
template<typename scalar_t >
void	gelqf (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Options const &opts)
	Distributed parallel LQ factorization.
template<typename scalar_t >
void	unmlq (Side side, Op op, Matrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Matrix< scalar_t > &C, Options const &opts)
	Distributed parallel multiply by \(Q\) from LQ factorization.
template<typename scalar_t >
void	svd (Matrix< scalar_t > A, std::vector< blas::real_type< scalar_t > > &Sigma, Matrix< scalar_t > &U, Matrix< scalar_t > &VT, Options const &opts)
	Distributed parallel matrix singular value decomposition.
template<typename scalar_t >
void	svd (Matrix< scalar_t > A, std::vector< blas::real_type< scalar_t > > &Sigma, Options const &opts=Options())
	Without U and VT, compute only singular values. Same as svd_vals.
template<typename scalar_t >
void	svd_vals (Matrix< scalar_t > A, std::vector< blas::real_type< scalar_t > > &Sigma, Options const &opts=Options())
	Compute only singular values. Same as svd without U and VT.
template<typename scalar_t >
void	gesvd (Matrix< scalar_t > A, std::vector< blas::real_type< scalar_t > > &Sigma, Matrix< scalar_t > &U, Matrix< scalar_t > &VT, Options const &opts=Options())
template<typename scalar_t >
void	gesvd (Matrix< scalar_t > A, std::vector< blas::real_type< scalar_t > > &Sigma, Options const &opts=Options())
	Without U and VT, compute only singular values.
template<typename scalar_t >
void	unmbr_ge2tb (Side side, Op op, Matrix< scalar_t > &A, TriangularFactors< scalar_t > T, Matrix< scalar_t > &C, Options const &opts)
	Multiplies the general m-by-n matrix C by Q from slate::he2hb as follows:
template<typename scalar_t >
void	ge2tb (Matrix< scalar_t > &A, TriangularFactors< scalar_t > &TU, TriangularFactors< scalar_t > &TV, Options const &opts)
	Distributed parallel reduction to band for 3-stage SVD.
template<typename scalar_t >
void	tb2bd (TriangularBandMatrix< scalar_t > &A, Matrix< scalar_t > &U, Matrix< scalar_t > &V, Options const &opts)
	Reduces a band matrix to a bidiagonal matrix using bulge chasing.
template<typename scalar_t >
void	bdsqr (Job jobu, Job jobvt, std::vector< blas::real_type< scalar_t > > &D, std::vector< blas::real_type< scalar_t > > &E, Matrix< scalar_t > &U, Matrix< scalar_t > &VT, Options const &opts=Options())
template<typename scalar_t >
void	heev (HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts)
	Distributed parallel Hermitian matrix eigen decomposition.
template<typename scalar_t >
void	heev (HermitianMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
	Without Z, compute only eigenvalues.
template<typename scalar_t >
void	syev (SymmetricMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	syev (SymmetricMatrix< scalar_t > &A, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	Without Z, compute only eigenvalues.
template<typename scalar_t >
void	hegv (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts)
	Distributed parallel computation of all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite eigenproblem, of the form:
template<typename scalar_t >
void	hegv (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options())
template<typename scalar_t >
void	sygv (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Matrix< scalar_t > &Z, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	sygv (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, std::vector< blas::real_type< scalar_t > > &Lambda, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
	Without Z, compute only eigenvalues.
template<typename scalar_t >
void	hegst (int64_t itype, HermitianMatrix< scalar_t > &A, HermitianMatrix< scalar_t > &B, Options const &opts)
	Distributed parallel reduction of a complex Hermitian positive-definite generalized eigenvalue problem to the standard form.
template<typename scalar_t >
void	sygst (int64_t itype, SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B, Options const &opts=Options(), enable_if_t< ! is_complex< scalar_t >::value > *=nullptr)
template<typename scalar_t >
void	he2hb (HermitianMatrix< scalar_t > &A, TriangularFactors< scalar_t > &T, Options const &opts)
	Distributed parallel reduction to band for 3-stage SVD.
template<typename scalar_t >
void	unmtr_he2hb (Side side, Op op, HermitianMatrix< scalar_t > &A, TriangularFactors< scalar_t > T, Matrix< scalar_t > &C, Options const &opts)
	Multiplies the general m-by-n matrix C by Q from slate::he2hb as follows:
template<typename scalar_t >
void	hb2st (HermitianBandMatrix< scalar_t > &A, Matrix< scalar_t > &V, Options const &opts)
	Reduces a band Hermitian matrix to a bidiagonal matrix using bulge chasing.
template<typename scalar_t >
void	unmtr_hb2st (Side side, Op op, Matrix< scalar_t > &V, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename real_t >
void	stedc (std::vector< real_t > &D, std::vector< real_t > &E, Matrix< real_t > &Q, Options const &opts)
	Computes all eigenvalues and eigenvectors of a real symmetric tridiagonal matrix in parallel, using the divide and conquer algorithm.
template<typename real_t >
void	stedc_deflate (int64_t n, int64_t n1, real_t &rho, real_t *D, real_t *Dsecular, real_t *z, real_t *zsecular, Matrix< real_t > &Q, Matrix< real_t > &Qtype, int64_t *itype, int64_t &nsecular, int64_t &Qtype12_begin, int64_t &Qtype12_end, int64_t &Qtype23_begin, int64_t &Qtype23_end, Options const &opts)
	Sorts the two sets of eigenvalues together into a single sorted set, then deflates eigenvalues, which both resolves stability issues (division by zero) and reduces the size of the problem.
template<typename real_t >
void	stedc_merge (int64_t n, int64_t n1, real_t rho, real_t *D, Matrix< real_t > &Q, Matrix< real_t > &Qtype, Matrix< real_t > &U, Options const &opts)
	Computes the updated eigensystem of a diagonal matrix after modification by a rank-one symmetric matrix, in parallel.
template<typename real_t >
void	stedc_secular (int64_t nsecular, int64_t n, real_t rho, real_t *D, real_t *z, real_t *Lambda, Matrix< real_t > &U, int64_t *itype, Options const &opts)
	Finds the nsecular roots of the secular equation, as defined by the values in rho, D, z, and computes the corresponding eigenvectors in U.
template<typename real_t >
void	stedc_solve (std::vector< real_t > &D, std::vector< real_t > &E, Matrix< real_t > &Q, Matrix< real_t > &W, Matrix< real_t > &U, Options const &opts)
	Computes all eigenvalues and eigenvectors of a symmetric tridiagonal matrix in parallel, using the divide and conquer algorithm.
template<typename real_t >
void	stedc_sort (std::vector< real_t > &D, Matrix< real_t > &Q, Matrix< real_t > &Qout, Options const &opts)
	Sorts eigenvalues in D and apply same permutation to eigenvectors in Q.
template<typename real_t >
void	stedc_z_vector (Matrix< real_t > &Q, std::vector< real_t > &z, Options const &opts)
	Communicates the z vector to all ranks.
template<typename scalar_t >
void	unmbr_tb2bd (Side side, Op op, Matrix< scalar_t > &V, Matrix< scalar_t > &C, Options const &opts=Options())
template<typename scalar_t >
void	sterf (std::vector< scalar_t > &D, std::vector< scalar_t > &E, Options const &opts)
	Computes all eigenvalues of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.
template<typename scalar_t >
void	steqr2 (Job jobz, std::vector< blas::real_type< scalar_t > > &D, std::vector< blas::real_type< scalar_t > > &E, Matrix< scalar_t > &Z, Options const &opts)
	Computes all eigenvalues/eigenvectors of a symmetric tridiagonal matrix using the Pal-Walker-Kahan variant of the QL or QR algorithm.
template<typename scalar_t >
blas::real_type< scalar_t >	gecondest (Norm in_norm, Matrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts)
	Distributed parallel estimate of the reciprocal of the condition number of a general matrix A, in either the 1-norm or the infinity-norm.
template<typename scalar_t >
void	gecondest (Norm in_norm, Matrix< scalar_t > &A, blas::real_type< scalar_t > *Anorm, blas::real_type< scalar_t > *rcond, Options const &opts=Options())
template<typename scalar_t >
blas::real_type< scalar_t >	pocondest (Norm in_norm, HermitianMatrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts)
	Distributed parallel estimate of the reciprocal of the condition number of a general matrix A, in either the 1-norm or the infinity-norm.
template<typename scalar_t >
blas::real_type< scalar_t >	trcondest (Norm in_norm, TriangularMatrix< scalar_t > &A, blas::real_type< scalar_t > Anorm, Options const &opts)
	Distributed parallel estimate of the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.
template<typename scalar_t >
void	trcondest (Norm in_norm, TriangularMatrix< scalar_t > &A, blas::real_type< scalar_t > *rcond, Options const &opts=Options())
template<typename scalar_t >
void	swap (SymmetricMatrix< scalar_t > &A, SymmetricMatrix< scalar_t > &B)
	Swaps contents of matrices A and B.
template<typename MatrixType >
MatrixType	transpose (MatrixType &A)
	Transpose a Tile or any type of Matrix object, changing op flag from NoTrans to Trans, or from Trans to NoTrans.
template<typename MatrixType >
MatrixType	transpose (MatrixType &&A)
	Converts rvalue refs to lvalue refs.
template<typename MatrixType >
MatrixType	conj_transpose (MatrixType &A)
	Conjugate-transpose a Tile or any type of Matrix object, changing op flag from NoTrans to ConjTrans, or from ConjTrans to NoTrans.
template<typename MatrixType >
MatrixType	conj_transpose (MatrixType &&A)
	Converts rvalue refs to lvalue refs.
template<typename scalar_t >
void	swap (TrapezoidMatrix< scalar_t > &A, TrapezoidMatrix< scalar_t > &B)
	Swaps contents of matrices A and B.
template<typename scalar_t >
void	swap (TriangularBandMatrix< scalar_t > &A, TriangularBandMatrix< scalar_t > &B)
	Swap contents of band matrices A and B.
template<typename scalar_t >
void	swap (TriangularMatrix< scalar_t > &A, TriangularMatrix< scalar_t > &B)
	Swaps contents of matrices A and B.
bool	operator< (Pivot const &lhs, Pivot const &rhs)
bool	operator!= (Pivot const &lhs, Pivot const &rhs)
template<typename T >
T	get_option (Options opts, Option option, T defval)
	Extracts an option.
template<>
double	get_option< double > (Options opts, Option option, double defval)
	Specialization for double.
template<slate::Option option>
auto	get_option (Options opts, typename OptValueType< option >::T defval)
template void	add< float > (float alpha, Matrix< float > &A, float beta, Matrix< float > &B, Options const &opts)
template void	add< double > (double alpha, Matrix< double > &A, double beta, Matrix< double > &B, Options const &opts)
template void	add< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, std::complex< float > beta, Matrix< std::complex< float > > &B, Options const &opts)
template void	add< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, std::complex< double > beta, Matrix< std::complex< double > > &B, Options const &opts)
template void	add< float > (float alpha, BaseTrapezoidMatrix< float > &A, float beta, BaseTrapezoidMatrix< float > &B, Options const &opts)
template void	add< double > (double alpha, BaseTrapezoidMatrix< double > &A, double beta, BaseTrapezoidMatrix< double > &B, Options const &opts)
template void	add< std::complex< float > > (std::complex< float > alpha, BaseTrapezoidMatrix< std::complex< float > > &A, std::complex< float > beta, BaseTrapezoidMatrix< std::complex< float > > &B, Options const &opts)
template void	add< std::complex< double > > (std::complex< double > alpha, BaseTrapezoidMatrix< std::complex< double > > &A, std::complex< double > beta, BaseTrapezoidMatrix< std::complex< double > > &B, Options const &opts)
char	to_char (MOSI mosi)
template<typename scalar_t >
void	bdsqr (lapack::Job jobu, lapack::Job jobvt, std::vector< blas::real_type< scalar_t > > &D, std::vector< blas::real_type< scalar_t > > &E, Matrix< scalar_t > &U, Matrix< scalar_t > &VT, Options const &opts)
	Computes the singular values and, optionally, the right and/or left singular vectors from the singular value decomposition (SVD) of a real (upper or lower) bidiagonal matrix.
template void	bdsqr< float > (lapack::Job jobu, lapack::Job jobvt, std::vector< float > &D, std::vector< float > &E, Matrix< float > &U, Matrix< float > &VT, Options const &opts)
template void	bdsqr< double > (lapack::Job jobu, lapack::Job jobvt, std::vector< double > &D, std::vector< double > &E, Matrix< double > &U, Matrix< double > &VT, Options const &opts)
template void	bdsqr< std::complex< float > > (lapack::Job jobu, lapack::Job jobvt, std::vector< float > &D, std::vector< float > &E, Matrix< std::complex< float > > &U, Matrix< std::complex< float > > &VT, Options const &opts)
template void	bdsqr< std::complex< double > > (lapack::Job jobu, lapack::Job jobvt, std::vector< double > &D, std::vector< double > &E, Matrix< std::complex< double > > &U, Matrix< std::complex< double > > &VT, Options const &opts)
template<typename TA , typename TB >
MethodCholQR	select_algo (TA &A, TB &B, Options const &opts)
template<Target target, typename scalar_t >
void	cholqr (Matrix< scalar_t > &A, Matrix< scalar_t > &R, Options const &opts)
	Select the requested function to compute A^H * A.
template void	cholqr< float > (Matrix< float > &A, Matrix< float > &R, Options const &opts)
template void	cholqr< double > (Matrix< double > &A, Matrix< double > &R, Options const &opts)
template void	cholqr< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &R, Options const &opts)
template void	cholqr< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &R, Options const &opts)
template void	colNorms (Norm in_norm, Matrix< float > &A, float *values, Options const &opts)
template void	colNorms (Norm in_norm, Matrix< double > &A, double *values, Options const &opts)
template void	colNorms (Norm in_norm, Matrix< std::complex< float > > &A, float *values, Options const &opts)
template void	colNorms (Norm in_norm, Matrix< std::complex< double > > &A, double *values, Options const &opts)
template void	copy (Matrix< float > &A, Matrix< float > &B, Options const &opts)
template void	copy (Matrix< float > &A, Matrix< double > &B, Options const &opts)
template void	copy (Matrix< double > &A, Matrix< float > &B, Options const &opts)
template void	copy (Matrix< double > &A, Matrix< double > &B, Options const &opts)
template void	copy (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	copy (Matrix< std::complex< float > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	copy (Matrix< std::complex< double > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	copy (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	copy (Matrix< float > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	copy (Matrix< double > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	copy (HermitianMatrix< float > &A, HermitianMatrix< float > &B, Options const &opts)
template void	copy (HermitianMatrix< float > &A, HermitianMatrix< double > &B, Options const &opts)
template void	copy (HermitianMatrix< double > &A, HermitianMatrix< float > &B, Options const &opts)
template void	copy (HermitianMatrix< double > &A, HermitianMatrix< double > &B, Options const &opts)
template void	copy (HermitianMatrix< std::complex< float > > &A, HermitianMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (HermitianMatrix< std::complex< float > > &A, HermitianMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (HermitianMatrix< std::complex< double > > &A, HermitianMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (HermitianMatrix< std::complex< double > > &A, HermitianMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (SymmetricMatrix< float > &A, SymmetricMatrix< float > &B, Options const &opts)
template void	copy (SymmetricMatrix< float > &A, SymmetricMatrix< double > &B, Options const &opts)
template void	copy (SymmetricMatrix< double > &A, SymmetricMatrix< float > &B, Options const &opts)
template void	copy (SymmetricMatrix< double > &A, SymmetricMatrix< double > &B, Options const &opts)
template void	copy (SymmetricMatrix< std::complex< float > > &A, SymmetricMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (SymmetricMatrix< std::complex< float > > &A, SymmetricMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (SymmetricMatrix< std::complex< double > > &A, SymmetricMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (SymmetricMatrix< std::complex< double > > &A, SymmetricMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (TrapezoidMatrix< float > &A, TrapezoidMatrix< float > &B, Options const &opts)
template void	copy (TrapezoidMatrix< float > &A, TrapezoidMatrix< double > &B, Options const &opts)
template void	copy (TrapezoidMatrix< double > &A, TrapezoidMatrix< float > &B, Options const &opts)
template void	copy (TrapezoidMatrix< double > &A, TrapezoidMatrix< double > &B, Options const &opts)
template void	copy (TrapezoidMatrix< std::complex< float > > &A, TrapezoidMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (TrapezoidMatrix< std::complex< float > > &A, TrapezoidMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (TrapezoidMatrix< std::complex< double > > &A, TrapezoidMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (TrapezoidMatrix< std::complex< double > > &A, TrapezoidMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (TriangularMatrix< float > &A, TriangularMatrix< float > &B, Options const &opts)
template void	copy (TriangularMatrix< float > &A, TriangularMatrix< double > &B, Options const &opts)
template void	copy (TriangularMatrix< double > &A, TriangularMatrix< float > &B, Options const &opts)
template void	copy (TriangularMatrix< double > &A, TriangularMatrix< double > &B, Options const &opts)
template void	copy (TriangularMatrix< std::complex< float > > &A, TriangularMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (TriangularMatrix< std::complex< float > > &A, TriangularMatrix< std::complex< double > > &B, Options const &opts)
template void	copy (TriangularMatrix< std::complex< double > > &A, TriangularMatrix< std::complex< float > > &B, Options const &opts)
template void	copy (TriangularMatrix< std::complex< double > > &A, TriangularMatrix< std::complex< double > > &B, Options const &opts)
template void	gbmm< float > (float alpha, BandMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	gbmm< double > (double alpha, BandMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	gbmm< std::complex< float > > (std::complex< float > alpha, BandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	gbmm< std::complex< double > > (std::complex< double > alpha, BandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template int64_t	gbsv< float > (BandMatrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template int64_t	gbsv< double > (BandMatrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template int64_t	gbsv< std::complex< float > > (BandMatrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	gbsv< std::complex< double > > (BandMatrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template int64_t	gbtrf< float > (BandMatrix< float > &A, Pivots &pivots, Options const &opts)
template int64_t	gbtrf< double > (BandMatrix< double > &A, Pivots &pivots, Options const &opts)
template int64_t	gbtrf< std::complex< float > > (BandMatrix< std::complex< float > > &A, Pivots &pivots, Options const &opts)
template int64_t	gbtrf< std::complex< double > > (BandMatrix< std::complex< double > > &A, Pivots &pivots, Options const &opts)
template void	gbtrs< float > (BandMatrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template void	gbtrs< double > (BandMatrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template void	gbtrs< std::complex< float > > (BandMatrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template void	gbtrs< std::complex< double > > (BandMatrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template void	ge2tb< float > (Matrix< float > &A, TriangularFactors< float > &TU, TriangularFactors< float > &TV, Options const &opts)
template void	ge2tb< double > (Matrix< double > &A, TriangularFactors< double > &TU, TriangularFactors< double > &TV, Options const &opts)
template void	ge2tb< std::complex< float > > (Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &TU, TriangularFactors< std::complex< float > > &TV, Options const &opts)
template void	ge2tb< std::complex< double > > (Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &TU, TriangularFactors< std::complex< double > > &TV, Options const &opts)
template float	gecondest< float > (Norm in_norm, Matrix< float > &A, float Anorm, Options const &opts)
template double	gecondest< double > (Norm in_norm, Matrix< double > &A, double Anorm, Options const &opts)
template float	gecondest< std::complex< float > > (Norm in_norm, Matrix< std::complex< float > > &A, float Anorm, Options const &opts)
template double	gecondest< std::complex< double > > (Norm in_norm, Matrix< std::complex< double > > &A, double Anorm, Options const &opts)
template void	gelqf< float > (Matrix< float > &A, TriangularFactors< float > &T, Options const &opts)
template void	gelqf< double > (Matrix< double > &A, TriangularFactors< double > &T, Options const &opts)
template void	gelqf< std::complex< float > > (Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Options const &opts)
template void	gelqf< std::complex< double > > (Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Options const &opts)
template<typename TA , typename TB >
MethodGels	select_algo (TA &A, TB &B, Options const &opts)
template void	gels< float > (Matrix< float > &A, Matrix< float > &B, Options const &opts)
template void	gels< double > (Matrix< double > &A, Matrix< double > &B, Options const &opts)
template void	gels< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	gels< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	gels_cholqr< float > (Matrix< float > &A, Matrix< float > &R, Matrix< float > &B, Options const &opts)
template void	gels_cholqr< double > (Matrix< double > &A, Matrix< double > &R, Matrix< double > &B, Options const &opts)
template void	gels_cholqr< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &R, Matrix< std::complex< float > > &B, Options const &opts)
template void	gels_cholqr< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &R, Matrix< std::complex< double > > &B, Options const &opts)
template void	gels_qr< float > (Matrix< float > &A, TriangularFactors< float > &T, Matrix< float > &B, Options const &opts)
template void	gels_qr< double > (Matrix< double > &A, TriangularFactors< double > &T, Matrix< double > &B, Options const &opts)
template void	gels_qr< std::complex< float > > (Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Matrix< std::complex< float > > &B, Options const &opts)
template void	gels_qr< std::complex< double > > (Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Matrix< std::complex< double > > &B, Options const &opts)
template<typename TA , typename TB >
MethodGemm	select_algo (TA &A, TB &B, Options &opts)
template void	gemm< float > (float alpha, Matrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	gemm< double > (double alpha, Matrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	gemm< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	gemm< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	gemmA< float > (float alpha, Matrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	gemmA< double > (double alpha, Matrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	gemmA< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	gemmA< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	gemmC< float > (float alpha, Matrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	gemmC< double > (double alpha, Matrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	gemmC< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	gemmC< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	geqrf< float > (Matrix< float > &A, TriangularFactors< float > &T, Options const &opts)
template void	geqrf< double > (Matrix< double > &A, TriangularFactors< double > &T, Options const &opts)
template void	geqrf< std::complex< float > > (Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Options const &opts)
template void	geqrf< std::complex< double > > (Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Options const &opts)
template void	gerbt (Matrix< float > &, Matrix< float > &, Matrix< float > &)
template void	gerbt (Matrix< double > &, Matrix< double > &, Matrix< double > &)
template void	gerbt (Matrix< std::complex< float > > &, Matrix< std::complex< float > > &, Matrix< std::complex< float > > &)
template void	gerbt (Matrix< std::complex< double > > &, Matrix< std::complex< double > > &, Matrix< std::complex< double > > &)
template void	gerbt (Matrix< float > &, Matrix< float > &)
template void	gerbt (Matrix< double > &, Matrix< double > &)
template void	gerbt (Matrix< std::complex< float > > &, Matrix< std::complex< float > > &)
template void	gerbt (Matrix< std::complex< double > > &, Matrix< std::complex< double > > &)
template int64_t	gesv< float > (Matrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template int64_t	gesv< double > (Matrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template int64_t	gesv< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	gesv< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template<>
int64_t	gesv_mixed< double > (Matrix< double > &A, Pivots &pivots, Matrix< double > &B, Matrix< double > &X, int &iter, Options const &opts)
template<>
int64_t	gesv_mixed< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Matrix< std::complex< double > > &X, int &iter, Options const &opts)
template<>
int64_t	gesv_mixed_gmres< double > (Matrix< double > &A, Pivots &pivots, Matrix< double > &B, Matrix< double > &X, int &iter, Options const &opts)
template<>
int64_t	gesv_mixed_gmres< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Matrix< std::complex< double > > &X, int &iter, Options const &opts)
template int64_t	gesv_nopiv< float > (Matrix< float > &A, Matrix< float > &B, Options const &opts)
template int64_t	gesv_nopiv< double > (Matrix< double > &A, Matrix< double > &B, Options const &opts)
template int64_t	gesv_nopiv< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	gesv_nopiv< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	gesv_rbt< float > (Matrix< float > &A, Matrix< float > &B, Matrix< float > &X, int &iter, Options const &opts)
template void	gesv_rbt< double > (Matrix< double > &A, Matrix< double > &B, Matrix< double > &X, int &iter, Options const &opts)
template void	gesv_rbt< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Matrix< std::complex< float > > &X, int &iter, Options const &opts)
template void	gesv_rbt< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Matrix< std::complex< double > > &X, int &iter, Options const &opts)
template int64_t	getrf< float > (Matrix< float > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf< double > (Matrix< double > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf_nopiv< float > (Matrix< float > &A, Options const &opts)
template int64_t	getrf_nopiv< double > (Matrix< double > &A, Options const &opts)
template int64_t	getrf_nopiv< std::complex< float > > (Matrix< std::complex< float > > &A, Options const &opts)
template int64_t	getrf_nopiv< std::complex< double > > (Matrix< std::complex< double > > &A, Options const &opts)
template int64_t	getrf_tntpiv< float > (Matrix< float > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf_tntpiv< double > (Matrix< double > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf_tntpiv< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Options const &opts)
template int64_t	getrf_tntpiv< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Options const &opts)
template void	getri< float > (Matrix< float > &A, Pivots &pivots, Options const &opts)
template void	getri< double > (Matrix< double > &A, Pivots &pivots, Options const &opts)
template void	getri< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Options const &opts)
template void	getri< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Options const &opts)
template void	getri< float > (Matrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template void	getri< double > (Matrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template void	getri< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template void	getri< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template void	getrs< float > (Matrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template void	getrs< double > (Matrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template void	getrs< std::complex< float > > (Matrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template void	getrs< std::complex< double > > (Matrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template void	getrs_nopiv< float > (Matrix< float > &A, Matrix< float > &B, Options const &opts)
template void	getrs_nopiv< double > (Matrix< double > &A, Matrix< double > &B, Options const &opts)
template void	getrs_nopiv< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	getrs_nopiv< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	hb2st< float > (HermitianBandMatrix< float > &A, Matrix< float > &V, Options const &opts)
template void	hb2st< double > (HermitianBandMatrix< double > &A, Matrix< double > &V, Options const &opts)
template void	hb2st< std::complex< float > > (HermitianBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &V, Options const &opts)
template void	hb2st< std::complex< double > > (HermitianBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &V, Options const &opts)
template void	hbmm< float > (Side side, float alpha, HermitianBandMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	hbmm< double > (Side side, double alpha, HermitianBandMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	hbmm< std::complex< float > > (Side side, std::complex< float > alpha, HermitianBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	hbmm< std::complex< double > > (Side side, std::complex< double > alpha, HermitianBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	he2hb< float > (HermitianMatrix< float > &A, TriangularFactors< float > &T, Options const &opts)
template void	he2hb< double > (HermitianMatrix< double > &A, TriangularFactors< double > &T, Options const &opts)
template void	he2hb< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Options const &opts)
template void	he2hb< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Options const &opts)
template void	heev< float > (HermitianMatrix< float > &A, std::vector< float > &Lambda, Matrix< float > &Z, Options const &opts)
template void	heev< double > (HermitianMatrix< double > &A, std::vector< double > &Lambda, Matrix< double > &Z, Options const &opts)
template void	heev< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, std::vector< float > &Lambda, Matrix< std::complex< float > > &Z, Options const &opts)
template void	heev< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, std::vector< double > &Lambda, Matrix< std::complex< double > > &Z, Options const &opts)
template void	hegst< float > (int64_t itype, HermitianMatrix< float > &A, HermitianMatrix< float > &B, Options const &opts)
template void	hegst< double > (int64_t itype, HermitianMatrix< double > &A, HermitianMatrix< double > &B, Options const &opts)
template void	hegst< std::complex< float > > (int64_t itype, HermitianMatrix< std::complex< float > > &A, HermitianMatrix< std::complex< float > > &B, Options const &opts)
template void	hegst< std::complex< double > > (int64_t itype, HermitianMatrix< std::complex< double > > &A, HermitianMatrix< std::complex< double > > &B, Options const &opts)
template void	hegv< float > (int64_t itype, HermitianMatrix< float > &A, HermitianMatrix< float > &B, std::vector< float > &Lambda, Matrix< float > &Z, Options const &opts)
template void	hegv< double > (int64_t itype, HermitianMatrix< double > &A, HermitianMatrix< double > &B, std::vector< double > &Lambda, Matrix< double > &Z, Options const &opts)
template void	hegv< std::complex< float > > (int64_t itype, HermitianMatrix< std::complex< float > > &A, HermitianMatrix< std::complex< float > > &B, std::vector< float > &Lambda, Matrix< std::complex< float > > &Z, Options const &opts)
template void	hegv< std::complex< double > > (int64_t itype, HermitianMatrix< std::complex< double > > &A, HermitianMatrix< std::complex< double > > &B, std::vector< double > &Lambda, Matrix< std::complex< double > > &Z, Options const &opts)
template<typename TA , typename TB >
MethodHemm	select_algo (TA &A, TB &B, Options const &opts)
template void	hemm< float > (Side side, float alpha, HermitianMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	hemm< double > (Side side, double alpha, HermitianMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	hemm< std::complex< float > > (Side side, std::complex< float > alpha, HermitianMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	hemm< std::complex< double > > (Side side, std::complex< double > alpha, HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	hemmA< float > (Side side, float alpha, HermitianMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	hemmA< double > (Side side, double alpha, HermitianMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	hemmA< std::complex< float > > (Side side, std::complex< float > alpha, HermitianMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	hemmA< std::complex< double > > (Side side, std::complex< double > alpha, HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	hemmC< float > (Side side, float alpha, HermitianMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	hemmC< double > (Side side, double alpha, HermitianMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	hemmC< std::complex< float > > (Side side, std::complex< float > alpha, HermitianMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	hemmC< std::complex< double > > (Side side, std::complex< double > alpha, HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	her2k< float > (float alpha, Matrix< float > &A, Matrix< float > &B, float beta, HermitianMatrix< float > &C, Options const &opts)
template void	her2k< double > (double alpha, Matrix< double > &A, Matrix< double > &B, double beta, HermitianMatrix< double > &C, Options const &opts)
template void	her2k< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, float beta, HermitianMatrix< std::complex< float > > &C, Options const &opts)
template void	her2k< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, double beta, HermitianMatrix< std::complex< double > > &C, Options const &opts)
template void	herk< float > (float alpha, Matrix< float > &A, float beta, HermitianMatrix< float > &C, Options const &opts)
template void	herk< double > (double alpha, Matrix< double > &A, double beta, HermitianMatrix< double > &C, Options const &opts)
template void	herk< std::complex< float > > (float alpha, Matrix< std::complex< float > > &A, float beta, HermitianMatrix< std::complex< float > > &C, Options const &opts)
template void	herk< std::complex< double > > (double alpha, Matrix< std::complex< double > > &A, double beta, HermitianMatrix< std::complex< double > > &C, Options const &opts)
template int64_t	hesv< float > (HermitianMatrix< float > &A, Pivots &pivots, BandMatrix< float > &T, Pivots &pivots2, Matrix< float > &H, Matrix< float > &B, Options const &opts)
template int64_t	hesv< double > (HermitianMatrix< double > &A, Pivots &pivots, BandMatrix< double > &T, Pivots &pivots2, Matrix< double > &H, Matrix< double > &B, Options const &opts)
template int64_t	hesv< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Pivots &pivots, BandMatrix< std::complex< float > > &T, Pivots &pivots2, Matrix< std::complex< float > > &H, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	hesv< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Pivots &pivots, BandMatrix< std::complex< double > > &T, Pivots &pivots2, Matrix< std::complex< double > > &H, Matrix< std::complex< double > > &B, Options const &opts)
template int64_t	hetrf< float > (HermitianMatrix< float > &A, Pivots &pivots, BandMatrix< float > &T, Pivots &pivots2, Matrix< float > &H, Options const &opts)
template int64_t	hetrf< double > (HermitianMatrix< double > &A, Pivots &pivots, BandMatrix< double > &T, Pivots &pivots2, Matrix< double > &H, Options const &opts)
template int64_t	hetrf< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Pivots &pivots, BandMatrix< std::complex< float > > &T, Pivots &pivots2, Matrix< std::complex< float > > &H, Options const &opts)
template int64_t	hetrf< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Pivots &pivots, BandMatrix< std::complex< double > > &T, Pivots &pivots2, Matrix< std::complex< double > > &H, Options const &opts)
template void	hetrs< float > (HermitianMatrix< float > &A, Pivots &pivots, BandMatrix< float > &T, Pivots &pivots2, Matrix< float > &B, Options const &opts)
template void	hetrs< double > (HermitianMatrix< double > &A, Pivots &pivots, BandMatrix< double > &T, Pivots &pivots2, Matrix< double > &B, Options const &opts)
template void	hetrs< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Pivots &pivots, BandMatrix< std::complex< float > > &T, Pivots &pivots2, Matrix< std::complex< float > > &B, Options const &opts)
template void	hetrs< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Pivots &pivots, BandMatrix< std::complex< double > > &T, Pivots &pivots2, Matrix< std::complex< double > > &B, Options const &opts)
template<typename scalar_t >
void	make_hermitian (Tile< scalar_t > &&T)
	Make the diagonal tiles hermitian.
template<typename scalar_t >
void	swapLocalRow (int64_t j_offset, int64_t n, Tile< scalar_t > &A, int64_t i1, Tile< scalar_t > &B, int64_t i2)
	Swap a partial row of two local tiles: A[ i1, j_offset : j_offset+n-1 ] and B[ i2, j_offset : j_offset+n-1 ].
template<typename scalar_t >
void	swapLocalRow (int64_t j_offset, int64_t n, Tile< scalar_t > &&A, int64_t i1, Tile< scalar_t > &&B, int64_t i2)
	Converts rvalue refs to lvalue refs.
template<typename scalar_t >
void	swapRemoteRow (int64_t j, int64_t n, Tile< scalar_t > &A, int64_t i, int other_rank, MPI_Comm mpi_comm, int tag=0)
	Swap a partial row, A[ i, j : j+n-1 ], with another MPI process.
template<typename scalar_t >
void	swapRemoteRow (int64_t j, int64_t n, Tile< scalar_t > &&A, int64_t i, int other_rank, MPI_Comm mpi_comm, int tag=0)
	Converts rvalue refs to lvalue refs.
template<typename scalar_t >
void	swapRemoteRowDevice (int64_t j, int64_t n, int device, Tile< scalar_t > &A, int64_t i, int other_rank, MPI_Comm mpi_comm, blas::Queue &queue, int tag=0)
	Swap a partial row, A[ i, j : j+n-1 ], on a GPU device, with another MPI process.
template<typename scalar_t >
void	swapRemoteRowDevice (int64_t j, int64_t n, int device, Tile< scalar_t > &&A, int64_t i, int other_rank, MPI_Comm mpi_comm, blas::Queue &queue, int tag=0)
	Converts rvalue refs to lvalue refs.
template<typename scalar_t >
void	swapRemoteElement (Tile< scalar_t > &A, int64_t i, int64_t j, int other_rank, MPI_Comm mpi_comm, int tag=0)
	Swap one element, A(i, j), with another MPI process.
template<typename scalar_t >
void	swapRemoteElement (Tile< scalar_t > &&A, int64_t i, int64_t j, int other_rank, MPI_Comm mpi_comm, int tag=0)
	Converts rvalue refs to lvalue refs.
template float	norm (Norm in_norm, Matrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, Matrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, Matrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, Matrix< std::complex< double > > &A, Options const &opts)
template float	norm (Norm in_norm, HermitianMatrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, HermitianMatrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, HermitianMatrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, HermitianMatrix< std::complex< double > > &A, Options const &opts)
template float	norm (Norm in_norm, SymmetricMatrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, SymmetricMatrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, SymmetricMatrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, SymmetricMatrix< std::complex< double > > &A, Options const &opts)
template float	norm (Norm in_norm, TrapezoidMatrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, TrapezoidMatrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, TrapezoidMatrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, TrapezoidMatrix< std::complex< double > > &A, Options const &opts)
template float	norm (Norm in_norm, BandMatrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, BandMatrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, BandMatrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, BandMatrix< std::complex< double > > &A, Options const &opts)
template float	norm (Norm in_norm, HermitianBandMatrix< float > &A, Options const &opts)
template double	norm (Norm in_norm, HermitianBandMatrix< double > &A, Options const &opts)
template float	norm (Norm in_norm, HermitianBandMatrix< std::complex< float > > &A, Options const &opts)
template double	norm (Norm in_norm, HermitianBandMatrix< std::complex< double > > &A, Options const &opts)
template int64_t	pbsv< float > (HermitianBandMatrix< float > &A, Matrix< float > &B, Options const &opts)
template int64_t	pbsv< double > (HermitianBandMatrix< double > &A, Matrix< double > &B, Options const &opts)
template int64_t	pbsv< std::complex< float > > (HermitianBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	pbsv< std::complex< double > > (HermitianBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template int64_t	pbtrf< float > (HermitianBandMatrix< float > &A, Options const &opts)
template int64_t	pbtrf< double > (HermitianBandMatrix< double > &A, Options const &opts)
template int64_t	pbtrf< std::complex< float > > (HermitianBandMatrix< std::complex< float > > &A, Options const &opts)
template int64_t	pbtrf< std::complex< double > > (HermitianBandMatrix< std::complex< double > > &A, Options const &opts)
template void	pbtrs< float > (HermitianBandMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	pbtrs< double > (HermitianBandMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	pbtrs< std::complex< float > > (HermitianBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	pbtrs< std::complex< double > > (HermitianBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template float	pocondest< float > (Norm in_norm, HermitianMatrix< float > &A, float Anorm, Options const &opts)
template double	pocondest< double > (Norm in_norm, HermitianMatrix< double > &A, double Anorm, Options const &opts)
template float	pocondest< std::complex< float > > (Norm in_norm, HermitianMatrix< std::complex< float > > &A, float Anorm, Options const &opts)
template double	pocondest< std::complex< double > > (Norm in_norm, HermitianMatrix< std::complex< double > > &A, double Anorm, Options const &opts)
template int64_t	posv< float > (HermitianMatrix< float > &A, Matrix< float > &B, Options const &opts)
template int64_t	posv< double > (HermitianMatrix< double > &A, Matrix< double > &B, Options const &opts)
template int64_t	posv< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template int64_t	posv< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template<>
int64_t	posv_mixed< double > (HermitianMatrix< double > &A, Matrix< double > &B, Matrix< double > &X, int &iter, Options const &opts)
template<>
int64_t	posv_mixed< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Matrix< std::complex< double > > &X, int &iter, Options const &opts)
template<>
int64_t	posv_mixed_gmres< double > (HermitianMatrix< double > &A, Matrix< double > &B, Matrix< double > &X, int &iter, Options const &opts)
template<>
int64_t	posv_mixed_gmres< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Matrix< std::complex< double > > &X, int &iter, Options const &opts)
template int64_t	potrf< float > (HermitianMatrix< float > &A, Options const &opts)
template int64_t	potrf< double > (HermitianMatrix< double > &A, Options const &opts)
template int64_t	potrf< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Options const &opts)
template int64_t	potrf< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Options const &opts)
template void	potri< float > (HermitianMatrix< float > &A, Options const &opts)
template void	potri< double > (HermitianMatrix< double > &A, Options const &opts)
template void	potri< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Options const &opts)
template void	potri< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Options const &opts)
template void	potrs< float > (HermitianMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	potrs< double > (HermitianMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	potrs< std::complex< float > > (HermitianMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	potrs< std::complex< double > > (HermitianMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
static double	pow10 (int y)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, int value)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, int64_t value)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, float value)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, double value)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, std::complex< float > value)
template int	snprintf_value (char *buf, size_t buf_len, int width, int precision, std::complex< double > value)
template void	print (const char *label, Tile< float > &A, blas::Queue &queue, Options const &opts)
template void	print (const char *label, Tile< double > &A, blas::Queue &queue, Options const &opts)
template void	print (const char *label, Tile< std::complex< float > > &A, blas::Queue &queue, Options const &opts)
template void	print (const char *label, Tile< std::complex< double > > &A, blas::Queue &queue, Options const &opts)
template<typename scalar_t >
void	send_recv_tile (BaseMatrix< scalar_t > &A, int64_t i, int64_t j, int mpi_rank, MPI_Comm comm)
	Sends tiles A(i, j) and receives it on rank 0.
template<typename scalar_t >
std::string	tile_row_string (BaseMatrix< scalar_t > &A, int64_t i, int64_t j, int64_t ti, Options const &opts, const char *opposite="", bool is_last_abbrev_cols=false)
	Returns string for row ti of tile A(i, j).
template<typename scalar_t >
std::string	tile_row_string (BaseMatrix< scalar_t > &A, int64_t i, int64_t j, int64_t ti, int width, int precision, const char *opposite="")
	Returns string for row ti of tile A(i, j).
template<typename scalar_t >
void	print_work (const char *label, BaseMatrix< scalar_t > &A, int64_t klt, int64_t kut, Options const &opts_)
	Print a SLATE distributed trapezoid matrix.
template void	print (const char *label, Matrix< float > &A, Options const &opts)
template void	print (const char *label, Matrix< double > &A, Options const &opts)
template void	print (const char *label, Matrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, Matrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, BandMatrix< float > &A, Options const &opts)
template void	print (const char *label, BandMatrix< double > &A, Options const &opts)
template void	print (const char *label, BandMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, BandMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, BaseTriangularBandMatrix< float > &A, Options const &opts)
template void	print (const char *label, BaseTriangularBandMatrix< double > &A, Options const &opts)
template void	print (const char *label, BaseTriangularBandMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, BaseTriangularBandMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, HermitianMatrix< float > &A, Options const &opts)
template void	print (const char *label, HermitianMatrix< double > &A, Options const &opts)
template void	print (const char *label, HermitianMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, HermitianMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, SymmetricMatrix< float > &A, Options const &opts)
template void	print (const char *label, SymmetricMatrix< double > &A, Options const &opts)
template void	print (const char *label, SymmetricMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, SymmetricMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, TrapezoidMatrix< float > &A, Options const &opts)
template void	print (const char *label, TrapezoidMatrix< double > &A, Options const &opts)
template void	print (const char *label, TrapezoidMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, TrapezoidMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, TriangularMatrix< float > &A, Options const &opts)
template void	print (const char *label, TriangularMatrix< double > &A, Options const &opts)
template void	print (const char *label, TriangularMatrix< std::complex< float > > &A, Options const &opts)
template void	print (const char *label, TriangularMatrix< std::complex< double > > &A, Options const &opts)
template void	print (const char *label, int64_t n, int const *x, int64_t incx, Options const &opts)
template void	print (const char *label, int64_t n, int64_t const *x, int64_t incx, Options const &opts)
template void	print (const char *label, int64_t n, float const *x, int64_t incx, Options const &opts)
template void	print (const char *label, int64_t n, double const *x, int64_t incx, Options const &opts)
template void	print (const char *label, int64_t n, std::complex< float > const *x, int64_t incx, Options const &opts)
template void	print (const char *label, int64_t n, std::complex< double > const *x, int64_t incx, Options const &opts)
template void	print (const char *label, std::vector< int > const &x, Options const &opts)
template void	print (const char *label, std::vector< int64_t > const &x, Options const &opts)
template void	print (const char *label, std::vector< float > const &x, Options const &opts)
template void	print (const char *label, std::vector< double > const &x, Options const &opts)
template void	print (const char *label, std::vector< std::complex< float > > const &x, Options const &opts)
template void	print (const char *label, std::vector< std::complex< double > > const &x, Options const &opts)
template void	redistribute< float > (Matrix< float > &A, Matrix< float > &B, Options const &opts)
template void	redistribute< double > (Matrix< double > &A, Matrix< double > &B, Options const &opts)
template void	redistribute< std::complex< float > > (Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	redistribute< std::complex< double > > (Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	scale (float numer, float denom, Matrix< float > &A, Options const &opts)
template void	scale (double numer, double denom, Matrix< double > &A, Options const &opts)
template void	scale (float numer, float denom, Matrix< std::complex< float > > &A, Options const &opts)
template void	scale (double numer, double denom, Matrix< std::complex< double > > &A, Options const &opts)
template void	scale (float numer, float denom, BaseTrapezoidMatrix< float > &A, Options const &opts)
template void	scale (double numer, double denom, BaseTrapezoidMatrix< double > &A, Options const &opts)
template void	scale (float numer, float denom, BaseTrapezoidMatrix< std::complex< float > > &A, Options const &opts)
template void	scale (double numer, double denom, BaseTrapezoidMatrix< std::complex< double > > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< float > const &R, std::vector< float > const &C, Matrix< float > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< double > const &R, std::vector< double > const &C, Matrix< double > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< float > const &R, std::vector< float > const &C, Matrix< std::complex< float > > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< double > const &R, std::vector< double > const &C, Matrix< std::complex< double > > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< std::complex< float > > const &R, std::vector< std::complex< float > > const &C, Matrix< std::complex< float > > &A, Options const &opts)
template void	scale_row_col (Equed equed, std::vector< std::complex< double > > const &R, std::vector< std::complex< double > > const &C, Matrix< std::complex< double > > &A, Options const &opts)
template void	set (float offdiag_value, float diag_value, Matrix< float > &A, Options const &opts)
template void	set (double offdiag_value, double diag_value, Matrix< double > &A, Options const &opts)
template void	set (std::complex< float > offdiag_value, std::complex< float > diag_value, Matrix< std::complex< float > > &A, Options const &opts)
template void	set (std::complex< double > offdiag_value, std::complex< double > diag_value, Matrix< std::complex< double > > &A, Options const &opts)
template void	set (float offdiag_value, float diag_value, BaseTrapezoidMatrix< float > &A, Options const &opts)
template void	set (double offdiag_value, double diag_value, BaseTrapezoidMatrix< double > &A, Options const &opts)
template void	set (std::complex< float > offdiag_value, std::complex< float > diag_value, BaseTrapezoidMatrix< std::complex< float > > &A, Options const &opts)
template void	set (std::complex< double > offdiag_value, std::complex< double > diag_value, BaseTrapezoidMatrix< std::complex< double > > &A, Options const &opts)
template void	set (std::function< float(int64_t i, int64_t j) > const &value, Matrix< float > &A, Options const &opts)
template void	set (std::function< double(int64_t i, int64_t j) > const &value, Matrix< double > &A, Options const &opts)
template void	set (std::function< std::complex< float >(int64_t i, int64_t j) > const &value, Matrix< std::complex< float > > &A, Options const &opts)
template void	set (std::function< std::complex< double >(int64_t i, int64_t j) > const &value, Matrix< std::complex< double > > &A, Options const &opts)
template void	set (std::function< float(int64_t i, int64_t j) > const &value, BaseTrapezoidMatrix< float > &A, Options const &opts)
template void	set (std::function< double(int64_t i, int64_t j) > const &value, BaseTrapezoidMatrix< double > &A, Options const &opts)
template void	set (std::function< std::complex< float >(int64_t i, int64_t j) > const &value, BaseTrapezoidMatrix< std::complex< float > > &A, Options const &opts)
template void	set (std::function< std::complex< double >(int64_t i, int64_t j) > const &value, BaseTrapezoidMatrix< std::complex< double > > &A, Options const &opts)
template void	stedc< float > (std::vector< float > &D, std::vector< float > &E, Matrix< float > &Q, Options const &opts)
template void	stedc< double > (std::vector< double > &D, std::vector< double > &E, Matrix< double > &Q, Options const &opts)
template void	stedc_deflate< float > (int64_t n, int64_t n1, float &rho, float *D, float *Dsecular, float *z, float *zsecular, Matrix< float > &Q, Matrix< float > &Qtype, int64_t *itype, int64_t &nsecular, int64_t &Qtype12_begin, int64_t &Qtype12_end, int64_t &Qtype23_begin, int64_t &Qtype23_end, Options const &opts)
template void	stedc_deflate< double > (int64_t n, int64_t n1, double &rho, double *D, double *Dsecular, double *z, double *zsecular, Matrix< double > &Q, Matrix< double > &Qtype, int64_t *itype, int64_t &nsecular, int64_t &Qtype12_begin, int64_t &Qtype12_end, int64_t &Qtype23_begin, int64_t &Qtype23_end, Options const &opts)
template void	stedc_merge< float > (int64_t n, int64_t n1, float rho, float *D, Matrix< float > &Q, Matrix< float > &Qtype, Matrix< float > &U, Options const &opts)
template void	stedc_merge< double > (int64_t n, int64_t n1, double rho, double *D, Matrix< double > &Q, Matrix< double > &Qtype, Matrix< double > &U, Options const &opts)
template void	stedc_secular< float > (int64_t nsecular, int64_t n, float rho, float *D, float *z, float *Lambda, Matrix< float > &U, int64_t *itype, Options const &opts)
template void	stedc_secular< double > (int64_t nsecular, int64_t n, double rho, double *D, double *z, double *Lambda, Matrix< double > &U, int64_t *itype, Options const &opts)
template void	stedc_solve< float > (std::vector< float > &D, std::vector< float > &E, Matrix< float > &Q, Matrix< float > &W, Matrix< float > &U, Options const &opts)
template void	stedc_solve< double > (std::vector< double > &D, std::vector< double > &E, Matrix< double > &Q, Matrix< double > &W, Matrix< double > &U, Options const &opts)
template void	stedc_sort< float > (std::vector< float > &D, Matrix< float > &Q, Matrix< float > &Qout, Options const &opts)
template void	stedc_sort< double > (std::vector< double > &D, Matrix< double > &Q, Matrix< double > &Qout, Options const &opts)
template void	stedc_z_vector< float > (Matrix< float > &Q, std::vector< float > &z, Options const &opts)
template void	stedc_z_vector< double > (Matrix< double > &Q, std::vector< double > &z, Options const &opts)
template void	steqr2< float > (Job job, std::vector< float > &D, std::vector< float > &E, Matrix< float > &Z, Options const &opts)
template void	steqr2< double > (Job job, std::vector< double > &D, std::vector< double > &E, Matrix< double > &Z, Options const &opts)
template void	steqr2< std::complex< float > > (Job job, std::vector< float > &D, std::vector< float > &E, Matrix< std::complex< float > > &Z, Options const &opts)
template void	steqr2< std::complex< double > > (Job job, std::vector< double > &D, std::vector< double > &E, Matrix< std::complex< double > > &Z, Options const &opts)
template void	sterf< float > (std::vector< float > &D, std::vector< float > &E, Options const &opts)
template void	sterf< double > (std::vector< double > &D, std::vector< double > &E, Options const &opts)
template void	svd< float > (Matrix< float > A, std::vector< float > &S, Matrix< float > &U, Matrix< float > &VT, Options const &opts)
template void	svd< double > (Matrix< double > A, std::vector< double > &S, Matrix< double > &U, Matrix< double > &VT, Options const &opts)
template void	svd< std::complex< float > > (Matrix< std::complex< float > > A, std::vector< float > &S, Matrix< std::complex< float > > &U, Matrix< std::complex< float > > &VT, Options const &opts)
template void	svd< std::complex< double > > (Matrix< std::complex< double > > A, std::vector< double > &S, Matrix< std::complex< double > > &U, Matrix< std::complex< double > > &VT, Options const &opts)
template void	symm< float > (Side side, float alpha, SymmetricMatrix< float > &A, Matrix< float > &B, float beta, Matrix< float > &C, Options const &opts)
template void	symm< double > (Side side, double alpha, SymmetricMatrix< double > &A, Matrix< double > &B, double beta, Matrix< double > &C, Options const &opts)
template void	symm< std::complex< float > > (Side side, std::complex< float > alpha, SymmetricMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, Matrix< std::complex< float > > &C, Options const &opts)
template void	symm< std::complex< double > > (Side side, std::complex< double > alpha, SymmetricMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, Matrix< std::complex< double > > &C, Options const &opts)
template void	syr2k< float > (float alpha, Matrix< float > &A, Matrix< float > &B, float beta, SymmetricMatrix< float > &C, Options const &opts)
template void	syr2k< double > (double alpha, Matrix< double > &A, Matrix< double > &B, double beta, SymmetricMatrix< double > &C, Options const &opts)
template void	syr2k< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, std::complex< float > beta, SymmetricMatrix< std::complex< float > > &C, Options const &opts)
template void	syr2k< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, std::complex< double > beta, SymmetricMatrix< std::complex< double > > &C, Options const &opts)
template void	syrk< float > (float alpha, Matrix< float > &A, float beta, SymmetricMatrix< float > &C, Options const &opts)
template void	syrk< double > (double alpha, Matrix< double > &A, double beta, SymmetricMatrix< double > &C, Options const &opts)
template void	syrk< std::complex< float > > (std::complex< float > alpha, Matrix< std::complex< float > > &A, std::complex< float > beta, SymmetricMatrix< std::complex< float > > &C, Options const &opts)
template void	syrk< std::complex< double > > (std::complex< double > alpha, Matrix< std::complex< double > > &A, std::complex< double > beta, SymmetricMatrix< std::complex< double > > &C, Options const &opts)
template void	tb2bd< float > (TriangularBandMatrix< float > &A, Matrix< float > &U, Matrix< float > &V, Options const &opts)
template void	tb2bd< double > (TriangularBandMatrix< double > &A, Matrix< double > &U, Matrix< double > &V, Options const &opts)
template void	tb2bd< std::complex< float > > (TriangularBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &U, Matrix< std::complex< float > > &V, Options const &opts)
template void	tb2bd< std::complex< double > > (TriangularBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &U, Matrix< std::complex< double > > &V, Options const &opts)
template void	tbsm< float > (blas::Side side, float alpha, TriangularBandMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	tbsm< double > (blas::Side side, double alpha, TriangularBandMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	tbsm< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularBandMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	tbsm< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularBandMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template<typename scalar_t >
void	tbsm (blas::Side side, scalar_t alpha, TriangularBandMatrix< scalar_t > &A, Pivots &pivots, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular band matrix-matrix solve.
template void	tbsm< float > (blas::Side side, float alpha, TriangularBandMatrix< float > &A, Pivots &pivots, Matrix< float > &B, Options const &opts)
template void	tbsm< double > (blas::Side side, double alpha, TriangularBandMatrix< double > &A, Pivots &pivots, Matrix< double > &B, Options const &opts)
template void	tbsm< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularBandMatrix< std::complex< float > > &A, Pivots &pivots, Matrix< std::complex< float > > &B, Options const &opts)
template void	tbsm< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularBandMatrix< std::complex< double > > &A, Pivots &pivots, Matrix< std::complex< double > > &B, Options const &opts)
template float	trcondest< float > (Norm in_norm, TriangularMatrix< float > &A, float Anorm, Options const &opts)
template double	trcondest< double > (Norm in_norm, TriangularMatrix< double > &A, double Anorm, Options const &opts)
template float	trcondest< std::complex< float > > (Norm in_norm, TriangularMatrix< std::complex< float > > &A, float Anorm, Options const &opts)
template double	trcondest< std::complex< double > > (Norm in_norm, TriangularMatrix< std::complex< double > > &A, double Anorm, Options const &opts)
template<typename scalar_t >
void	trmm (blas::Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular matrix-matrix multiplication.
template void	trmm< float > (blas::Side side, float alpha, TriangularMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	trmm< double > (blas::Side side, double alpha, TriangularMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	trmm< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	trmm< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template<typename TA , typename TB >
MethodTrsm	select_algo (TA &A, TB &B, Options const &opts)
template<typename scalar_t >
void	trsm (blas::Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular matrix-matrix solve.
template void	trsm< float > (blas::Side side, float alpha, TriangularMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	trsm< double > (blas::Side side, double alpha, TriangularMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	trsm< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	trsm< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template<typename scalar_t >
void	trsmA (blas::Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular matrix-matrix solve.
template void	trsmA< float > (blas::Side side, float alpha, TriangularMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	trsmA< double > (blas::Side side, double alpha, TriangularMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	trsmA< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	trsmA< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template<typename scalar_t >
void	trsmB (blas::Side side, scalar_t alpha, TriangularMatrix< scalar_t > &A, Matrix< scalar_t > &B, Options const &opts)
	Distributed parallel triangular matrix-matrix solve.
template void	trsmB< float > (blas::Side side, float alpha, TriangularMatrix< float > &A, Matrix< float > &B, Options const &opts)
template void	trsmB< double > (blas::Side side, double alpha, TriangularMatrix< double > &A, Matrix< double > &B, Options const &opts)
template void	trsmB< std::complex< float > > (blas::Side side, std::complex< float > alpha, TriangularMatrix< std::complex< float > > &A, Matrix< std::complex< float > > &B, Options const &opts)
template void	trsmB< std::complex< double > > (blas::Side side, std::complex< double > alpha, TriangularMatrix< std::complex< double > > &A, Matrix< std::complex< double > > &B, Options const &opts)
template void	trtri< float > (TriangularMatrix< float > &A, Options const &opts)
template void	trtri< double > (TriangularMatrix< double > &A, Options const &opts)
template void	trtri< std::complex< float > > (TriangularMatrix< std::complex< float > > &A, Options const &opts)
template void	trtri< std::complex< double > > (TriangularMatrix< std::complex< double > > &A, Options const &opts)
template void	trtrm< float > (TriangularMatrix< float > &A, Options const &opts)
template void	trtrm< double > (TriangularMatrix< double > &A, Options const &opts)
template void	trtrm< std::complex< float > > (TriangularMatrix< std::complex< float > > &A, Options const &opts)
template void	trtrm< std::complex< double > > (TriangularMatrix< std::complex< double > > &A, Options const &opts)
template void	unmbr_ge2tb< float > (Side side, Op op, Matrix< float > &A, TriangularFactors< float > T, Matrix< float > &C, Options const &opts)
template void	unmbr_ge2tb< double > (Side side, Op op, Matrix< double > &A, TriangularFactors< double > T, Matrix< double > &C, Options const &opts)
template void	unmbr_ge2tb< std::complex< float > > (Side side, Op op, Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > T, Matrix< std::complex< float > > &C, Options const &opts)
template void	unmbr_ge2tb< std::complex< double > > (Side side, Op op, Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > T, Matrix< std::complex< double > > &C, Options const &opts)
template void	unmlq< float > (Side side, Op op, Matrix< float > &A, TriangularFactors< float > &T, Matrix< float > &C, Options const &opts)
template void	unmlq< double > (Side side, Op op, Matrix< double > &A, TriangularFactors< double > &T, Matrix< double > &C, Options const &opts)
template void	unmlq< std::complex< float > > (Side side, Op op, Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Matrix< std::complex< float > > &C, Options const &opts)
template void	unmlq< std::complex< double > > (Side side, Op op, Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Matrix< std::complex< double > > &C, Options const &opts)
template void	unmqr< float > (Side side, Op op, Matrix< float > &A, TriangularFactors< float > &T, Matrix< float > &C, Options const &opts)
template void	unmqr< double > (Side side, Op op, Matrix< double > &A, TriangularFactors< double > &T, Matrix< double > &C, Options const &opts)
template void	unmqr< std::complex< float > > (Side side, Op op, Matrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > &T, Matrix< std::complex< float > > &C, Options const &opts)
template void	unmqr< std::complex< double > > (Side side, Op op, Matrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > &T, Matrix< std::complex< double > > &C, Options const &opts)
template<typename scalar_t >
void	unmtr_hb2st (Side side, Op op, Matrix< scalar_t > &V, Matrix< scalar_t > &C, const std::map< Option, Value > &opts)
	Multiplies the general m-by-n matrix C by Q from slate::hb2st as follows:
template void	unmtr_hb2st< float > (Side side, Op op, Matrix< float > &V, Matrix< float > &C, const std::map< Option, Value > &opts)
template void	unmtr_hb2st< double > (Side side, Op op, Matrix< double > &V, Matrix< double > &C, const std::map< Option, Value > &opts)
template void	unmtr_hb2st< std::complex< float > > (Side side, Op op, Matrix< std::complex< float > > &V, Matrix< std::complex< float > > &C, const std::map< Option, Value > &opts)
template void	unmtr_hb2st< std::complex< double > > (Side side, Op op, Matrix< std::complex< double > > &V, Matrix< std::complex< double > > &C, const std::map< Option, Value > &opts)
template void	unmtr_he2hb< float > (Side side, Op op, HermitianMatrix< float > &A, TriangularFactors< float > T, Matrix< float > &C, Options const &opts)
template void	unmtr_he2hb< double > (Side side, Op op, HermitianMatrix< double > &A, TriangularFactors< double > T, Matrix< double > &C, Options const &opts)
template void	unmtr_he2hb< std::complex< float > > (Side side, Op op, HermitianMatrix< std::complex< float > > &A, TriangularFactors< std::complex< float > > T, Matrix< std::complex< float > > &C, Options const &opts)
template void	unmtr_he2hb< std::complex< double > > (Side side, Op op, HermitianMatrix< std::complex< double > > &A, TriangularFactors< std::complex< double > > T, Matrix< std::complex< double > > &C, Options const &opts)
template<typename matrix_type >
void	generate_matrix (MatrixParams &params, matrix_type &A, slate::Options const &opts=slate::Options())
void	from_string (std::string const &str, Origin *val)
const char *	to_c_string (Origin value)
std::string	to_string (Origin value)
Target	origin2target (Origin origin)
	Convert Origin to Target.
void	from_string (std::string const &str, Target *val)
const char *	to_c_string (Target value)
std::string	to_string (Target value)
void	from_string (std::string const &str, GridOrder *val)
const char *	to_c_string (GridOrder value)
std::string	to_string (GridOrder value)
void	from_string (std::string const &str, NormScope *val)
const char *	to_c_string (NormScope value)
std::string	to_string (NormScope value)

Variables
const char *	MethodTrsm_help = "auto; A or trsmA; B or trsmB"
const char *	MethodGemm_help = "auto; A or gemmA; C or gemmC"
const char *	MethodHemm_help = "auto; A or hemmA; C or hemmC"
const char *	MethodCholQR_help = "auto; gemmA; gemmC; herkA; herkC"
const char *	MethodGels_help = "auto; QR; CholQR"
const char *	MethodLU_help = "auto; PPLU or PartialPiv; CALU; NoPiv; RBT; BEAM"
const char *	MethodEig_help
const char *	MethodSVD_help
const int	HostNum = -1
const int	AllDevices = -2
const int	AnyDevice = -3
const int	MinOmpActiveLevels = 4
	Minimum number of OpenMP active parallel levels to allow multi-threaded panel implementation.
std::map< std::string, double >	timers
	Map of timers, in seconds, for top-level routines.
const char *	GridOrder_help = "c or col; r or row"
const char *	NormScope_help = "m or matrix; c, cols, or columns; r or rows"
const char *	Origin_help
const char *	Target_help

Detailed Description

SLATE's top-level namespace.

Typedef Documentation

Value

using slate::Value = typedef OptionValue

Deprecated:

Enumeration Type Documentation

MethodCholQR

enum class slate::MethodCholQR : char

strong

Algorithm to use for Cholesky QR.

Enumerator
Auto	Let SLATE decide.
GemmA	Use gemm-A algorithm to compute A^H A.
GemmC	Use gemm-C algorithm to compute A^H A.
HerkA	Use herk-A algorithm to compute A^H A; not yet implemented.
HerkC	Use herk-C algorithm to compute A^H A.

MethodEig

enum class slate::MethodEig : char

strong

Algorithm to use for eigenvalues (eig).

Enumerator
Auto	Let SLATE decide.
QR	QR iteration.
DC	Divide and conquer.
Bisection	Bisection; not yet implemented.
MRRR	Multiple Relatively Robust Representations (MRRR); not yet implemented.

MethodGels

enum class slate::MethodGels : char

strong

Algorithm to use for least squares (gels).

Enumerator
Auto	Let SLATE decide.
QR	Use Householder QR factorization.
CholQR	Use Cholesky QR factorization; use when A is well-conditioned.

MethodGemm

enum class slate::MethodGemm : char

strong

Algorithm to use for general matrix multiply (gemm).

Enumerator
Auto	Let SLATE decide.
A	Matrix A is stationary, C is sent; use when C is small.
C	Matrix C is stationary, A is sent; use when C is large.

MethodHemm

enum class slate::MethodHemm : char

strong

Algorithm to use for Hermitian matrix multiply (hemm).

Enumerator
Auto	Let SLATE decide.
A	Matrix A is stationary, C is sent; use when C is small.
C	Matrix C is stationary, A is sent; use when C is large.

MethodLU

enum class slate::MethodLU : char

strong

Algorithm to use for LU factorization and solve.

Enumerator
Auto	Let SLATE decide.
PartialPiv	Use classical partial pivoting.
CALU	Use Communication Avoiding LU (CALU)
NoPiv	Use no-pivoting LU.
RBT	Use Random Butterfly Transform (RBT)
BEAM	Use BEAM LU factorization.

MethodSVD

enum class slate::MethodSVD : char

strong

Algorithm to use for singular value decomposition (SVD).

Enumerator
Auto	Let SLATE decide.
QR	QR iteration.
DC	Divide and conquer; not yet implemented.
Bisection	Bisection; not yet implemented.

MethodTrsm

enum class slate::MethodTrsm : char

strong

Algorithm to use for triangular solve (trsm).

Enumerator
Auto	Let SLATE decide.
A	Matrix A is stationary, B is sent; use when B is small.
B	Matrix B is stationary, A is sent; use when B is large.

MOSI

enum slate::MOSI

A tile state in the MOSI coherency protocol.

Enumerator
Modified	tile data is modified, other instances should be Invalid, cannot be purged
OnHold	a hold is placed on this tile instance, cannot be purged
Shared	tile data is up-to-date, other instances may be Shared, or Invalid, may be purged
Invalid	tile data is obsolete, other instances may be Modified, Shared, or Invalid, may be purged

Function Documentation

add_sumsq()

template<typename real_t >

void slate::add_sumsq	(	real_t &	scale,
		real_t &	sumsq,
		real_t	absx
	)

Adds new value to scaled, sum-of-squares representation.

On exit, scale and sumsq are updated such that:

scale^2 sumsq := scale^2 sumsq + (absx)^2

cabs1()

float slate::cabs1 ( float  x )

inline

Returns

abs(r) + abs(i)

ceildiv()

template<typename T >

constexpr T slate::ceildiv ( T  x, T  y  )

inlineconstexpr

Returns

ceil( x / y ), for integer type T.

combine_sumsq()

template<typename real_t >

void slate::combine_sumsq	(	real_t &	scale1,
		real_t &	sumsq1,
		real_t	scale2,
		real_t	sumsq2
	)

Adds two scaled, sum-of-squares representations.

On exit, scale1 and sumsq1 are updated such that:

scale1^2 sumsq1 := scale1^2 sumsq1 + scale2^2 sumsq2.

gecondest()

template<typename scalar_t >

blas::real_type< scalar_t > slate::gecondest	(	Norm	in_norm,
		Matrix< scalar_t > &	A,
		blas::real_type< scalar_t >	Anorm,
		Options const &	opts
	)

Distributed parallel estimate of the reciprocal of the condition number of a general matrix A, in either the 1-norm or the infinity-norm.

Generic implementation for any target.

The reciprocal of the condition number computed as:

\[ rcond = \frac{1}{\|\|A\|\| \times \|\|A^{-1}\|\-} \]

where \(A\) is the output of the LU factorization (getrf).

Template Parameters

scalar_t

One of float, double, std::complex<float>, std::complex<double>.

Parameters

[in]	in_norm	rcond to compute: Norm::One: 1-norm condition number Norm::Inf: infinity-norm condition number
[in]	A	On entry, the n-by-n matrix \(A\). It is the output of the LU factorization of a general matrix.
[in]	Anorm	If Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]	opts	Additional options, as map of name = value pairs. Possible options: Option::Target: Implementation to target. Possible values: HostTask: OpenMP tasks on CPU host [default]. HostNest: nested OpenMP parallel for loop on CPU host. HostBatch: batched BLAS on CPU host. Devices: batched BLAS on GPU device.

Returns

rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

get_option()

template<typename T >

T slate::get_option	(	Options	opts,
		Option	option,
		T	defval
	)

Extracts an option.

Parameters

[in]	opt	Map of options and values.
[in]	option	Option to get.
[in]	defval	Default option value if option is not found in map.

global2local()

int64_t slate::global2local ( int64_t  global, int64_t  nb, int  nprocs  )

inline

Returns

local index corresponding to global index, for a 2D block-cyclic distributed matrix.

Parameters

[in]	global	The global index of the distributed matrix entry.
[in]	nb	Block size, size of the blocks the distributed matrix is split into.
[in]	nprocs	The total number processes over which the distributed matrix is distributed.

Corresponds to ScaLAPACK's indxg2l. Dummy arguments iproc, isrcproc are excluded.

id()

const char * slate::id

(

)

Returns

SLATE git commit hash ID.

local2global()

int64_t slate::local2global ( int64_t  local, int64_t  nb, int  iproc, int  isrcproc, int  nprocs  )

inline

Returns

global index corresponding to local index, for a 2D block-cyclic distributed matrix.

Parameters

[in]	local	The local index of the distributed matrix entry.
[in]	nb	Block size the distributed matrix is split into.
[in]	iproc	The coordinate of the process whose local array row or col is to be determined.
[in]	isrcproc	The coordinate of the process that possesses the first row/col of the distributed matrix.
[in]	nprocs	The total number processes over which the distributed matrix is distributed.

Corresponds to ScaLAPACK's indxl2g.

max_nan()

template<typename real_t >

real_t slate::max_nan ( real_t  x, real_t  y  )

inline

max that propagates nan consistently:

max_nan( 1,   nan ) = nan
max_nan( nan, 1   ) = nan

num_local_rows_cols()

int64_t slate::num_local_rows_cols ( int64_t  n, int64_t  nb, int  iproc, int  isrcproc, int  nprocs  )

inline

Computes the number of rows or cols of a distributed matrix owned by the process iproc.

for a 2D block-cyclic distributed matrix.

Parameters

[in]	n	The number of rows/cols in distributed matrix.
[in]	nb	Block size in block-cyclic distribution.
[in]	iproc	The coordinate of the process whose local number of rows/cols is to be determined.
[in]	isrcproc	The coordinate of the process that possesses the first row or col of the distributed matrix.
[in]	nprocs	The total number processes over which the matrix is distributed.

Corresponds to ScaLAPACK's numroc.

origin2target()

Target slate::origin2target ( Origin  origin )

inline

Convert Origin to Target.

Host, ScaLAPACK => Target Host; Devices => Target Devices.

pocondest()

template<typename scalar_t >

blas::real_type< scalar_t > slate::pocondest	(	Norm	in_norm,
		HermitianMatrix< scalar_t > &	A,
		blas::real_type< scalar_t >	Anorm,
		Options const &	opts
	)

Distributed parallel estimate of the reciprocal of the condition number of a general matrix A, in either the 1-norm or the infinity-norm.

Generic implementation for any target.

The reciprocal of the condition number computed as:

\[ rcond = \frac{1}{\|\|A\|\| \times \|\|A^{-1}\|\-} \]

where \(A\) is the output of the Cholesky factorization (potrf).

Template Parameters

scalar_t

One of float, double, std::complex<float>, std::complex<double>.

Parameters

[in]	in_norm	rcond to compute: Norm::One: 1-norm condition number Norm::Inf: infinity-norm condition number
[in]	A	On entry, the n-by-n matrix \(A\). It is the output of the Cholesky factorization of a Hermitian matrix.
[in]	Anorm	If Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]	opts	Additional options, as map of name = value pairs. Possible options: Option::Target: Implementation to target. Possible values: HostTask: OpenMP tasks on CPU host [default]. HostNest: nested OpenMP parallel for loop on CPU host. HostBatch: batched BLAS on CPU host. Devices: batched BLAS on GPU device.

Returns

rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

pow10()

static double slate::pow10 ( int  y )

inlinestatic

Returns

10^y for 0 <= y <= 20.

print() [1/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		BandMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed band matrix.

Rank 0 does the printing, and must have enough memory to fit one entire block row of the matrix. Tiles outside the bandwidth are printed as "0", with no trailing decimals. For block-sparse matrices, missing tiles are print as "nan".

print() [2/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		BaseTriangularBandMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed BaseTriangular (triangular, symmetric, and Hermitian) band matrix.

Rank 0 does the printing, and must have enough memory to fit one entire block row of the matrix. Tiles outside the bandwidth are printed as "0", with no trailing decimals. For block-sparse matrices, missing tiles are print as "nan".

Entries in the A.uplo triangle are printed; entries in the opposite triangle are printed as "nan".

Having said that, if the printed matrix is a lower triangular matrix, then the routine will print the tiles of upper part of the matrix as "nan", and the lower part tiles that are inside the bandwidth will be printed as they are, whereas the non existing tiles, tiles outside the bandwidth, will be printed as "0", with no trailing decimals. This is to follow MATLAB convention and to make it easier for debugging.

print() [3/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		HermitianMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed Hermitian matrix.

Also prints Matlab tril or triu command to fix entries in opposite triangle. todo: fix complex diag in Matlab? (Sca)LAPACK ignores imag part.

print() [4/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		int64_t	n,
		scalar_t const *	x,
		int64_t	incx,
		Options const &	opts
	)

Print a vector.

Every MPI rank does its own printing, so protect with if (mpi_rank == 0) as desired.

print() [5/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		Matrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed matrix.

Rank 0 does the printing, and must have enough memory to fit one entire block row of the matrix. For block-sparse matrices, missing tiles are print as "nan".

print() [6/10]

template<typename scalar_type >

void slate::print	(	const char *	label,
		std::vector< scalar_type > const &	x,
		Options const &	opts
	)

Print a vector.

Every MPI rank does its own printing, so protect with if (mpi_rank == 0) as desired.

print() [7/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		SymmetricMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed symmetric matrix.

Also prints Matlab tril or triu command to fix entries in opposite triangle.

print() [8/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		Tile< scalar_t > &	A,
		blas::Queue &	queue,
		Options const &	opts
	)

Print a SLATE tile, on either CPU or GPU.

Does not change MSI status. No MPI is involved.

print() [9/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		TrapezoidMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed trapezoid matrix.

Also prints Matlab tril or triu command to fix entries in opposite triangle. todo: fix unit diag in Matlab.

print() [10/10]

template<typename scalar_t >

void slate::print	(	const char *	label,
		TriangularMatrix< scalar_t > &	A,
		Options const &	opts
	)

Print a SLATE distributed triangular matrix.

Also prints Matlab tril or triu command to fix entries in opposite triangle. todo: fix unit diag in Matlab.

print_work()

template<typename scalar_t >

void slate::print_work	(	const char *	label,
		BaseMatrix< scalar_t > &	A,
		int64_t	klt,
		int64_t	kut,
		Options const &	opts_
	)

Print a SLATE distributed trapezoid matrix.

Rank 0 does the printing, and must have enough memory to fit one entire block row of the matrix. For block-sparse matrices, missing tiles are print as "nan".

This version handles trapezoid, triangular, symmetric, and Hermitian matrices. Entries in the A.uplo triangle are printed; entries in the opposite triangle are printed as "nan".

roundup()

template<typename T >

constexpr T slate::roundup ( T  x, T  y  )

inlineconstexpr

Returns

ceil( x / y )*y, i.e., x rounded up to next multiple of y.

scale_row_col()

template<typename scalar_t , typename scalar_t2 >

void slate::scale_row_col	(	Equed	equed,
		std::vector< scalar_t2 > const &	R,
		std::vector< scalar_t2 > const &	C,
		Matrix< scalar_t > &	A,
		Options const &	opts
	)

Apply row or column scaling, or both, to a Matrix.

Transposition is currently ignored. TODO: Inspect transposition?

Template Parameters

scalar_t

One of float, double, std::complex<float>, std::complex<double>.

Parameters

[in]	equed	Form of scaling to do. Equed::Row: sets \( A = diag(R) A \) Equed::Col: sets \( A = A diag(C) \) Equed::Both: sets \( A = diag(R) A diag(C) \)
[in,out]	R	Vector of length m containing row scaling factors.
[in,out]	C	Vector of length n containing column scaling factors.
[in,out]	A	The m-by-n matrix A.
[in]	opts	Additional options, as map of name = value pairs. Possible options: Option::Target: Implementation to target. Possible values: HostTask: OpenMP tasks on CPU host [default]. HostNest: [uses HostTask] HostBatch: [uses HostTask] Devices: batched BLAS on GPU device.

send_recv_tile()

template<typename scalar_t >

void slate::send_recv_tile	(	BaseMatrix< scalar_t > &	A,
		int64_t	i,
		int64_t	j,
		int	mpi_rank,
		MPI_Comm	comm
	)

Sends tiles A(i, j) and receives it on rank 0.

If rank != 0 and tile A(i, j) is local, sends it to rank 0. If rank == 0, inserts and receives tile A(i, j), unless tile didn't exist on sender.

sign()

template<typename real_t >

real_t slate::sign

(

real_t

val

)

Sign (signum) function.

Returns

-1 if val < 0, 0 if val == 0, +1 if val > 0.

snprintf_value()

template<typename real_t , enable_if_t< std::is_floating_point< real_t >::value > * = nullptr>

int slate::snprintf_value	(	char *	buf,
		size_t	buf_len,
		int	width,
		int	precision,
		real_t	value
	)

Print real value to a buffer buf of length buf_len.

For w = width and p = precision:

• integers are printed with v.0f where v = w-p
• small values < 0.01 or large values > threshold are printed with w.pg
• modest values are printed with w.pf. To ensure data fits, set threshold = 10^(w - p - 2) and w >= p + 6.

sqr()

template<typename scalar_t >

scalar_t slate::sqr ( scalar_t  x )

inline

Square of number.

Returns

x^2

stedc_sort()

template<typename real_t >

void slate::stedc_sort	(	std::vector< real_t > &	D,
		Matrix< real_t > &	Q,
		Matrix< real_t > &	Qout,
		Options const &	opts
	)

Sorts eigenvalues in D and apply same permutation to eigenvectors in Q.

Corresponds to ScaLAPACK pdlasrt.

Parameters

[in,out]	D	On entry, unsorted eigenvalues. On exit, eigenvalues in ascending order.
[in]	Q	Eigenvectors corresponding to D.
[out]	Qout	On exit, the eigenvectors ordered according to sorted D.
[in]	opts	Currently unused.

tile_row_string() [1/2]

template<typename scalar_t >

std::string slate::tile_row_string	(	BaseMatrix< scalar_t > &	A,
		int64_t	i,
		int64_t	j,
		int64_t	ti,
		int	width,
		int	precision,
		const char *	opposite = ""
	)

Returns string for row ti of tile A(i, j).

If tile doesn't exist, returns string with NAN values. For upper or lower tiles, uses opposite for values in the opposite (lower or upper, respectively) triangle. Works for all matrix types.

tile_row_string() [2/2]

template<typename scalar_t >

std::string slate::tile_row_string	(	BaseMatrix< scalar_t > &	A,
		int64_t	i,
		int64_t	j,
		int64_t	ti,
		Options const &	opts,
		const char *	opposite = "",
		bool	is_last_abbrev_cols = false
	)

Returns string for row ti of tile A(i, j).

If tile doesn't exist, returns string with NAN values. For upper or lower tiles, uses opposite for values in the opposite (lower or upper, respectively) triangle. Works for all matrix types.

trcondest()

template<typename scalar_t >

blas::real_type< scalar_t > slate::trcondest	(	Norm	in_norm,
		TriangularMatrix< scalar_t > &	A,
		blas::real_type< scalar_t >	Anorm,
		Options const &	opts
	)

Distributed parallel estimate of the reciprocal of the condition number of a triangular matrix A, in either the 1-norm or the infinity-norm.

Generic implementation for any target.

The reciprocal of the condition number computed as:

\[ rcond = \frac{1}{\|\|A\|\| \times \|\|A^{-1}\|\|} \]

where \(A\) is an upper triangular matrix.

Template Parameters

scalar_t

One of float, double, std::complex<float>, std::complex<double>.

Parameters

[in]	in_norm	rcond to compute: Norm::One: 1-norm condition number Norm::Inf: infinity-norm condition number
[in]	A	On entry, the n-by-n triangular matrix \(A\).
[in]	Anorm	If Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]	opts	Additional options, as map of name = value pairs. Possible options: Option::Target: Implementation to target. Possible values: HostTask: OpenMP tasks on CPU host [default]. HostNest: nested OpenMP parallel for loop on CPU host. HostBatch: batched BLAS on CPU host. Devices: batched BLAS on GPU device.

Returns

rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

version()

int slate::version

(

)

Returns

SLATE version. Version is integer of form yyyymmrr, where yyyy is year, mm is month, and rr is release counter within month, starting at 00.

Variable Documentation

MethodEig_help

const char * slate::MethodEig_help

Initial value:

= "auto; QR (QR iteration); DC (divide & conquer); "
                                "bisection; MRRR"

MethodSVD_help

const char * slate::MethodSVD_help

Initial value:

= "auto; QR (QR iteration); DC (divide & conquer); "
                                "bisection"

Origin_help

const char * slate::Origin_help

Initial value:

= "d, dev, or devices; h or host; "
                                "s, scalpk, or scalapack"

Target_help

const char * slate::Target_help

Initial value:

= "d, dev, or devices; h or host; t or task; "
                                "n or nest; b or batch"

timers

std::map< std::string, double > slate::timers

Map of timers, in seconds, for top-level routines.

For example: timers[ "gels" ] is time for gels, timers[ "gels::geqrf" ] is time for geqrf inside gels.