SLATE 2024.05.31
Software for Linear Algebra Targeting Exascale
Loading...
Searching...
No Matches
slate Namespace Reference

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

Namespaces

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

Classes

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

Typedefs

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

Enumerations

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

Functions

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

Variables

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

Detailed Description

SLATE's top-level namespace.

Typedef Documentation

◆ Value

Enumeration Type Documentation

◆ MethodCholQR

enum class slate::MethodCholQR : char
strong

Algorithm to use for Cholesky QR.

Enumerator
Auto 

Let SLATE decide.

GemmA 

Use gemm-A algorithm to compute A^H A.

GemmC 

Use gemm-C algorithm to compute A^H A.

HerkA 

Use herk-A algorithm to compute A^H A; not yet implemented.

HerkC 

Use herk-C algorithm to compute A^H A.

◆ MethodEig

enum class slate::MethodEig : char
strong

Algorithm to use for eigenvalues (eig).

Enumerator
Auto 

Let SLATE decide.

QR 

QR iteration.

DC 

Divide and conquer.

Bisection 

Bisection; not yet implemented.

MRRR 

Multiple Relatively Robust Representations (MRRR); not yet implemented.

◆ MethodGels

enum class slate::MethodGels : char
strong

Algorithm to use for least squares (gels).

Enumerator
Auto 

Let SLATE decide.

QR 

Use Householder QR factorization.

CholQR 

Use Cholesky QR factorization; use when A is well-conditioned.

◆ MethodGemm

enum class slate::MethodGemm : char
strong

Algorithm to use for general matrix multiply (gemm).

Enumerator
Auto 

Let SLATE decide.

Matrix A is stationary, C is sent; use when C is small.

Matrix C is stationary, A is sent; use when C is large.

◆ MethodHemm

enum class slate::MethodHemm : char
strong

Algorithm to use for Hermitian matrix multiply (hemm).

Enumerator
Auto 

Let SLATE decide.

Matrix A is stationary, C is sent; use when C is small.

Matrix C is stationary, A is sent; use when C is large.

◆ MethodLU

enum class slate::MethodLU : char
strong

Algorithm to use for LU factorization and solve.

Enumerator
Auto 

Let SLATE decide.

PartialPiv 

Use classical partial pivoting.

CALU 

Use Communication Avoiding LU (CALU)

NoPiv 

Use no-pivoting LU.

RBT 

Use Random Butterfly Transform (RBT)

BEAM 

Use BEAM LU factorization.

◆ MethodSVD

enum class slate::MethodSVD : char
strong

Algorithm to use for singular value decomposition (SVD).

Enumerator
Auto 

Let SLATE decide.

QR 

QR iteration.

DC 

Divide and conquer; not yet implemented.

Bisection 

Bisection; not yet implemented.

◆ MethodTrsm

enum class slate::MethodTrsm : char
strong

Algorithm to use for triangular solve (trsm).

Enumerator
Auto 

Let SLATE decide.

Matrix A is stationary, B is sent; use when B is small.

Matrix B is stationary, A is sent; use when B is large.

◆ MOSI

A tile state in the MOSI coherency protocol.

Enumerator
Modified 

tile data is modified, other instances should be Invalid, cannot be purged

OnHold 

a hold is placed on this tile instance, cannot be purged

Shared 

tile data is up-to-date, other instances may be Shared, or Invalid, may be purged

Invalid 

tile data is obsolete, other instances may be Modified, Shared, or Invalid, may be purged

Function Documentation

◆ add_sumsq()

template<typename real_t >
void slate::add_sumsq ( real_t &  scale,
real_t &  sumsq,
real_t  absx 
)

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

On exit, scale and sumsq are updated such that:

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

◆ cabs1()

float slate::cabs1 ( float  x)
inline
Returns
abs(r) + abs(i)

◆ ceildiv()

template<typename T >
constexpr T slate::ceildiv ( x,
y 
)
inlineconstexpr
Returns
ceil( x / y ), for integer type T.

◆ combine_sumsq()

template<typename real_t >
void slate::combine_sumsq ( real_t &  scale1,
real_t &  sumsq1,
real_t  scale2,
real_t  sumsq2 
)

Adds two scaled, sum-of-squares representations.

On exit, scale1 and sumsq1 are updated such that:

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

◆ gecondest()

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

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

Generic implementation for any target.

The reciprocal of the condition number computed as:

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

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

