SLATE 2024.05.31
Software for Linear Algebra Targeting Exascale
|
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 ¶ms, 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 ¶ms, 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 ¶ms, 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 ¶ms, slate::Matrix< scalar_t > &A, slate::Options const &opts=slate::Options()) |
template<typename scalar_t > | |
void | generate_matrix (MatgenParams ¶ms, slate::BaseTrapezoidMatrix< scalar_t > &A, slate::Options const &opts=slate::Options()) |
template<typename scalar_t > | |
void | generate_matrix (MatgenParams ¶ms, 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 ¶ms, 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 |
SLATE's top-level namespace.
using slate::Value = typedef OptionValue |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
|
strong |
enum slate::MOSI |
A tile state in the MOSI coherency protocol.
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
|
inline |
|
inlineconstexpr |
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.
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).
scalar_t | One of float, double, std::complex<float>, std::complex<double>. |
[in] | in_norm | rcond to compute:
|
[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:
|
T slate::get_option | ( | Options | opts, |
Option | option, | ||
T | defval | ||
) |
Extracts an option.
[in] | opt | Map of options and values. |
[in] | option | Option to get. |
[in] | defval | Default option value if option is not found in map. |
|
inline |
[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.
const char * slate::id | ( | ) |
|
inline |
[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.
|
inline |
max that propagates nan consistently:
max_nan( 1, nan ) = nan max_nan( nan, 1 ) = nan
|
inline |
Computes the number of rows or cols of a distributed matrix owned by the process iproc.
for a 2D block-cyclic distributed matrix.
[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.
|
inline |
Convert Origin to Target.
Host, ScaLAPACK => Target Host; Devices => Target Devices.
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).
scalar_t | One of float, double, std::complex<float>, std::complex<double>. |
[in] | in_norm | rcond to compute:
|
[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:
|
|
inlinestatic |
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".
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.
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.
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.
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".
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.
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.
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.
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.
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.
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".
|
inlineconstexpr |
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?
scalar_t | One of float, double, std::complex<float>, std::complex<double>. |
[in] | equed | Form of scaling to do.
|
[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:
|
void slate::send_recv_tile | ( | BaseMatrix< scalar_t > & | A, |
int64_t | i, | ||
int64_t | j, | ||
int | mpi_rank, | ||
MPI_Comm | comm | ||
) |
real_t slate::sign | ( | real_t | val | ) |
Sign (signum) function.
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:
|
inline |
Square of number.
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.
[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. |
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.
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.
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.
scalar_t | One of float, double, std::complex<float>, std::complex<double>. |
[in] | in_norm | rcond to compute:
|
[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:
|
int slate::version | ( | ) |
const char * slate::MethodEig_help |
const char * slate::MethodSVD_help |
const char * slate::Origin_help |
const char * slate::Target_help |
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.