lapack library

Classes

Array<T>

Box<T>

Complex

Complex64List

DelegatingBox<T>

Matrix<T>

Matrix3d<T>

Matrix3dItemAccessor1<T>

Matrix3dItemAccessor2<T>

MatrixItemAccessor<T>

Nin

Nout

NoutDelegator<T extends Nout>

NullNout

StreamNout

Extensions

ArrayExtension on Array<T>

BoolFormatSpecifiersExtension on bool

ComplexFloat64x2Extension on Complex

ComplexListTupleExtension on List<ComplexTuple>

ComplexTupleExtension on ComplexTuple

DoubleArrayFormatSpecifiersExtension on Array<double>

DoubleComplexExtension on double

DoubleFormatSpecifiersExtension on double

DoubleIterableFormatSpecifiersExtension on Iterable<double>

Float64x2ComplexExtension on Float64x2

FunctionExtensions on Complex

IntArrayFormatSpecifiersExtension on Array<int>

IntFormatSpecifiersExtension on int

IntIterableFormatSpecifiersExtension on Iterable<int>

NumComplexExtension on num

RangeExtension on int

StringFormatSpecifiersExtension on String

StringIterableFormatSpecifiersExtension on Iterable<String>

Constants

deight → const double

dfour → const double

dhalf → const double

digits → const int Function(double _)

done → const double

dp → const int

dprefix → const String

dten → const double

dthree → const double

dtwo → const double

dzero → const double

epsilon → const double Function(double v)

exponent → const int Function(double _)

huge → const N Function<N extends num>(N n)

maxexponent → const int Function(double _)

minexponent → const int Function(double _)

one → const double

oneIndexedArrayOffset → const int

oneIndexedMatrix3dOffset → const ({int x, int y, int z})

oneIndexedMatrixOffset → const ({int x, int y})

radix32 → const N Function<N extends num>(N n)

radix64 → const N Function<N extends num>(N n)

tiny → const double Function(double v)

wp → const int

zero → const double

zeroIndexedArrayOffset → const int

zeroIndexedMatrix3dOffset → const ({int x, int y, int z})

zeroIndexedMatrixOffset → const ({int x, int y})

zhalf → const Complex

zone → const Complex

zprefix → const String

zzero → const Complex

Properties

dbignum → double

final

deps → double

final

drtmax → double

final

drtmin → double

final

dsafmax → double

final

dsafmin → double

final

dsbig → num

final

dsmlnum → double

final

dssml → num

final

dtbig → num

final

dtsml → num

final

dulp → double

final

ilaenv ↔ int Function(int ISPEC, String NAME, String OPTS, int N1, int N2, int N3, int N4)

getter/setter pair

ilaenv2stage ↔ int Function(int ISPEC, String NAME, String OPTS, int N1, int N2, int N3, int N4)

getter/setter pair

sbig → num

final

ssml → num

final

tbig → num

final

tsml → num

final

xerbla ↔ void Function(String SRNAME, int INFO)

getter/setter pair

Functions