Template Parameters
scalar_tOne of float, double, std::complex<float>, std::complex<double>.
Parameters
[in]in_normrcond to compute:
  • Norm::One: 1-norm condition number
  • Norm::Inf: infinity-norm condition number
[in]AOn entry, the n-by-n matrix \(A\). It is the output of the LU factorization of a general matrix.
[in]AnormIf Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]optsAdditional options, as map of name = value pairs. Possible options:
  • Option::Target: Implementation to target. Possible values:
    • HostTask: OpenMP tasks on CPU host [default].
    • HostNest: nested OpenMP parallel for loop on CPU host.
    • HostBatch: batched BLAS on CPU host.
    • Devices: batched BLAS on GPU device.
Returns
rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

◆ get_option()

template<typename T >
T slate::get_option ( Options  opts,
Option  option,
defval 
)

Extracts an option.

Parameters
[in]optMap of options and values.
[in]optionOption to get.
[in]defvalDefault option value if option is not found in map.

◆ global2local()

int64_t slate::global2local ( int64_t  global,
int64_t  nb,
int  nprocs 
)
inline
Returns
local index corresponding to global index, for a 2D block-cyclic distributed matrix.
Parameters
[in]globalThe global index of the distributed matrix entry.
[in]nbBlock size, size of the blocks the distributed matrix is split into.
[in]nprocsThe total number processes over which the distributed matrix is distributed.

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

◆ id()

const char * slate::id ( )
Returns
SLATE git commit hash ID.

◆ local2global()

int64_t slate::local2global ( int64_t  local,
int64_t  nb,
int  iproc,
int  isrcproc,
int  nprocs 
)
inline
Returns
global index corresponding to local index, for a 2D block-cyclic distributed matrix.
Parameters
[in]localThe local index of the distributed matrix entry.
[in]nbBlock size the distributed matrix is split into.
[in]iprocThe coordinate of the process whose local array row or col is to be determined.
[in]isrcprocThe coordinate of the process that possesses the first row/col of the distributed matrix.
[in]nprocsThe total number processes over which the distributed matrix is distributed.

Corresponds to ScaLAPACK's indxl2g.

◆ max_nan()

template<typename real_t >
real_t slate::max_nan ( real_t  x,
real_t  y 
)
inline

max that propagates nan consistently:

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

◆ num_local_rows_cols()

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

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

for a 2D block-cyclic distributed matrix.

Parameters
[in]nThe number of rows/cols in distributed matrix.
[in]nbBlock size in block-cyclic distribution.
[in]iprocThe coordinate of the process whose local number of rows/cols is to be determined.
[in]isrcprocThe coordinate of the process that possesses the first row or col of the distributed matrix.
[in]nprocsThe total number processes over which the matrix is distributed.

Corresponds to ScaLAPACK's numroc.

◆ origin2target()

Target slate::origin2target ( Origin  origin)
inline

Convert Origin to Target.

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

◆ pocondest()

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

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

Generic implementation for any target.

The reciprocal of the condition number computed as:

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

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

Template Parameters
scalar_tOne of float, double, std::complex<float>, std::complex<double>.
Parameters
[in]in_normrcond to compute:
  • Norm::One: 1-norm condition number
  • Norm::Inf: infinity-norm condition number
[in]AOn entry, the n-by-n matrix \(A\). It is the output of the Cholesky factorization of a Hermitian matrix.
[in]AnormIf Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]optsAdditional options, as map of name = value pairs. Possible options:
  • Option::Target: Implementation to target. Possible values:
    • HostTask: OpenMP tasks on CPU host [default].
    • HostNest: nested OpenMP parallel for loop on CPU host.
    • HostBatch: batched BLAS on CPU host.
    • Devices: batched BLAS on GPU device.
Returns
rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

◆ pow10()

static double slate::pow10 ( int  y)
inlinestatic
Returns
10^y for 0 <= y <= 20.

◆ print() [1/10]

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

Print a SLATE distributed band matrix.

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

◆ print() [2/10]

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

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

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

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

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

◆ print() [3/10]

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

Print a SLATE distributed Hermitian matrix.

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

◆ print() [4/10]

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

Print a vector.

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

◆ print() [5/10]

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

Print a SLATE distributed matrix.

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

◆ print() [6/10]

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

Print a vector.

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

◆ print() [7/10]

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

Print a SLATE distributed symmetric matrix.

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

◆ print() [8/10]

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

Print a SLATE tile, on either CPU or GPU.

Does not change MSI status. No MPI is involved.

◆ print() [9/10]

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

Print a SLATE distributed trapezoid matrix.

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

◆ print() [10/10]

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

Print a SLATE distributed triangular matrix.

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

◆ print_work()

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

Print a SLATE distributed trapezoid matrix.

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

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

◆ roundup()

template<typename T >
constexpr T slate::roundup ( x,
y 
)
inlineconstexpr
Returns
ceil( x / y )*y, i.e., x rounded up to next multiple of y.

◆ scale_row_col()

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

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

Transposition is currently ignored. TODO: Inspect transposition?

Template Parameters
scalar_tOne of float, double, std::complex<float>, std::complex<double>.
Parameters
[in]equedForm of scaling to do.
  • Equed::Row: sets \( A = diag(R) A \)
  • Equed::Col: sets \( A = A diag(C) \)
  • Equed::Both: sets \( A = diag(R) A diag(C) \)
[in,out]RVector of length m containing row scaling factors.
[in,out]CVector of length n containing column scaling factors.
[in,out]AThe m-by-n matrix A.
[in]optsAdditional options, as map of name = value pairs. Possible options:
  • Option::Target: Implementation to target. Possible values:
    • HostTask: OpenMP tasks on CPU host [default].
    • HostNest: [uses HostTask]
    • HostBatch: [uses HostTask]
    • Devices: batched BLAS on GPU device.

◆ send_recv_tile()

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

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

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

◆ sign()

template<typename real_t >
real_t slate::sign ( real_t  val)

Sign (signum) function.

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

◆ snprintf_value()

template<typename real_t , enable_if_t< std::is_floating_point< real_t >::value > * = nullptr>
int slate::snprintf_value ( char *  buf,
size_t  buf_len,
int  width,
int  precision,
real_t  value 
)

Print real value to a buffer buf of length buf_len.

For w = width and p = precision:

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

◆ sqr()

template<typename scalar_t >
scalar_t slate::sqr ( scalar_t  x)
inline

Square of number.

Returns
x^2

◆ stedc_sort()

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

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

Corresponds to ScaLAPACK pdlasrt.

Parameters
[in,out]DOn entry, unsorted eigenvalues. On exit, eigenvalues in ascending order.
[in]QEigenvectors corresponding to D.
[out]QoutOn exit, the eigenvectors ordered according to sorted D.
[in]optsCurrently unused.

◆ tile_row_string() [1/2]

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

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

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

◆ tile_row_string() [2/2]

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

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

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

◆ trcondest()

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

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

Generic implementation for any target.

The reciprocal of the condition number computed as:

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

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

Template Parameters
scalar_tOne of float, double, std::complex<float>, std::complex<double>.
Parameters
[in]in_normrcond to compute:
  • Norm::One: 1-norm condition number
  • Norm::Inf: infinity-norm condition number
[in]AOn entry, the n-by-n triangular matrix \(A\).
[in]AnormIf Norm::One, the 1-norm of the original matrix A. If Norm::Inf, the infinity-norm of the original matrix A.
[in]optsAdditional options, as map of name = value pairs. Possible options:
  • Option::Target: Implementation to target. Possible values:
    • HostTask: OpenMP tasks on CPU host [default].
    • HostNest: nested OpenMP parallel for loop on CPU host.
    • HostBatch: batched BLAS on CPU host.
    • Devices: batched BLAS on GPU device.
Returns
rcond The reciprocal of the condition number of the matrix A, computed as stated above. rcond is used instead of cond to handle overflow better.

◆ version()

int slate::version ( )
Returns
SLATE version. Version is integer of form yyyymmrr, where yyyy is year, mm is month, and rr is release counter within month, starting at 00.

Variable Documentation

◆ MethodEig_help

const char * slate::MethodEig_help
Initial value:
= "auto; QR (QR iteration); DC (divide & conquer); "
"bisection; MRRR"

◆ MethodSVD_help

const char * slate::MethodSVD_help
Initial value:
= "auto; QR (QR iteration); DC (divide & conquer); "
"bisection"

◆ Origin_help

const char * slate::Origin_help
Initial value:
= "d, dev, or devices; h or host; "
"s, scalpk, or scalapack"

◆ Target_help

const char * slate::Target_help
Initial value:
= "d, dev, or devices; h or host; t or task; "
"n or nest; b or batch"

◆ timers

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

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

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