cgetrf(int M, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

cgetrs(String TRANS, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

chla_transtype(int TRANS) → String

clag2z(int M, int N, Matrix<Complex> SA_, int LDSA, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

cpotrf(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

cpotrs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

dasum(int N, Array<double> DX, int INCX) → double

daxpy(int N, double DA, Array<double> DX_, int INCX, Array<double> DY_, int INCY) → void

dbbcsd(String JOBU1, String JOBU2, String JOBV1T, String JOBV2T, String TRANS, int M, int P, int Q, Array<double> THETA_, Array<double> PHI_, Matrix<double> U1_, int LDU1, Matrix<double> U2_, int LDU2, Matrix<double> V1T_, int LDV1T, Matrix<double> V2T_, int LDV2T, Array<double> B11D_, Array<double> B11E_, Array<double> B12D_, Array<double> B12E_, Array<double> B21D_, Array<double> B21E_, Array<double> B22D_, Array<double> B22E_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dbdsdc(String UPLO, String COMPQ, int N, Array<double> D_, Array<double> E_, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<double> Q_, Array<int> IQ_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dbdsqr(String UPLO, int N, int NCVT, int NRU, int NCC, Array<double> D_, Array<double> E_, Matrix<double> VT_, int LDVT, Matrix<double> U_, int LDU, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dbdsvdx(String UPLO, String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, Box<int> NS, Array<double> S_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dcabs1(Complex Z) → double

dcopy(int N, Array<double> DX_, int INCX, Array<double> DY_, int INCY) → void

ddisna(String JOB, int M, int N, Array<double> D_, Array<double> SEP_, Box<int> INFO) → void

ddot(int N, Array<double> DX_, int INCX, Array<double> DY_, int INCY) → double

dgbbrd(String VECT, int M, int N, int NCC, int KL, int KU, Matrix<double> AB_, int LDAB, Array<double> D_, Array<double> E_, Matrix<double> Q_, int LDQ, Matrix<double> PT_, int LDPT, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dgbcon(String NORM, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgbequ(int M, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

dgbequb(int M, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

dgbmv(String TRANS, int M, int N, int KL, int KU, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dgbrfs(String TRANS, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgbrfsx(String TRANS, String EQUED, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgbsv(int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgbsvx(String FACT, String TRANS, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgbsvxx(String FACT, String TRANS, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgbtf2(int M, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<int> IPIV_, Box<int> INFO) → void

dgbtrf(int M, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<int> IPIV_, Box<int> INFO) → void

dgbtrs(String TRANS, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgebak(String JOB, String SIDE, int N, int ILO, int IHI, Array<double> SCALE_, int M, Matrix<double> V_, int LDV, Box<int> INFO) → void

dgebal(String JOB, int N, Matrix<double> A_, int LDA, Box<int> ILO, Box<int> IHI, Array<double> SCALE_, Box<int> INFO) → void

dgebd2(int M, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAUQ_, Array<double> TAUP_, Array<double> WORK_, Box<int> INFO) → void

dgebrd(int M, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAUQ_, Array<double> TAUP_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgecon(String NORM, int N, Matrix<double> A_, int LDA, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgedmd(String JOBS, String JOBZ, String JOBR, String JOBF, int WHTSVD, int M, int N, Matrix<double> X_, int LDX, Matrix<double> Y_, int LDY, int NRNK, double TOL, Box<int> K, Array<double> REIG_, Array<double> IMEIG_, Matrix<double> Z_, int LDZ, Array<double> RES_, Matrix<double> B_, int LDB, Matrix<double> W_, int LDW, Matrix<double> S_, int LDS, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dgedmdq(String JOBS, String JOBZ, String JOBR, String JOBQ, String JOBT, String JOBF, int WHTSVD, int M, int N, Matrix<double> F_, int LDF, Matrix<double> X_, int LDX, Matrix<double> Y_, int LDY, int NRNK, double TOL, Box<int> K, Array<double> REIG_, Array<double> IMEIG_, Matrix<double> Z_, int LDZ, Array<double> RES_, Matrix<double> B_, int LDB, Matrix<double> V_, int LDV, Matrix<double> S_, int LDS, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dgeequ(int M, int N, Matrix<double> A_, int LDA, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

dgeequb(int M, int N, Matrix<double> A_, int LDA, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

dgees(String JOBVS, String SORT, bool SELECT(double, double), int N, Matrix<double> A_, int LDA, Box<int> SDIM, Array<double> WR_, Array<double> WI_, Matrix<double> VS_, int LDVS, Array<double> WORK_, int LWORK, Array<bool> BWORK_, Box<int> INFO) → void

dgeesx(String JOBVS, String SORT, bool SELECT(double, double), String SENSE, int N, Matrix<double> A_, int LDA, Box<int> SDIM, Array<double> WR_, Array<double> WI_, Matrix<double> VS_, int LDVS, Box<double> RCONDE, Box<double> RCONDV, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Array<bool> BWORK_, Box<int> INFO) → void

dgeev(String JOBVL, String JOBVR, int N, Matrix<double> A_, int LDA, Array<double> WR_, Array<double> WI_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeevx(String BALANC, String JOBVL, String JOBVR, String SENSE, int N, Matrix<double> A_, int LDA, Array<double> WR_, Array<double> WI_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Box<int> ILO, Box<int> IHI, Array<double> SCALE_, Box<double> ABNRM, Array<double> RCONDE_, Array<double> RCONDV_, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgehd2(int N, int ILO, int IHI, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgehrd(int N, int ILO, int IHI, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgejsv(String JOBA, String JOBU, String JOBV, String JOBR, String JOBT, String JOBP, int M, int N, Matrix<double> A_, int LDA, Array<double> SVA_, Matrix<double> U_, int LDU, Matrix<double> V_, int LDV, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgelq(int M, int N, Matrix<double> A_, int LDA, Array<double> T_, int TSIZE, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgelq2(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgelqf(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgelqt(int M, int N, int MB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, Box<int> INFO) → void

dgelqt3(int M, int N, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Box<int> INFO) → void

dgels(String TRANS, int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgelsd(int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> S_, double RCOND, Box<int> RANK, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgelss(int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> S_, Box<double> RCOND, Box<int> RANK, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgelst(String TRANS, int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgelsy(int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<int> JPVT_, double RCOND, Box<int> RANK, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgemlq(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> T_, int TSIZE, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgemlqt(String SIDE, String TRANS, int M, int N, int K, int MB, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dgemm(String TRANSA, String TRANSB, int M, int N, int K, double ALPHA, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double BETA, Matrix<double> C_, int LDC) → void

dgemqr(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> T_, int TSIZE, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgemqrt(String SIDE, String TRANS, int M, int N, int K, int NB, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dgemv(String TRANS, int M, int N, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dgeql2(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgeqlf(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeqp3(int M, int N, Matrix<double> A_, int LDA, Array<int> JPVT_, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeqp3rk(int M, int N, int NRHS, int KMAX, Box<double> ABSTOL, Box<double> RELTOL, Matrix<double> A_, int LDA, Box<int> K, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<double> TAU_, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgeqr(int M, int N, Matrix<double> A_, int LDA, Array<double> T_, int TSIZE, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeqr2(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgeqr2p(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgeqrf(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeqrfp(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgeqrt(int M, int N, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, Box<int> INFO) → void

dgeqrt2(int M, int N, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Box<int> INFO) → void

dgeqrt3(int M, int N, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Box<int> INFO) → void

dger(int M, int N, double ALPHA, Array<double> X_, int INCX, Array<double> Y_, int INCY, Matrix<double> A_, int LDA) → void

dgerfs(String TRANS, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgerfsx(String TRANS, String EQUED, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgerq2(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dgerqf(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgesc2(int N, Matrix<double> A_, int LDA, Array<double> RHS_, Array<int> IPIV_, Array<int> JPIV_, Box<double> SCALE) → void

dgesdd(String JOBZ, int M, int N, Matrix<double> A_, int LDA, Array<double> S_, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgesv(int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgesvd(String JOBU, String JOBVT, int M, int N, Matrix<double> A_, int LDA, Array<double> S_, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgesvdq(String JOBA, String JOBP, String JOBR, String JOBU, String JOBV, int M, int N, Matrix<double> A_, int LDA, Array<double> S_, Matrix<double> U_, int LDU, Matrix<double> V_, int LDV, Box<int> NUMRANK, Array<int> IWORK_, int LIWORK, Array<double> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Box<int> INFO) → void

dgesvdx(String JOBU, String JOBVT, String RANGE, int M, int N, Matrix<double> A_, int LDA, double VL, double VU, int IL, int IU, Box<int> NS, Array<double> S_, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dgesvj(String JOBA, String JOBU, String JOBV, int M, int N, Matrix<double> A_, int LDA, Array<double> SVA_, int MV, Matrix<double> V_, int LDV, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgesvx(String FACT, String TRANS, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgesvxx(String FACT, String TRANS, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgetc2(int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<int> JPIV_, Box<int> INFO) → void

dgetf2(int M, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

dgetrf(int M, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

dgetrf2(int M, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

dgetri(int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgetrs(String TRANS, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgetsls(String TRANS, int M, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgetsqrhrt(int M, int N, int MB1, int NB1, int NB2, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggbak(String JOB, String SIDE, int N, int ILO, int IHI, Array<double> LSCALE_, Array<double> RSCALE_, int M, Matrix<double> V_, int LDV, Box<int> INFO) → void

dggbal(String JOB, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> ILO, Box<int> IHI, Array<double> LSCALE_, Array<double> RSCALE_, Array<double> WORK_, Box<int> INFO) → void

dgges(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(double ZR, double ZI, double D), int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> SDIM, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VSL_, int LDVSL, Matrix<double> VSR_, int LDVSR, Array<double> WORK_, int LWORK, Array<bool> BWORK_, Box<int> INFO) → void

dgges3(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(double ZR, double ZI, double D), int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> SDIM, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VSL_, int LDVSL, Matrix<double> VSR_, int LDVSR, Array<double> WORK_, int LWORK, Array<bool> BWORK_, Box<int> INFO) → void

dggesx(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(double ZR, double ZI, double D), String SENSE, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> SDIM, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VSL_, int LDVSL, Matrix<double> VSR_, int LDVSR, Array<double> RCONDE_, Array<double> RCONDV_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Array<bool> BWORK_, Box<int> INFO) → void

dggev(String JOBVL, String JOBVR, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggev3(String JOBVL, String JOBVR, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggevx(String BALANC, String JOBVL, String JOBVR, String SENSE, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Box<int> ILO, Box<int> IHI, Array<double> LSCALE_, Array<double> RSCALE_, Box<double> ABNRM, Box<double> BBNRM, Array<double> RCONDE_, Array<double> RCONDV_, Array<double> WORK_, int LWORK, Array<int> IWORK_, Array<bool> BWORK_, Box<int> INFO) → void

dggglm(int N, int M, int P, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> D_, Array<double> X_, Array<double> Y_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgghd3(String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgghrd(String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Box<int> INFO) → void

dgglse(int M, int N, int P, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> C_, Array<double> D_, Array<double> X_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggqrf(int N, int M, int P, Matrix<double> A_, int LDA, Array<double> TAUA_, Matrix<double> B_, int LDB, Array<double> TAUB_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggrqf(int M, int P, int N, Matrix<double> A_, int LDA, Array<double> TAUA_, Matrix<double> B_, int LDB, Array<double> TAUB_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dggsvd3(String JOBU, String JOBV, String JOBQ, int M, int N, int P, Box<int> K, Box<int> L, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHA_, Array<double> BETA_, Matrix<double> U_, int LDU, Matrix<double> V_, int LDV, Matrix<double> Q_, int LDQ, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dggsvp3(String JOBU, String JOBV, String JOBQ, int M, int P, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double TOLA, double TOLB, Box<int> K, Box<int> L, Matrix<double> U_, int LDU, Matrix<double> V_, int LDV, Matrix<double> Q_, int LDQ, Array<int> IWORK_, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgsvj0(String JOBV, int M, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> SVA_, int MV, Matrix<double> V_, int LDV, double EPS, double SFMIN, double TOL, int NSWEEP, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgsvj1(String JOBV, int M, int N, int N1, Matrix<double> A_, int LDA, Array<double> D_, Array<double> SVA_, int MV, Matrix<double> V_, int LDV, double EPS, double SFMIN, double TOL, int NSWEEP, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dgtcon(String NORM, int N, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DU2_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgtrfs(String TRANS, int N, int NRHS, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DLF_, Array<double> DF_, Array<double> DUF_, Array<double> DU2_, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgtsv(int N, int NRHS, Array<double> DL_, Array<double> D_, Array<double> DU_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgtsvx(String FACT, String TRANS, int N, int NRHS, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DLF_, Array<double> DF_, Array<double> DUF_, Array<double> DU2_, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dgttrf(int N, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DU2_, Array<int> IPIV_, Box<int> INFO) → void

dgttrs(String TRANS, int N, int NRHS, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DU2_, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dgtts2(int ITRANS, int N, int NRHS, Array<double> DL_, Array<double> D_, Array<double> DU_, Array<double> DU2_, Array<int> IPIV_, Matrix<double> B_, int LDB) → void

dhgeqz(String JOB, String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<double> H_, int LDH, Matrix<double> T_, int LDT, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dhsein(String SIDE, String EIGSRC, String INITV, Array<bool> SELECT_, int N, Matrix<double> H_, int LDH, Array<double> WR_, Array<double> WI_, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, int MM, Box<int> M, Array<double> WORK_, Array<int> IFAILL_, Array<int> IFAILR_, Box<int> INFO) → void

dhseqr(String JOB, String COMPZ, int N, int ILO, int IHI, Matrix<double> H_, int LDH, Array<double> WR_, Array<double> WI_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

digits32(double _) → int

digits64(double _) → int

disnan(double DIN) → bool

dla_gbamv(int TRANS, int M, int N, int KL, int KU, double ALPHA, Matrix<double> AB_, int LDAB, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dla_gbrcond(String TRANS, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, int CMODE, Array<double> C_, Box<int> INFO, Array<double> WORK_, Array<int> IWORK_) → double

dla_gbrfsx_extended(int PREC_TYPE, int TRANS_TYPE, int N, int KL, int KU, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<double> RES_, Array<double> AYB_, Array<double> DY_, Array<double> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

dla_gbrpvgrw(int N, int KL, int KU, int NCOLS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB) → double

dla_geamv(int TRANS, int M, int N, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dla_gercond(String TRANS, int N, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, int CMODE, Array<double> C_, Box<int> INFO, Array<double> WORK_, Array<int> IWORK_) → double

dla_gerfsx_extended(int PREC_TYPE, int TRANS_TYPE, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERRS_N_, Matrix<double> ERRS_C_, Array<double> RES_, Array<double> AYB_, Array<double> DY_, Array<double> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

dla_gerpvgrw(int N, int NCOLS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF) → double

dla_lin_berr(int N, int NZ, int NRHS, Matrix<double> RES_, Matrix<double> AYB_, Array<double> BERR_) → void

dla_porcond(String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, int CMODE, Array<double> C_, Box<int> INFO, Array<double> WORK_, Array<int> IWORK_) → double

dla_porfsx_extended(int PREC_TYPE, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, bool COLEQU, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<double> RES_, Array<double> AYB_, Array<double> DY_, Array<double> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

dla_porpvgrw(String UPLO, int NCOLS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<double> WORK_) → double

dla_syamv(int UPLO, int N, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dla_syrcond(String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, int CMODE, Array<double> C_, Box<int> INFO, Array<double> WORK_, Array<int> IWORK_) → double

dla_syrfsx_extended(int PREC_TYPE, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<double> B_, int LDB, Matrix<double> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<double> RES_, Array<double> AYB_, Array<double> DY_, Array<double> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

dla_syrpvgrw(String UPLO, int N, int INFO, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Array<double> WORK_) → double

dla_wwaddw(int N, Array<double> X_, Array<double> Y_, Array<double> W_) → void

dlabad(Box<double> SMALL, Box<double> LARGE) → void

dlabrd(int M, int N, int NB, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAUQ_, Array<double> TAUP_, Matrix<double> X_, int LDX, Matrix<double> Y_, int LDY) → void

dlacn2(int N, Array<double> V_, Array<double> X_, Array<int> ISGN_, Box<double> EST, Box<int> KASE, Array<int> ISAVE) → void

dlacon(int N, Array<double> V_, Array<double> X_, Array<int> ISGN_, Box<double> EST, Box<int> KASE) → void

dlacpy(String UPLO, int M, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB) → void

dladiv(double A, double B, double C, double D, Box<double> P, Box<double> Q) → void

dladiv1(Box<double> A, double B, double C, double D, Box<double> P, Box<double> Q) → void

dladiv2(double A, double B, double C, double D, double R, double T) → double

dlae2(double A, double B, double C, Box<double> RT1, Box<double> RT2) → void

dlaebz(int IJOB, int NITMAX, int N, int MMAX, int MINP, int NBMIN, double ABSTOL, double RELTOL, double PIVMIN, Array<double> D_, Array<double> E_, Array<double> E2_, Array<int> NVAL_, Matrix<double> AB_, Array<double> C_, Box<int> MOUT, Matrix<int> NAB_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlaed0(int ICOMPQ, int QSIZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Q_, int LDQ, Matrix<double> QSTORE_, int LDQS, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlaed1(int N, Array<double> D_, Matrix<double> Q_, int LDQ, Array<int> INDXQ_, Box<double> RHO, int CUTPNT, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlaed2(Box<int> K, int N, int N1, Array<double> D_, Matrix<double> Q_, int LDQ, Array<int> INDXQ_, Box<double> RHO, Array<double> Z_, Array<double> DLAMBDA_, Array<double> W_, Array<double> Q2_, Array<int> INDX_, Array<int> INDXC_, Array<int> INDXP_, Array<int> COLTYP_, Box<int> INFO) → void

dlaed3(int K, int N, int N1, Array<double> D_, Matrix<double> Q_, int LDQ, double RHO, Array<double> DLAMBDA_, Array<double> Q2_, Array<int> INDX_, Array<int> CTOT_, Array<double> W_, Array<double> S_, Box<int> INFO) → void

dlaed4(int N, int I, Array<double> D_, Array<double> Z_, Array<double> DELTA_, double RHO, Box<double> DLAM, Box<int> INFO) → void

dlaed5(int I, Array<double> D_, Array<double> Z_, Array<double> DELTA_, double RHO, Box<double> DLAM) → void

dlaed6(int KNITER, bool ORGATI, double RHO, Array<double> D_, Array<double> Z_, double FINIT, Box<double> TAU, Box<int> INFO) → void

dlaed7(int ICOMPQ, int N, int QSIZ, int TLVLS, int CURLVL, int CURPBM, Array<double> D_, Matrix<double> Q_, int LDQ, Array<int> INDXQ_, Box<double> RHO, int CUTPNT, Array<double> QSTORE_, Array<int> QPTR_, Array<int> PRMPTR_, Array<int> PERM_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, Matrix<double> GIVNUM_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlaed8(int ICOMPQ, Box<int> K, int N, int QSIZ, Array<double> D_, Matrix<double> Q_, int LDQ, Array<int> INDXQ_, Box<double> RHO, int CUTPNT, Array<double> Z_, Array<double> DLAMBDA_, Matrix<double> Q2_, int LDQ2, Array<double> W_, Array<int> PERM_, Box<int> GIVPTR, Matrix<int> GIVCOL_, Matrix<double> GIVNUM_, Array<int> INDXP_, Array<int> INDX_, Box<int> INFO) → void

dlaed9(int K, int KSTART, int KSTOP, int N, Array<double> D_, Matrix<double> Q_, int LDQ, double RHO, Array<double> DLAMBDA_, Array<double> W_, Matrix<double> S_, int LDS, Box<int> INFO) → void

dlaeda(int N, int TLVLS, int CURLVL, int CURPBM, Array<int> PRMPTR_, Array<int> PERM_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, Matrix<double> GIVNUM_, Array<double> Q_, Array<int> QPTR_, Array<double> Z_, Array<double> ZTEMP_, Box<int> INFO) → void

dlaein(bool RIGHTV, bool NOINIT, int N, Matrix<double> H_, int LDH, double WR, double WI, Array<double> VR_, Array<double> VI_, Matrix<double> B_, int LDB, Array<double> WORK_, double EPS3, double SMLNUM, double BIGNUM, Box<int> INFO) → void

dlaev2(double A, double B, double C, Box<double> RT1, Box<double> RT2, Box<double> CS1, Box<double> SN1) → void

dlaexc(bool WANTQ, int N, Matrix<double> T_, int LDT, Matrix<double> Q_, int LDQ, int J1, int N1, int N2, Array<double> WORK_, Box<int> INFO) → void

dlag2(Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double SAFMIN, Box<double> SCALE1, Box<double> SCALE2, Box<double> WR1, Box<double> WR2, Box<double> WI) → void

dlag2s(int M, int N, Matrix<double> A_, int LDA, Matrix<double> SA_, int LDSA, Box<int> INFO) → void

dlags2(bool UPPER, double A1, double A2, double A3, double B1, double B2, double B3, Box<double> CSU, Box<double> SNU, Box<double> CSV, Box<double> SNV, Box<double> CSQ, Box<double> SNQ) → void

dlagtf(int N, Array<double> A_, double LAMBDA, Array<double> B_, Array<double> C_, double TOL, Array<double> D_, Array<int> IN_, Box<int> INFO) → void

dlagtm(String TRANS, int N, int NRHS, double ALPHA, Array<double> DL_, Array<double> D_, Array<double> DU_, Matrix<double> X_, int LDX, double BETA, Matrix<double> B_, int LDB) → void

dlagts(int JOB, int N, Array<double> A_, Array<double> B_, Array<double> C_, Array<double> D_, Array<int> IN_, Array<double> Y_, Box<double> TOL, Box<int> INFO) → void

dlagv2(Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Box<double> CSL, Box<double> SNL, Box<double> CSR, Box<double> SNR) → void

dlahqr(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<double> H_, int LDH, Array<double> WR_, Array<double> WI_, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Box<int> INFO) → void

dlahr2(int N, int K, int NB, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> T_, int LDT, Matrix<double> Y_, int LDY) → void

dlaic1(int JOB, int J, Array<double> X_, double SEST, Array<double> W_, double GAMMA, Box<double> SESTPR, Box<double> S, Box<double> C) → void

dlaisnan(double DIN1, double _) → bool

dlaln2(bool LTRANS, int NA, int NW, double SMIN, double CA, Matrix<double> A_, int LDA, double D1, double D2, Matrix<double> B_, int LDB, double WR, double WI, Matrix<double> X_, int LDX, Box<double> SCALE, Box<double> XNORM, Box<int> INFO) → void

dlals0(int ICOMPQ, int NL, int NR, int SQRE, int NRHS, Matrix<double> B_, int LDB, Matrix<double> BX_, int LDBX, Array<int> PERM_, int GIVPTR, Matrix<int> GIVCOL_, int LDGCOL, Matrix<double> GIVNUM_, int LDGNUM, Matrix<double> POLES_, Array<double> DIFL_, Matrix<double> DIFR_, Array<double> Z_, int K, double C, double S, Array<double> WORK_, Box<int> INFO) → void

dlalsa(int ICOMPQ, int SMLSIZ, int N, int NRHS, Matrix<double> B_, int LDB, Matrix<double> BX_, int LDBX, Matrix<double> U_, int LDU, Matrix<double> VT_, Array<int> K_, Matrix<double> DIFL_, Matrix<double> DIFR_, Matrix<double> Z_, Matrix<double> POLES_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, int LDGCOL, Matrix<int> PERM_, Matrix<double> GIVNUM_, Array<double> C_, Array<double> S_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlalsd(String UPLO, int SMLSIZ, int N, int NRHS, Array<double> D_, Array<double> E_, Matrix<double> B_, int LDB, double RCOND, Box<int> RANK, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlamc3(double A, double B) → double

dlamch(String CMACH) → double

dlamrg(int N1, int N2, Array<double> A_, int DTRD1, int DTRD2, Array<int> INDEX) → void

dlamswlq(String SIDE, String TRANS, int M, int N, int K, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlamtsqr(String SIDE, String TRANS, int M, int N, int K, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlaneg(int N, Array<double> D_, Array<double> LLD_, double SIGMA, double PIVMIN, int R) → int

dlangb(String NORM, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<double> WORK) → double

dlange(String NORM, int M, int N, Matrix<double> A_, int LDA, Array<double> WORK_) → double

dlangt(String NORM, int N, Array<double> DL_, Array<double> D_, Array<double> DU_) → double

dlanhs(String NORM, int N, Matrix<double> A_, int LDA, Array<double> WORK_) → double

dlansb(String NORM, String UPLO, int N, int K, Matrix<double> AB_, int LDAB, Array<double> WORK) → double

dlansf(String NORM, String TRANSR, String UPLO, int N, Array<double> A_, Array<double> WORK_) → double

dlansp(String NORM, String UPLO, int N, Array<double> AP_, Array<double> WORK) → double

dlanst(String NORM, int N, Array<double> D_, Array<double> E_) → double

dlansy(String NORM, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> WORK_) → double

dlantb(String NORM, String UPLO, String DIAG, int N, int K, Matrix<double> AB_, int LDAB, Array<double> WORK_) → double

dlantp(String NORM, String UPLO, String DIAG, int N, Array<double> AP_, Array<double> WORK_) → double

dlantr(String NORM, String UPLO, String DIAG, int M, int N, Matrix<double> A_, int LDA, Array<double> WORK_) → double

dlanv2(Box<double> A, Box<double> B, Box<double> C, Box<double> D, Box<double> RT1R, Box<double> RT1I, Box<double> RT2R, Box<double> RT2I, Box<double> CS, Box<double> SN) → void

dlaorhr_col_getrfnp(int M, int N, Matrix<double> A_, int LDA, Array<double> D_, Box<int> INFO) → void

dlaorhr_col_getrfnp2(int M, int N, Matrix<double> A_, int LDA, Array<double> D_, Box<int> INFO) → void

dlapll(int N, Array<double> X_, int INCX, Array<double> Y_, int INCY, Box<double> SSMIN) → void

dlapmr(bool FORWRD, int M, int N, Matrix<double> X_, int LDX, Array<int> K) → void

dlapmt(bool FORWRD, int M, int N, Matrix<double> X_, int LDX, Array<int> K) → void

dlapy2(double X, double Y) → double

dlapy3(double X, double Y, double Z) → double

dlaqgb(int M, int N, int KL, int KU, Matrix<double> AB_, int LDAB, Array<double> R_, Array<double> C_, double ROWCND, double COLCND, double AMAX, Box<String> EQUED) → void

dlaqge(int M, int N, Matrix<double> A_, int LDA, Array<double> R_, Array<double> C_, double ROWCND, double COLCND, double AMAX, Box<String> EQUED) → void

dlaqp2(int M, int N, int OFFSET, Matrix<double> A_, int LDA, Array<int> JPVT_, Array<double> TAU_, Array<double> VN1_, Array<double> VN2_, Array<double> WORK) → void

dlaqp2rk(int M, int N, int NRHS, int IOFFSET, Box<int> KMAX, double ABSTOL, double RELTOL, int KP1, double MAXC2NRM, Matrix<double> A_, int LDA, Box<int> K, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<double> TAU_, Array<double> VN1_, Array<double> VN2_, Array<double> WORK_, Box<int> INFO) → void

dlaqp3rk(int M, int N, int NRHS, int IOFFSET, Box<int> NB, double ABSTOL, double RELTOL, int KP1, double MAXC2NRM, Matrix<double> A_, int LDA, Box<bool> DONE, Box<int> KB, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<double> TAU_, Array<double> VN1_, Array<double> VN2_, Array<double> AUXV_, Matrix<double> F_, int LDF, Array<int> IWORK_, Box<int> INFO) → void

dlaqps(int M, int N, int OFFSET, int NB, Box<int> KB, Matrix<double> A_, int LDA, Array<int> JPVT_, Array<double> TAU_, Array<double> VN1_, Array<double> VN2_, Array<double> AUXV_, Matrix<double> F_, int LDF) → void

dlaqr0(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<double> H_, int LDH, Array<double> WR_, Array<double> WI_, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlaqr1(int N, Matrix<double> H_, int LDH, double SR1, double SI1, double SR2, double SI2, Array<double> V) → void

dlaqr2(bool WANTT, bool WANTZ, int N, int KTOP, int KBOT, int NW, Matrix<double> H_, int LDH, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<double> SR_, Array<double> SI_, Matrix<double> V_, int LDV, int NH, Matrix<double> T_, int LDT, int NV, Matrix<double> WV_, int LDWV, Array<double> WORK_, int LWORK) → void

dlaqr3(bool WANTT, bool WANTZ, int N, int KTOP, int KBOT, int NW, Matrix<double> H_, int LDH, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<double> SR_, Array<double> SI_, Matrix<double> V_, int LDV, int NH, Matrix<double> T_, int LDT, int NV, Matrix<double> WV_, int LDWV, Array<double> WORK_, int LWORK) → void

dlaqr4(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<double> H_, int LDH, Array<double> WR_, Array<double> WI_, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlaqr5(bool WANTT, bool WANTZ, int KACC22, int N, int KTOP, int KBOT, int NSHFTS, Array<double> SR_, Array<double> SI_, Matrix<double> H_, int LDH, int ILOZ, int IHIZ, Matrix<double> Z_, int LDZ, Matrix<double> V_, int LDV, Matrix<double> U_, int LDU, int NV, Matrix<double> WV_, int LDWV, int NH, Matrix<double> WH_, int LDWH) → void

dlaqsb(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

dlaqsp(String UPLO, int N, Array<double> AP_, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

dlaqsy(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

dlaqtr(bool LTRAN, bool LREAL, int N, Matrix<double> T_, int LDT, Array<double> B_, double W, Box<double> SCALE, Array<double> X_, Array<double> WORK_, Box<int> INFO) → void

dlaqz0(String WANTS, String WANTQ, String WANTZ, int N, int ILO, int IHI, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, int REC, Box<int> INFO) → void

dlaqz1(Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double SR1, double SR2, double SI, double BETA1, double BETA2, Array<double> V) → void

dlaqz2(bool ILQ, bool ILZ, int K, int ISTARTM, int ISTOPM, int IHI, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, int NQ, int QSTART, Matrix<double> Q_, int LDQ, int NZ, int ZSTART, Matrix<double> Z_, int LDZ) → void

dlaqz3(bool ILSCHUR, bool ILQ, bool ILZ, int N, int ILO, int IHI, int NW, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> QC_, int LDQC, Matrix<double> ZC_, int LDZC, Array<double> WORK_, int LWORK, int REC, Box<int> INFO) → void

dlaqz4(bool ILSCHUR, bool ILQ, bool ILZ, int N, int ILO, int IHI, int NSHIFTS, int NBLOCK_DESIRED, Array<double> SR_, Array<double> SI_, Array<double> SS_, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Matrix<double> QC_, int LDQC, Matrix<double> ZC_, int LDZC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlar1v(int N, int B1, int BN, double LAMBDA, Array<double> D_, Array<double> L_, Array<double> LD_, Array<double> LLD_, double PIVMIN, double GAPTOL, Array<double> Z_, bool WANTNC, Box<int> NEGCNT, Box<double> ZTZ, Box<double> MINGMA, Box<int> R, Array<int> ISUPPZ_, Box<double> NRMINV, Box<double> RESID, Box<double> RQCORR, Array<double> WORK) → void

dlar2v(int N, Array<double> X_, Array<double> Y_, Array<double> Z_, int INCX, Array<double> C_, Array<double> S_, int INCC) → void

dlarf(String SIDE, int M, int N, Array<double> V_, int INCV, double TAU, Matrix<double> C_, int LDC, Array<double> WORK) → void

dlarfb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Matrix<double> WORK_, int LDWORK) → void

dlarfb_gett(String IDENT, int M, int N, int K, Matrix<double> T_, int LDT, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> WORK_, int LDWORK) → void

dlarfg(int N, Box<double> ALPHA, Array<double> X_, int INCX, Box<double> TAU) → void

dlarfgp(int N, Box<double> ALPHA, Array<double> X_, int INCX, Box<double> TAU) → void

dlarft(String DIRECT, String STOREV, int N, int K, Matrix<double> V_, int LDV, Array<double> TAU_, Matrix<double> T_, int LDT) → void

dlarfx(String SIDE, int M, int N, Array<double> V_, double TAU, Matrix<double> C_, int LDC, Array<double> WORK_) → void

dlarfy(String UPLO, int N, Array<double> V_, int INCV, double TAU, Matrix<double> C_, int LDC, Array<double> WORK_) → void

dlargv(int N, Array<double> X_, int INCX, Array<double> Y_, int INCY, Array<double> C_, int INCC) → void

dlarmm(double ANORM, double BNORM, double CNORM) → double

dlarnv(int IDIST, Array<int> ISEED_, int N, Array<double> X_) → void

dlarra(int N, Array<double> D_, Array<double> E_, Array<double> E2_, double SPLTOL, double TNRM, Box<int> NSPLIT, Array<int> ISPLIT_, Box<int> INFO) → void

dlarrb(int N, Array<double> D_, Array<double> LLD_, int IFIRST, int ILAST, double RTOL1, double RTOL2, int OFFSET, Array<double> W_, Array<double> WGAP_, Array<double> WERR_, Array<double> WORK_, Array<int> IWORK_, double PIVMIN, double SPDIAM, int TWIST, Box<int> INFO) → void

dlarrc(String JOBT, int N, double VL, double VU, Array<double> D_, Array<double> E_, double PIVMIN, Box<int> EIGCNT, Box<int> LCNT, Box<int> RCNT, Box<int> INFO) → void

dlarrd(String RANGE, String ORDER, int N, double VL, double VU, int IL, int IU, Array<double> GERS_, double RELTOL, Array<double> D_, Array<double> E_, Array<double> E2_, double PIVMIN, int NSPLIT, Array<int> ISPLIT_, Box<int> M, Array<double> W_, Array<double> WERR_, Box<double> WL, Box<double> WU, Array<int> IBLOCK_, Array<int> INDEXW_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlarre(String RANGE, int N, Box<double> VL, Box<double> VU, int IL, int IU, Array<double> D_, Array<double> E_, Array<double> E2_, double RTOL1, double RTOL2, double SPLTOL, Box<int> NSPLIT, Array<int> ISPLIT_, Box<int> M, Array<double> W_, Array<double> WERR_, Array<double> WGAP_, Array<int> IBLOCK_, Array<int> INDEXW_, Array<double> GERS_, Box<double> PIVMIN, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlarrf(int N, Array<double> D_, Array<double> L_, Array<double> LD_, int CLSTRT, int CLEND, Array<double> W_, Array<double> WGAP_, Array<double> WERR_, double SPDIAM, double CLGAPL, double CLGAPR, double PIVMIN, Box<double> SIGMA, Array<double> DPLUS_, Array<double> LPLUS_, Array<double> WORK_, Box<int> INFO) → void

dlarrj(int N, Array<double> D_, Array<double> E2_, int IFIRST, int ILAST, double RTOL, int OFFSET, Array<double> W_, Array<double> WERR_, Array<double> WORK_, Array<int> IWORK_, double PIVMIN, double SPDIAM, Box<int> INFO) → void

dlarrk(int N, int IW, double GL, double GU, Array<double> D_, Array<double> E2_, double PIVMIN, double RELTOL, Box<double> W, Box<double> WERR, Box<int> INFO) → void

dlarrr(int N, Array<double> D_, Array<double> E_, Box<int> INFO) → void

dlarrv(int N, double VL, double VU, Array<double> D_, Array<double> L_, double PIVMIN, Array<int> ISPLIT_, int M, int DOL, int DOU, double MINRGP, Box<double> RTOL1, Box<double> RTOL2, Array<double> W_, Array<double> WERR_, Array<double> WGAP_, Array<int> IBLOCK_, Array<int> INDEXW_, Array<double> GERS_, Matrix<double> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlarscl2(int M, int N, Array<double> D_, Matrix<double> X_, int LDX) → void

dlartg(double f, double g, Box<double> c, Box<double> s, Box<double> r) → void

dlartgp(double F, double G, Box<double> CS, Box<double> SN, Box<double> R) → void

dlartgs(double X, double Y, double SIGMA, Box<double> CS, Box<double> SN) → void

dlartv(int N, Array<double> X_, int INCX, Array<double> Y_, int INCY, Array<double> C_, Array<double> S_, int INCC) → void

dlaruv(Array<int> ISEED_, int N, Array<double> X) → void

dlarz(String SIDE, int M, int N, int L, Array<double> V_, int INCV, double TAU, Matrix<double> C_, int LDC, Array<double> WORK_) → void

dlarzb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, int L, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> C_, int LDC, Matrix<double> WORK_, int LDWORK) → void

dlarzt(String DIRECT, String STOREV, int N, int K, Matrix<double> V_, int LDV, Array<double> TAU_, Matrix<double> T_, int LDT) → void

dlas2(double F, double G, double H, Box<double> SSMIN, Box<double> SSMAX) → void

dlascl(String TYPE, int KL, int KU, double CFROM, double CTO, int M, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dlascl2(int M, int N, Array<double> D_, Matrix<double> X_, int LDX) → void

dlasd0(int N, int SQRE, Array<double> D_, Array<double> E_, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, int SMLSIZ, Array<int> IWORK_, Array<double> WORK_, Box<int> INFO) → void

dlasd1(int NL, int NR, int SQRE, Array<double> D_, Box<double> ALPHA, Box<double> BETA, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<int> IDXQ_, Array<int> IWORK_, Array<double> WORK_, Box<int> INFO) → void

dlasd2(int NL, int NR, int SQRE, Box<int> K, Array<double> D_, Array<double> Z_, double ALPHA, double BETA, Matrix<double> U_, int LDU, Matrix<double> VT_, int LDVT, Array<double> DSIGMA_, Matrix<double> U2_, int LDU2, Matrix<double> VT2_, int LDVT2, Array<int> IDXP_, Array<int> IDX_, Array<int> IDXC_, Array<int> IDXQ_, Array<int> COLTYP_, Box<int> INFO) → void

dlasd3(int NL, int NR, int SQRE, int K, Array<double> D_, Matrix<double> Q_, int LDQ, Array<double> DSIGMA_, Matrix<double> U_, int LDU, Matrix<double> U2_, int LDU2, Matrix<double> VT_, int LDVT, Matrix<double> VT2_, int LDVT2, Array<int> IDXC_, Array<int> CTOT_, Array<double> Z_, Box<int> INFO) → void

dlasd4(int N, int I, Array<double> D_, Array<double> Z_, Array<double> DELTA_, double RHO, Box<double> SIGMA, Array<double> WORK_, Box<int> INFO) → void

dlasd5(int I, Array<double> D_, Array<double> Z_, Array<double> DELTA_, double RHO, Box<double> DSIGMA, Array<double> WORK) → void

dlasd6(int ICOMPQ, int NL, int NR, int SQRE, Array<double> D_, Array<double> VF_, Array<double> VL_, Box<double> ALPHA, Box<double> BETA, Array<int> IDXQ_, Array<int> PERM_, Box<int> GIVPTR, Matrix<int> GIVCOL_, int LDGCOL, Matrix<double> GIVNUM_, int LDGNUM, Matrix<double> POLES_, Array<double> DIFL_, Array<double> DIFR_, Array<double> Z_, Box<int> K, Box<double> C, Box<double> S, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlasd7(int ICOMPQ, int NL, int NR, int SQRE, Box<int> K, Array<double> D_, Array<double> Z_, Array<double> ZW_, Array<double> VF_, Array<double> VFW_, Array<double> VL_, Array<double> VLW_, double ALPHA, double BETA, Array<double> DSIGMA_, Array<int> IDX_, Array<int> IDXP_, Array<int> IDXQ_, Array<int> PERM_, Box<int> GIVPTR, Matrix<int> GIVCOL_, int LDGCOL, Matrix<double> GIVNUM_, int LDGNUM, Box<double> C, Box<double> S, Box<int> INFO) → void

dlasd8(int ICOMPQ, int K, Array<double> D_, Array<double> Z_, Array<double> VF_, Array<double> VL_, Array<double> DIFL_, Matrix<double> DIFR_, int LDDIFR, Array<double> DSIGMA_, Array<double> WORK_, Box<int> INFO) → void

dlasda(int ICOMPQ, int SMLSIZ, int N, int SQRE, Array<double> D_, Array<double> E_, Matrix<double> U_, int LDU, Matrix<double> VT_, Array<int> K_, Matrix<double> DIFL_, Matrix<double> DIFR_, Matrix<double> Z_, Matrix<double> POLES_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, int LDGCOL, Matrix<int> PERM_, Matrix<double> GIVNUM_, Array<double> C_, Array<double> S_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dlasdq(String UPLO, int SQRE, int N, int NCVT, int NRU, int NCC, Array<double> D_, Array<double> E_, Matrix<double> VT_, int LDVT, Matrix<double> U_, int LDU, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dlasdt(int N, Box<int> LVL, Box<int> ND, Array<int> INODE_, Array<int> NDIML_, Array<int> NDIMR_, int MSUB) → void

dlaset(String UPLO, int M, int N, double ALPHA, double BETA, Matrix<double> A_, int LDA) → void

dlasq1(int N, Array<double> D_, Array<double> E_, Array<double> WORK_, Box<int> INFO) → void

dlasq2(int N, Array<double> Z_, Box<int> INFO) → void

dlasq3(int I0, Box<int> N0, Array<double> Z_, Box<int> PP, Box<double> DMIN, Box<double> SIGMA, Box<double> DESIG, Box<double> QMAX, Box<int> NFAIL, Box<int> ITER, Box<int> NDIV, bool IEEE, Box<int> TTYPE, Box<double> DMIN1, Box<double> DMIN2, Box<double> DN, Box<double> DN1, Box<double> DN2, Box<double> G, Box<double> TAU) → void

dlasq4(int I0, int N0, Array<double> Z_, int PP, int N0IN, double DMIN, double DMIN1, double DMIN2, double DN, double DN1, double DN2, Box<double> TAU, Box<int> TTYPE, Box<double> G) → void

dlasq5(int I0, int N0, Array<double> Z_, int PP, Box<double> TAU, double SIGMA, Box<double> DMIN, Box<double> DMIN1, Box<double> DMIN2, Box<double> DN, Box<double> DNM1, Box<double> DNM2, bool IEEE, double EPS) → void

dlasq6(int I0, int N0, Array<double> Z_, int PP, Box<double> DMIN, Box<double> DMIN1, Box<double> DMIN2, Box<double> DN, Box<double> DNM1, Box<double> DNM2) → void

dlasr(String SIDE, String PIVOT, String DIRECT, int M, int N, Array<double> C_, Array<double> S_, Matrix<double> A_, int LDA) → void

dlasrt(String ID, int N, Array<double> D_, Box<int> INFO) → void

dlassq(int n, Array<double> x_, int incx, Box<double> scale, Box<double> sumsq) → void

dlasv2(double F, double G, double H, Box<double> SSMIN, Box<double> SSMAX, Box<double> SNR, Box<double> CSR, Box<double> SNL, Box<double> CSL) → void

dlaswlq(int M, int N, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlaswp(int N, Matrix<double> A_, int LDA, int K1, int K2, Array<int> IPIV_, int INCX) → void

dlasy2(bool LTRANL, bool LTRANR, int ISGN, int N1, int N2, Matrix<double> TL_, int LDTL, Matrix<double> TR_, int LDTR, Matrix<double> B_, int LDB, Box<double> SCALE, Matrix<double> X_, int LDX, Box<double> XNORM, Box<int> INFO) → void

dlasyf(String UPLO, int N, int NB, Box<int> KB, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> W_, int LDW, Box<int> INFO) → void

dlasyf_aa(String UPLO, int J1, int M, int NB, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> H_, int LDH, Array<double> WORK_) → void

dlasyf_rk(String UPLO, int N, int NB, Box<int> KB, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Matrix<double> W_, int LDW, Box<int> INFO) → void

dlasyf_rook(String UPLO, int N, int NB, Box<int> KB, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> W_, int LDW, Box<int> INFO) → void

dlat2s(String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> SA_, int LDSA, Box<int> INFO) → void

dlatbs(String UPLO, String TRANS, String DIAG, String NORMIN, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

dlatdf(int IJOB, int N, Matrix<double> Z_, int LDZ, Array<double> RHS_, Box<double> RDSUM, Box<double> RDSCAL, Array<int> IPIV_, Array<int> JPIV) → void

dlatps(String UPLO, String TRANS, String DIAG, String NORMIN, int N, Array<double> AP_, Array<double> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

dlatrd(String UPLO, int N, int NB, Matrix<double> A_, int LDA, Array<double> E_, Array<double> TAU_, Matrix<double> W_, int LDW) → void

dlatrs(String UPLO, String TRANS, String DIAG, String NORMIN, int N, Matrix<double> A_, int LDA, Array<double> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

dlatrs3(String UPLO, String TRANS, String DIAG, String NORMIN, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> X_, int LDX, Array<double> SCALE_, Array<double> CNORM_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlatrz(int M, int N, int L, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_) → void

dlatsqr(int M, int N, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dlauu2(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dlauum(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dnrm2(int n, Array<double> x_, int incx) → double

dopgtr(String UPLO, int N, Array<double> AP_, Array<double> TAU_, Matrix<double> Q_, int LDQ, Array<double> WORK_, Box<int> INFO) → void

dopmtr(String SIDE, String UPLO, String TRANS, int M, int N, Array<double> AP_, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dorbdb(String TRANS, String SIGNS, int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X12_, int LDX12, Matrix<double> X21_, int LDX21, Matrix<double> X22_, int LDX22, Array<double> THETA_, Array<double> PHI_, Array<double> TAUP1_, Array<double> TAUP2_, Array<double> TAUQ1_, Array<double> TAUQ2_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb1(int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<double> TAUP1_, Array<double> TAUP2_, Array<double> TAUQ1_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb2(int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<double> TAUP1_, Array<double> TAUP2_, Array<double> TAUQ1_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb3(int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<double> TAUP1_, Array<double> TAUP2_, Array<double> TAUQ1_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb4(int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<double> TAUP1_, Array<double> TAUP2_, Array<double> TAUQ1_, Array<double> PHANTOM_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb5(int M1, int M2, int N, Array<double> X1_, int INCX1, Array<double> X2_, int INCX2, Matrix<double> Q1_, int LDQ1, Matrix<double> Q2_, int LDQ2, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorbdb6(int M1, int M2, int N, Array<double> X1_, int INCX1, Array<double> X2_, int INCX2, Matrix<double> Q1_, int LDQ1, Matrix<double> Q2_, int LDQ2, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorcsd(String JOBU1, String JOBU2, String JOBV1T, String JOBV2T, String TRANS, String SIGNS, int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X12_, int LDX12, Matrix<double> X21_, int LDX21, Matrix<double> X22_, int LDX22, Array<double> THETA_, Matrix<double> U1_, int LDU1, Matrix<double> U2_, int LDU2, Matrix<double> V1T_, int LDV1T, Matrix<double> V2T_, int LDV2T, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dorcsd2by1(String JOBU1, String JOBU2, String JOBV1T, int M, int P, int Q, Matrix<double> X11_, int LDX11, Matrix<double> X21_, int LDX21, Array<double> THETA_, Matrix<double> U1_, int LDU1, Matrix<double> U2_, int LDU2, Matrix<double> V1T_, int LDV1T, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dorg2l(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dorg2r(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dorgbr(String VECT, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorghr(int N, int ILO, int IHI, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgl2(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dorglq(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgql(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgqr(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgr2(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, Box<int> INFO) → void

dorgrq(int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgtr(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgtsqr(int M, int N, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorgtsqr_row(int M, int N, int MB, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorhr_col(int M, int N, int NB, Matrix<double> A_, int LDA, Matrix<double> T_, int LDT, Array<double> D_, Box<int> INFO) → void

dorm22(String SIDE, String TRANS, int M, int N, int N1, int N2, Matrix<double> Q_, int LDQ, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorm2l(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dorm2r(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dormbr(String VECT, String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormhr(String SIDE, String TRANS, int M, int N, int ILO, int IHI, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dorml2(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dormlq(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormql(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormqr(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormr2(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dormr3(String SIDE, String TRANS, int M, int N, int K, int L, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, Box<int> INFO) → void

dormrq(String SIDE, String TRANS, int M, int N, int K, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormrz(String SIDE, String TRANS, int M, int N, int K, int L, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dormtr(String SIDE, String UPLO, String TRANS, int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Matrix<double> C_, int LDC, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dpbcon(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpbequ(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

dpbrfs(String UPLO, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpbstf(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Box<int> INFO) → void

dpbsv(String UPLO, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> B_, int LDB, Box<int> INFO) → void

dpbsvx(String FACT, String UPLO, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> AFB_, int LDAFB, Box<String> EQUED, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpbtf2(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Box<int> INFO) → void

dpbtrf(String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Box<int> INFO) → void

dpbtrs(String UPLO, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> B_, int LDB, Box<int> INFO) → void

dpftrf(String TRANSR, String UPLO, int N, Array<double> A_, Box<int> INFO) → void

dpftri(String TRANSR, String UPLO, int N, Array<double> A_, Box<int> INFO) → void

dpftrs(String TRANSR, String UPLO, int N, int NRHS, Array<double> A_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dpocon(String UPLO, int N, Matrix<double> A_, int LDA, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpoequ(int N, Matrix<double> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

dpoequb(int N, Matrix<double> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

dporfs(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dporfsx(String UPLO, String EQUED, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dposv(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

dposvx(String FACT, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Box<String> EQUED, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dposvxx(String FACT, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Box<String> EQUED, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpotf2(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dpotrf(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dpotrf2(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dpotri(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dpotrs(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

dppcon(String UPLO, int N, Array<double> AP_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dppequ(String UPLO, int N, Array<double> AP_, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

dpprfs(String UPLO, int N, int NRHS, Array<double> AP_, Array<double> AFP_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dppsv(String UPLO, int N, int NRHS, Array<double> AP_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dppsvx(String FACT, String UPLO, int N, int NRHS, Array<double> AP_, Array<double> AFP_, Box<String> EQUED, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dpptrf(String UPLO, int N, Array<double> AP_, Box<int> INFO) → void

dpptri(String UPLO, int N, Array<double> AP_, Box<int> INFO) → void

dpptrs(String UPLO, int N, int NRHS, Array<double> AP_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dpstf2(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> PIV_, Box<int> RANK, double TOL, Array<double> WORK_, Box<int> INFO) → void

dpstrf(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> PIV_, Box<int> RANK, double TOL, Array<double> WORK_, Box<int> INFO) → void

dptcon(int N, Array<double> D_, Array<double> E_, double ANORM, Box<double> RCOND, Array<double> WORK_, Box<int> INFO) → void

dpteqr(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dptrfs(int N, int NRHS, Array<double> D_, Array<double> E_, Array<double> DF_, Array<double> EF_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Box<int> INFO) → void

dptsv(int N, int NRHS, Array<double> D_, Array<double> E_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dptsvx(String FACT, int N, int NRHS, Array<double> D_, Array<double> E_, Array<double> DF_, Array<double> EF_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Box<int> INFO) → void

dpttrf(int N, Array<double> D_, Array<double> E_, Box<int> INFO) → void

dpttrs(int N, int NRHS, Array<double> D_, Array<double> E_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dptts2(int N, int NRHS, Array<double> D_, Array<double> E_, Matrix<double> B_, int LDB) → void

drot(int N, Array<double> DX_, int INCX, Array<double> DY_, int INCY, double C, double S) → void

drotg(Box<double> a, Box<double> b, Box<double> c, Box<double> s) → void

drotm(int N, Array<double> DX_, int INCX, Array<double> DY_, int INCY, Array<double> DPARAM) → void

drotmg(Box<double> DD1, Box<double> DD2, Box<double> DX1, double DY1, Array<double> DPARAM) → void

droundup_lwork(int LWORK) → double

drscl(int N, double SA, Array<double> SX_, int INCX) → void

dsb2st_kernels(String UPLO, bool WANTZ, int TTYPE, int ST, int ED, int SWEEP, int N, int NB, int IB, Matrix<double> A_, int LDA, Array<double> V_, Array<double> TAU_, int LDVT, Array<double> WORK_) → void

dsbev(String JOBZ, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dsbev_2stage(String JOBZ, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsbevd(String JOBZ, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsbevd_2stage(String JOBZ, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsbevx(String JOBZ, String RANGE, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Matrix<double> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsbevx_2stage(String JOBZ, String RANGE, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Matrix<double> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsbgst(String VECT, String UPLO, int N, int KA, int KB, Matrix<double> AB_, int LDAB, Matrix<double> BB_, int LDBB, Matrix<double> X_, int LDX, Array<double> WORK_, Box<int> INFO) → void

dsbgv(String JOBZ, String UPLO, int N, int KA, int KB, Matrix<double> AB_, int LDAB, Matrix<double> BB_, int LDBB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dsbgvd(String JOBZ, String UPLO, int N, int KA, int KB, Matrix<double> AB_, int LDAB, Matrix<double> BB_, int LDBB, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsbgvx(String JOBZ, String RANGE, String UPLO, int N, int KA, int KB, Matrix<double> AB_, int LDAB, Matrix<double> BB_, int LDBB, Matrix<double> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsbmv(String UPLO, int N, int K, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dsbtrd(String VECT, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> D_, Array<double> E_, Matrix<double> Q_, int LDQ, Array<double> WORK_, Box<int> INFO) → void

dscal(int N, double DA, Array<double> DX_, int INCX) → void

dsdot(int N, Array<double> SX_, int INCX, Array<double> SY_, int INCY) → double

dsecnd() → double

dsfrk(String TRANSR, String UPLO, String TRANS, int N, int K, double ALPHA, Matrix<double> A_, int LDA, double BETA, Array<double> C_) → void

dsgesv(int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Matrix<double> WORK_, Array<double> SWORK_, Box<int> ITER, Box<int> INFO) → void

dspcon(String UPLO, int N, Array<double> AP_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dspev(String JOBZ, String UPLO, int N, Array<double> AP_, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dspevd(String JOBZ, String UPLO, int N, Array<double> AP_, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dspevx(String JOBZ, String RANGE, String UPLO, int N, Array<double> AP_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dspgst(int ITYPE, String UPLO, int N, Array<double> AP_, Array<double> BP_, Box<int> INFO) → void

dspgv(int ITYPE, String JOBZ, String UPLO, int N, Array<double> AP_, Array<double> BP_, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dspgvd(int ITYPE, String JOBZ, String UPLO, int N, Array<double> AP_, Array<double> BP_, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dspgvx(int ITYPE, String JOBZ, String RANGE, String UPLO, int N, Array<double> AP_, Array<double> BP_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dspmv(String UPLO, int N, double ALPHA, Array<double> AP_, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dsposv(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Matrix<double> WORK_, Array<double> SWORK_, Box<int> ITER, Box<int> INFO) → void

dspr(String UPLO, int N, double ALPHA, Array<double> X_, int INCX, Array<double> AP) → void

dspr2(String UPLO, int N, double ALPHA, Array<double> X_, int INCX, Array<double> Y_, int INCY, Array<double> AP_) → void

dsprfs(String UPLO, int N, int NRHS, Array<double> AP_, Array<double> AFP_, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dspsv(String UPLO, int N, int NRHS, Array<double> AP_, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dspsvx(String FACT, String UPLO, int N, int NRHS, Array<double> AP_, Array<double> AFP_, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsptrd(String UPLO, int N, Array<double> AP_, Array<double> D_, Array<double> E_, Array<double> TAU_, Box<int> INFO) → void

dsptrf(String UPLO, int N, Array<double> AP_, Array<int> IPIV_, Box<int> INFO) → void

dsptri(String UPLO, int N, Array<double> AP_, Array<int> IPIV_, Array<double> WORK_, Box<int> INFO) → void

dsptrs(String UPLO, int N, int NRHS, Array<double> AP_, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dstebz(String RANGE, String ORDER, int N, double VL, double VU, int IL, int IU, double ABSTOL, Array<double> D_, Array<double> E_, Box<int> M, Box<int> NSPLIT, Array<double> W_, Array<int> IBLOCK_, Array<int> ISPLIT_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dstedc(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dstegr(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dstein(int N, Array<double> D_, Array<double> E_, int M, Array<double> W_, Array<int> IBLOCK_, Array<int> ISPLIT_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dstemr(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, int NZC, Array<int> ISUPPZ_, Box<bool> TRYRAC, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsteqr(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dsterf(int N, Array<double> D_, Array<double> E_, Box<int> INFO) → void

dstev(String JOBZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

dstevd(String JOBZ, int N, Array<double> D_, Array<double> E_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dstevr(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dstevx(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dswap(int N, Array<double> DX_, int INCX, Array<double> DY_, int INCY) → void

dsycon(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsycon_3(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsycon_rook(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsyconv(String UPLO, String WAY, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> E_, Box<int> INFO) → void

dsyconvf(String UPLO, String WAY, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Box<int> INFO) → void

dsyconvf_rook(String UPLO, String WAY, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Box<int> INFO) → void

dsyequb(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Array<double> WORK_, Box<int> INFO) → void

dsyev(String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> W_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsyev_2stage(String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> W_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsyevd(String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> W_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsyevd_2stage(String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> W_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsyevr(String JOBZ, String RANGE, String UPLO, int N, Matrix<double> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsyevr_2stage(String JOBZ, String RANGE, String UPLO, int N, Matrix<double> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsyevx(String JOBZ, String RANGE, String UPLO, int N, Matrix<double> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsyevx_2stage(String JOBZ, String RANGE, String UPLO, int N, Matrix<double> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsygs2(int ITYPE, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

dsygst(int ITYPE, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

dsygv(int ITYPE, String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> W_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsygv_2stage(int ITYPE, String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> W_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsygvd(int ITYPE, String JOBZ, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> W_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dsygvx(int ITYPE, String JOBZ, String RANGE, String UPLO, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<double> Z_, int LDZ, Array<double> WORK_, int LWORK, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

dsymm(String SIDE, String UPLO, int M, int N, double ALPHA, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double BETA, Matrix<double> C_, int LDC) → void

dsymv(String UPLO, int N, double ALPHA, Matrix<double> A_, int LDA, Array<double> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

dsyr(String UPLO, int N, double ALPHA, Array<double> X_, int INCX, Matrix<double> A_, int LDA) → void

dsyr2(String UPLO, int N, double ALPHA, Array<double> X_, int INCX, Array<double> Y_, int INCY, Matrix<double> A_, int LDA) → void

dsyr2k(String UPLO, String TRANS, int N, int K, double ALPHA, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double BETA, Matrix<double> C_, int LDC) → void

dsyrfs(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsyrfsx(String UPLO, String EQUED, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsyrk(String UPLO, String TRANS, int N, int K, double ALPHA, Matrix<double> A_, int LDA, double BETA, Matrix<double> C_, int LDC) → void

dsysv(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsysv_aa(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsysv_aa_2stage(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<double> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsysv_rk(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsysv_rook(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsysvx(String FACT, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dsysvxx(String FACT, String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> S_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dsyswapr(String UPLO, int N, Matrix<double> A_, int LDA, int I1, int I2) → void

dsytd2(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAU_, Box<int> INFO) → void

dsytf2(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

dsytf2_rk(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Box<int> INFO) → void

dsytf2_rook(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

dsytrd(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrd_2stage(String VECT, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> D_, Array<double> E_, Array<double> TAU_, Array<double> HOUS2_, int LHOUS2, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrd_sb2st(String STAGE1, String VECT, String UPLO, int N, int KD, Matrix<double> AB_, int LDAB, Array<double> D_, Array<double> E_, Array<double> HOUS_, int LHOUS, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrd_sy2sb(String UPLO, int N, int KD, Matrix<double> A_, int LDA, Matrix<double> AB_, int LDAB, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrf(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrf_aa(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrf_aa_2stage(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrf_rk(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrf_rook(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytri(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, Box<int> INFO) → void

dsytri2(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytri2x(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> WORK_, int NB, Box<int> INFO) → void

dsytri_3(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytri_3x(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Matrix<double> WORK_, int NB, Box<int> INFO) → void

dsytri_rook(String UPLO, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Array<double> WORK_, Box<int> INFO) → void

dsytrs(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dsytrs2(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, Box<int> INFO) → void

dsytrs_3(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<double> E_, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dsytrs_aa(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dsytrs_aa_2stage(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<double> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dsytrs_rook(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dtbcon(String NORM, String UPLO, String DIAG, int N, int KD, Matrix<double> AB_, int LDAB, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtbmv(String UPLO, String TRANS, String DIAG, int N, int K, Matrix<double> A_, int LDA, Array<double> X_, int INCX) → void

dtbrfs(String UPLO, String TRANS, String DIAG, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtbsv(String UPLO, String TRANS, String DIAG, int N, int K, Matrix<double> A_, int LDA, Array<double> X_, int INCX) → void

dtbtrs(String UPLO, String TRANS, String DIAG, int N, int KD, int NRHS, Matrix<double> AB_, int LDAB, Matrix<double> B_, int LDB, Box<int> INFO) → void

dtfsm(String TRANSR, String SIDE, String UPLO, String TRANS, String DIAG, int M, int N, double ALPHA, Array<double> A_, Matrix<double> B_, int LDB) → void

dtftri(String TRANSR, String UPLO, String DIAG, int N, Array<double> A_, Box<int> INFO) → void

dtfttp(String TRANSR, String UPLO, int N, Array<double> ARF_, Array<double> AP_, Box<int> INFO) → void

dtfttr(String TRANSR, String UPLO, int N, Array<double> ARF_, Matrix<double> A_, int LDA, Box<int> INFO) → void

dtgevc(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<double> S_, int LDS, Matrix<double> P_, int LDP, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, int MM, Box<int> M, Array<double> WORK_, Box<int> INFO) → void

dtgex2(bool WANTQ, bool WANTZ, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, int J1, int N1, int N2, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dtgexc(bool WANTQ, bool WANTZ, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Box<int> IFST, Box<int> ILST, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dtgsen(int IJOB, bool WANTQ, bool WANTZ, Array<bool> SELECT_, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> ALPHAR_, Array<double> ALPHAI_, Array<double> BETA_, Matrix<double> Q_, int LDQ, Matrix<double> Z_, int LDZ, Box<int> M, Box<double> PL, Box<double> PR, Array<double> DIF_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dtgsja(String JOBU, String JOBV, String JOBQ, int M, int P, int N, int K, int L, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, double TOLA, double TOLB, Array<double> ALPHA_, Array<double> BETA_, Matrix<double> U_, int LDU, Matrix<double> V_, int LDV, Matrix<double> Q_, int LDQ, Array<double> WORK_, Box<int> NCYCLE, Box<int> INFO) → void

dtgsna(String JOB, String HOWMNY, Array<bool> SELECT_, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Array<double> S_, Array<double> DIF_, int MM, Box<int> M, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dtgsy2(String TRANS, int IJOB, int M, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> C_, int LDC, Matrix<double> D_, int LDD, Matrix<double> E_, int LDE, Matrix<double> F_, int LDF, Box<double> SCALE, Box<double> RDSUM, Box<double> RDSCAL, Array<int> IWORK_, Box<int> PQ, Box<int> INFO) → void

dtgsyl(String TRANS, int IJOB, int M, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> C_, int LDC, Matrix<double> D_, int LDD, Matrix<double> E_, int LDE, Matrix<double> F_, int LDF, Box<double> SCALE, Box<double> DIF, Array<double> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

dtpcon(String NORM, String UPLO, String DIAG, int N, Array<double> AP_, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtplqt(int M, int N, int L, int MB, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> T_, int LDT, Array<double> WORK_, Box<int> INFO) → void

dtplqt2(int M, int N, int L, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> T_, int LDT, Box<int> INFO) → void

dtpmlqt(String SIDE, String TRANS, int M, int N, int K, int L, int MB, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> WORK_, Box<int> INFO) → void

dtpmqrt(String SIDE, String TRANS, int M, int N, int K, int L, int NB, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Array<double> WORK_, Box<int> INFO) → void

dtpmv(String UPLO, String TRANS, String DIAG, int N, Array<double> AP_, Array<double> X_, int INCX) → void

dtpqrt(int M, int N, int L, int NB, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> T_, int LDT, Array<double> WORK_, Box<int> INFO) → void

dtpqrt2(int M, int N, int L, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> T_, int LDT, Box<int> INFO) → void

dtprfb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, int L, Matrix<double> V_, int LDV, Matrix<double> T_, int LDT, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> WORK_, int LDWORK) → void

dtprfs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Array<double> AP_, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtpsv(String UPLO, String TRANS, String DIAG, int N, Array<double> AP_, Array<double> X_, int INCX) → void

dtptri(String UPLO, String DIAG, int N, Array<double> AP_, Box<int> INFO) → void

dtptrs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Array<double> AP_, Matrix<double> B_, int LDB, Box<int> INFO) → void

dtpttf(String TRANSR, String UPLO, int N, Array<double> AP_, Array<double> ARF_, Box<int> INFO) → void

dtpttr(String UPLO, int N, Array<double> AP_, Matrix<double> A_, int LDA, Box<int> INFO) → void

dtrcon(String NORM, String UPLO, String DIAG, int N, Matrix<double> A_, int LDA, Box<double> RCOND, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtrevc(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<double> T_, int LDT, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, int MM, Box<int> M, Array<double> WORK_, Box<int> INFO) → void

dtrevc3(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<double> T_, int LDT, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, int MM, Box<int> M, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dtrexc(String COMPQ, int N, Matrix<double> T_, int LDT, Matrix<double> Q_, int LDQ, Box<int> IFST, Box<int> ILST, Array<double> WORK_, Box<int> INFO) → void

dtrmm(String SIDE, String UPLO, String TRANSA, String DIAG, int M, int N, double ALPHA, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB) → void

dtrmv(String UPLO, String TRANS, String DIAG, int N, Matrix<double> A_, int LDA, Array<double> X_, int INCX) → void

dtrrfs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

dtrsen(String JOB, String COMPQ, Array<bool> SELECT_, int N, Matrix<double> T_, int LDT, Matrix<double> Q_, int LDQ, Array<double> WR_, Array<double> WI_, Box<int> M, Box<double> S, Box<double> SEP, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

dtrsm(String SIDE, String UPLO, String TRANSA, String DIAG, int M, int N, double ALPHA, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB) → void

dtrsna(String JOB, String HOWMNY, Array<bool> SELECT_, int N, Matrix<double> T_, int LDT, Matrix<double> VL_, int LDVL, Matrix<double> VR_, int LDVR, Array<double> S_, Array<double> SEP_, int MM, Box<int> M, Matrix<double> WORK_, int LDWORK, Array<int> IWORK_, Box<int> INFO) → void

dtrsv(String UPLO, String TRANS, String DIAG, int N, Matrix<double> A_, int LDA, Array<double> X_, int INCX) → void

dtrsyl(String TRANA, String TRANB, int ISGN, int M, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> C_, int LDC, Box<double> SCALE, Box<int> INFO) → void

dtrsyl3(String TRANA, String TRANB, int ISGN, int M, int N, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Matrix<double> C_, int LDC, Box<double> SCALE, Array<int> IWORK_, int LIWORK, Matrix<double> SWORK_, Box<int> LDSWORK, Box<int> INFO) → void

dtrti2(String UPLO, String DIAG, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dtrtri(String UPLO, String DIAG, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

dtrtrs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

dtrttf(String TRANSR, String UPLO, int N, Matrix<double> A_, int LDA, Array<double> ARF_, Box<int> INFO) → void

dtrttp(String UPLO, int N, Matrix<double> A_, int LDA, Array<double> AP_, Box<int> INFO) → void

dtzrzf(int M, int N, Matrix<double> A_, int LDA, Array<double> TAU_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

dzasum(int N, Array<Complex> ZX_, int INCX) → double

dznrm2(int n, Array<Complex> x_, int incx) → double

dzsum1(int N, Array<Complex> CX_, int INCX) → double

epsilon32(double v) → double

epsilon64(double v) → double

exponent32(double x) → int

exponent64(double x) → int

huge32<N extends num>(N n) → N

huge64<N extends num>(N n) → N

idamax(int N, Array<double> DX_, int INCX) → int

ieeeck(int ISPEC, double ZERO, double ONE) → bool

iladiag(String DIAG) → int

iladlc(int M, int N, Matrix<double> A_, int LDA) → int

iladlr(int M, int N, Matrix<double> A_, int LDA) → int

ilaprec(String PREC) → int

ilatrans(String TRANS) → int

ilauplo(String UPLO) → int

ilaver(Box<int> VERS_MAJOR, Box<int> VERS_MINOR, Box<int> VERS_PATCH) → void

ilazlc(int M, int N, Matrix<Complex> A, int LDA) → int

ilazlr(int M, int N, Matrix<Complex> A, int LDA) → int

iparam2stage(int ISPEC, String NAME, String OPTS, int NI, int NBI, int IBI, int NXI) → int

iparmq(int ISPEC, String NAME, String OPTS, int N, int ILO, int IHI, int LWORK) → int

izamax(int N, Array<Complex> ZX_, int INCX) → int

izmax1(int N, Array<Complex> ZX_, int INCX) → int

log10(double x) → double

lsame(String CA, String CB) → bool

lsamen(int N, String CA, String CB) → bool

max<T extends num>(T a, T b) → T

maxexponent32(double _) → int

maxexponent64(double _) → int

min<T extends num>(T a, T b) → T

minexponent32(double _) → int

minexponent64(double _) → int

nint(double x) → int

pow(num x, num exponent) → num

radix<N extends num>(N n) → N

random_number(Box<double> r) → void

sgetrf(int M, int N, Matrix<double> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

sgetrs(String TRANS, int N, int NRHS, Matrix<double> A_, int LDA, Array<int> IPIV_, Matrix<double> B_, int LDB, Box<int> INFO) → void

sign<T extends num>(T a, num b) → T

slag2d(int M, int N, Matrix<double> SA_, int LDSA, Matrix<double> A_, int LDA, Box<int> INFO) → void

slamc3(double A, double B) → double

slamch(String CMACH) → double

spotrf(String UPLO, int N, Matrix<double> A_, int LDA, Box<int> INFO) → void

spotrs(String UPLO, int N, int NRHS, Matrix<double> A_, int LDA, Matrix<double> B_, int LDB, Box<int> INFO) → void

tiny32(double _) → double

tiny64(double _) → double

xerbla_array(String SRNAME_ARRAY, int SRNAME_LEN, int INFO) → void

zaxpy(int N, Complex ZA, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY) → void

zbbcsd(String JOBU1, String JOBU2, String JOBV1T, String JOBV2T, String TRANS, int M, int P, int Q, Array<double> THETA_, Array<double> PHI_, Matrix<Complex> U1_, int LDU1, Matrix<Complex> U2_, int LDU2, Matrix<Complex> V1T_, int LDV1T, Matrix<Complex> V2T_, int LDV2T, Array<double> B11D_, Array<double> B11E_, Array<double> B12D_, Array<double> B12E_, Array<double> B21D_, Array<double> B21E_, Array<double> B22D_, Array<double> B22E_, Array<double> RWORK_, int LRWORK, Box<int> INFO) → void

zbdsqr(String UPLO, int N, int NCVT, int NRU, int NCC, Array<double> D_, Array<double> E_, Matrix<Complex> VT_, int LDVT, Matrix<Complex> U_, int LDU, Matrix<Complex> C_, int LDC, Array<double> RWORK_, Box<int> INFO) → void

zcgesv(int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Matrix<Complex> WORK_, Array<Complex> SWORK_, Array<double> RWORK_, Box<int> ITER, Box<int> INFO) → void

zcopy(int N, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY) → void

zcposv(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Matrix<Complex> WORK_, Array<Complex> SWORK_, Array<double> RWORK_, Box<int> ITER, Box<int> INFO) → void

zdotc(int N, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY) → Complex

zdotu(int N, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY) → Complex

zdrot(int N, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY, double C, double S) → void

zdrscl(int N, double SA, Array<Complex> SX_, int INCX) → void

zdscal(int N, double DA, Array<Complex> ZX_, int INCX) → void

zgbbrd(String VECT, int M, int N, int NCC, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<double> D_, Array<double> E_, Matrix<Complex> Q_, int LDQ, Matrix<Complex> PT_, int LDPT, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbcon(String NORM, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbequ(int M, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

zgbequb(int M, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

zgbmv(String TRANS, int M, int N, int KL, int KU, Complex ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zgbrfs(String TRANS, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbrfsx(String TRANS, String EQUED, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbsv(int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgbsvx(String FACT, String TRANS, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbsvxx(String FACT, String TRANS, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgbtf2(int M, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<int> IPIV_, Box<int> INFO) → void

zgbtrf(int M, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<int> IPIV_, Box<int> INFO) → void

zgbtrs(String TRANS, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgebak(String JOB, String SIDE, int N, int ILO, int IHI, Array<double> SCALE_, int M, Matrix<Complex> V_, int LDV, Box<int> INFO) → void

zgebal(String JOB, int N, Matrix<Complex> A_, int LDA, Box<int> ILO, Box<int> IHI, Array<double> SCALE_, Box<int> INFO) → void

zgebd2(int M, int N, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAUQ_, Array<Complex> TAUP_, Array<Complex> WORK_, Box<int> INFO) → void

zgebrd(int M, int N, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAUQ_, Array<Complex> TAUP_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgecon(String NORM, int N, Matrix<Complex> A_, int LDA, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgedmd(String JOBS, String JOBZ, String JOBR, String JOBF, int WHTSVD, int M, int N, Matrix<Complex> X_, int LDX, Matrix<Complex> Y_, int LDY, int NRNK, double TOL, Box<int> K, Array<Complex> EIGS_, Matrix<Complex> Z_, int LDZ, Array<double> RES_, Matrix<Complex> B_, int LDB, Matrix<Complex> W_, int LDW, Matrix<Complex> S_, int LDS, Array<Complex> ZWORK_, int LZWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zgedmdq(String JOBS, String JOBZ, String JOBR, String JOBQ, String JOBT, String JOBF, int WHTSVD, int M, int N, Matrix<Complex> F_, int LDF, Matrix<Complex> X_, int LDX, Matrix<Complex> Y_, int LDY, int NRNK, double TOL, Box<int> K, Array<Complex> EIGS_, Matrix<Complex> Z_, int LDZ, Array<double> RES_, Matrix<Complex> B_, int LDB, Matrix<Complex> V_, int LDV, Matrix<Complex> S_, int LDS, Array<Complex> ZWORK_, int LZWORK, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zgeequ(int M, int N, Matrix<Complex> A_, int LDA, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

zgeequb(int M, int N, Matrix<Complex> A_, int LDA, Array<double> R_, Array<double> C_, Box<double> ROWCND, Box<double> COLCND, Box<double> AMAX, Box<int> INFO) → void

zgees(String JOBVS, String SORT, bool SELECT(Complex), int N, Matrix<Complex> A_, int LDA, Box<int> SDIM, Array<Complex> W_, Matrix<Complex> VS_, int LDVS, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<bool> BWORK_, Box<int> INFO) → void

zgeesx(String JOBVS, String SORT, bool SELECT(Complex), String SENSE, int N, Matrix<Complex> A_, int LDA, Box<int> SDIM, Array<Complex> W_, Matrix<Complex> VS_, int LDVS, Box<double> RCONDE, Box<double> RCONDV, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<bool> BWORK_, Box<int> INFO) → void

zgeev(String JOBVL, String JOBVR, int N, Matrix<Complex> A_, int LDA, Array<Complex> W_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgeevx(String BALANC, String JOBVL, String JOBVR, String SENSE, int N, Matrix<Complex> A_, int LDA, Array<Complex> W_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Box<int> ILO, Box<int> IHI, Array<double> SCALE_, Box<double> ABNRM, Array<double> RCONDE_, Array<double> RCONDV_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgehd2(int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgehrd(int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgejsv(String JOBA, String JOBU, String JOBV, String JOBR, String JOBT, String JOBP, int M, int N, Matrix<Complex> A_, int LDA, Array<double> SVA_, Matrix<Complex> U_, int LDU, Matrix<Complex> V_, int LDV, Array<Complex> CWORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, Box<int> INFO) → void

zgelq(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> T_, int TSIZE, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgelq2(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgelqf(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgelqt(int M, int N, int MB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, Box<int> INFO) → void

zgelqt3(int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Box<int> INFO) → void

zgels(String TRANS, int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgelsd(int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> S_, double RCOND, Box<int> RANK, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zgelss(int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> S_, double RCOND, Box<int> RANK, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgelst(String TRANS, int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgelsy(int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<int> JPVT_, double RCOND, Box<int> RANK, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgemlq(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> T_, int TSIZE, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgemlqt(String SIDE, String TRANS, int M, int N, int K, int MB, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zgemm(String TRANSA, String TRANSB, int M, int N, int K, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Complex BETA, Matrix<Complex> C_, int LDC) → void

zgemqr(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> T_, int TSIZE, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgemqrt(String SIDE, String TRANS, int M, int N, int K, int NB, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zgemv(String TRANS, int M, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zgeql2(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgeqlf(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgeqp3(int M, int N, Matrix<Complex> A_, int LDA, Array<int> JPVT_, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgeqp3rk(int M, int N, int NRHS, int KMAX, Box<double> ABSTOL, Box<double> RELTOL, Matrix<Complex> A_, int LDA, Box<int> K, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zgeqr(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> T_, int TSIZE, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgeqr2(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgeqr2p(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgeqrf(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgeqrfp(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgeqrt(int M, int N, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, Box<int> INFO) → void

zgeqrt2(int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Box<int> INFO) → void

zgeqrt3(int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Box<int> INFO) → void

zgerc(int M, int N, Complex ALPHA, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Matrix<Complex> A_, int LDA) → void

zgerfs(String TRANS, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgerfsx(String TRANS, String EQUED, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgerq2(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zgerqf(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgeru(int M, int N, Complex ALPHA, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Matrix<Complex> A_, int LDA) → void

zgesc2(int N, Matrix<Complex> A_, int LDA, Array<Complex> RHS_, Array<int> IPIV_, Array<int> JPIV_, Box<double> SCALE) → void

zgesdd(String JOBZ, int M, int N, Matrix<Complex> A_, int LDA, Array<double> S_, Matrix<Complex> U_, int LDU, Matrix<Complex> VT_, int LDVT, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zgesv(int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgesvd(String JOBU, String JOBVT, int M, int N, Matrix<Complex> A_, int LDA, Array<double> S_, Matrix<Complex> U_, int LDU, Matrix<Complex> VT_, int LDVT, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zgesvdq(String JOBA, String JOBP, String JOBR, String JOBU, String JOBV, int M, int N, Matrix<Complex> A_, int LDA, Array<double> S_, Matrix<Complex> U_, int LDU, Matrix<Complex> V_, int LDV, Box<int> NUMRANK, Array<int> IWORK_, int LIWORK, Array<Complex> CWORK_, int LCWORK, Array<double> RWORK_, int LRWORK, Box<int> INFO) → void

zgesvdx(String JOBU, String JOBVT, String RANGE, int M, int N, Matrix<Complex> A_, int LDA, double VL, double VU, int IL, int IU, Box<int> NS, Array<double> S_, Matrix<Complex> U_, int LDU, Matrix<Complex> VT_, int LDVT, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zgesvj(String JOBA, String JOBU, String JOBV, int M, int N, Matrix<Complex> A_, int LDA, Array<double> SVA_, int MV, Matrix<Complex> V_, int LDV, Array<Complex> CWORK_, int LWORK, Array<double> RWORK_, int LRWORK, Box<int> INFO) → void

zgesvx(String FACT, String TRANS, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgesvxx(String FACT, String TRANS, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> R_, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgetc2(int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<int> JPIV_, Box<int> INFO) → void

zgetf2(int M, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zgetrf(int M, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zgetrf2(int M, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zgetri(int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgetrs(String TRANS, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgetsls(String TRANS, int M, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgetsqrhrt(int M, int N, int MB1, int NB1, int NB2, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zggbak(String JOB, String SIDE, int N, int ILO, int IHI, Array<double> LSCALE_, Array<double> RSCALE_, int M, Matrix<Complex> V_, int LDV, Box<int> INFO) → void

zggbal(String JOB, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> ILO, Box<int> IHI, Array<double> LSCALE_, Array<double> RSCALE_, Array<double> WORK_, Box<int> INFO) → void

zgges(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(Complex, Complex), int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> SDIM, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VSL_, int LDVSL, Matrix<Complex> VSR_, int LDVSR, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<bool> BWORK_, Box<int> INFO) → void

zgges3(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(Complex, Complex), int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> SDIM, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VSL_, int LDVSL, Matrix<Complex> VSR_, int LDVSR, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<bool> BWORK_, Box<int> INFO) → void

zggesx(String JOBVSL, String JOBVSR, String SORT, bool SELCTG(Complex, Complex), String SENSE, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> SDIM, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VSL_, int LDVSL, Matrix<Complex> VSR_, int LDVSR, Array<double> RCONDE_, Array<double> RCONDV_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, int LIWORK, Array<bool> BWORK_, Box<int> INFO) → void

zggev(String JOBVL, String JOBVR, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zggev3(String JOBVL, String JOBVR, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zggevx(String BALANC, String JOBVL, String JOBVR, String SENSE, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Box<int> ILO, Box<int> IHI, Array<double> LSCALE_, Array<double> RSCALE_, Box<double> ABNRM, Box<double> BBNRM, Array<double> RCONDE_, Array<double> RCONDV_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Array<bool> BWORK_, Box<int> INFO) → void

zggglm(int N, int M, int P, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> D_, Array<Complex> X_, Array<Complex> Y_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgghd3(String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgghrd(String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Box<int> INFO) → void

zgglse(int M, int N, int P, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> C_, Array<Complex> D_, Array<Complex> X_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zggqrf(int N, int M, int P, Matrix<Complex> A_, int LDA, Array<Complex> TAUA_, Matrix<Complex> B_, int LDB, Array<Complex> TAUB_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zggrqf(int M, int P, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAUA_, Matrix<Complex> B_, int LDB, Array<Complex> TAUB_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zggsvd3(String JOBU, String JOBV, String JOBQ, int M, int N, int P, Box<int> K, Box<int> L, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> ALPHA_, Array<double> BETA_, Matrix<Complex> U_, int LDU, Matrix<Complex> V_, int LDV, Matrix<Complex> Q_, int LDQ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zggsvp3(String JOBU, String JOBV, String JOBQ, int M, int P, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, double TOLA, double TOLB, Box<int> K, Box<int> L, Matrix<Complex> U_, int LDU, Matrix<Complex> V_, int LDV, Matrix<Complex> Q_, int LDQ, Array<int> IWORK_, Array<double> RWORK_, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgsvj0(String JOBV, int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> D_, Array<double> SVA_, int MV, Matrix<Complex> V_, int LDV, double EPS, double SFMIN, double TOL, int NSWEEP, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgsvj1(String JOBV, int M, int N, int N1, Matrix<Complex> A_, int LDA, Array<Complex> D_, Array<double> SVA_, int MV, Matrix<Complex> V_, int LDV, double EPS, double SFMIN, double TOL, int NSWEEP, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zgtcon(String NORM, int N, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DU2_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zgtrfs(String TRANS, int N, int NRHS, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DLF_, Array<Complex> DF_, Array<Complex> DUF_, Array<Complex> DU2_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgtsv(int N, int NRHS, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgtsvx(String FACT, String TRANS, int N, int NRHS, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DLF_, Array<Complex> DF_, Array<Complex> DUF_, Array<Complex> DU2_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zgttrf(int N, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DU2_, Array<int> IPIV_, Box<int> INFO) → void

zgttrs(String TRANS, int N, int NRHS, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DU2_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zgtts2(int ITRANS, int N, int NRHS, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Array<Complex> DU2_, Array<int> IPIV_, Matrix<Complex> B_, int LDB) → void

zhb2st_kernels(String UPLO, bool WANTZ, int TTYPE, int ST, int ED, int SWEEP, int N, int NB, int IB, Matrix<Complex> A_, int LDA, Array<Complex> V_, Array<Complex> TAU_, int LDVT, Array<Complex> WORK_) → void

zhbev(String JOBZ, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhbev_2stage(String JOBZ, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zhbevd(String JOBZ, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhbevd_2stage(String JOBZ, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhbevx(String JOBZ, String RANGE, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Matrix<Complex> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhbevx_2stage(String JOBZ, String RANGE, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Matrix<Complex> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhbgst(String VECT, String UPLO, int N, int KA, int KB, Matrix<Complex> AB_, int LDAB, Matrix<Complex> BB_, int LDBB, Matrix<Complex> X_, int LDX, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhbgv(String JOBZ, String UPLO, int N, int KA, int KB, Matrix<Complex> AB_, int LDAB, Matrix<Complex> BB_, int LDBB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhbgvd(String JOBZ, String UPLO, int N, int KA, int KB, Matrix<Complex> AB_, int LDAB, Matrix<Complex> BB_, int LDBB, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhbgvx(String JOBZ, String RANGE, String UPLO, int N, int KA, int KB, Matrix<Complex> AB_, int LDAB, Matrix<Complex> BB_, int LDBB, Matrix<Complex> Q_, int LDQ, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhbmv(String UPLO, int N, int K, Complex ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zhbtrd(String VECT, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> D_, Array<double> E_, Matrix<Complex> Q_, int LDQ, Array<Complex> WORK_, Box<int> INFO) → void

zhecon(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zhecon_3(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zhecon_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zheequb(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Array<Complex> WORK_, Box<int> INFO) → void

zheev(String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zheev_2stage(String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zheevd(String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zheevd_2stage(String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zheevr(String JOBZ, String RANGE, String UPLO, int N, Matrix<Complex> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<int> ISUPPZ_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zheevr_2stage(String JOBZ, String RANGE, String UPLO, int N, Matrix<Complex> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<int> ISUPPZ_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zheevx(String JOBZ, String RANGE, String UPLO, int N, Matrix<Complex> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zheevx_2stage(String JOBZ, String RANGE, String UPLO, int N, Matrix<Complex> A_, int LDA, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhegs2(int ITYPE, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhegst(int ITYPE, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhegv(int ITYPE, String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zhegv_2stage(int ITYPE, String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zhegvd(int ITYPE, String JOBZ, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<double> W_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhegvx(int ITYPE, String JOBZ, String RANGE, String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhemm(String SIDE, String UPLO, int M, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Complex BETA, Matrix<Complex> C_, int LDC) → void

zhemv(String UPLO, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zher(String UPLO, int N, double ALPHA, Array<Complex> X_, int INCX, Matrix<Complex> A_, int LDA) → void

zher2(String UPLO, int N, Complex ALPHA, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Matrix<Complex> A_, int LDA) → void

zher2k(String UPLO, String TRANS, int N, int K, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, double BETA, Matrix<Complex> C_, int LDC) → void

zherfs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zherfsx(String UPLO, String EQUED, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zherk(String UPLO, String TRANS, int N, int K, double ALPHA, Matrix<Complex> A_, int LDA, double BETA, Matrix<Complex> C_, int LDC) → void

zhesv(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhesv_aa(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhesv_aa_2stage(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhesv_rk(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhesv_rook(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhesvx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zhesvxx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zheswapr(String UPLO, int N, Matrix<Complex> A_, int LDA, int I1, int I2) → void

zhetd2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAU_, Box<int> INFO) → void

zhetf2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zhetf2_rk(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Box<int> INFO) → void

zhetf2_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zhetrd(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrd_2stage(String VECT, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAU_, Array<Complex> HOUS2_, int LHOUS2, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrd_hb2st(String STAGE1, String VECT, String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> D_, Array<double> E_, Array<Complex> HOUS_, int LHOUS, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrd_he2hb(String UPLO, int N, int KD, Matrix<Complex> A_, int LDA, Matrix<Complex> AB_, int LDAB, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrf(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrf_aa(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrf_aa_2stage(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrf_rk(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrf_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetri(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zhetri2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetri2x(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> WORK_, int NB, Box<int> INFO) → void

zhetri_3(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetri_3x(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> WORK_, int NB, Box<int> INFO) → void

zhetri_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zhetrs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhetrs2(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, Box<int> INFO) → void

zhetrs_3(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhetrs_aa(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zhetrs_aa_2stage(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhetrs_rook(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhfrk(String TRANSR, String UPLO, String TRANS, int N, int K, double ALPHA, Matrix<Complex> A_, int LDA, double BETA, Array<Complex> C_) → void

zhgeqz(String JOB, String COMPQ, String COMPZ, int N, int ILO, int IHI, Matrix<Complex> H_, int LDH, Matrix<Complex> T_, int LDT, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zhpcon(String UPLO, int N, Array<Complex> AP, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zhpev(String JOBZ, String UPLO, int N, Array<Complex> AP_, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhpevd(String JOBZ, String UPLO, int N, Array<Complex> AP_, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhpevx(String JOBZ, String RANGE, String UPLO, int N, Array<Complex> AP_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhpgst(int ITYPE, String UPLO, int N, Array<Complex> AP_, Array<Complex> BP_, Box<int> INFO) → void

zhpgv(int ITYPE, String JOBZ, String UPLO, int N, Array<Complex> AP_, Array<Complex> BP_, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhpgvd(int ITYPE, String JOBZ, String UPLO, int N, Array<Complex> AP_, Array<Complex> BP_, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zhpgvx(int ITYPE, String JOBZ, String RANGE, String UPLO, int N, Array<Complex> AP_, Array<Complex> BP_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zhpmv(String UPLO, int N, Complex ALPHA, Array<Complex> AP_, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zhpr(String UPLO, int N, double ALPHA, Array<Complex> X_, int INCX, Array<Complex> AP) → void

zhpr2(String UPLO, int N, Complex ALPHA, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Array<Complex> AP) → void

zhprfs(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhpsv(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhpsvx(String FACT, String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zhptrd(String UPLO, int N, Array<Complex> AP_, Array<double> D_, Array<double> E_, Array<Complex> TAU_, Box<int> INFO) → void

zhptrf(String UPLO, int N, Array<Complex> AP_, Array<int> IPIV_, Box<int> INFO) → void

zhptri(String UPLO, int N, Array<Complex> AP, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zhptrs(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zhsein(String SIDE, String EIGSRC, String INITV, Array<bool> SELECT_, int N, Matrix<Complex> H_, int LDH, Array<Complex> W_, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, int MM, Box<int> M, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IFAILL_, Array<int> IFAILR_, Box<int> INFO) → void

zhseqr(String JOB, String COMPZ, int N, int ILO, int IHI, Matrix<Complex> H_, int LDH, Array<Complex> W_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zla_gbamv(int TRANS, int M, int N, int KL, int KU, double ALPHA, Matrix<Complex> AB_, int LDAB, Array<Complex> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

zla_gbrcond_c(String TRANS, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Array<double> C_, bool CAPPLY, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_gbrcond_x(String TRANS, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, Array<Complex> X_, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_gbrfsx_extended(int PREC_TYPE, int TRANS_TYPE, int N, int KL, int KU, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<Complex> RES_, Array<double> AYB_, Array<Complex> DY_, Array<Complex> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

zla_gbrpvgrw(int N, int KL, int KU, int NCOLS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB) → double

zla_geamv(int TRANS, int M, int N, double ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

zla_gercond_c(String TRANS, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> C_, bool CAPPLY, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_gercond_x(String TRANS, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<Complex> X_, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_gerfsx_extended(int PREC_TYPE, int TRANS_TYPE, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERRS_N_, Matrix<double> ERRS_C_, Array<Complex> RES_, Array<double> AYB_, Array<Complex> DY_, Array<Complex> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

zla_gerpvgrw(int N, int NCOLS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF) → double

zla_heamv(int UPLO, int N, double ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

zla_hercond_c(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> C_, bool CAPPLY, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_hercond_x(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<Complex> X_, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_herfsx_extended(int PREC_TYPE, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<Complex> RES_, Array<double> AYB_, Array<Complex> DY_, Array<Complex> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

zla_herpvgrw(String UPLO, int N, int INFO, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> WORK_) → double

zla_lin_berr(int N, int NZ, int NRHS, Matrix<Complex> RES_, Matrix<double> AYB_, Array<double> BERR_) → void

zla_porcond_c(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<double> C_, bool CAPPLY, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_porcond_x(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<Complex> X_, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_porfsx_extended(int PREC_TYPE, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, bool COLEQU, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<Complex> RES_, Array<double> AYB_, Array<Complex> DY_, Array<Complex> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

zla_porpvgrw(String UPLO, int NCOLS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<double> WORK_) → double

zla_syamv(int UPLO, int N, double ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, double BETA, Array<double> Y_, int INCY) → void

zla_syrcond_c(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> C_, bool CAPPLY, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_syrcond_x(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<Complex> X_, Box<int> INFO, Array<Complex> WORK_, Array<double> RWORK_) → double

zla_syrfsx_extended(int PREC_TYPE, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, bool COLEQU, Array<double> C_, Matrix<Complex> B_, int LDB, Matrix<Complex> Y_, int LDY, Array<double> BERR_OUT_, int N_NORMS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, Array<Complex> RES_, Array<double> AYB_, Array<Complex> DY_, Array<Complex> Y_TAIL_, double RCOND, int ITHRESH, double RTHRESH, double DZ_UB, bool IGNORE_CWISE, Box<int> INFO) → void

zla_syrpvgrw(String UPLO, int N, Box<int> INFO, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> WORK_) → double

zla_wwaddw(int N, Array<Complex> X_, Array<Complex> Y_, Array<Complex> W_) → void

zlabrd(int M, int N, int NB, Matrix<Complex> A_, int LDA, Array<double> D_, Array<double> E_, Array<Complex> TAUQ_, Array<Complex> TAUP_, Matrix<Complex> X_, int LDX, Matrix<Complex> Y_, int LDY) → void

zlacgv(int N, Array<Complex> X_, int INCX) → void

zlacn2(int N, Array<Complex> V_, Array<Complex> X_, Box<double> EST, Box<int> KASE, Array<int> ISAVE_) → void

zlacon(int N, Array<Complex> V_, Array<Complex> X_, Box<double> EST, Box<int> KASE) → void

zlacp2(String UPLO, int M, int N, Matrix<double> A_, int LDA, Matrix<Complex> B_, int LDB) → void

zlacpy(String UPLO, int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB) → void

zlacrm(int M, int N, Matrix<Complex> A_, int LDA, Matrix<double> B_, int LDB, Matrix<Complex> C_, int LDC, Array<double> RWORK_) → void

zlacrt(int N, Array<Complex> CX_, int INCX, Array<Complex> CY_, int INCY, Complex C, Complex S) → void

zladiv(Complex X, Complex Y) → Complex

zlaed0(int QSIZ, int N, Array<double> D_, Array<double> E_, Matrix<Complex> Q_, int LDQ, Matrix<Complex> QSTORE_, int LDQS, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zlaed7(int N, int CUTPNT, int QSIZ, int TLVLS, int CURLVL, int CURPBM, Array<double> D_, Matrix<Complex> Q_, int LDQ, Box<double> RHO, Array<int> INDXQ_, Array<double> QSTORE_, Array<int> QPTR_, Array<int> PRMPTR_, Array<int> PERM_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, Matrix<double> GIVNUM_, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zlaed8(Box<int> K, int N, int QSIZ, Matrix<Complex> Q_, int LDQ, Array<double> D_, Box<double> RHO, int CUTPNT, Array<double> Z_, Array<double> DLAMBDA_, Matrix<Complex> Q2_, int LDQ2, Array<double> W_, Array<int> INDXP_, Array<int> INDX_, Array<int> INDXQ_, Array<int> PERM_, Box<int> GIVPTR, Matrix<int> GIVCOL_, Matrix<double> GIVNUM_, Box<int> INFO) → void

zlaein(bool RIGHTV, bool NOINIT, int N, Matrix<Complex> H_, int LDH, Complex W, Array<Complex> V_, Matrix<Complex> B_, int LDB, Array<double> RWORK_, double EPS3, double SMLNUM, Box<int> INFO) → void

zlaesy(Complex A, Complex B, Complex C, Box<Complex> RT1, Box<Complex> RT2, Box<Complex> EVSCAL, Box<Complex> CS1, Box<Complex> SN1) → void

zlaev2(Complex A, Complex B, Complex C, Box<double> RT1, Box<double> RT2, Box<double> CS1, Box<Complex> SN1) → void

zlag2c(int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> SA_, int LDSA, Box<int> INFO) → void

zlags2(bool UPPER, double A1, Complex A2, double A3, double B1, Complex B2, double B3, Box<double> CSU, Box<Complex> SNU, Box<double> CSV, Box<Complex> SNV, Box<double> CSQ, Box<Complex> SNQ) → void

zlagtm(String TRANS, int N, int NRHS, double ALPHA, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_, Matrix<Complex> X_, int LDX, double BETA, Matrix<Complex> B_, int LDB) → void

zlahef(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlahef_aa(String UPLO, int J1, int M, int NB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> H_, int LDH, Array<Complex> WORK_) → void

zlahef_rk(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlahef_rook(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlahqr(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<Complex> H_, int LDH, Array<Complex> W_, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Box<int> INFO) → void

zlahr2(int N, int K, int NB, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> T_, int LDT, Matrix<Complex> Y_, int LDY) → void

zlaic1(int JOB, int J, Array<Complex> X_, double SEST, Array<Complex> W_, Complex GAMMA, Box<double> SESTPR, Box<Complex> S, Box<Complex> C) → void

zlals0(int ICOMPQ, int NL, int NR, int SQRE, int NRHS, Matrix<Complex> B_, int LDB, Matrix<Complex> BX_, int LDBX, Array<int> PERM_, int GIVPTR, Matrix<int> GIVCOL_, int LDGCOL, Matrix<double> GIVNUM_, int LDGNUM, Matrix<double> POLES_, Array<double> DIFL_, Matrix<double> DIFR_, Array<double> Z_, int K, double C, double S, Array<double> RWORK_, Box<int> INFO) → void

zlalsa(int ICOMPQ, int SMLSIZ, int N, int NRHS, Matrix<Complex> B_, int LDB, Matrix<Complex> BX_, int LDBX, Matrix<double> U_, int LDU, Matrix<double> VT_, Array<int> K_, Matrix<double> DIFL_, Matrix<double> DIFR_, Matrix<double> Z_, Matrix<double> POLES_, Array<int> GIVPTR_, Matrix<int> GIVCOL_, int LDGCOL, Matrix<int> PERM_, Matrix<double> GIVNUM_, Array<double> C_, Array<double> S_, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zlalsd(String UPLO, int SMLSIZ, int N, int NRHS, Array<double> D_, Array<double> E_, Matrix<Complex> B_, int LDB, double RCOND, Box<int> RANK, Array<Complex> WORK_, Array<double> RWORK_, Array<int> IWORK_, Box<int> INFO) → void

zlamswlq(String SIDE, String TRANS, int M, int N, int K, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlamtsqr(String SIDE, String TRANS, int M, int N, int K, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlangb(String NORM, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<double> WORK_) → double

zlange(String NORM, int M, int N, Matrix<Complex> A_, int LDA, Array<double> WORK_) → double

zlangt(String NORM, int N, Array<Complex> DL_, Array<Complex> D_, Array<Complex> DU_) → double

zlanhb(String NORM, String UPLO, int N, int K, Matrix<Complex> AB_, int LDAB, Array<double> WORK_) → double

zlanhe(String NORM, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> WORK_) → double

zlanhf(String NORM, String TRANSR, String UPLO, int N, Array<Complex> A_, Array<double> WORK_) → double

zlanhp(String NORM, String UPLO, int N, Array<Complex> AP_, Array<double> WORK_) → double

zlanhs(String NORM, int N, Matrix<Complex> A_, int LDA, Array<double> WORK_) → double

zlanht(String NORM, int N, Array<double> D_, Array<Complex> E_) → double

zlansb(String NORM, String UPLO, int N, int K, Matrix<Complex> AB_, int LDAB, Array<double> WORK_) → double

zlansp(String NORM, String UPLO, int N, Array<Complex> AP_, Array<double> WORK_) → double

zlansy(String NORM, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> WORK_) → double

zlantb(String NORM, String UPLO, String DIAG, int N, int K, Matrix<Complex> AB_, int LDAB, Array<double> WORK_) → double

zlantp(String NORM, String UPLO, String DIAG, int N, Array<Complex> AP_, Array<double> WORK_) → double

zlantr(String NORM, String UPLO, String DIAG, int M, int N, Matrix<Complex> A_, int LDA, Array<double> WORK_) → double

zlapll(int N, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Box<double> SSMIN) → void

zlapmr(bool FORWRD, int M, int N, Matrix<Complex> X_, int LDX, Array<int> K_) → void

zlapmt(bool FORWRD, int M, int N, Matrix<Complex> X_, int LDX, Array<int> K_) → void

zlaqgb(int M, int N, int KL, int KU, Matrix<Complex> AB_, int LDAB, Array<double> R_, Array<double> C_, double ROWCND, double COLCND, double AMAX, Box<String> EQUED) → void

zlaqge(int M, int N, Matrix<Complex> A_, int LDA, Array<double> R_, Array<double> C_, double ROWCND, double COLCND, double AMAX, Box<String> EQUED) → void

zlaqhb(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqhe(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqhp(String UPLO, int N, Array<Complex> AP_, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqp2(int M, int N, int OFFSET, Matrix<Complex> A_, int LDA, Array<int> JPVT_, Array<Complex> TAU_, Array<double> VN1_, Array<double> VN2_, Array<Complex> WORK_) → void

zlaqp2rk(int M, int N, int NRHS, int IOFFSET, Box<int> KMAX, double ABSTOL, double RELTOL, int KP1, double MAXC2NRM, Matrix<Complex> A_, int LDA, Box<int> K, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<Complex> TAU_, Array<double> VN1_, Array<double> VN2_, Array<Complex> WORK_, Box<int> INFO) → void

zlaqp3rk(int M, int N, int NRHS, int IOFFSET, Box<int> NB, double ABSTOL, double RELTOL, int KP1, double MAXC2NRM, Matrix<Complex> A_, int LDA, Box<bool> DONE, Box<int> KB, Box<double> MAXC2NRMK, Box<double> RELMAXC2NRMK, Array<int> JPIV_, Array<Complex> TAU_, Array<double> VN1_, Array<double> VN2_, Array<Complex> AUXV_, Matrix<Complex> F_, int LDF, Array<int> IWORK_, Box<int> INFO) → void

zlaqps(int M, int N, int OFFSET, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<int> JPVT_, Array<Complex> TAU_, Array<double> VN1_, Array<double> VN2_, Array<Complex> AUXV_, Matrix<Complex> F_, int LDF) → void

zlaqr0(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<Complex> H_, int LDH, Array<Complex> W_, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlaqr1(int N, Matrix<Complex> H_, int LDH, Complex S1, Complex S2, Array<Complex> V_) → void

zlaqr2(bool WANTT, bool WANTZ, int N, int KTOP, int KBOT, int NW, Matrix<Complex> H_, int LDH, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<Complex> SH_, Matrix<Complex> V_, int LDV, int NH, Matrix<Complex> T_, int LDT, int NV, Matrix<Complex> WV_, int LDWV, Array<Complex> WORK_, int LWORK) → void

zlaqr3(bool WANTT, bool WANTZ, int N, int KTOP, int KBOT, int NW, Matrix<Complex> H_, int LDH, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<Complex> SH_, Matrix<Complex> V_, int LDV, int NH, Matrix<Complex> T_, int LDT, int NV, Matrix<Complex> WV_, int LDWV, Array<Complex> WORK_, int LWORK) → void

zlaqr4(bool WANTT, bool WANTZ, int N, int ILO, int IHI, Matrix<Complex> H_, int LDH, Array<Complex> W_, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlaqr5(bool WANTT, bool WANTZ, int KACC22, int N, int KTOP, int KBOT, int NSHFTS, Array<Complex> S_, Matrix<Complex> H_, int LDH, int ILOZ, int IHIZ, Matrix<Complex> Z_, int LDZ, Matrix<Complex> V_, int LDV, Matrix<Complex> U_, int LDU, int NV, Matrix<Complex> WV_, int LDWV, int NH, Matrix<Complex> WH_, int LDWH) → void

zlaqsb(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqsp(String UPLO, int N, Array<Complex> AP_, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqsy(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> S_, double SCOND, double AMAX, Box<String> EQUED) → void

zlaqz0(String WANTS, String WANTQ, String WANTZ, int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int REC, Box<int> INFO) → void

zlaqz1(bool ILQ, bool ILZ, int K, int ISTARTM, int ISTOPM, int IHI, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, int NQ, int QSTART, Matrix<Complex> Q_, int LDQ, int NZ, int ZSTART, Matrix<Complex> Z_, int LDZ) → void

zlaqz2(bool ILSCHUR, bool ILQ, bool ILZ, int N, int ILO, int IHI, int NW, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Box<int> NS, Box<int> ND, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> QC_, int LDQC, Matrix<Complex> ZC_, int LDZC, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int REC, Box<int> INFO) → void

zlaqz3(bool ILSCHUR, bool ILQ, bool ILZ, int N, int ILO, int IHI, int NSHIFTS, int NBLOCK_DESIRED, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Matrix<Complex> QC_, int LDQC, Matrix<Complex> ZC_, int LDZC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlar1v(int N, int B1, int BN, double LAMBDA, Array<double> D_, Array<double> L_, Array<double> LD_, Array<double> LLD_, double PIVMIN, double GAPTOL, Array<Complex> Z_, bool WANTNC, Box<int> NEGCNT, Box<double> ZTZ, Box<double> MINGMA, Box<int> R, Array<int> ISUPPZ_, Box<double> NRMINV, Box<double> RESID, Box<double> RQCORR, Array<double> WORK_) → void

zlar2v(int N, Array<Complex> X_, Array<Complex> Y_, Array<Complex> Z_, int INCX, Array<double> C_, Array<Complex> S_, int INCC) → void

zlarcm(int M, int N, Matrix<double> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> C_, int LDC, Array<double> RWORK_) → void

zlarf(String SIDE, int M, int N, Array<Complex> V_, int INCV, Complex TAU, Matrix<Complex> C_, int LDC, Array<Complex> WORK_) → void

zlarfb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Matrix<Complex> WORK_, int LDWORK) → void

zlarfb_gett(String IDENT, int M, int N, int K, Matrix<Complex> T_, int LDT, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> WORK_, int LDWORK) → void

zlarfg(int N, Box<Complex> ALPHA, Array<Complex> X_, int INCX, Box<Complex> TAU) → void

zlarfgp(int N, Box<Complex> ALPHA, Array<Complex> X_, int INCX, Box<Complex> TAU) → void

zlarft(String DIRECT, String STOREV, int N, int K, Matrix<Complex> V_, int LDV, Array<Complex> TAU_, Matrix<Complex> T_, int LDT) → void

zlarfx(String SIDE, int M, int N, Array<Complex> V_, Complex TAU, Matrix<Complex> C_, int LDC, Array<Complex> WORK_) → void

zlarfy(String UPLO, int N, Array<Complex> V_, int INCV, Complex TAU, Matrix<Complex> C_, int LDC, Array<Complex> WORK_) → void

zlargv(int N, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Array<double> C_, int INCC) → void

zlarnv(int IDIST, Array<int> ISEED_, int N, Array<Complex> X_) → void

zlarrv(int N, double VL, double VU, Array<double> D_, Array<double> L_, double PIVMIN, Array<int> ISPLIT_, int M, int DOL, int DOU, double MINRGP, Box<double> RTOL1, Box<double> RTOL2, Array<double> W_, Array<double> WERR_, Array<double> WGAP_, Array<int> IBLOCK_, Array<int> INDEXW_, Array<double> GERS_, Matrix<Complex> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, Array<int> IWORK_, Box<int> INFO) → void

zlarscl2(int M, int N, Array<double> D_, Matrix<Complex> X_, int LDX) → void

zlartg(Complex f, Complex g, Box<double> c, Box<Complex> s, Box<Complex> r) → void

zlartv(int N, Array<Complex> X_, int INCX, Array<Complex> Y_, int INCY, Array<double> C_, Array<Complex> S_, int INCC) → void

zlarz(String SIDE, int M, int N, int L, Array<Complex> V_, int INCV, Complex TAU, Matrix<Complex> C_, int LDC, Array<Complex> WORK_) → void

zlarzb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, int L, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> C_, int LDC, Matrix<Complex> WORK_, int LDWORK) → void

zlarzt(String DIRECT, String STOREV, int N, int K, Matrix<Complex> V_, int LDV, Array<Complex> TAU_, Matrix<Complex> T_, int LDT) → void

zlascl(String TYPE, int KL, int KU, double CFROM, double CTO, int M, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zlascl2(int M, int N, Array<double> D, Matrix<Complex> X_, int LDX) → void

zlaset(String UPLO, int M, int N, Complex ALPHA, Complex BETA, Matrix<Complex> A_, int LDA) → void

zlasr(String SIDE, String PIVOT, String DIRECT, int M, int N, Array<double> C_, Array<double> S_, Matrix<Complex> A_, int LDA) → void

zlassq(int n, Array<Complex> x_, int incx, Box<double> scale, Box<double> sumsq) → void

zlaswlq(int M, int N, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlaswp(int N, Matrix<Complex> A_, int LDA, int K1, int K2, Array<int> IPIV_, int INCX) → void

zlasyf(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlasyf_aa(String UPLO, int J1, int M, int NB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> H_, int LDH, Array<Complex> WORK_) → void

zlasyf_rk(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlasyf_rook(String UPLO, int N, int NB, Box<int> KB, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> W_, int LDW, Box<int> INFO) → void

zlat2c(String UPLO, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> SA_, int LDSA, Box<int> INFO) → void

zlatbs(String UPLO, String TRANS, String DIAG, String NORMIN, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<Complex> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

zlatdf(int IJOB, int N, Matrix<Complex> Z_, int LDZ, Array<Complex> RHS_, Box<double> RDSUM, Box<double> RDSCAL, Array<int> IPIV_, Array<int> JPIV_) → void

zlatps(String UPLO, String TRANS, String DIAG, String NORMIN, int N, Array<Complex> AP_, Array<Complex> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

zlatrd(String UPLO, int N, int NB, Matrix<Complex> A_, int LDA, Array<double> E_, Array<Complex> TAU_, Matrix<Complex> W_, int LDW) → void

zlatrs(String UPLO, String TRANS, String DIAG, String NORMIN, int N, Matrix<Complex> A_, int LDA, Array<Complex> X_, Box<double> SCALE, Array<double> CNORM_, Box<int> INFO) → void

zlatrs3(String UPLO, String TRANS, String DIAG, String NORMIN, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> X_, int LDX, Array<double> SCALE_, Array<double> CNORM_, Array<double> WORK_, int LWORK, Box<int> INFO) → void

zlatrz(int M, int N, int L, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_) → void

zlatsqr(int M, int N, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zlaunhr_col_getrfnp(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> D_, Box<int> INFO) → void

zlaunhr_col_getrfnp2(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> D_, Box<int> INFO) → void

zlauu2(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zlauum(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zpbcon(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Box<double> ANORM, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpbequ(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

zpbrfs(String UPLO, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpbstf(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Box<int> INFO) → void

zpbsv(String UPLO, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zpbsvx(String FACT, String UPLO, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> AFB_, int LDAFB, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpbtf2(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Box<int> INFO) → void

zpbtrf(String UPLO, int N, int KD, Matrix<Complex> AB_, int LDAB, Box<int> INFO) → void

zpbtrs(String UPLO, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zpftrf(String TRANSR, String UPLO, int N, Array<Complex> A_, Box<int> INFO) → void

zpftri(String TRANSR, String UPLO, int N, Array<Complex> A_, Box<int> INFO) → void

zpftrs(String TRANSR, String UPLO, int N, int NRHS, Array<Complex> A_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zpocon(String UPLO, int N, Matrix<Complex> A_, int LDA, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpoequ(int N, Matrix<Complex> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

zpoequb(int N, Matrix<Complex> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

zporfs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zporfsx(String UPLO, String EQUED, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zposv(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zposvx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zposvxx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpotf2(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zpotrf(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zpotrf2(String UPLO, int N, Matrix<Complex> A, int LDA, Box<int> INFO) → void

zpotri(String UPLO, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

zpotrs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zppcon(String UPLO, int N, Array<Complex> AP_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zppequ(String UPLO, int N, Array<Complex> AP_, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Box<int> INFO) → void

zpprfs(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zppsv(String UPLO, int N, int NRHS, Array<Complex> AP_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zppsvx(String FACT, String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpptrf(String UPLO, int N, Array<Complex> AP_, Box<int> INFO) → void

zpptri(String UPLO, int N, Array<Complex> AP_, Box<int> INFO) → void

zpptrs(String UPLO, int N, int NRHS, Array<Complex> AP_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zpstf2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> PIV_, Box<int> RANK, double TOL, Array<double> WORK_, Box<int> INFO) → void

zpstrf(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> PIV_, Box<int> RANK, double TOL, Array<double> WORK_, Box<int> INFO) → void

zptcon(int N, Array<double> D_, Array<Complex> E_, double ANORM, Box<double> RCOND, Array<double> RWORK_, Box<int> INFO) → void

zpteqr(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<Complex> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

zptrfs(String UPLO, int N, int NRHS, Array<double> D_, Array<Complex> E_, Array<double> DF_, Array<Complex> EF_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zptsv(int N, int NRHS, Array<double> D_, Array<Complex> E_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zptsvx(String FACT, int N, int NRHS, Array<double> D_, Array<Complex> E_, Array<double> DF_, Array<Complex> EF_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zpttrf(int N, Array<double> D_, Array<Complex> E_, Box<int> INFO) → void

zpttrs(String UPLO, int N, int NRHS, Array<double> D_, Array<Complex> E_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zptts2(int IUPLO, int N, int NRHS, Array<double> D_, Array<Complex> E_, Matrix<Complex> B_, int LDB) → void

zrot(int N, Array<Complex> CX, int INCX, Array<Complex> CY, int INCY, double C, Complex S) → void

zrotg(Box<Complex> a, Complex b, Box<double> c, Box<Complex> s) → void

zrscl(int N, Complex A, Array<Complex> X_, int INCX) → void

zscal(int N, Complex ZA, Array<Complex> ZX_, int INCX) → void

zspcon(String UPLO, int N, Array<Complex> AP_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zspmv(String UPLO, int N, Complex ALPHA, Array<Complex> AP_, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zspr(String UPLO, int N, Complex ALPHA, Array<Complex> X_, int INCX, Array<Complex> AP_) → void

zsprfs(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zspsv(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zspsvx(String FACT, String UPLO, int N, int NRHS, Array<Complex> AP_, Array<Complex> AFP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zsptrf(String UPLO, int N, Array<Complex> AP_, Array<int> IPIV_, Box<int> INFO) → void

zsptri(String UPLO, int N, Array<Complex> AP_, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zsptrs(String UPLO, int N, int NRHS, Array<Complex> AP_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zstedc(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<Complex> Z_, int LDZ, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zstegr(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, double ABSTOL, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, Array<int> ISUPPZ_, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zstein(int N, Array<double> D_, Array<double> E_, int M, Array<double> W_, Array<int> IBLOCK_, Array<int> ISPLIT_, Matrix<Complex> Z_, int LDZ, Array<double> WORK_, Array<int> IWORK_, Array<int> IFAIL_, Box<int> INFO) → void

zstemr(String JOBZ, String RANGE, int N, Array<double> D_, Array<double> E_, double VL, double VU, int IL, int IU, Box<int> M, Array<double> W_, Matrix<Complex> Z_, int LDZ, int NZC, Array<int> ISUPPZ_, Box<bool> TRYRAC, Array<double> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

zsteqr(String COMPZ, int N, Array<double> D_, Array<double> E_, Matrix<Complex> Z_, int LDZ, Array<double> WORK_, Box<int> INFO) → void

zswap(int N, Array<Complex> ZX_, int INCX, Array<Complex> ZY_, int INCY) → void

zsycon(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zsycon_3(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zsycon_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, double ANORM, Box<double> RCOND, Array<Complex> WORK_, Box<int> INFO) → void

zsyconv(String UPLO, String WAY, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> E_, Box<int> INFO) → void

zsyconvf(String UPLO, String WAY, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Box<int> INFO) → void

zsyconvf_rook(String UPLO, String WAY, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Box<int> INFO) → void

zsyequb(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<double> S_, Box<double> SCOND, Box<double> AMAX, Array<Complex> WORK_, Box<int> INFO) → void

zsymm(String SIDE, String UPLO, int M, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Complex BETA, Matrix<Complex> C_, int LDC) → void

zsymv(String UPLO, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX, Complex BETA, Array<Complex> Y_, int INCY) → void

zsyr(String UPLO, int N, Complex ALPHA, Array<Complex> X_, int INCX, Matrix<Complex> A_, int LDA) → void

zsyr2k(String UPLO, String TRANS, int N, int K, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Complex BETA, Matrix<Complex> C_, int LDC) → void

zsyrfs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zsyrfsx(String UPLO, String EQUED, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zsyrk(String UPLO, String TRANS, int N, int K, Complex ALPHA, Matrix<Complex> A_, int LDA, Complex BETA, Matrix<Complex> C_, int LDC) → void

zsysv(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsysv_aa(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsysv_aa_2stage(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsysv_rk(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsysv_rook(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsysvx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, Box<int> INFO) → void

zsysvxx(String FACT, String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> AF_, int LDAF, Array<int> IPIV_, Box<String> EQUED, Array<double> S_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Box<double> RCOND, Box<double> RPVGRW, Array<double> BERR_, int N_ERR_BNDS, Matrix<double> ERR_BNDS_NORM_, Matrix<double> ERR_BNDS_COMP_, int NPARAMS, Array<double> PARAMS_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

zsyswapr(String UPLO, int N, Matrix<Complex> A_, int LDA, int I1, int I2) → void

zsytf2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zsytf2_rk(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Box<int> INFO) → void

zsytf2_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Box<int> INFO) → void

zsytrf(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytrf_aa(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytrf_aa_2stage(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytrf_rk(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytrf_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytri(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zsytri2(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytri2x(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> WORK_, int NB, Box<int> INFO) → void

zsytri_3(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytri_3x(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> WORK_, int NB, Box<int> INFO) → void

zsytri_rook(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Array<Complex> WORK_, Box<int> INFO) → void

zsytrs(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zsytrs2(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, Box<int> INFO) → void

zsytrs_3(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> E_, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zsytrs_aa(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zsytrs_aa_2stage(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<Complex> TB_, int LTB, Array<int> IPIV_, Array<int> IPIV2_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

zsytrs_rook(String UPLO, int N, int NRHS, Matrix<Complex> A_, int LDA, Array<int> IPIV_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

ztbcon(String NORM, String UPLO, String DIAG, int N, int KD, Matrix<Complex> AB_, int LDAB, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztbmv(String UPLO, String TRANS, String DIAG, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX) → void

ztbrfs(String UPLO, String TRANS, String DIAG, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztbsv(String UPLO, String TRANS, String DIAG, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX) → void

ztbtrs(String UPLO, String TRANS, String DIAG, int N, int KD, int NRHS, Matrix<Complex> AB_, int LDAB, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

ztfsm(String TRANSR, String SIDE, String UPLO, String TRANS, String DIAG, int M, int N, Complex ALPHA, Array<Complex> A_, Matrix<Complex> B_, int LDB) → void

ztftri(String TRANSR, String UPLO, String DIAG, int N, Array<Complex> A_, Box<int> INFO) → void

ztfttp(String TRANSR, String UPLO, int N, Array<Complex> ARF_, Array<Complex> AP_, Box<int> INFO) → void

ztfttr(String TRANSR, String UPLO, int N, Array<Complex> ARF_, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

ztgevc(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<Complex> S_, int LDS, Matrix<Complex> P_, int LDP, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, int MM, Box<int> M, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztgex2(bool WANTQ, bool WANTZ, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, int J1, Box<int> INFO) → void

ztgexc(bool WANTQ, bool WANTZ, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, int IFST, Box<int> ILST, Box<int> INFO) → void

ztgsen(int IJOB, bool WANTQ, bool WANTZ, Array<bool> SELECT_, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> ALPHA_, Array<Complex> BETA_, Matrix<Complex> Q_, int LDQ, Matrix<Complex> Z_, int LDZ, Box<int> M, Box<double> PL, Box<double> PR, Array<double> DIF_, Array<Complex> WORK_, int LWORK, Array<int> IWORK_, int LIWORK, Box<int> INFO) → void

ztgsja(String JOBU, String JOBV, String JOBQ, int M, int P, int N, int K, int L, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, double TOLA, double TOLB, Array<double> ALPHA_, Array<double> BETA_, Matrix<Complex> U_, int LDU, Matrix<Complex> V_, int LDV, Matrix<Complex> Q_, int LDQ, Array<Complex> WORK_, Box<int> NCYCLE, Box<int> INFO) → void

ztgsna(String JOB, String HOWMNY, Array<bool> SELECT_, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Array<double> S_, Array<double> DIF_, int MM, Box<int> M, Array<Complex> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

ztgsy2(String TRANS, int IJOB, int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> C_, int LDC, Matrix<Complex> D_, int LDD, Matrix<Complex> E_, int LDE, Matrix<Complex> F_, int LDF, Box<double> SCALE, Box<double> RDSUM, Box<double> RDSCAL, Box<int> INFO) → void

ztgsyl(String TRANS, int IJOB, int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> C_, int LDC, Matrix<Complex> D_, int LDD, Matrix<Complex> E_, int LDE, Matrix<Complex> F_, int LDF, Box<double> SCALE, Box<double> DIF, Array<Complex> WORK_, int LWORK, Array<int> IWORK_, Box<int> INFO) → void

ztpcon(String NORM, String UPLO, String DIAG, int N, Array<Complex> AP_, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztplqt(int M, int N, int L, int MB, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, Box<int> INFO) → void

ztplqt2(int M, int N, int L, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> T_, int LDT, Box<int> INFO) → void

ztpmlqt(String SIDE, String TRANS, int M, int N, int K, int L, int MB, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, Box<int> INFO) → void

ztpmqrt(String SIDE, String TRANS, int M, int N, int K, int L, int NB, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Array<Complex> WORK_, Box<int> INFO) → void

ztpmv(String UPLO, String TRANS, String DIAG, int N, Array<Complex> AP_, Array<Complex> X_, int INCX) → void

ztpqrt(int M, int N, int L, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, Box<int> INFO) → void

ztpqrt2(int M, int N, int L, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> T_, int LDT, Box<int> INFO) → void

ztprfb(String SIDE, String TRANS, String DIRECT, String STOREV, int M, int N, int K, int L, Matrix<Complex> V_, int LDV, Matrix<Complex> T_, int LDT, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> WORK_, int LDWORK) → void

ztprfs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Array<Complex> AP_, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztpsv(String UPLO, String TRANS, String DIAG, int N, Array<Complex> AP_, Array<Complex> X_, int INCX) → void

ztptri(String UPLO, String DIAG, int N, Array<Complex> AP_, Box<int> INFO) → void

ztptrs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Array<Complex> AP_, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

ztpttf(String TRANSR, String UPLO, int N, Array<Complex> AP_, Array<Complex> ARF_, Box<int> INFO) → void

ztpttr(String UPLO, int N, Array<Complex> AP_, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

ztrcon(String NORM, String UPLO, String DIAG, int N, Matrix<Complex> A_, int LDA, Box<double> RCOND, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztrevc(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<Complex> T_, int LDT, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, int MM, Box<int> M, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztrevc3(String SIDE, String HOWMNY, Array<bool> SELECT_, int N, Matrix<Complex> T_, int LDT, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, int MM, Box<int> M, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Box<int> INFO) → void

ztrexc(String COMPQ, int N, Matrix<Complex> T_, int LDT, Matrix<Complex> Q_, int LDQ, int IFST, int ILST, Box<int> INFO) → void

ztrmm(String SIDE, String UPLO, String TRANSA, String DIAG, int M, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB) → void

ztrmv(String UPLO, String TRANS, String DIAG, int N, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX) → void

ztrrfs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> X_, int LDX, Array<double> FERR_, Array<double> BERR_, Array<Complex> WORK_, Array<double> RWORK_, Box<int> INFO) → void

ztrsen(String JOB, String COMPQ, Array<bool> SELECT_, int N, Matrix<Complex> T_, int LDT, Matrix<Complex> Q_, int LDQ, Array<Complex> W_, Box<int> M, Box<double> S, Box<double> SEP, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

ztrsm(String SIDE, String UPLO, String TRANSA, String DIAG, int M, int N, Complex ALPHA, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB) → void

ztrsna(String JOB, String HOWMNY, Array<bool> SELECT_, int N, Matrix<Complex> T_, int LDT, Matrix<Complex> VL_, int LDVL, Matrix<Complex> VR_, int LDVR, Array<double> S_, Array<double> SEP_, int MM, Box<int> M, Matrix<Complex> WORK_, int LDWORK, Array<double> RWORK_, Box<int> INFO) → void

ztrsv(String UPLO, String TRANS, String DIAG, int N, Matrix<Complex> A_, int LDA, Array<Complex> X_, int INCX) → void

ztrsyl(String TRANA, String TRANB, int ISGN, int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> C_, int LDC, Box<double> SCALE, Box<int> INFO) → void

ztrsyl3(String TRANA, String TRANB, int ISGN, int M, int N, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Matrix<Complex> C_, int LDC, Box<double> SCALE, Matrix<double> SWORK_, Box<int> LDSWORK, Box<int> INFO) → void

ztrti2(String UPLO, String DIAG, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

ztrtri(String UPLO, String DIAG, int N, Matrix<Complex> A_, int LDA, Box<int> INFO) → void

ztrtrs(String UPLO, String TRANS, String DIAG, int N, int NRHS, Matrix<Complex> A_, int LDA, Matrix<Complex> B_, int LDB, Box<int> INFO) → void

ztrttf(String TRANSR, String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> ARF_, Box<int> INFO) → void

ztrttp(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> AP_, Box<int> INFO) → void

ztzrzf(int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb(String TRANS, String SIGNS, int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X12_, int LDX12, Matrix<Complex> X21_, int LDX21, Matrix<Complex> X22_, int LDX22, Array<double> THETA_, Array<double> PHI_, Array<Complex> TAUP1_, Array<Complex> TAUP2_, Array<Complex> TAUQ1_, Array<Complex> TAUQ2_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb1(int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<Complex> TAUP1_, Array<Complex> TAUP2_, Array<Complex> TAUQ1_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb2(int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<Complex> TAUP1_, Array<Complex> TAUP2_, Array<Complex> TAUQ1_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb3(int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<Complex> TAUP1_, Array<Complex> TAUP2_, Array<Complex> TAUQ1_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb4(int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X21_, int LDX21, Array<double> THETA_, Array<double> PHI_, Array<Complex> TAUP1_, Array<Complex> TAUP2_, Array<Complex> TAUQ1_, Array<Complex> PHANTOM_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb5(int M1, int M2, int N, Array<Complex> X1_, int INCX1, Array<Complex> X2_, int INCX2, Matrix<Complex> Q1_, int LDQ1, Matrix<Complex> Q2_, int LDQ2, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunbdb6(int M1, int M2, int N, Array<Complex> X1_, int INCX1, Array<Complex> X2_, int INCX2, Matrix<Complex> Q1_, int LDQ1, Matrix<Complex> Q2_, int LDQ2, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zuncsd(String JOBU1, String JOBU2, String JOBV1T, String JOBV2T, String TRANS, String SIGNS, int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X12_, int LDX12, Matrix<Complex> X21_, int LDX21, Matrix<Complex> X22_, int LDX22, Array<double> THETA_, Matrix<Complex> U1_, int LDU1, Matrix<Complex> U2_, int LDU2, Matrix<Complex> V1T_, int LDV1T, Matrix<Complex> V2T_, int LDV2T, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, Box<int> INFO) → void

zuncsd2by1(String JOBU1, String JOBU2, String JOBV1T, int M, int P, int Q, Matrix<Complex> X11_, int LDX11, Matrix<Complex> X21_, int LDX21, Array<double> THETA_, Matrix<Complex> U1_, int LDU1, Matrix<Complex> U2_, int LDU2, Matrix<Complex> V1T_, int LDV1T, Array<Complex> WORK_, int LWORK, Array<double> RWORK_, int LRWORK, Array<int> IWORK_, Box<int> INFO) → void

zung2l(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zung2r(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zungbr(String VECT, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunghr(int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungl2(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zunglq(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungql(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungqr(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungr2(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, Box<int> INFO) → void

zungrq(int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungtr(String UPLO, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungtsqr(int M, int N, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zungtsqr_row(int M, int N, int MB, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunhr_col(int M, int N, int NB, Matrix<Complex> A_, int LDA, Matrix<Complex> T_, int LDT, Array<Complex> D_, Box<int> INFO) → void

zunm22(String SIDE, String TRANS, int M, int N, int N1, int N2, Matrix<Complex> Q_, int LDQ, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunm2l(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zunm2r(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zunmbr(String VECT, String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmhr(String SIDE, String TRANS, int M, int N, int ILO, int IHI, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunml2(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zunmlq(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmql(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmqr(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmr2(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zunmr3(String SIDE, String TRANS, int M, int N, int K, int L, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

zunmrq(String SIDE, String TRANS, int M, int N, int K, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmrz(String SIDE, String TRANS, int M, int N, int K, int L, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zunmtr(String SIDE, String UPLO, String TRANS, int M, int N, Matrix<Complex> A_, int LDA, Array<Complex> TAU_, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, int LWORK, Box<int> INFO) → void

zupgtr(String UPLO, int N, Array<Complex> AP_, Array<Complex> TAU_, Matrix<Complex> Q_, int LDQ, Array<Complex> WORK_, Box<int> INFO) → void

zupmtr(String SIDE, String UPLO, String TRANS, int M, int N, Array<Complex> AP, Array<Complex> TAU, Matrix<Complex> C_, int LDC, Array<Complex> WORK_, Box<int> INFO) → void

Typedefs

ComplexTuple = (num, num)

Exceptions / Errors

EOF