Section L: math library functions - Linux man pages

caxpy(l)

CAXPY constant times vector plus vector

cbdsqr(l)

computes singular values and, , right/left singular vectors from singular value decomposition of real N-by-N bidiagonal matrix B using implicit zero-shift QR ...

ccopy(l)

CCOPY copie vector x to vector y

cdotc(l)

forms dot product of two vectors, conjugating first vector

cdotu(l)

CDOTU form dot product of two vectors

cgbbrd(l)

reduces complex general m-by-n band matrix to real upper bidiagonal form B by unitary transformation

cgbcon(l)

estimates reciprocal of condition number of complex general band matrix , in either 1-norm or infinity-norm

cgbequ(l)

computes row/column scalings intended to equilibrate M-by-N band matrix/reduce its condition number

cgbequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

cgbmv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

cgbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is banded, and provides error bounds and backward error estimates for solution

cgbrfsx(l)

CGBRFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

cgbsv(l)

computes solution to complex system of linear equations * X = B, where is band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are ...

cgbsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

cgbsvxx(l)

CGBSVXX use LU factorization to compute solution to complex system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

cgbtf2(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

cgbtrf(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

cgbtrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general band matrix using LU factorization computed by CGBTRF

cgebak(l)

forms right/left eigenvectors of complex general matrix by backward transformation on computed eigenvectors of balanced matrix output by CGEBAL

cgebal(l)

balances general complex matrix

cgebd2(l)

reduces complex general m by n matrix to upper/lower real bidiagonal form B by unitary transformation

cgebrd(l)

reduces general complex M-by-N matrix to upper/lower bidiagonal form B by unitary transformation

cgecon(l)

estimates reciprocal of condition number of general complex matrix , in either 1-norm or infinity-norm, using LU factorization computed by CGETRF

cgeequ(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

cgeequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

cgees(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

cgeesx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

cgeev(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

cgeevx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

cgegs(l)

routine i deprecated/has been replaced by routine CGGES

cgegv(l)

routine i deprecated/has been replaced by routine CGGEV

cgehd2(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

cgehrd(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

cgelq2(l)

computes LQ factorization of complex m by n matrix

cgelqf(l)

computes LQ factorization of complex M-by-N matrix

cgels(l)

solves overdetermined or underdetermined complex linear systems involving M-by-N matrix , or its conjugate-transpose, using QR or LQ factorization of

cgelsd(l)

computes minimum-norm solution to real linear least squares problem

cgelss(l)

computes minimum norm solution to complex linear least squares problem

cgelsx(l)

routine i deprecated/has been replaced by routine CGELSY

cgelsy(l)

computes minimum-norm solution to complex linear least squares problem

cgemm(l)

performs one of matrix-matrix operations C := alpha*op*op + beta*C

cgemv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

cgeql2(l)

computes QL factorization of complex m by n matrix

cgeqlf(l)

computes QL factorization of complex M-by-N matrix

cgeqp3(l)

computes QR factorization with column pivoting of matrix

cgeqpf(l)

routine i deprecated/has been replaced by routine CGEQP3

cgeqr2(l)

computes QR factorization of complex m by n matrix

cgeqrf(l)

computes QR factorization of complex M-by-N matrix

cgerc(l)

performs rank 1 operation := alpha*x*conjg +

cgerfs(l)

improves computed solution to system of linear equations/provides error bounds/backward error estimates for solution

cgerfsx(l)

CGERFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

cgerq2(l)

computes RQ factorization of complex m by n matrix

cgerqf(l)

computes RQ factorization of complex M-by-N matrix

cgeru(l)

performs rank 1 operation := alpha*x*y' +

cgesc2(l)

solves system of linear equations * X = scale* RHS with general N-by-N matrix using LU factorization with complete pivoting computed by CGETC2

cgesdd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors, by using divide-and-conquer method

cgesv(l)

computes solution to complex system of linear equations * X = B

cgesvd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors

cgesvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B

cgesvxx(l)

CGESVXX use LU factorization to compute solution to complex system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

cgetc2(l)

computes LU factorization, using complete pivoting, of n-by-n matrix

cgetf2(l)

computes LU factorization of general m-by-n matrix using partial pivoting with row interchanges

cgetrf(l)

computes LU factorization of general M-by-N matrix using partial pivoting with row interchanges

cgetri(l)

computes inverse of matrix using LU factorization computed by CGETRF

cgetrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general N-by-N matrix using LU factorization computed by CGETRF

cggbak(l)

forms right or left eigenvectors of complex generalized eigenvalue problem *x = lambda*B*x, by backward transformation on computed eigenvectors of balanced ...

cggbal(l)

balances pair of general complex matrices

cgges(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, generalized complex Schur form , and left/right Schur vectors

cggesx(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, complex Schur form

cggev(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, and , left/right generalized eigenvectors

cggevx(l)

computes for pair of N-by-N complex nonsymmetric matrices generalized eigenvalues, and , left/right generalized eigenvectors

cggglm(l)

solves general Gauss-Markov linear model problem

cgghrd(l)

reduces pair of complex matrices to generalized upper Hessenberg form using unitary transformations, where is general matrix and B is upper triangular

cgglse(l)

solves linear equality-constrained least squares problem

cggqrf(l)

computes generalized QR factorization of N-by-M matrix/N-by-P matrix B

cggrqf(l)

computes generalized RQ factorization of M-by-N matrix/P-by-N matrix B

cggsvd(l)

computes generalized singular value decomposition of M-by-N complex matrix/P-by-N complex matrix B

cggsvp(l)

computes unitary matrices U, V and Q such that N-K-L K L U'**Q = K if M-K-L >= 0

cgtcon(l)

estimates reciprocal of condition number of complex tridiagonal matrix using LU factorization as computed by CGTTRF

cgtrfs(l)

improves computed solution to system of linear equations when coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for ...

cgtsv(l)

solves equation *X = B

cgtsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

cgttrf(l)

computes LU factorization of complex tridiagonal matrix using elimination with partial pivoting/row interchanges

cgttrs(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

cgtts2(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

chbev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

chbevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

chbevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian band matrix

chbgst(l)

reduces complex Hermitian-definite banded generalized eigenproblem *x = lambda*B*x to standard form C*y = lambda*y

chbgv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

chbgvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

chbgvx(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

chbmv(l)

performs matrix-vector operation y := alpha**x + beta*y

chbtrd(l)

reduces complex Hermitian band matrix to real symmetric tridiagonal form T by unitary similarity transformation

checon(l)

estimates reciprocal of condition number of complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by CHETRF

cheequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

cheev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

cheevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

cheevr(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

cheevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

chegs2(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

chegst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

chegv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chegvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chegvx(l)

computes selected eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chemm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

chemv(l)

performs matrix-vector operation y := alpha**x + beta*y

cher(l)

performs hermitian rank 1 operation := alpha*x*conjg +

cher2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

cher2k(l)

performs one of hermitian rank 2k operations C := alpha**conjg + conjg*B*conjg + beta*C

cherfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

cherfsx(l)

CHERFSX improve computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

cherk(l)

performs one of hermitian rank k operations C := alpha**conjg + beta*C

chesv(l)

computes solution to complex system of linear equations * X = B

chesvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

chesvxx(l)

CHESVXX use diagonal pivoting factorization to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric matrix and X and B are ...

chetd2(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

chetf2(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

chetrd(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

chetrf(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

chetri(l)

computes inverse of complex Hermitian indefinite matrix using factorization = U*D*U**H/= L*D*L**H computed by CHETRF

chetrs(l)

solves system of linear equations *X = B with complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by CHETRF

chfrk(l)

3 BLAS like routine for C in RFP Format

chgeqz(l)

computes eigenvalues of complex matrix pair

chla_transtype(l)

subroutine translate from BLAST-specified integer constant to char string specifying transposition operation

chpcon(l)

estimates reciprocal of condition number of complex Hermitian packed matrix using factorization = U*D*U**H/= L*D*L**H computed by CHPTRF

chpev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

chpevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

chpevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

chpgst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form, using packed storage

chpgv(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chpgvd(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chpgvx(l)

computes selected eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

chpmv(l)

performs matrix-vector operation y := alpha**x + beta*y

chpr(l)

performs hermitian rank 1 operation := alpha*x*conjg +

chpr2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

chprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward ...

chpsv(l)

computes solution to complex system of linear equations * X = B

chpsvx(l)

uses diagonal pivoting factorization = U*D*U**H or = L*D*L**H to compute solution to complex system of linear equations * X = B, where is N-by-N Hermitian ...

chptrd(l)

reduces complex Hermitian matrix stored in packed form to real symmetric tridiagonal form T by unitary similarity transformation

chptrf(l)

computes factorization of complex Hermitian packed matrix using Bunch-Kaufman diagonal pivoting method

chptri(l)

computes inverse of complex Hermitian indefinite matrix in packed storage using factorization = U*D*U**H/= L*D*L**H computed by CHPTRF

chptrs(l)

solves system of linear equations *X = B with complex Hermitian matrix stored in packed format using factorization = U*D*U**H/= L*D*L**H computed by CHPTRF

chsein(l)

uses inverse iteration to find specified right/left eigenvectors of complex upper Hessenberg matrix H

chseqr(l)

CHSEQR compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

cla_gbamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

cla_gbrcond_c(l)

CLA_GBRCOND_C Compute infinity norm condition number of op * inv(diag) where C is REAL vector

cla_gbrcond_x(l)

CLA_GBRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX vector

cla_gbrfsx_extended(l)

computes

cla_gbrpvgrw(l)

computes

cla_geamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

cla_gercond_c(l)

CLA_GERCOND_C compute infinity norm condition number of op * inv(diag) where C is REAL vector

cla_gercond_x(l)

CLA_GERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX vector

cla_gerfsx_extended(l)

computes

cla_heamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

cla_hercond_c(l)

CLA_HERCOND_C compute infinity norm condition number of op * inv(diag) where C is REAL vector

cla_hercond_x(l)

CLA_HERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX vector

cla_herfsx_extended(l)

computes

cla_herpvgrw(l)

computes

cla_lin_berr(l)

CLA_LIN_BERR compute component-wise relative backward error from formula max ( abs(R)/( abs(op)*abs + abs ) ) where abs is component-wise absolute value of ...

cla_porcond_c(l)

SLA_PORCOND_C Compute infinity norm condition number of op * inv(diag) where C is REAL vector WORK is COMPLEX workspace of size 2*N, and RWORK is REAL ...

cla_porcond_x(l)

CLA_PORCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX vector

cla_porfsx_extended(l)

computes

cla_porpvgrw(l)

computes

cla_rpvgrw(l)

computes

cla_syamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

cla_syrcond_c(l)

CLA_SYRCOND_C Compute infinity norm condition number of op * inv(diag) where C is REAL vector

cla_syrcond_x(l)

CLA_SYRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX vector

cla_syrfsx_extended(l)

computes

cla_syrpvgrw(l)

computes

cla_wwaddw(l)

CLA_WWADDW add vector W into doubled-single vector

clabrd(l)

reduces first NB rows and columns of complex general m by n matrix to upper or lower real bidiagonal form by unitary transformation Q' * * P, and returns ...

clacgv(l)

conjugates complex vector of length N

clacn2(l)

estimates 1-norm of square, complex matrix

clacon(l)

estimates 1-norm of square, complex matrix

clacp2(l)

copies all/part of real two-dimensional matrix to complex matrix B

clacpy(l)

copies all/part of two-dimensional matrix to another matrix B

clacrm(l)

performs very simple matrix-matrix multiplication

clacrt(l)

performs operation ==> where c/s are complex/vectors x/y are complex

cladiv(l)

:= X/Y, where X and Y are complex

claed0(l)

divide and conquer method, CLAED0 computes all eigenvalues of symmetric tridiagonal matrix which is one diagonal block of those from reducing dense or band ...

claed7(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

claed8(l)

merges two sets of eigenvalues together into single sorted set

claein(l)

uses inverse iteration to find right/left eigenvector corresponding to eigenvalue W of complex upper Hessenberg matrix H

claesy(l)

computes eigendecomposition of 2-by-2 symmetric matrix ( ; ) provided norm of matrix of eigenvectors is larger than some threshold value

claev2(l)

computes eigendecomposition of 2-by-2 Hermitian matrix [ B ] [ CONJG C ]

clag2z(l)

converts COMPLEX matrix, SA, to COMPLEX*16 matrix

clags2(l)

computes 2-by-2 unitary matrices U, V and Q, such that if then U'**Q = U'**Q = and V'*B*Q = V'**Q = or if then U'**Q = U'**Q = and V'*B*Q = V'**Q = where U = ...

clagtm(l)

performs matrix-vector product of form B := alpha * * X + beta * B where is tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta ...

clahef(l)

computes partial factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

clahqr(l)

CLAHQR i auxiliary routine called by CHSEQR to update eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with Hessenberg submatrix in ...

clahr2(l)

reduces first NB columns of complex general n-BY- matrix so that elements below k-th subdiagonal are zero

clahrd(l)

reduces first NB columns of complex general n-by- matrix so that elements below k-th subdiagonal are zero

claic1(l)

applies one step of incremental condition estimation in its simplest version

clals0(l)

applies back multiplying factors of either left/right singular vector matrix of diagonal matrix appended by row to right hand side matrix B in solving least ...

clalsa(l)

is itermediate step in solving least squares problem by computing SVD of coefficient matrix in compact form

clalsd(l)

uses singular value decomposition of to solve least squares problem of finding X to minimize Euclidean norm of each column of *X-B, where is N-by-N upper ...

clangb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n band matrix , with kl sub-diagonals and ku ...

clange(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex matrix

clangt(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex tridiagonal matrix

clanhb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n hermitian band matrix , with k super-diagonals

clanhe(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix

clanhf(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian matrix in RFP format

clanhp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix , supplied in packed form

clanhs(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of Hessenberg matrix

clanht(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian tridiagonal matrix

clansb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n symmetric band matrix , with k super-diagonals

clansp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix , supplied in packed form

clansy(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix

clantb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n triangular band matrix , with diagonals

clantp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of triangular matrix , supplied in packed form

clantr(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of trapezoidal or triangular matrix

clapll(l)

two column vectors X and Y, let =

clapmt(l)

rearranges columns of M by N matrix X as specified by permutation K,K,...,K of integers 1,...,N

claqgb(l)

equilibrates general M by N band matrix with KL subdiagonals/KU superdiagonals using row/scaling factors in vectors R/C

claqge(l)

equilibrates general M by N matrix using row/column scaling factors in vectors R/C

claqhb(l)

equilibrates Hermitian band matrix using scaling factors in vector S

claqhe(l)

equilibrates Hermitian matrix using scaling factors in vector S

claqhp(l)

equilibrates Hermitian matrix using scaling factors in vector S

claqp2(l)

computes QR factorization with column pivoting of block

claqps(l)

computes step of QR factorization with column pivoting of complex M-by-N matrix by using Blas-3

claqr0(l)

CLAQR0 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

claqr1(l)

claqr2(l)

claqr3(l)

claqr4(l)

CLAQR4 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

claqr5(l)

claqsb(l)

equilibrates symmetric band matrix using scaling factors in vector S

claqsp(l)

equilibrates symmetric matrix using scaling factors in vector S

claqsy(l)

equilibrates symmetric matrix using scaling factors in vector S

clar1v(l)

computes r-th column of inverse of sumbmatrix in rows B1 through BN of tridiagonal matrix L D L^T - sigma I

clar2v(l)

applies vector of complex plane rotations with real cosines from both sides to sequence of 2-by-2 complex Hermitian matrices

clarcm(l)

performs very simple matrix-matrix multiplication

clarf(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

clarfb(l)

applies complex block reflector H or its transpose H' to complex M-by-N matrix C, from either left or right

clarfg(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

clarfp(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

clarft(l)

forms triangular factor T of complex block reflector H of order n, which is defined as product of k elementary reflectors

clarfx(l)

applies complex elementary reflector H to complex m by n matrix C, from either left or right

clargv(l)

generates vector of complex plane rotations with real cosines, determined by elements of complex vectors x and y

clarnv(l)

returns vector of n random complex numbers from uniform/normal distribution

clarrv(l)

computes eigenvectors of tridiagonal matrix T = L D L^T given L, D and APPROXIMATIONS to eigenvalues of L D L^T

clarscl2(l)

performs reciprocal diagonal scaling on vector

clartg(l)

generates plane rotation so that [ CS SN ] [ F ] [ R ] [ __ ]

clartv(l)

applies vector of complex plane rotations with real cosines to elements of complex vectors x/y

clarz(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

clarzb(l)

applies complex block reflector H/its transpose H**H to complex distributed M-by-N C from left/right

clarzt(l)

forms triangular factor T of complex block reflector H of order > n, which is defined as product of k elementary reflectors

clascl(l)

multiplies M by N complex matrix by real scalar CTO/CFROM

clascl2(l)

performs diagonal scaling on vector

claset(l)

initializes 2-D array to BETA on diagonal/ALPHA on offdiagonals

clasr(l)

applies sequence of real plane rotations to complex matrix , from either left or right

classq(l)

returns values scl and ssq such that *ssq = x**2 +...+ x**2 + *sumsq

claswp(l)

performs series of row interchanges on matrix

clasyf(l)

computes partial factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

clatbs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

clatdf(l)

computes contribution to reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that norm of x is as large as possible

clatps(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

clatrd(l)

reduces NB rows and columns of complex Hermitian matrix to Hermitian tridiagonal form by unitary similarity transformation Q' * * Q, and returns matrices V and ...

clatrs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

clatrz(l)

factors M-by- complex upper trapezoidal matrix [ A1 A2 ] = [ ] as * Z by means of unitary transformations, where Z is -by- unitary matrix and, R and A1 are ...

clatzm(l)

routine i deprecated/has been replaced by routine CUNMRZ

clauu2(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

clauum(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

cpbcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPBTRF

cpbequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite band matrix/reduce its condition number

cpbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and banded, and provides error bounds and ...

cpbstf(l)

computes split Cholesky factorization of complex Hermitian positive definite band matrix

cpbsv(l)

computes solution to complex system of linear equations * X = B

cpbsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

cpbtf2(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

cpbtrf(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

cpbtrs(l)

solves system of linear equations *X = B with Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPBTRF

cpftrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

cpftri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPFTRF

cpftrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPFTRF

cpocon(l)

estimates reciprocal of condition number of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPOTRF

cpoequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix/reduce its condition number

cpoequb(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

cporfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite

cporfsx(l)

CPORFSX improve computed solution to system of linear equations when coefficient matrix is symmetric positive definite, and provides error bounds and backward ...

cposv(l)

computes solution to complex system of linear equations * X = B

cposvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

cposvxx(l)

CPOSVXX use Cholesky factorization = U**T*U or = L*L**T to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric positive ...

cpotf2(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

cpotrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

cpotri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPOTRF

cpotrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPOTRF

cppcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite packed matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPPTRF

cppequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix in packed storage/reduce its condition number

cpprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and packed, and provides error bounds and ...

cppsv(l)

computes solution to complex system of linear equations * X = B

cppsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

cpptrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix stored in packed format

cpptri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by CPPTRF

cpptrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix in packed storage using Cholesky factorization = U**H*U/= L*L**H computed by ...

cpstf2(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

cpstrf(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

cptcon(l)

computes reciprocal of condition number of complex Hermitian positive definite tridiagonal matrix using factorization = L*D*L**H/= U**H*D*U computed by CPTTRF

cpteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric positive definite tridiagonal matrix by first factoring matrix using SPTTRF and then calling CBDSQR ...

cptrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and ...

cptsv(l)

computes solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS ...

cptsvx(l)

uses factorization = L*D*L**H to compute solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix ...

cpttrf(l)

computes L*D*L' factorization of complex Hermitian positive definite tridiagonal matrix

cpttrs(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by CPTTRF

cptts2(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by CPTTRF

crot(l)

applies plane rotation, where cos is real and sin is complex, and vectors CX and CY are complex

crotg(l)

determines complex Givens rotation

cscal(l)

CSCAL scale vector by constant

cspcon(l)

estimates reciprocal of condition number of complex symmetric packed matrix using factorization = U*D*U**T/= L*D*L**T computed by CSPTRF

cspmv(l)

performs matrix-vector operation y := alpha**x + beta*y

cspr(l)

performs symmetric rank 1 operation := alpha*x*conjg +

csprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward ...

cspsv(l)

computes solution to complex system of linear equations * X = B

cspsvx(l)

uses diagonal pivoting factorization = U*D*U**T or = L*D*L**T to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric ...

csptrf(l)

computes factorization of complex symmetric matrix stored in packed format using Bunch-Kaufman diagonal pivoting method

csptri(l)

computes inverse of complex symmetric indefinite matrix in packed storage using factorization = U*D*U**T/= L*D*L**T computed by CSPTRF

csptrs(l)

solves system of linear equations *X = B with complex symmetric matrix stored in packed format using factorization = U*D*U**T/= L*D*L**T computed by CSPTRF

csrot(l)

plane rotation, where cos and sin are real and vectors cx and cy are complex

csrscl(l)

multiplies n-element complex vector x by real scalar 1/

csscal(l)

CSSCAL scale complex vector by real constant

cstedc(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using divide and conquer method

cstegr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

cstein(l)

computes eigenvectors of real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration

cstemr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

csteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using implicit QL or QR method

cswap(l)

CSWAP interchange two vectors

csycon(l)

estimates reciprocal of condition number of complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by CSYTRF

csyequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

csymm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

csymv(l)

performs matrix-vector operation y := alpha**x + beta*y

csyr(l)

performs symmetric rank 1 operation := alpha*x* +

csyr2k(l)

performs one of symmetric rank 2k operations C := alpha**B' + alpha*B*' + beta*C

csyrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

csyrfsx(l)

CSYRFSX improve computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

csyrk(l)

performs one of symmetric rank k operations C := alpha**' + beta*C

csysv(l)

computes solution to complex system of linear equations * X = B

csysvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

csysvxx(l)

CSYSVXX use diagonal pivoting factorization to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric matrix and X and B are ...

csytf2(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

csytrf(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

csytri(l)

computes inverse of complex symmetric indefinite matrix using factorization = U*D*U**T/= L*D*L**T computed by CSYTRF

csytrs(l)

solves system of linear equations *X = B with complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by CSYTRF

ctbcon(l)

estimates reciprocal of condition number of triangular band matrix , in either 1-norm or infinity-norm

ctbmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ctbrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular band coefficient matrix

ctbsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ctbtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ctfsm(l)

3 BLAS like routine for in RFP Format

ctftri(l)

computes inverse of triangular matrix stored in RFP format

ctfttp(l)

copies triangular matrix from rectangular full packed format to standard packed format

ctfttr(l)

copies triangular matrix from rectangular full packed format to standard full format

ctgevc(l)

computes some or all of right/left eigenvectors of pair of complex matrices , where S and P are upper triangular

ctgex2(l)

swaps adjacent diagonal 1 by 1 blocks/

ctgexc(l)

reorders generalized Schur decomposition of complex matrix pair , using unitary equivalence transformation := Q * * Z', so that diagonal block of with row ...

ctgsen(l)

reorders generalized Schur decomposition of complex matrix pair (in terms of unitary equivalence trans- formation Q' * * Z), so that selected cluster of ...

ctgsja(l)

computes generalized singular value decomposition of two complex upper triangular matrices/B

ctgsna(l)

estimates reciprocal condition numbers for specified eigenvalues/eigenvectors of matrix pair

ctgsy2(l)

solves generalized Sylvester equation * R - L * B = scale D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices

ctgsyl(l)

solves generalized Sylvester equation

ctpcon(l)

estimates reciprocal of condition number of packed triangular matrix , in either 1-norm or infinity-norm

ctpmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ctprfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular packed coefficient matrix

ctpsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ctptri(l)

computes inverse of complex upper/lower triangular matrix stored in packed format

ctptrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ctpttf(l)

copies triangular matrix from standard packed format to rectangular full packed format

ctpttr(l)

copies triangular matrix from standard packed format to standard full format

ctrcon(l)

estimates reciprocal of condition number of triangular matrix , in either 1-norm or infinity-norm

ctrevc(l)

computes some/all of right/left eigenvectors of complex upper triangular matrix T

ctrexc(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that diagonal element of T with row index IFST is moved to row ILST

ctrmm(l)

performs one of matrix-matrix operations B := alpha*op*B, or B := alpha*B*op where alpha is scalar, B is m by n matrix, is unit, or non-unit, upper or lower ...

ctrmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ctrrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular coefficient matrix

ctrsen(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that selected cluster of eigenvalues appears in leading positions on diagonal of upper triangular ...

ctrsm(l)

solves one of matrix equations op*X = alpha*B, or X*op = alpha*B

ctrsna(l)

estimates reciprocal condition numbers for specified eigenvalues/right eigenvectors of complex upper triangular matrix T

ctrsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ctrsyl(l)

solves complex Sylvester matrix equation

ctrti2(l)

computes inverse of complex upper/lower triangular matrix

ctrtri(l)

computes inverse of complex upper/lower triangular matrix

ctrtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ctrttf(l)

copies triangular matrix from standard full format to rectangular full packed format

ctrttp(l)

copies triangular matrix from full format to standard packed format

ctzrqf(l)

routine i deprecated/has been replaced by routine CTZRZF

ctzrzf(l)

reduces M-by-N complex upper trapezoidal matrix to upper triangular form by means of unitary transformations

cung2l(l)

generates m by n complex matrix Q with orthonormal columns

cung2r(l)

generates m by n complex matrix Q with orthonormal columns

cungbr(l)

generates one of complex unitary matrices Q/P**H determined by CGEBRD when reducing complex matrix to bidiagonal form

cunghr(l)

generates complex unitary matrix Q which is defined as product of IHI-ILO elementary reflectors of order N, as returned by CGEHRD

cungl2(l)

generates m-by-n complex matrix Q with orthonormal rows

cunglq(l)

generates M-by-N complex matrix Q with orthonormal rows

cungql(l)

generates M-by-N complex matrix Q with orthonormal columns

cungqr(l)

generates M-by-N complex matrix Q with orthonormal columns

cungr2(l)

generates m by n complex matrix Q with orthonormal rows

cungrq(l)

generates M-by-N complex matrix Q with orthonormal rows

cungtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors of order N, as returned by CHETRD

cunm2l(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

cunm2r(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

cunmbr(l)

VECT = 'Q', CUNMBR overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmhr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunml2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

cunmlq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmql(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmqr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmr2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

cunmr3(l)

overwrites general complex m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

cunmrq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmrz(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cunmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

cupgtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors H of order n, as returned by CHPTRD using packed storage

cupmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dasum(l)

DASUM take sum of absolute values

daxpy(l)

DAXPY constant times vector plus vector

dbdsdc(l)

computes singular value decomposition of real N-by-N bidiagonal matrix B

dbdsqr(l)

computes singular values and, , right/left singular vectors from singular value decomposition of real N-by-N bidiagonal matrix B using implicit zero-shift QR ...

dcabs1(l)

computes absolute value of double complex number =====================================================================

dcopy(l)

DCOPY copie vector, x, to vector, y

ddisna(l)

computes reciprocal condition numbers for eigenvectors of real symmetric/complex Hermitian matrix/for left/right singular vectors of general m-by-n matrix

ddot(l)

DDOT form dot product of two vectors

dgbbrd(l)

reduces real general m-by-n band matrix to upper bidiagonal form B by orthogonal transformation

dgbcon(l)

estimates reciprocal of condition number of real general band matrix , in either 1-norm or infinity-norm

dgbequ(l)

computes row/column scalings intended to equilibrate M-by-N band matrix/reduce its condition number

dgbequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

dgbmv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y

dgbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is banded, and provides error bounds and backward error estimates for solution

dgbrfsx(l)

DGBRFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

dgbsv(l)

computes solution to real system of linear equations * X = B, where is band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are ...

dgbsvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B, **T * X = B, or **H * X = B

dgbsvxx(l)

DGBSVXX use LU factorization to compute solution to double precision system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS ...

dgbtf2(l)

computes LU factorization of real m-by-n band matrix using partial pivoting with row interchanges

dgbtrf(l)

computes LU factorization of real m-by-n band matrix using partial pivoting with row interchanges

dgbtrs(l)

solves system of linear equations * X = B/' * X = B with general band matrix using LU factorization computed by DGBTRF

dgebak(l)

forms right/left eigenvectors of real general matrix by backward transformation on computed eigenvectors of balanced matrix output by DGEBAL

dgebal(l)

balances general real matrix

dgebd2(l)

reduces real general m by n matrix to upper/lower bidiagonal form B by orthogonal transformation

dgebrd(l)

reduces general real M-by-N matrix to upper/lower bidiagonal form B by orthogonal transformation

dgecon(l)

estimates reciprocal of condition number of general real matrix , in either 1-norm or infinity-norm, using LU factorization computed by DGETRF

dgeequ(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

dgeequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

dgees(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues, real Schur form T, and, , matrix of Schur vectors Z

dgeesx(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues, real Schur form T, and, , matrix of Schur vectors Z

dgeev(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

dgeevx(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

dgegs(l)

routine i deprecated/has been replaced by routine DGGES

dgegv(l)

routine i deprecated/has been replaced by routine DGGEV

dgehd2(l)

reduces real general matrix to upper Hessenberg form H by orthogonal similarity transformation

dgehrd(l)

reduces real general matrix to upper Hessenberg form H by orthogonal similarity transformation

dgejsv(l)

computes singular value decomposition of real M-by-N matrix [], where M >= N

dgelq2(l)

computes LQ factorization of real m by n matrix

dgelqf(l)

computes LQ factorization of real M-by-N matrix

dgels(l)

solves overdetermined or underdetermined real linear systems involving M-by-N matrix , or its transpose, using QR or LQ factorization of

dgelsd(l)

computes minimum-norm solution to real linear least squares problem

dgelss(l)

computes minimum norm solution to real linear least squares problem

dgelsx(l)

routine i deprecated/has been replaced by routine DGELSY

dgelsy(l)

computes minimum-norm solution to real linear least squares problem

dgemm(l)

performs one of matrix-matrix operations C := alpha*op*op + beta*C

dgemv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y

dgeql2(l)

computes QL factorization of real m by n matrix

dgeqlf(l)

computes QL factorization of real M-by-N matrix

dgeqp3(l)

computes QR factorization with column pivoting of matrix

dgeqpf(l)

routine i deprecated/has been replaced by routine DGEQP3

dgeqr2(l)

computes QR factorization of real m by n matrix

dgeqrf(l)

computes QR factorization of real M-by-N matrix

dger(l)

performs rank 1 operation := alpha*x*y' +

dgerfs(l)

improves computed solution to system of linear equations/provides error bounds/backward error estimates for solution

dgerfsx(l)

DGERFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

dgerq2(l)

computes RQ factorization of real m by n matrix

dgerqf(l)

computes RQ factorization of real M-by-N matrix

dgesc2(l)

solves system of linear equations * X = scale* RHS with general N-by-N matrix using LU factorization with complete pivoting computed by DGETC2

dgesdd(l)

computes singular value decomposition of real M-by-N matrix , computing left and right singular vectors

dgesv(l)

computes solution to real system of linear equations * X = B

dgesvd(l)

computes singular value decomposition of real M-by-N matrix , computing left/right singular vectors

dgesvj(l)

computes singular value decomposition of real M-by-N matrix , where M >= N

dgesvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B

dgesvxx(l)

DGESVXX use LU factorization to compute solution to double precision system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS ...

dgetc2(l)

computes LU factorization with complete pivoting of n-by-n matrix

dgetf2(l)

computes LU factorization of general m-by-n matrix using partial pivoting with row interchanges

dgetrf(l)

computes LU factorization of general M-by-N matrix using partial pivoting with row interchanges

dgetri(l)

computes inverse of matrix using LU factorization computed by DGETRF

dgetrs(l)

solves system of linear equations * X = B/' * X = B with general N-by-N matrix using LU factorization computed by DGETRF

dggbak(l)

forms right or left eigenvectors of real generalized eigenvalue problem *x = lambda*B*x, by backward transformation on computed eigenvectors of balanced pair ...

dggbal(l)

balances pair of general real matrices

dgges(l)

computes for pair of N-by-N real nonsymmetric matrices

dggesx(l)

computes for pair of N-by-N real nonsymmetric matrices , generalized eigenvalues, real Schur form , and

dggev(l)

computes for pair of N-by-N real nonsymmetric matrices

dggevx(l)

computes for pair of N-by-N real nonsymmetric matrices

dggglm(l)

solves general Gauss-Markov linear model problem

dgghrd(l)

reduces pair of real matrices to generalized upper Hessenberg form using orthogonal transformations, where is general matrix and B is upper triangular

dgglse(l)

solves linear equality-constrained least squares problem

dggqrf(l)

computes generalized QR factorization of N-by-M matrix/N-by-P matrix B

dggrqf(l)

computes generalized RQ factorization of M-by-N matrix/P-by-N matrix B

dggsvd(l)

computes generalized singular value decomposition of M-by-N real matrix/P-by-N real matrix B

dggsvp(l)

computes orthogonal matrices U, V and Q such that N-K-L K L U'**Q = K if M-K-L >= 0

dgsvj0(l)

is called from DGESVJ as pre-processor/that is its main purpose

dgsvj1(l)

is called from SGESVJ as pre-processor/that is its main purpose

dgtcon(l)

estimates reciprocal of condition number of real tridiagonal matrix using LU factorization as computed by DGTTRF

dgtrfs(l)

improves computed solution to system of linear equations when coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for ...

dgtsv(l)

solves equation *X = B

dgtsvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B or **T * X = B

dgttrf(l)

computes LU factorization of real tridiagonal matrix using elimination with partial pivoting/row interchanges

dgttrs(l)

solves one of systems of equations *X = B or '*X = B

dgtts2(l)

solves one of systems of equations *X = B or '*X = B

dhgeqz(l)

computes eigenvalues of real matrix pair

dhsein(l)

uses inverse iteration to find specified right/left eigenvectors of real upper Hessenberg matrix H

dhseqr(l)

DHSEQR compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

disnan(l)

returns .TRUE

dla_gbamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

dla_gbrcond(l)

DLA_GERCOND Estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

dla_gbrfsx_extended(l)

computes

dla_gbrpvgrw(l)

computes

dla_geamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

dla_gercond(l)

DLA_GERCOND estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

dla_gerfsx_extended(l)

computes

dla_lin_berr(l)

DLA_LIN_BERR compute component-wise relative backward error from formula max ( abs(R)/( abs(op)*abs + abs ) ) where abs is component-wise absolute value of ...

dla_porcond(l)

DLA_PORCOND Estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

dla_porfsx_extended(l)

computes

dla_porpvgrw(l)

computes

dla_rpvgrw(l)

computes

dla_syamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

dla_syrcond(l)

DLA_SYRCOND estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

dla_syrfsx_extended(l)

computes

dla_syrpvgrw(l)

computes

dla_wwaddw(l)

DLA_WWADDW add vector W into doubled-single vector

dlabad(l)

takes input values computed by DLAMCH for underflow and overflow, and returns square root of each of these values if log of LARGE is sufficiently large

dlabrd(l)

reduces first NB rows and columns of real general m by n matrix to upper or lower bidiagonal form by orthogonal transformation Q' * * P, and returns matrices X ...

dlacn2(l)

estimates 1-norm of square, real matrix

dlacon(l)

estimates 1-norm of square, real matrix

dlacpy(l)

copies all/part of two-dimensional matrix to another matrix B

dladiv(l)

performs complex division in real arithmetic + i*b p + i*q = --------- c + i*d algorithm is due to Robert L

dlae2(l)

computes eigenvalues of 2-by-2 symmetric matrix [ B ] [ B C ]

dlaebz(l)

contains iteration loops which compute and use function N, which is count of eigenvalues of symmetric tridiagonal matrix T less than or equal to its argument w

dlaed0(l)

computes all eigenvalues/corresponding eigenvectors of symmetric tridiagonal matrix using divide/conquer method

dlaed1(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

dlaed2(l)

merges two sets of eigenvalues together into single sorted set

dlaed3(l)

finds roots of secular equation, as defined by values in D, W, and RHO, between 1 and K

dlaed4(l)

subroutine compute I-th updated eigenvalue of symmetric rank-one modification to diagonal matrix whose elements are given in array d, and that D < D for i ...

dlaed5(l)

subroutine compute I-th eigenvalue of symmetric rank-one modification of 2-by-2 diagonal matrix diag + RHO diagonal elements in array D are assumed to satisfy ...

dlaed6(l)

computes positive/negative root of z z z f = rho + --------- + ---------- + --------- d-x d-x d-x It is assumed that if ORGATI = .true

dlaed7(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

dlaed8(l)

merges two sets of eigenvalues together into single sorted set

dlaed9(l)

finds roots of secular equation, as defined by values in D, Z, and RHO, between KSTART and KSTOP

dlaeda(l)

computes Z vector corresponding to merge step in CURLVLth step of merge process with TLVLS steps for CURPBMth problem

dlaein(l)

uses inverse iteration to find right/left eigenvector corresponding to eigenvalue of real upper Hessenberg matrix H

dlaev2(l)

computes eigendecomposition of 2-by-2 symmetric matrix [ B ] [ B C ]

dlaexc(l)

swaps adjacent diagonal blocks T11/T22 of order 1/2 in upper quasi-triangular matrix T by orthogonal similarity transformation

dlag2(l)

computes eigenvalues of 2 x 2 generalized eigenvalue problem - w B, with scaling as necessary to avoid over-/underflow

dlag2s(l)

converts DOUBLE PRECISION matrix, SA, to SINGLE PRECISION matrix

dlags2(l)

computes 2-by-2 orthogonal matrices U, V and Q, such that if then U'**Q = U'**Q = and V'*B*Q = V'**Q = or if then U'**Q = U'**Q = and V'*B*Q = V'**Q = rows of ...

dlagtf(l)

factorizes matrix , where T is n by n tridiagonal matrix and lambda is scalar, as T - lambda*I = PLU

dlagtm(l)

performs matrix-vector product of form B := alpha * * X + beta * B where is tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta ...

dlagts(l)

may be used to solve one of systems of equations *x = y or '*x = y

dlagv2(l)

computes Generalized Schur factorization of real 2-by-2 matrix pencil where B is upper triangular

dlahqr(l)

DLAHQR i auxiliary routine called by DHSEQR to update eigenvalues and Schur decomposition already computed by DHSEQR, by dealing with Hessenberg submatrix in ...

dlahr2(l)

reduces first NB columns of real general n-BY- matrix so that elements below k-th subdiagonal are zero

dlahrd(l)

reduces first NB columns of real general n-by- matrix so that elements below k-th subdiagonal are zero

dlaic1(l)

applies one step of incremental condition estimation in its simplest version

dlaisnan(l)

routine i not for general use

dlaln2(l)

solves system of form X = s B/X = s B with possible scaling/perturbation of

dlals0(l)

applies back multiplying factors of either left/right singular vector matrix of diagonal matrix appended by row to right hand side matrix B in solving least ...

dlalsa(l)

is itermediate step in solving least squares problem by computing SVD of coefficient matrix in compact form

dlalsd(l)

uses singular value decomposition of to solve least squares problem of finding X to minimize Euclidean norm of each column of *X-B, where is N-by-N upper ...

dlamch(l)

double precision machine parameters

dlamchtst(l)

dlamrg(l)

will create permutation list which will merge elements of into single set which is sorted in ascending order

dlaneg(l)

computes Sturm count, number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T

dlangb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n band matrix , with kl sub-diagonals and ku ...

dlange(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real matrix

dlangt(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real tridiagonal matrix

dlanhs(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of Hessenberg matrix

dlansb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n symmetric band matrix , with k super-diagonals

dlansf(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix in RFP format

dlansp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix , supplied in packed form

dlanst(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric tridiagonal matrix

dlansy(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix

dlantb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n triangular band matrix , with diagonals

dlantp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of triangular matrix , supplied in packed form

dlantr(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of trapezoidal or triangular matrix

dlanv2(l)

computes Schur factorization of real 2-by-2 nonsymmetric matrix in standard form

dlapll(l)

two column vectors X and Y, let =

dlapmt(l)

rearranges columns of M by N matrix X as specified by permutation K,K,...,K of integers 1,...,N

dlapy2(l)

returns sqrt, taking care not to cause unnecessary overflow

dlapy3(l)

returns sqrt, taking care not to cause unnecessary overflow

dlaqgb(l)

equilibrates general M by N band matrix with KL subdiagonals/KU superdiagonals using row/scaling factors in vectors R/C

dlaqge(l)

equilibrates general M by N matrix using row/column scaling factors in vectors R/C

dlaqp2(l)

computes QR factorization with column pivoting of block

dlaqps(l)

computes step of QR factorization with column pivoting of real M-by-N matrix by using Blas-3

dlaqr0(l)

DLAQR0 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

dlaqr1(l)

dlaqr2(l)

dlaqr3(l)

dlaqr4(l)

DLAQR4 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

dlaqr5(l)

dlaqsb(l)

equilibrates symmetric band matrix using scaling factors in vector S

dlaqsp(l)

equilibrates symmetric matrix using scaling factors in vector S

dlaqsy(l)

equilibrates symmetric matrix using scaling factors in vector S

dlaqtr(l)

solves real quasi-triangular system op*p = scale*c, if LREAL = .TRUE

dlar1v(l)

computes r-th column of inverse of sumbmatrix in rows B1 through BN of tridiagonal matrix L D L^T - sigma I

dlar2v(l)

applies vector of real plane rotations from both sides to sequence of 2-by-2 real symmetric matrices, defined by elements of vectors x, y and z

dlarf(l)

applies real elementary reflector H to real m by n matrix C, from either left or right

dlarfb(l)

applies real block reflector H or its transpose H' to real m by n matrix C, from either left or right

dlarfg(l)

generates real elementary reflector H of order n, such that H * = , H' * H = I

dlarfp(l)

generates real elementary reflector H of order n, such that H * = , H' * H = I

dlarft(l)

forms triangular factor T of real block reflector H of order n, which is defined as product of k elementary reflectors

dlarfx(l)

applies real elementary reflector H to real m by n matrix C, from either left or right

dlargv(l)

generates vector of real plane rotations, determined by elements of real vectors x and y

dlarnv(l)

returns vector of n random real numbers from uniform/normal distribution

dlarra(l)

splitting points with threshold SPLTOL

dlarrb(l)

relatively robust representation L D L^T, DLARRB does limited bisection to refine eigenvalues of L D L^T

dlarrc(l)

number of eigenvalues of symmetric tridiagonal matrix T in interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'

dlarrd(l)

computes eigenvalues of symmetric tridiagonal matrix T to suitable accuracy

dlarre(l)

find desired eigenvalues of given real symmetric tridiagonal matrix T, DLARRE sets any small off-diagonal elements to zero, and for each unreduced block T_i ...

dlarrf(l)

initial representation L D L^T and its cluster of close eigenvalues , W, W,

dlarrj(l)

initial eigenvalue approximations of T, DLARRJ does bisection to refine eigenvalues of T

dlarrk(l)

computes one eigenvalue of symmetric tridiagonal matrix T to suitable accuracy

dlarrr(l)

tests to decide whether symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in eigenvalues

dlarrv(l)

computes eigenvectors of tridiagonal matrix T = L D L^T given L, D and APPROXIMATIONS to eigenvalues of L D L^T

dlarscl2(l)

performs reciprocal diagonal scaling on vector

dlartg(l)

make plane rotation so that [ CS SN ]

dlartv(l)

applies vector of real plane rotations to elements of real vectors x/y

dlaruv(l)

returns vector of n random real numbers from uniform

dlarz(l)

applies real elementary reflector H to real M-by-N matrix C, from either left or right

dlarzb(l)

applies real block reflector H/its transpose H**T to real distributed M-by-N C from left/right

dlarzt(l)

forms triangular factor T of real block reflector H of order > n, which is defined as product of k elementary reflectors

dlas2(l)

computes singular values of 2-by-2 matrix [ F G ] [ 0 H ]

dlascl(l)

multiplies M by N real matrix by real scalar CTO/CFROM

dlascl2(l)

performs diagonal scaling on vector

dlasd0(l)

divide and conquer approach, DLASD0 computes singular value decomposition of real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = ...

dlasd1(l)

computes SVD of upper bidiagonal N-by-M matrix B

dlasd2(l)

merges two sets of singular values together into single sorted set

dlasd3(l)

finds all square roots of roots of secular equation, as defined by values in D and Z

dlasd4(l)

subroutine compute square root of I-th updated eigenvalue of positive symmetric rank-one modification to positive diagonal matrix whose entries are given as ...

dlasd5(l)

subroutine compute square root of I-th eigenvalue of positive symmetric rank-one modification of 2-by-2 diagonal matrix diag * diag + RHO diagonal entries in ...

dlasd6(l)

computes SVD of updated upper bidiagonal matrix B obtained by merging two smaller ones by appending row

dlasd7(l)

merges two sets of singular values together into single sorted set

dlasd8(l)

finds square roots of roots of secular equation

dlasd9(l)

find square roots of roots of secular equation

dlasda(l)

divide and conquer approach, DLASDA computes singular value decomposition of real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = ...

dlasdq(l)

computes singular value decomposition of real bidiagonal matrix with diagonal D and offdiagonal E, accumulating transformations if desired

dlasdt(l)

creates tree of subproblems for bidiagonal divide/conquer

dlaset(l)

initializes m-by-n matrix to BETA on diagonal/ALPHA on offdiagonals

dlasq1(l)

computes singular values of real N-by-N bidiagonal matrix with diagonal D/off-diagonal E

dlasq2(l)

computes all eigenvalues of symmetric positive definite tridiagonal matrix associated with qd array Z to high relative accuracy are computed to high relative ...

dlasq3(l)

checks for deflation, computes shift and calls dqds

dlasq4(l)

computes approximation TAU to smallest eigenvalue using values of d from previous transform

dlasq5(l)

computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines

dlasq6(l)

computes one dqd transform in ping-pong form, with protection against underflow and overflow

dlasr(l)

applies sequence of plane rotations to real matrix

dlasrt(l)

number in D in increasing order/in decreasing order

dlassq(l)

returns values scl and smsq such that *smsq = x**2 +...+ x**2 + *sumsq

dlasv2(l)

computes singular value decomposition of 2-by-2 triangular matrix [ F G ] [ 0 H ]

dlaswp(l)

performs series of row interchanges on matrix

dlasy2(l)

solves for N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op*X + ISGN*X*op = SCALE*B

dlasyf(l)

computes partial factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

dlat2s(l)

converts DOUBLE PRECISION triangular matrix, SA, to SINGLE PRECISION triangular matrix

dlatbs(l)

solves one of triangular systems *x = s*b or '*x = s*b with scaling to prevent overflow, where is upper or lower triangular band matrix

dlatdf(l)

uses LU factorization of n-by-n matrix Z computed by DGETC2 and computes contribution to reciprocal Dif-estimate by solving Z * x = b for x, and choosing r.h.s

dlatps(l)

solves one of triangular systems *x = s*b or '*x = s*b with scaling to prevent overflow, where is upper or lower triangular matrix stored in packed form

dlatrd(l)

reduces NB rows and columns of real symmetric matrix to symmetric tridiagonal form by orthogonal similarity transformation Q' * * Q, and returns matrices V and ...

dlatrs(l)

solves one of triangular systems *x = s*b/'*x = s*b with scaling to prevent overflow

dlatrz(l)

factors M-by- real upper trapezoidal matrix [ A1 A2 ] = [ ] as * Z, by means of orthogonal transformations

dlatzm(l)

routine i deprecated/has been replaced by routine DORMRZ

dlauu2(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

dlauum(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

dlazq3(l)

for deflation, computes shift and calls dqds

dlazq4(l)

approximation TAU to smallest eigenvalue using values of d from previous transform

dnrm2(l)

This version written on 25-October-1982

dopgtr(l)

generates real orthogonal matrix Q which is defined as product of n-1 elementary reflectors H of order n, as returned by DSPTRD using packed storage

dopmtr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dorg2l(l)

generates m by n real matrix Q with orthonormal columns

dorg2r(l)

generates m by n real matrix Q with orthonormal columns

dorgbr(l)

generates one of real orthogonal matrices Q/P**T determined by DGEBRD when reducing real matrix to bidiagonal form

dorghr(l)

generates real orthogonal matrix Q which is defined as product of IHI-ILO elementary reflectors of order N, as returned by DGEHRD

dorgl2(l)

generates m by n real matrix Q with orthonormal rows

dorglq(l)

generates M-by-N real matrix Q with orthonormal rows

dorgql(l)

generates M-by-N real matrix Q with orthonormal columns

dorgqr(l)

generates M-by-N real matrix Q with orthonormal columns

dorgr2(l)

generates m by n real matrix Q with orthonormal rows

dorgrq(l)

generates M-by-N real matrix Q with orthonormal rows

dorgtr(l)

generates real orthogonal matrix Q which is defined as product of n-1 elementary reflectors of order N, as returned by DSYTRD

dorm2l(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

dorm2r(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

dormbr(l)

VECT = 'Q', DORMBR overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormhr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dorml2(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

dormlq(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormql(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormqr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormr2(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

dormr3(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

dormrq(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormrz(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dormtr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

dpbcon(l)

estimates reciprocal of condition number of real symmetric positive definite band matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPBTRF

dpbequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite band matrix/reduce its condition number

dpbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and banded, and provides error bounds and ...

dpbstf(l)

computes split Cholesky factorization of real symmetric positive definite band matrix

dpbsv(l)

computes solution to real system of linear equations * X = B

dpbsvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

dpbtf2(l)

computes Cholesky factorization of real symmetric positive definite band matrix

dpbtrf(l)

computes Cholesky factorization of real symmetric positive definite band matrix

dpbtrs(l)

solves system of linear equations *X = B with symmetric positive definite band matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPBTRF

dpftrf(l)

computes Cholesky factorization of real symmetric positive definite matrix

dpftri(l)

computes inverse of symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPFTRF

dpftrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPFTRF

dpocon(l)

estimates reciprocal of condition number of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPOTRF

dpoequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

dpoequb(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

dporfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite

dporfsx(l)

DPORFSX improve computed solution to system of linear equations when coefficient matrix is symmetric positive definite, and provides error bounds and backward ...

dposv(l)

computes solution to real system of linear equations * X = B

dposvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

dposvxx(l)

DPOSVXX use Cholesky factorization = U**T*U or = L*L**T to compute solution to double precision system of linear equations * X = B, where is N-by-N symmetric ...

dpotf2(l)

computes Cholesky factorization of real symmetric positive definite matrix

dpotrf(l)

computes Cholesky factorization of real symmetric positive definite matrix

dpotri(l)

computes inverse of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPOTRF

dpotrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPOTRF

dppcon(l)

estimates reciprocal of condition number of real symmetric positive definite packed matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPPTRF

dppequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix in packed storage/reduce its condition number

dpprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and packed, and provides error bounds and ...

dppsv(l)

computes solution to real system of linear equations * X = B

dppsvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

dpptrf(l)

computes Cholesky factorization of real symmetric positive definite matrix stored in packed format

dpptri(l)

computes inverse of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by DPPTRF

dpptrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix in packed storage using Cholesky factorization = U**T*U/= L*L**T computed by ...

dpstf2(l)

computes Cholesky factorization with complete pivoting of real symmetric positive semidefinite matrix

dpstrf(l)

computes Cholesky factorization with complete pivoting of real symmetric positive semidefinite matrix

dptcon(l)

computes reciprocal of condition number of real symmetric positive definite tridiagonal matrix using factorization = L*D*L**T/= U**T*D*U computed by DPTTRF

dpteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric positive definite tridiagonal matrix by first factoring matrix using DPTTRF, and then calling DBDSQR ...

dptrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and ...

dptsv(l)

computes solution to real system of linear equations *X = B, where is N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices

dptsvx(l)

uses factorization = L*D*L**T to compute solution to real system of linear equations *X = B, where is N-by-N symmetric positive definite tridiagonal matrix and ...

dpttrf(l)

computes L*D*L' factorization of real symmetric positive definite tridiagonal matrix

dpttrs(l)

solves tridiagonal system of form * X = B using L*D*L' factorization of computed by DPTTRF

dptts2(l)

solves tridiagonal system of form * X = B using L*D*L' factorization of computed by DPTTRF

drot(l)

DROT applie plane rotation

drotg(l)

DROTG construct givens plane rotation

drotm(l)

APPLY MODIFIED GIVENS TRANSFORMATION, H, TO 2 BY N MATRIX , WHERE **T INDICATES TRANSPOSE

drotmg(l)

CONSTRUCT MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS SECOND COMPONENT OF 2-VECTOR (DSQRT*DX1,DSQRT*

drscl(l)

multiplies n-element real vector x by real scalar 1/

dsbev(l)

computes all eigenvalues and, , eigenvectors of real symmetric band matrix

dsbevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric band matrix

dsbevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric band matrix

dsbgst(l)

reduces real symmetric-definite banded generalized eigenproblem *x = lambda*B*x to standard form C*y = lambda*y

dsbgv(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

dsbgvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

dsbgvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

dsbmv(l)

performs matrix-vector operation y := alpha**x + beta*y

dsbtrd(l)

reduces real symmetric band matrix to symmetric tridiagonal form T by orthogonal similarity transformation

dscal(l)

DSCAL scale vector by constant

dsdot(l)

accumulation/result

dsecnd(l)

user time for process in seconds

dsecnd_ext_etime(l)

user time for process in seconds

dsecnd_ext_etime_(l)

user time for process in seconds

dsecnd_int_cpu_time(l)

user time for process in seconds

dsecnd_int_etime(l)

user time for process in seconds

dsecnd_none(l)

nothing instead of returning user time for process in seconds

dsecndtst(l)

dsfrk(l)

3 BLAS like routine for C in RFP Format

dsgesv(l)

computes solution to real system of linear equations * X = B

dspcon(l)

estimates reciprocal of condition number of real symmetric packed matrix using factorization = U*D*U**T/= L*D*L**T computed by DSPTRF

dspev(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

dspevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

dspevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

dspgst(l)

reduces real symmetric-definite generalized eigenproblem to standard form, using packed storage

dspgv(l)

computes all eigenvalues and, , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dspgvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dspgvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dspmv(l)

performs matrix-vector operation y := alpha**x + beta*y

dsposv(l)

computes solution to real system of linear equations * X = B

dspr(l)

performs symmetric rank 1 operation := alpha*x*x' +

dspr2(l)

performs symmetric rank 2 operation := alpha*x*y' + alpha*y*x' +

dsprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward ...

dspsv(l)

computes solution to real system of linear equations * X = B

dspsvx(l)

uses diagonal pivoting factorization = U*D*U**T or = L*D*L**T to compute solution to real system of linear equations * X = B, where is N-by-N symmetric matrix ...

dsptrd(l)

reduces real symmetric matrix stored in packed form to symmetric tridiagonal form T by orthogonal similarity transformation

dsptrf(l)

computes factorization of real symmetric matrix stored in packed format using Bunch-Kaufman diagonal pivoting method

dsptri(l)

computes inverse of real symmetric indefinite matrix in packed storage using factorization = U*D*U**T/= L*D*L**T computed by DSPTRF

dsptrs(l)

solves system of linear equations *X = B with real symmetric matrix stored in packed format using factorization = U*D*U**T/= L*D*L**T computed by DSPTRF

dstebz(l)

computes eigenvalues of symmetric tridiagonal matrix T

dstedc(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using divide and conquer method

dstegr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

dstein(l)

computes eigenvectors of real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration

dstemr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

dsteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using implicit QL or QR method

dsterf(l)

computes all eigenvalues of symmetric tridiagonal matrix using Pal-Walker-Kahan variant of QL/QR algorithm

dstev(l)

computes all eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

dstevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

dstevr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

dstevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

dswap(l)

interchanges two vectors

dsycon(l)

estimates reciprocal of condition number of real symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by DSYTRF

dsyequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

dsyev(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix

dsyevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix

dsyevr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix

dsyevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix

dsygs2(l)

reduces real symmetric-definite generalized eigenproblem to standard form

dsygst(l)

reduces real symmetric-definite generalized eigenproblem to standard form

dsygv(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dsygvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dsygvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

dsymm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

dsymv(l)

performs matrix-vector operation y := alpha**x + beta*y

dsyr(l)

performs symmetric rank 1 operation := alpha*x*x' +

dsyr2(l)

performs symmetric rank 2 operation := alpha*x*y' + alpha*y*x' +

dsyr2k(l)

performs one of symmetric rank 2k operations C := alpha**B' + alpha*B*' + beta*C

dsyrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

dsyrfsx(l)

DSYRFSX improve computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

dsyrk(l)

performs one of symmetric rank k operations C := alpha**' + beta*C

dsysv(l)

computes solution to real system of linear equations * X = B

dsysvx(l)

uses diagonal pivoting factorization to compute solution to real system of linear equations * X = B

dsysvxx(l)

DSYSVXX use diagonal pivoting factorization to compute solution to double precision system of linear equations * X = B, where is N-by-N symmetric matrix and X ...

dsytd2(l)

reduces real symmetric matrix to symmetric tridiagonal form T by orthogonal similarity transformation

dsytf2(l)

computes factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

dsytrd(l)

reduces real symmetric matrix to real symmetric tridiagonal form T by orthogonal similarity transformation

dsytrf(l)

computes factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

dsytri(l)

computes inverse of real symmetric indefinite matrix using factorization = U*D*U**T/= L*D*L**T computed by DSYTRF

dsytrs(l)

solves system of linear equations *X = B with real symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by DSYTRF

dtbcon(l)

estimates reciprocal of condition number of triangular band matrix , in either 1-norm or infinity-norm

dtbmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

dtbrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular band coefficient matrix

dtbsv(l)

solves one of systems of equations *x = b, or '*x = b

dtbtrs(l)

solves triangular system of form * X = B or **T * X = B

dtfsm(l)

3 BLAS like routine for in RFP Format

dtftri(l)

computes inverse of triangular matrix stored in RFP format

dtfttp(l)

copies triangular matrix from rectangular full packed format to standard packed format

dtfttr(l)

copies triangular matrix from rectangular full packed format to standard full format

dtgevc(l)

computes some or all of right/left eigenvectors of pair of real matrices , where S is quasi-triangular matrix and P is upper triangular

dtgex2(l)

swaps adjacent diagonal blocks/of size 1-by-1/2-by-2 in upper triangular matrix pair by orthogonal equivalence transformation

dtgexc(l)

reorders generalized real Schur decomposition of real matrix pair using orthogonal equivalence transformation = Q * * Z'

dtgsen(l)

reorders generalized real Schur decomposition of real matrix pair (in terms of orthonormal equivalence trans- formation Q' * * Z), so that selected cluster of ...

dtgsja(l)

computes generalized singular value decomposition of two real upper triangular matrices/B

dtgsna(l)

estimates reciprocal condition numbers for specified eigenvalues/eigenvectors of matrix pair in generalized real Schur canonical form (or of any matrix pair ...

dtgsy2(l)

solves generalized Sylvester equation

dtgsyl(l)

solves generalized Sylvester equation

dtpcon(l)

estimates reciprocal of condition number of packed triangular matrix , in either 1-norm or infinity-norm

dtpmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

dtprfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular packed coefficient matrix

dtpsv(l)

solves one of systems of equations *x = b, or '*x = b

dtptri(l)

computes inverse of real upper/lower triangular matrix stored in packed format

dtptrs(l)

solves triangular system of form * X = B or **T * X = B

dtpttf(l)

copies triangular matrix from standard packed format to rectangular full packed format

dtpttr(l)

copies triangular matrix from standard packed format to standard full format

dtrcon(l)

estimates reciprocal of condition number of triangular matrix , in either 1-norm or infinity-norm

dtrevc(l)

computes some/all of right/left eigenvectors of real upper quasi-triangular matrix T

dtrexc(l)

reorders real Schur factorization of real matrix = Q*T*Q**T, so that diagonal block of T with row index IFST is moved to row ILST

dtrmm(l)

performs one of matrix-matrix operations B := alpha*op*B, or B := alpha*B*op

dtrmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

dtrrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular coefficient matrix

dtrsen(l)

reorders real Schur factorization of real matrix = Q*T*Q**T, so that selected cluster of eigenvalues appears in leading diagonal blocks of upper ...

dtrsm(l)

solves one of matrix equations op*X = alpha*B, or X*op = alpha*B

dtrsna(l)

estimates reciprocal condition numbers for specified eigenvalues/right eigenvectors of real upper quasi-triangular matrix T

dtrsv(l)

solves one of systems of equations *x = b, or '*x = b

dtrsyl(l)

solves real Sylvester matrix equation

dtrti2(l)

computes inverse of real upper/lower triangular matrix

dtrtri(l)

computes inverse of real upper/lower triangular matrix

dtrtrs(l)

solves triangular system of form * X = B or **T * X = B

dtrttf(l)

copies triangular matrix from standard full format to rectangular full packed format

dtrttp(l)

copies triangular matrix from full format to standard packed format

dtzrqf(l)

routine i deprecated/has been replaced by routine DTZRZF

dtzrzf(l)

reduces M-by-N real upper trapezoidal matrix to upper triangular form by means of orthogonal transformations

dx(l)

start Data Explorer visualization system. directly start User Interface , executive , Data Prompter, Module Builder or Tutorial

dzasum(l)

DZASUM take sum of absolute values

dznrm2(l)

This version written on 25-October-1982

dzsum1(l)

takes sum of absolute values of complex vector/returns double precision result

icamax(l)

ICAMAX find index of element having max

icmax1(l)

finds index of element whose real part has maximum absolute value

idamax(l)

IDAMAX find index of element having max

ieeeck(l)

is called from ILAENV to verify that Infinity/possibly NaN arithmetic is safe (i.e

ilaclc(l)

scans for its last non-zero column

ilaclr(l)

scans for its last non-zero row

iladiag(l)

subroutine translated from char string specifying if matrix has unit diagonal/not to relevant BLAST-specified integer constant

iladlc(l)

scans for its last non-zero column

iladlr(l)

scans for its last non-zero row

ilaenv(l)

is called from LAPACK routines to choose problem-dependent parameters for local environment

ilaprec(l)

subroutine translated from char string specifying intermediate precision to relevant BLAST-specified integer constant

ilaslc(l)

scans for its last non-zero column

ilaslr(l)

scans for its last non-zero row

ilatrans(l)

subroutine translate from char string specifying transposition operation to relevant BLAST-specified integer constant

ilauplo(l)

subroutine translated from char string specifying upper-/lower-triangular matrix to relevant BLAST-specified integer constant

ilaver(l)

subroutine return Lapack version Arguments ========= VERS_MAJOR INTEGER return lapack major version VERS_MINOR INTEGER return lapack minor version from major ...

ilazlc(l)

scans for its last non-zero column

ilazlr(l)

scans for its last non-zero row

iparmq(l)

This program sets problem/machine dependent parameters useful for xHSEQR/its subroutines

isamax(l)

ISAMAX find index of element having max

izamax(l)

IZAMAX find index of element having max

izmax1(l)

finds index of element whose real part has maximum absolute value

lapack(l)

lapack_version(l)

lsame(l)

returns .TRUE

lsamen(l)

tests if first N letters of CA are same as first N letters of CB, regardless of case

lsametst(l)

sasum(l)

SASUM take sum of absolute values

saxpy(l)

SAXPY constant times vector plus vector

sbdsdc(l)

computes singular value decomposition of real N-by-N bidiagonal matrix B

sbdsqr(l)

computes singular values and, , right/left singular vectors from singular value decomposition of real N-by-N bidiagonal matrix B using implicit zero-shift QR ...

scabs1(l)

computes absolute value of complex number =====================================================================

scasum(l)

SCASUM take sum of absolute values of complex vector/returns single precision result

scnrm2(l)

This version written on 25-October-1982

scopy(l)

SCOPY copie vector, x, to vector, y

scsum1(l)

takes sum of absolute values of complex vector/returns single precision result

sdisna(l)

computes reciprocal condition numbers for eigenvectors of real symmetric/complex Hermitian matrix/for left/right singular vectors of general m-by-n matrix

sdot(l)

SDOT form dot product of two vectors

sdsdot(l)

second(l)

user time for process in seconds

second_ext_etime(l)

user time for process in seconds

second_ext_etime_(l)

user time for process in seconds

second_int_cpu_time(l)

user time for process in seconds

second_int_etime(l)

user time for process in seconds

second_none(l)

nothing instead of returning user time for process in seconds

secondtst(l)

sgbbrd(l)

reduces real general m-by-n band matrix to upper bidiagonal form B by orthogonal transformation

sgbcon(l)

estimates reciprocal of condition number of real general band matrix , in either 1-norm or infinity-norm

sgbequ(l)

computes row/column scalings intended to equilibrate M-by-N band matrix/reduce its condition number

sgbequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

sgbmv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y

sgbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is banded, and provides error bounds and backward error estimates for solution

sgbrfsx(l)

SGBRFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

sgbsv(l)

computes solution to real system of linear equations * X = B, where is band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are ...

sgbsvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B, **T * X = B, or **H * X = B

sgbsvxx(l)

SGBSVXX use LU factorization to compute solution to real system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

sgbtf2(l)

computes LU factorization of real m-by-n band matrix using partial pivoting with row interchanges

sgbtrf(l)

computes LU factorization of real m-by-n band matrix using partial pivoting with row interchanges

sgbtrs(l)

solves system of linear equations * X = B/' * X = B with general band matrix using LU factorization computed by SGBTRF

sgebak(l)

forms right/left eigenvectors of real general matrix by backward transformation on computed eigenvectors of balanced matrix output by SGEBAL

sgebal(l)

balances general real matrix

sgebd2(l)

reduces real general m by n matrix to upper/lower bidiagonal form B by orthogonal transformation

sgebrd(l)

reduces general real M-by-N matrix to upper/lower bidiagonal form B by orthogonal transformation

sgecon(l)

estimates reciprocal of condition number of general real matrix , in either 1-norm or infinity-norm, using LU factorization computed by SGETRF

sgeequ(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

sgeequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

sgees(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues, real Schur form T, and, , matrix of Schur vectors Z

sgeesx(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues, real Schur form T, and, , matrix of Schur vectors Z

sgeev(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

sgeevx(l)

computes for N-by-N real nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

sgegs(l)

routine i deprecated/has been replaced by routine SGGES

sgegv(l)

routine i deprecated/has been replaced by routine SGGEV

sgehd2(l)

reduces real general matrix to upper Hessenberg form H by orthogonal similarity transformation

sgehrd(l)

reduces real general matrix to upper Hessenberg form H by orthogonal similarity transformation

sgejsv(l)

[], where M >= N

sgelq2(l)

computes LQ factorization of real m by n matrix

sgelqf(l)

computes LQ factorization of real M-by-N matrix

sgels(l)

solves overdetermined or underdetermined real linear systems involving M-by-N matrix , or its transpose, using QR or LQ factorization of

sgelsd(l)

computes minimum-norm solution to real linear least squares problem

sgelss(l)

computes minimum norm solution to real linear least squares problem

sgelsx(l)

routine i deprecated/has been replaced by routine SGELSY

sgelsy(l)

computes minimum-norm solution to real linear least squares problem

sgemm(l)

performs one of matrix-matrix operations C := alpha*op*op + beta*C

sgemv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y

sgeql2(l)

computes QL factorization of real m by n matrix

sgeqlf(l)

computes QL factorization of real M-by-N matrix

sgeqp3(l)

computes QR factorization with column pivoting of matrix

sgeqpf(l)

routine i deprecated/has been replaced by routine SGEQP3

sgeqr2(l)

computes QR factorization of real m by n matrix

sgeqrf(l)

computes QR factorization of real M-by-N matrix

sger(l)

performs rank 1 operation := alpha*x*y' +

sgerfs(l)

improves computed solution to system of linear equations/provides error bounds/backward error estimates for solution

sgerfsx(l)

SGERFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

sgerq2(l)

computes RQ factorization of real m by n matrix

sgerqf(l)

computes RQ factorization of real M-by-N matrix

sgesc2(l)

solves system of linear equations * X = scale* RHS with general N-by-N matrix using LU factorization with complete pivoting computed by SGETC2

sgesdd(l)

computes singular value decomposition of real M-by-N matrix , computing left and right singular vectors

sgesv(l)

computes solution to real system of linear equations * X = B

sgesvd(l)

computes singular value decomposition of real M-by-N matrix , computing left/right singular vectors

sgesvj(l)

computes singular value decomposition of real M-by-N matrix , where M >= N

sgesvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B

sgesvxx(l)

SGESVXX use LU factorization to compute solution to real system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

sgetc2(l)

computes LU factorization with complete pivoting of n-by-n matrix

sgetf2(l)

computes LU factorization of general m-by-n matrix using partial pivoting with row interchanges

sgetrf(l)

computes LU factorization of general M-by-N matrix using partial pivoting with row interchanges

sgetri(l)

computes inverse of matrix using LU factorization computed by SGETRF

sgetrs(l)

solves system of linear equations * X = B/' * X = B with general N-by-N matrix using LU factorization computed by SGETRF

sggbak(l)

forms right or left eigenvectors of real generalized eigenvalue problem *x = lambda*B*x, by backward transformation on computed eigenvectors of balanced pair ...

sggbal(l)

balances pair of general real matrices

sgges(l)

computes for pair of N-by-N real nonsymmetric matrices

sggesx(l)

computes for pair of N-by-N real nonsymmetric matrices , generalized eigenvalues, real Schur form , and

sggev(l)

computes for pair of N-by-N real nonsymmetric matrices

sggevx(l)

computes for pair of N-by-N real nonsymmetric matrices

sggglm(l)

solves general Gauss-Markov linear model problem

sgghrd(l)

reduces pair of real matrices to generalized upper Hessenberg form using orthogonal transformations, where is general matrix and B is upper triangular

sgglse(l)

solves linear equality-constrained least squares problem

sggqrf(l)

computes generalized QR factorization of N-by-M matrix/N-by-P matrix B

sggrqf(l)

computes generalized RQ factorization of M-by-N matrix/P-by-N matrix B

sggsvd(l)

computes generalized singular value decomposition of M-by-N real matrix/P-by-N real matrix B

sggsvp(l)

computes orthogonal matrices U, V and Q such that N-K-L K L U'**Q = K if M-K-L >= 0

sgsvj0(l)

is called from SGESVJ as pre-processor/that is its main purpose

sgsvj1(l)

is called from SGESVJ as pre-processor/that is its main purpose

sgtcon(l)

estimates reciprocal of condition number of real tridiagonal matrix using LU factorization as computed by SGTTRF

sgtrfs(l)

improves computed solution to system of linear equations when coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for ...

sgtsv(l)

solves equation *X = B

sgtsvx(l)

uses LU factorization to compute solution to real system of linear equations * X = B or **T * X = B

sgttrf(l)

computes LU factorization of real tridiagonal matrix using elimination with partial pivoting/row interchanges

sgttrs(l)

solves one of systems of equations *X = B or '*X = B

sgtts2(l)

solves one of systems of equations *X = B or '*X = B

shgeqz(l)

computes eigenvalues of real matrix pair

shsein(l)

uses inverse iteration to find specified right/left eigenvectors of real upper Hessenberg matrix H

shseqr(l)

SHSEQR compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

sisnan(l)

returns .TRUE

sla_gbamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

sla_gbrcond(l)

SLA_GERCOND Estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

sla_gbrfsx_extended(l)

computes

sla_gbrpvgrw(l)

computes

sla_geamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

sla_gercond(l)

SLA_GERCOND estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

sla_gerfsx_extended(l)

computes

sla_lin_berr(l)

SLA_LIN_BERR compute component-wise relative backward error from formula max ( abs(R)/( abs(op)*abs + abs ) ) where abs is component-wise absolute value of ...

sla_porcond(l)

SLA_PORCOND Estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

sla_porfsx_extended(l)

computes

sla_porpvgrw(l)

computes

sla_rpvgrw(l)

computes

sla_syamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

sla_syrcond(l)

SLA_SYRCOND estimate Skeel condition number of op * op2 where op2 is determined by CMODE as follows CMODE = 1 op2 = C CMODE = 0 op2 = I CMODE = -1 op2 = inv ...

sla_syrfsx_extended(l)

computes

sla_syrpvgrw(l)

computes

sla_wwaddw(l)

SLA_WWADDW add vector W into doubled-single vector

slabad(l)

takes input values computed by SLAMCH for underflow and overflow, and returns square root of each of these values if log of LARGE is sufficiently large

slabrd(l)

reduces first NB rows and columns of real general m by n matrix to upper or lower bidiagonal form by orthogonal transformation Q' * * P, and returns matrices X ...

slacn2(l)

estimates 1-norm of square, real matrix

slacon(l)

estimates 1-norm of square, real matrix

slacpy(l)

copies all/part of two-dimensional matrix to another matrix B

sladiv(l)

performs complex division in real arithmetic + i*b p + i*q = --------- c + i*d algorithm is due to Robert L

slae2(l)

computes eigenvalues of 2-by-2 symmetric matrix [ B ] [ B C ]

slaebz(l)

contains iteration loops which compute and use function N, which is count of eigenvalues of symmetric tridiagonal matrix T less than or equal to its argument w

slaed0(l)

computes all eigenvalues/corresponding eigenvectors of symmetric tridiagonal matrix using divide/conquer method

slaed1(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

slaed2(l)

merges two sets of eigenvalues together into single sorted set

slaed3(l)

finds roots of secular equation, as defined by values in D, W, and RHO, between 1 and K

slaed4(l)

subroutine compute I-th updated eigenvalue of symmetric rank-one modification to diagonal matrix whose elements are given in array d, and that D < D for i ...

slaed5(l)

subroutine compute I-th eigenvalue of symmetric rank-one modification of 2-by-2 diagonal matrix diag + RHO diagonal elements in array D are assumed to satisfy ...

slaed6(l)

computes positive/negative root of z z z f = rho + --------- + ---------- + --------- d-x d-x d-x It is assumed that if ORGATI = .true

slaed7(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

slaed8(l)

merges two sets of eigenvalues together into single sorted set

slaed9(l)

finds roots of secular equation, as defined by values in D, Z, and RHO, between KSTART and KSTOP

slaeda(l)

computes Z vector corresponding to merge step in CURLVLth step of merge process with TLVLS steps for CURPBMth problem

slaein(l)

uses inverse iteration to find right/left eigenvector corresponding to eigenvalue of real upper Hessenberg matrix H

slaev2(l)

computes eigendecomposition of 2-by-2 symmetric matrix [ B ] [ B C ]

slaexc(l)

swaps adjacent diagonal blocks T11/T22 of order 1/2 in upper quasi-triangular matrix T by orthogonal similarity transformation

slag2(l)

computes eigenvalues of 2 x 2 generalized eigenvalue problem - w B, with scaling as necessary to avoid over-/underflow

slag2d(l)

converts SINGLE PRECISION matrix, SA, to DOUBLE PRECISION matrix

slags2(l)

computes 2-by-2 orthogonal matrices U, V and Q, such that if then U'**Q = U'**Q = and V'*B*Q = V'**Q = or if then U'**Q = U'**Q = and V'*B*Q = V'**Q = rows of ...

slagtf(l)

factorizes matrix , where T is n by n tridiagonal matrix and lambda is scalar, as T - lambda*I = PLU

slagtm(l)

performs matrix-vector product of form B := alpha * * X + beta * B where is tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta ...

slagts(l)

may be used to solve one of systems of equations *x = y or '*x = y

slagv2(l)

computes Generalized Schur factorization of real 2-by-2 matrix pencil where B is upper triangular

slahqr(l)

SLAHQR i auxiliary routine called by SHSEQR to update eigenvalues and Schur decomposition already computed by SHSEQR, by dealing with Hessenberg submatrix in ...

slahr2(l)

reduces first NB columns of real general n-BY- matrix so that elements below k-th subdiagonal are zero

slahrd(l)

reduces first NB columns of real general n-by- matrix so that elements below k-th subdiagonal are zero

slaic1(l)

applies one step of incremental condition estimation in its simplest version

slaisnan(l)

routine i not for general use

slaln2(l)

solves system of form X = s B/X = s B with possible scaling/perturbation of

slals0(l)

applies back multiplying factors of either left/right singular vector matrix of diagonal matrix appended by row to right hand side matrix B in solving least ...

slalsa(l)

is itermediate step in solving least squares problem by computing SVD of coefficient matrix in compact form

slalsd(l)

uses singular value decomposition of to solve least squares problem of finding X to minimize Euclidean norm of each column of *X-B, where is N-by-N upper ...

slamch(l)

single precision machine parameters

slamchtst(l)

slamrg(l)

will create permutation list which will merge elements of into single set which is sorted in ascending order

slaneg(l)

computes Sturm count, number of negative pivots encountered while factoring tridiagonal T - sigma I = L D L^T

slangb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n band matrix , with kl sub-diagonals and ku ...

slange(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real matrix

slangt(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real tridiagonal matrix

slanhs(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of Hessenberg matrix

slansb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n symmetric band matrix , with k super-diagonals

slansf(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix in RFP format

slansp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix , supplied in packed form

slanst(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric tridiagonal matrix

slansy(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of real symmetric matrix

slantb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n triangular band matrix , with diagonals

slantp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of triangular matrix , supplied in packed form

slantr(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of trapezoidal or triangular matrix

slanv2(l)

computes Schur factorization of real 2-by-2 nonsymmetric matrix in standard form

slapll(l)

two column vectors X and Y, let =

slapmt(l)

rearranges columns of M by N matrix X as specified by permutation K,K,...,K of integers 1,...,N

slapy2(l)

returns sqrt, taking care not to cause unnecessary overflow

slapy3(l)

returns sqrt, taking care not to cause unnecessary overflow

slaqgb(l)

equilibrates general M by N band matrix with KL subdiagonals/KU superdiagonals using row/scaling factors in vectors R/C

slaqge(l)

equilibrates general M by N matrix using row/column scaling factors in vectors R/C

slaqp2(l)

computes QR factorization with column pivoting of block

slaqps(l)

computes step of QR factorization with column pivoting of real M-by-N matrix by using Blas-3

slaqr0(l)

SLAQR0 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

slaqr1(l)

slaqr2(l)

slaqr3(l)

slaqr4(l)

SLAQR4 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**T, where T is upper quasi-triangular matrix , and ...

slaqr5(l)

slaqsb(l)

equilibrates symmetric band matrix using scaling factors in vector S

slaqsp(l)

equilibrates symmetric matrix using scaling factors in vector S

slaqsy(l)

equilibrates symmetric matrix using scaling factors in vector S

slaqtr(l)

solves real quasi-triangular system op*p = scale*c, if LREAL = .TRUE

slar1v(l)

computes r-th column of inverse of sumbmatrix in rows B1 through BN of tridiagonal matrix L D L^T - sigma I

slar2v(l)

applies vector of real plane rotations from both sides to sequence of 2-by-2 real symmetric matrices, defined by elements of vectors x, y and z

slarf(l)

applies real elementary reflector H to real m by n matrix C, from either left or right

slarfb(l)

applies real block reflector H or its transpose H' to real m by n matrix C, from either left or right

slarfg(l)

generates real elementary reflector H of order n, such that H * = , H' * H = I

slarfp(l)

generates real elementary reflector H of order n, such that H * = , H' * H = I

slarft(l)

forms triangular factor T of real block reflector H of order n, which is defined as product of k elementary reflectors

slarfx(l)

applies real elementary reflector H to real m by n matrix C, from either left or right

slargv(l)

generates vector of real plane rotations, determined by elements of real vectors x and y

slarnv(l)

returns vector of n random real numbers from uniform/normal distribution

slarra(l)

splitting points with threshold SPLTOL

slarrb(l)

relatively robust representation L D L^T, SLARRB does limited bisection to refine eigenvalues of L D L^T

slarrc(l)

number of eigenvalues of symmetric tridiagonal matrix T in interval (VL,VU] if JOBT = 'T', and of L D L^T if JOBT = 'L'

slarrd(l)

computes eigenvalues of symmetric tridiagonal matrix T to suitable accuracy

slarre(l)

find desired eigenvalues of given real symmetric tridiagonal matrix T, SLARRE sets any small off-diagonal elements to zero, and for each unreduced block T_i ...

slarrf(l)

initial representation L D L^T and its cluster of close eigenvalues , W, W,

slarrj(l)

initial eigenvalue approximations of T, SLARRJ does bisection to refine eigenvalues of T

slarrk(l)

computes one eigenvalue of symmetric tridiagonal matrix T to suitable accuracy

slarrr(l)

tests to decide whether symmetric tridiagonal matrix T warrants expensive computations which guarantee high relative accuracy in eigenvalues

slarrv(l)

computes eigenvectors of tridiagonal matrix T = L D L^T given L, D and APPROXIMATIONS to eigenvalues of L D L^T

slarscl2(l)

performs reciprocal diagonal scaling on vector

slartg(l)

make plane rotation so that [ CS SN ]

slartv(l)

applies vector of real plane rotations to elements of real vectors x/y

slaruv(l)

returns vector of n random real numbers from uniform

slarz(l)

applies real elementary reflector H to real M-by-N matrix C, from either left or right

slarzb(l)

applies real block reflector H/its transpose H**T to real distributed M-by-N C from left/right

slarzt(l)

forms triangular factor T of real block reflector H of order > n, which is defined as product of k elementary reflectors

slas2(l)

computes singular values of 2-by-2 matrix [ F G ] [ 0 H ]

slascl(l)

multiplies M by N real matrix by real scalar CTO/CFROM

slascl2(l)

performs diagonal scaling on vector

slasd0(l)

divide and conquer approach, SLASD0 computes singular value decomposition of real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = ...

slasd1(l)

computes SVD of upper bidiagonal N-by-M matrix B

slasd2(l)

merges two sets of singular values together into single sorted set

slasd3(l)

finds all square roots of roots of secular equation, as defined by values in D and Z

slasd4(l)

subroutine compute square root of I-th updated eigenvalue of positive symmetric rank-one modification to positive diagonal matrix whose entries are given as ...

slasd5(l)

subroutine compute square root of I-th eigenvalue of positive symmetric rank-one modification of 2-by-2 diagonal matrix diag * diag + RHO diagonal entries in ...

slasd6(l)

computes SVD of updated upper bidiagonal matrix B obtained by merging two smaller ones by appending row

slasd7(l)

merges two sets of singular values together into single sorted set

slasd8(l)

finds square roots of roots of secular equation

slasd9(l)

find square roots of roots of secular equation

slasda(l)

divide and conquer approach, SLASDA computes singular value decomposition of real upper bidiagonal N-by-M matrix B with diagonal D and offdiagonal E, where M = ...

slasdq(l)

computes singular value decomposition of real bidiagonal matrix with diagonal D and offdiagonal E, accumulating transformations if desired

slasdt(l)

creates tree of subproblems for bidiagonal divide/conquer

slaset(l)

initializes m-by-n matrix to BETA on diagonal/ALPHA on offdiagonals

slasq1(l)

computes singular values of real N-by-N bidiagonal matrix with diagonal D/off-diagonal E

slasq2(l)

computes all eigenvalues of symmetric positive definite tridiagonal matrix associated with qd array Z to high relative accuracy are computed to high relative ...

slasq3(l)

checks for deflation, computes shift and calls dqds

slasq4(l)

computes approximation TAU to smallest eigenvalue using values of d from previous transform

slasq5(l)

computes one dqds transform in ping-pong form, one version for IEEE machines another for non IEEE machines

slasq6(l)

computes one dqd transform in ping-pong form, with protection against underflow and overflow

slasr(l)

applies sequence of plane rotations to real matrix

slasrt(l)

number in D in increasing order/in decreasing order

slassq(l)

returns values scl and smsq such that *smsq = x**2 +...+ x**2 + *sumsq

slasv2(l)

computes singular value decomposition of 2-by-2 triangular matrix [ F G ] [ 0 H ]

slaswp(l)

performs series of row interchanges on matrix

slasy2(l)

solves for N1 by N2 matrix X, 1 <= N1,N2 <= 2, in op*X + ISGN*X*op = SCALE*B

slasyf(l)

computes partial factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

slatbs(l)

solves one of triangular systems *x = s*b or '*x = s*b with scaling to prevent overflow, where is upper or lower triangular band matrix

slatdf(l)

uses LU factorization of n-by-n matrix Z computed by SGETC2 and computes contribution to reciprocal Dif-estimate by solving Z * x = b for x, and choosing r.h.s

slatps(l)

solves one of triangular systems *x = s*b or '*x = s*b with scaling to prevent overflow, where is upper or lower triangular matrix stored in packed form

slatrd(l)

reduces NB rows and columns of real symmetric matrix to symmetric tridiagonal form by orthogonal similarity transformation Q' * * Q, and returns matrices V and ...

slatrs(l)

solves one of triangular systems *x = s*b/'*x = s*b with scaling to prevent overflow

slatrz(l)

factors M-by- real upper trapezoidal matrix [ A1 A2 ] = [ ] as * Z, by means of orthogonal transformations

slatzm(l)

routine i deprecated/has been replaced by routine SORMRZ

slauu2(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

slauum(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

slazq3(l)

for deflation, computes shift and calls dqds

slazq4(l)

approximation TAU to smallest eigenvalue using values of d from previous transform

snrm2(l)

returns euclidean norm of vector via function name, so that SNRM2 := sqrt

sopgtr(l)

generates real orthogonal matrix Q which is defined as product of n-1 elementary reflectors H of order n, as returned by SSPTRD using packed storage

sopmtr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sorg2l(l)

generates m by n real matrix Q with orthonormal columns

sorg2r(l)

generates m by n real matrix Q with orthonormal columns

sorgbr(l)

generates one of real orthogonal matrices Q/P**T determined by SGEBRD when reducing real matrix to bidiagonal form

sorghr(l)

generates real orthogonal matrix Q which is defined as product of IHI-ILO elementary reflectors of order N, as returned by SGEHRD

sorgl2(l)

generates m by n real matrix Q with orthonormal rows

sorglq(l)

generates M-by-N real matrix Q with orthonormal rows

sorgql(l)

generates M-by-N real matrix Q with orthonormal columns

sorgqr(l)

generates M-by-N real matrix Q with orthonormal columns

sorgr2(l)

generates m by n real matrix Q with orthonormal rows

sorgrq(l)

generates M-by-N real matrix Q with orthonormal rows

sorgtr(l)

generates real orthogonal matrix Q which is defined as product of n-1 elementary reflectors of order N, as returned by SSYTRD

sorm2l(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

sorm2r(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

sormbr(l)

VECT = 'Q', SORMBR overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormhr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sorml2(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

sormlq(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormql(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormqr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormr2(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

sormr3(l)

overwrites general real m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'T', or C * Q if SIDE = 'R' and TRANS = ...

sormrq(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormrz(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

sormtr(l)

overwrites general real M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

spbcon(l)

estimates reciprocal of condition number of real symmetric positive definite band matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPBTRF

spbequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite band matrix/reduce its condition number

spbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and banded, and provides error bounds and ...

spbstf(l)

computes split Cholesky factorization of real symmetric positive definite band matrix

spbsv(l)

computes solution to real system of linear equations * X = B

spbsvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

spbtf2(l)

computes Cholesky factorization of real symmetric positive definite band matrix

spbtrf(l)

computes Cholesky factorization of real symmetric positive definite band matrix

spbtrs(l)

solves system of linear equations *X = B with symmetric positive definite band matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPBTRF

spftrf(l)

computes Cholesky factorization of real symmetric positive definite matrix

spftri(l)

computes inverse of real positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPFTRF

spftrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPFTRF

spocon(l)

estimates reciprocal of condition number of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPOTRF

spoequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

spoequb(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

sporfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite

sporfsx(l)

SPORFSX improve computed solution to system of linear equations when coefficient matrix is symmetric positive definite, and provides error bounds and backward ...

sposv(l)

computes solution to real system of linear equations * X = B

sposvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

sposvxx(l)

SPOSVXX use Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B, where is N-by-N symmetric positive ...

spotf2(l)

computes Cholesky factorization of real symmetric positive definite matrix

spotrf(l)

computes Cholesky factorization of real symmetric positive definite matrix

spotri(l)

computes inverse of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPOTRF

spotrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPOTRF

sppcon(l)

estimates reciprocal of condition number of real symmetric positive definite packed matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPPTRF

sppequ(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix in packed storage/reduce its condition number

spprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and packed, and provides error bounds and ...

sppsv(l)

computes solution to real system of linear equations * X = B

sppsvx(l)

uses Cholesky factorization = U**T*U or = L*L**T to compute solution to real system of linear equations * X = B

spptrf(l)

computes Cholesky factorization of real symmetric positive definite matrix stored in packed format

spptri(l)

computes inverse of real symmetric positive definite matrix using Cholesky factorization = U**T*U/= L*L**T computed by SPPTRF

spptrs(l)

solves system of linear equations *X = B with symmetric positive definite matrix in packed storage using Cholesky factorization = U**T*U/= L*L**T computed by ...

spstf2(l)

computes Cholesky factorization with complete pivoting of real symmetric positive semidefinite matrix

spstrf(l)

computes Cholesky factorization with complete pivoting of real symmetric positive semidefinite matrix

sptcon(l)

computes reciprocal of condition number of real symmetric positive definite tridiagonal matrix using factorization = L*D*L**T/= U**T*D*U computed by SPTTRF

spteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric positive definite tridiagonal matrix by first factoring matrix using SPTTRF, and then calling SBDSQR ...

sptrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric positive definite and tridiagonal, and provides error bounds and ...

sptsv(l)

computes solution to real system of linear equations *X = B, where is N-by-N symmetric positive definite tridiagonal matrix, and X and B are N-by-NRHS matrices

sptsvx(l)

uses factorization = L*D*L**T to compute solution to real system of linear equations *X = B, where is N-by-N symmetric positive definite tridiagonal matrix and ...

spttrf(l)

computes L*D*L' factorization of real symmetric positive definite tridiagonal matrix

spttrs(l)

solves tridiagonal system of form * X = B using L*D*L' factorization of computed by SPTTRF

sptts2(l)

solves tridiagonal system of form * X = B using L*D*L' factorization of computed by SPTTRF

squeleton(l)

of ROUTINE> computes <text> Arguments ========= <Arg1> TYPE Description of argument <Arg2> TYPE Description of argument Further Details ...

srot(l)

applies plane rotation

srotg(l)

SROTG construct givens plane rotation

srotm(l)

APPLY MODIFIED GIVENS TRANSFORMATION, H, TO 2 BY N MATRIX , WHERE **T INDICATES TRANSPOSE

srotmg(l)

CONSTRUCT MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS SECOND COMPONENT OF 2-VECTOR (SQRT*SX1,SQRT*

srscl(l)

multiplies n-element real vector x by real scalar 1/

ssbev(l)

computes all eigenvalues and, , eigenvectors of real symmetric band matrix

ssbevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric band matrix

ssbevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric band matrix

ssbgst(l)

reduces real symmetric-definite banded generalized eigenproblem *x = lambda*B*x to standard form C*y = lambda*y

ssbgv(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

ssbgvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

ssbgvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite banded eigenproblem, of form *x=*B*x

ssbmv(l)

performs matrix-vector operation y := alpha**x + beta*y

ssbtrd(l)

reduces real symmetric band matrix to symmetric tridiagonal form T by orthogonal similarity transformation

sscal(l)

scales vector by constant

ssfrk(l)

3 BLAS like routine for C in RFP Format

sspcon(l)

estimates reciprocal of condition number of real symmetric packed matrix using factorization = U*D*U**T/= L*D*L**T computed by SSPTRF

sspev(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

sspevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

sspevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix in packed storage

sspgst(l)

reduces real symmetric-definite generalized eigenproblem to standard form, using packed storage

sspgv(l)

computes all eigenvalues and, , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

sspgvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

sspgvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

sspmv(l)

performs matrix-vector operation y := alpha**x + beta*y

sspr(l)

performs symmetric rank 1 operation := alpha*x*x' +

sspr2(l)

performs symmetric rank 2 operation := alpha*x*y' + alpha*y*x' +

ssprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward ...

sspsv(l)

computes solution to real system of linear equations * X = B

sspsvx(l)

uses diagonal pivoting factorization = U*D*U**T or = L*D*L**T to compute solution to real system of linear equations * X = B, where is N-by-N symmetric matrix ...

ssptrd(l)

reduces real symmetric matrix stored in packed form to symmetric tridiagonal form T by orthogonal similarity transformation

ssptrf(l)

computes factorization of real symmetric matrix stored in packed format using Bunch-Kaufman diagonal pivoting method

ssptri(l)

computes inverse of real symmetric indefinite matrix in packed storage using factorization = U*D*U**T/= L*D*L**T computed by SSPTRF

ssptrs(l)

solves system of linear equations *X = B with real symmetric matrix stored in packed format using factorization = U*D*U**T/= L*D*L**T computed by SSPTRF

sstebz(l)

computes eigenvalues of symmetric tridiagonal matrix T

sstedc(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using divide and conquer method

sstegr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

sstein(l)

computes eigenvectors of real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration

sstemr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

ssteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using implicit QL or QR method

ssterf(l)

computes all eigenvalues of symmetric tridiagonal matrix using Pal-Walker-Kahan variant of QL/QR algorithm

sstev(l)

computes all eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

sstevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

sstevr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

sstevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix

sswap(l)

interchanges two vectors

ssycon(l)

estimates reciprocal of condition number of real symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by SSYTRF

ssyequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

ssyev(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix

ssyevd(l)

computes all eigenvalues and, , eigenvectors of real symmetric matrix

ssyevr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix

ssyevx(l)

computes selected eigenvalues and, , eigenvectors of real symmetric matrix

ssygs2(l)

reduces real symmetric-definite generalized eigenproblem to standard form

ssygst(l)

reduces real symmetric-definite generalized eigenproblem to standard form

ssygv(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

ssygvd(l)

computes all eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

ssygvx(l)

computes selected eigenvalues, and , eigenvectors of real generalized symmetric-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

ssymm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

ssymv(l)

performs matrix-vector operation y := alpha**x + beta*y

ssyr(l)

performs symmetric rank 1 operation := alpha*x*x' +

ssyr2(l)

performs symmetric rank 2 operation := alpha*x*y' + alpha*y*x' +

ssyr2k(l)

performs one of symmetric rank 2k operations C := alpha**B' + alpha*B*' + beta*C

ssyrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

ssyrfsx(l)

SSYRFSX improve computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

ssyrk(l)

performs one of symmetric rank k operations C := alpha**' + beta*C

ssysv(l)

computes solution to real system of linear equations * X = B

ssysvx(l)

uses diagonal pivoting factorization to compute solution to real system of linear equations * X = B

ssysvxx(l)

SSYSVXX use diagonal pivoting factorization to compute solution to real system of linear equations * X = B, where is N-by-N symmetric matrix and X and B are ...

ssytd2(l)

reduces real symmetric matrix to symmetric tridiagonal form T by orthogonal similarity transformation

ssytf2(l)

computes factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

ssytrd(l)

reduces real symmetric matrix to real symmetric tridiagonal form T by orthogonal similarity transformation

ssytrf(l)

computes factorization of real symmetric matrix using Bunch-Kaufman diagonal pivoting method

ssytri(l)

computes inverse of real symmetric indefinite matrix using factorization = U*D*U**T/= L*D*L**T computed by SSYTRF

ssytrs(l)

solves system of linear equations *X = B with real symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by SSYTRF

stbcon(l)

estimates reciprocal of condition number of triangular band matrix , in either 1-norm or infinity-norm

stbmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

stbrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular band coefficient matrix

stbsv(l)

solves one of systems of equations *x = b, or '*x = b

stbtrs(l)

solves triangular system of form * X = B or **T * X = B

stfsm(l)

3 BLAS like routine for in RFP Format

stftri(l)

computes inverse of triangular matrix stored in RFP format

stfttp(l)

copies triangular matrix from rectangular full packed format to standard packed format

stfttr(l)

copies triangular matrix from rectangular full packed format to standard full format

stgevc(l)

computes some or all of right/left eigenvectors of pair of real matrices , where S is quasi-triangular matrix and P is upper triangular

stgex2(l)

swaps adjacent diagonal blocks/of size 1-by-1/2-by-2 in upper triangular matrix pair by orthogonal equivalence transformation

stgexc(l)

reorders generalized real Schur decomposition of real matrix pair using orthogonal equivalence transformation = Q * * Z'

stgsen(l)

reorders generalized real Schur decomposition of real matrix pair (in terms of orthonormal equivalence trans- formation Q' * * Z), so that selected cluster of ...

stgsja(l)

computes generalized singular value decomposition of two real upper triangular matrices/B

stgsna(l)

estimates reciprocal condition numbers for specified eigenvalues/eigenvectors of matrix pair in generalized real Schur canonical form (or of any matrix pair ...

stgsy2(l)

solves generalized Sylvester equation

stgsyl(l)

solves generalized Sylvester equation

stpcon(l)

estimates reciprocal of condition number of packed triangular matrix , in either 1-norm or infinity-norm

stpmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

stprfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular packed coefficient matrix

stpsv(l)

solves one of systems of equations *x = b, or '*x = b

stptri(l)

computes inverse of real upper/lower triangular matrix stored in packed format

stptrs(l)

solves triangular system of form * X = B or **T * X = B

stpttf(l)

copies triangular matrix from standard packed format to rectangular full packed format

stpttr(l)

copies triangular matrix from standard packed format to standard full format

strcon(l)

estimates reciprocal of condition number of triangular matrix , in either 1-norm or infinity-norm

strevc(l)

computes some/all of right/left eigenvectors of real upper quasi-triangular matrix T

strexc(l)

reorders real Schur factorization of real matrix = Q*T*Q**T, so that diagonal block of T with row index IFST is moved to row ILST

strmm(l)

performs one of matrix-matrix operations B := alpha*op*B, or B := alpha*B*op

strmv(l)

performs one of matrix-vector operations x := *x, or x := '*x

strrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular coefficient matrix

strsen(l)

reorders real Schur factorization of real matrix = Q*T*Q**T, so that selected cluster of eigenvalues appears in leading diagonal blocks of upper ...

strsm(l)

solves one of matrix equations op*X = alpha*B, or X*op = alpha*B

strsna(l)

estimates reciprocal condition numbers for specified eigenvalues/right eigenvectors of real upper quasi-triangular matrix T

strsv(l)

solves one of systems of equations *x = b, or '*x = b

strsyl(l)

solves real Sylvester matrix equation

strti2(l)

computes inverse of real upper/lower triangular matrix

strtri(l)

computes inverse of real upper/lower triangular matrix

strtrs(l)

solves triangular system of form * X = B or **T * X = B

strttf(l)

copies triangular matrix from standard full format to rectangular full packed format

strttp(l)

copies triangular matrix from full format to standard packed format

stzrqf(l)

routine i deprecated/has been replaced by routine STZRZF

stzrzf(l)

reduces M-by-N real upper trapezoidal matrix to upper triangular form by means of orthogonal transformations

tstiee(l)

called from LAPACK routines to choose problem-dependent parameters for local environment

xerbla(l)

is error handler for LAPACK routines

xerbla_array(l)

assists other languages in calling XERBLA, LAPACK and BLAS error handler

zaxpy(l)

ZAXPY constant times vector plus vector

zbdsqr(l)

computes singular values and, , right/left singular vectors from singular value decomposition of real N-by-N bidiagonal matrix B using implicit zero-shift QR ...

zcgesv(l)

computes solution to complex system of linear equations * X = B

zcopy(l)

ZCOPY copie vector, x, to vector, y

zcposv(l)

computes solution to complex system of linear equations * X = B

zdotc(l)

forms dot product of vector

zdotu(l)

ZDOTU form dot product of two vectors

zdrot(l)

plane rotation, where cos and sin are real and vectors cx and cy are complex

zdrscl(l)

multiplies n-element complex vector x by real scalar 1/

zdscal(l)

ZDSCAL scale vector by constant

zgbbrd(l)

reduces complex general m-by-n band matrix to real upper bidiagonal form B by unitary transformation

zgbcon(l)

estimates reciprocal of condition number of complex general band matrix , in either 1-norm or infinity-norm

zgbequ(l)

computes row/column scalings intended to equilibrate M-by-N band matrix/reduce its condition number

zgbequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgbmv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

zgbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is banded, and provides error bounds and backward error estimates for solution

zgbrfsx(l)

ZGBRFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgbsv(l)

computes solution to complex system of linear equations * X = B, where is band matrix of order N with KL subdiagonals and KU superdiagonals, and X and B are ...

zgbsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

zgbsvxx(l)

ZGBSVXX use LU factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

zgbtf2(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

zgbtrf(l)

computes LU factorization of complex m-by-n band matrix using partial pivoting with row interchanges

zgbtrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general band matrix using LU factorization computed by ZGBTRF

zgebak(l)

forms right/left eigenvectors of complex general matrix by backward transformation on computed eigenvectors of balanced matrix output by ZGEBAL

zgebal(l)

balances general complex matrix

zgebd2(l)

reduces complex general m by n matrix to upper/lower real bidiagonal form B by unitary transformation

zgebrd(l)

reduces general complex M-by-N matrix to upper/lower bidiagonal form B by unitary transformation

zgecon(l)

estimates reciprocal of condition number of general complex matrix , in either 1-norm or infinity-norm, using LU factorization computed by ZGETRF

zgeequ(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgeequb(l)

computes row/column scalings intended to equilibrate M-by-N matrix/reduce its condition number

zgees(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

zgeesx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues, Schur form T, and, , matrix of Schur vectors Z

zgeev(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

zgeevx(l)

computes for N-by-N complex nonsymmetric matrix , eigenvalues and, , left/right eigenvectors

zgegs(l)

routine i deprecated/has been replaced by routine ZGGES

zgegv(l)

routine i deprecated/has been replaced by routine ZGGEV

zgehd2(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

zgehrd(l)

reduces complex general matrix to upper Hessenberg form H by unitary similarity transformation

zgelq2(l)

computes LQ factorization of complex m by n matrix

zgelqf(l)

computes LQ factorization of complex M-by-N matrix

zgels(l)

solves overdetermined or underdetermined complex linear systems involving M-by-N matrix , or its conjugate-transpose, using QR or LQ factorization of

zgelsd(l)

computes minimum-norm solution to real linear least squares problem

zgelss(l)

computes minimum norm solution to complex linear least squares problem

zgelsx(l)

routine i deprecated/has been replaced by routine ZGELSY

zgelsy(l)

computes minimum-norm solution to complex linear least squares problem

zgemm(l)

performs one of matrix-matrix operations C := alpha*op*op + beta*C

zgemv(l)

performs one of matrix-vector operations y := alpha**x + beta*y, or y := alpha*'*x + beta*y, or y := alpha*conjg*x + beta*y

zgeql2(l)

computes QL factorization of complex m by n matrix

zgeqlf(l)

computes QL factorization of complex M-by-N matrix

zgeqp3(l)

computes QR factorization with column pivoting of matrix

zgeqpf(l)

routine i deprecated/has been replaced by routine ZGEQP3

zgeqr2(l)

computes QR factorization of complex m by n matrix

zgeqrf(l)

computes QR factorization of complex M-by-N matrix

zgerc(l)

performs rank 1 operation := alpha*x*conjg +

zgerfs(l)

improves computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgerfsx(l)

ZGERFSX improve computed solution to system of linear equations/provides error bounds/backward error estimates for solution

zgerq2(l)

computes RQ factorization of complex m by n matrix

zgerqf(l)

computes RQ factorization of complex M-by-N matrix

zgeru(l)

performs rank 1 operation := alpha*x*y' +

zgesc2(l)

solves system of linear equations * X = scale* RHS with general N-by-N matrix using LU factorization with complete pivoting computed by ZGETC2

zgesdd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors, by using divide-and-conquer method

zgesv(l)

computes solution to complex system of linear equations * X = B

zgesvd(l)

computes singular value decomposition of complex M-by-N matrix , computing left/right singular vectors

zgesvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B

zgesvxx(l)

ZGESVXX use LU factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N matrix and X and B are N-by-NRHS matrices

zgetc2(l)

computes LU factorization, using complete pivoting, of n-by-n matrix

zgetf2(l)

computes LU factorization of general m-by-n matrix using partial pivoting with row interchanges

zgetrf(l)

computes LU factorization of general M-by-N matrix using partial pivoting with row interchanges

zgetri(l)

computes inverse of matrix using LU factorization computed by ZGETRF

zgetrs(l)

solves system of linear equations * X = B, **T * X = B, or **H * X = B with general N-by-N matrix using LU factorization computed by ZGETRF

zggbak(l)

forms right or left eigenvectors of complex generalized eigenvalue problem *x = lambda*B*x, by backward transformation on computed eigenvectors of balanced ...

zggbal(l)

balances pair of general complex matrices

zgges(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, generalized complex Schur form , and left/right Schur vectors

zggesx(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, complex Schur form

zggev(l)

computes for pair of N-by-N complex nonsymmetric matrices , generalized eigenvalues, and , left/right generalized eigenvectors

zggevx(l)

computes for pair of N-by-N complex nonsymmetric matrices generalized eigenvalues, and , left/right generalized eigenvectors

zggglm(l)

solves general Gauss-Markov linear model problem

zgghrd(l)

reduces pair of complex matrices to generalized upper Hessenberg form using unitary transformations, where is general matrix and B is upper triangular

zgglse(l)

solves linear equality-constrained least squares problem

zggqrf(l)

computes generalized QR factorization of N-by-M matrix/N-by-P matrix B

zggrqf(l)

computes generalized RQ factorization of M-by-N matrix/P-by-N matrix B

zggsvd(l)

computes generalized singular value decomposition of M-by-N complex matrix/P-by-N complex matrix B

zggsvp(l)

computes unitary matrices U, V and Q such that N-K-L K L U'**Q = K if M-K-L >= 0

zgtcon(l)

estimates reciprocal of condition number of complex tridiagonal matrix using LU factorization as computed by ZGTTRF

zgtrfs(l)

improves computed solution to system of linear equations when coefficient matrix is tridiagonal, and provides error bounds and backward error estimates for ...

zgtsv(l)

solves equation *X = B

zgtsvx(l)

uses LU factorization to compute solution to complex system of linear equations * X = B, **T * X = B, or **H * X = B

zgttrf(l)

computes LU factorization of complex tridiagonal matrix using elimination with partial pivoting/row interchanges

zgttrs(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

zgtts2(l)

solves one of systems of equations * X = B, **T * X = B, or **H * X = B

zhbev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian band matrix

zhbgst(l)

reduces complex Hermitian-definite banded generalized eigenproblem *x = lambda*B*x to standard form C*y = lambda*y

zhbgv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbgvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbgvx(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite banded eigenproblem, of form *x=*B*x

zhbmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zhbtrd(l)

reduces complex Hermitian band matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhecon(l)

estimates reciprocal of condition number of complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zheequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

zheev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevr(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

zheevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix

zhegs2(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

zhegst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form

zhegv(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhegvd(l)

computes all eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhegvx(l)

computes selected eigenvalues, and , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhemm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

zhemv(l)

performs matrix-vector operation y := alpha**x + beta*y

zher(l)

performs hermitian rank 1 operation := alpha*x*conjg +

zher2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

zher2k(l)

performs one of hermitian rank 2k operations C := alpha**conjg + conjg*B*conjg + beta*C

zherfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

zherfsx(l)

ZHERFSX improve computed solution to system of linear equations when coefficient matrix is Hermitian indefinite, and provides error bounds and backward error ...

zherk(l)

performs one of hermitian rank k operations C := alpha**conjg + beta*C

zhesv(l)

computes solution to complex system of linear equations * X = B

zhesvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

zhesvxx(l)

ZHESVXX use diagonal pivoting factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric matrix and X and B ...

zhetd2(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhetf2(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zhetrd(l)

reduces complex Hermitian matrix to real symmetric tridiagonal form T by unitary similarity transformation

zhetrf(l)

computes factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zhetri(l)

computes inverse of complex Hermitian indefinite matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zhetrs(l)

solves system of linear equations *X = B with complex Hermitian matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHETRF

zhfrk(l)

3 BLAS like routine for C in RFP Format

zhgeqz(l)

computes eigenvalues of complex matrix pair

zhpcon(l)

estimates reciprocal of condition number of complex Hermitian packed matrix using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhpev(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpevd(l)

computes all eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpevx(l)

computes selected eigenvalues and, , eigenvectors of complex Hermitian matrix in packed storage

zhpgst(l)

reduces complex Hermitian-definite generalized eigenproblem to standard form, using packed storage

zhpgv(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpgvd(l)

computes all eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpgvx(l)

computes selected eigenvalues and, , eigenvectors of complex generalized Hermitian-definite eigenproblem, of form *x=*B*x, *Bx=*x, or B**x=*x

zhpmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zhpr(l)

performs hermitian rank 1 operation := alpha*x*conjg +

zhpr2(l)

performs hermitian rank 2 operation := alpha*x*conjg + conjg*y*conjg +

zhprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian indefinite and packed, and provides error bounds and backward ...

zhpsv(l)

computes solution to complex system of linear equations * X = B

zhpsvx(l)

uses diagonal pivoting factorization = U*D*U**H or = L*D*L**H to compute solution to complex system of linear equations * X = B, where is N-by-N Hermitian ...

zhptrd(l)

reduces complex Hermitian matrix stored in packed form to real symmetric tridiagonal form T by unitary similarity transformation

zhptrf(l)

computes factorization of complex Hermitian packed matrix using Bunch-Kaufman diagonal pivoting method

zhptri(l)

computes inverse of complex Hermitian indefinite matrix in packed storage using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhptrs(l)

solves system of linear equations *X = B with complex Hermitian matrix stored in packed format using factorization = U*D*U**H/= L*D*L**H computed by ZHPTRF

zhsein(l)

uses inverse iteration to find specified right/left eigenvectors of complex upper Hessenberg matrix H

zhseqr(l)

ZHSEQR compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zla_gbamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

zla_gbrcond_c(l)

ZLA_GBRCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_gbrcond_x(l)

ZLA_GBRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_gbrfsx_extended(l)

computes

zla_gbrpvgrw(l)

computes

zla_geamv(l)

performs one of matrix-vector operations y := alpha*abs*abs + beta*abs

zla_gercond_c(l)

ZLA_GERCOND_C compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_gercond_x(l)

ZLA_GERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_gerfsx_extended(l)

computes

zla_heamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

zla_hercond_c(l)

ZLA_HERCOND_C compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_hercond_x(l)

ZLA_HERCOND_X compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_herfsx_extended(l)

computes

zla_herpvgrw(l)

computes

zla_lin_berr(l)

ZLA_LIN_BERR compute componentwise relative backward error from formula max ( abs(R)/( abs(op)*abs + abs ) ) where abs is componentwise absolute value of ...

zla_porcond_c(l)

DLA_PORCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector Arguments ========= C DOUBLE PRECISION vector

zla_porcond_x(l)

ZLA_PORCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_porfsx_extended(l)

computes

zla_porpvgrw(l)

computes

zla_rpvgrw(l)

computes

zla_syamv(l)

performs matrix-vector operation y := alpha*abs*abs + beta*abs

zla_syrcond_c(l)

ZLA_SYRCOND_C Compute infinity norm condition number of op * inv(diag) where C is DOUBLE PRECISION vector

zla_syrcond_x(l)

ZLA_SYRCOND_X Compute infinity norm condition number of op * diag where X is COMPLEX*16 vector

zla_syrfsx_extended(l)

computes

zla_syrpvgrw(l)

computes

zla_wwaddw(l)

ZLA_WWADDW add vector W into doubled-single vector

zlabrd(l)

reduces first NB rows and columns of complex general m by n matrix to upper or lower real bidiagonal form by unitary transformation Q' * * P, and returns ...

zlacgv(l)

conjugates complex vector of length N

zlacn2(l)

estimates 1-norm of square, complex matrix

zlacon(l)

estimates 1-norm of square, complex matrix

zlacp2(l)

copies all/part of real two-dimensional matrix to complex matrix B

zlacpy(l)

copies all/part of two-dimensional matrix to another matrix B

zlacrm(l)

performs very simple matrix-matrix multiplication

zlacrt(l)

performs operation ==> where c/s are complex/vectors x/y are complex

zladiv(l)

:= X/Y, where X and Y are complex

zlaed0(l)

divide and conquer method, ZLAED0 computes all eigenvalues of symmetric tridiagonal matrix which is one diagonal block of those from reducing dense or band ...

zlaed7(l)

computes updated eigensystem of diagonal matrix after modification by rank-one symmetric matrix

zlaed8(l)

merges two sets of eigenvalues together into single sorted set

zlaein(l)

uses inverse iteration to find right/left eigenvector corresponding to eigenvalue W of complex upper Hessenberg matrix H

zlaesy(l)

computes eigendecomposition of 2-by-2 symmetric matrix ( ; ) provided norm of matrix of eigenvectors is larger than some threshold value

zlaev2(l)

computes eigendecomposition of 2-by-2 Hermitian matrix [ B ] [ CONJG C ]

zlag2c(l)

converts COMPLEX*16 matrix, SA, to COMPLEX matrix

zlags2(l)

computes 2-by-2 unitary matrices U, V and Q, such that if then U'**Q = U'**Q = and V'*B*Q = V'**Q = or if then U'**Q = U'**Q = and V'*B*Q = V'**Q = where U = ...

zlagtm(l)

performs matrix-vector product of form B := alpha * * X + beta * B where is tridiagonal matrix of order N, B and X are N by NRHS matrices, and alpha and beta ...

zlahef(l)

computes partial factorization of complex Hermitian matrix using Bunch-Kaufman diagonal pivoting method

zlahqr(l)

ZLAHQR i auxiliary routine called by CHSEQR to update eigenvalues and Schur decomposition already computed by CHSEQR, by dealing with Hessenberg submatrix in ...

zlahr2(l)

reduces first NB columns of complex general n-BY- matrix so that elements below k-th subdiagonal are zero

zlahrd(l)

reduces first NB columns of complex general n-by- matrix so that elements below k-th subdiagonal are zero

zlaic1(l)

applies one step of incremental condition estimation in its simplest version

zlals0(l)

applies back multiplying factors of either left/right singular vector matrix of diagonal matrix appended by row to right hand side matrix B in solving least ...

zlalsa(l)

is itermediate step in solving least squares problem by computing SVD of coefficient matrix in compact form

zlalsd(l)

uses singular value decomposition of to solve least squares problem of finding X to minimize Euclidean norm of each column of *X-B, where is N-by-N upper ...

zlangb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n band matrix , with kl sub-diagonals and ku ...

zlange(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex matrix

zlangt(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex tridiagonal matrix

zlanhb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n hermitian band matrix , with k super-diagonals

zlanhe(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix

zlanhf(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian matrix in RFP format

zlanhp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex hermitian matrix , supplied in packed form

zlanhs(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of Hessenberg matrix

zlanht(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex Hermitian tridiagonal matrix

zlansb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n symmetric band matrix , with k super-diagonals

zlansp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix , supplied in packed form

zlansy(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of complex symmetric matrix

zlantb(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of n by n triangular band matrix , with diagonals

zlantp(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of triangular matrix , supplied in packed form

zlantr(l)

returns value of one norm, or Frobenius norm, or infinity norm, or element of largest absolute value of trapezoidal or triangular matrix

zlapll(l)

two column vectors X and Y, let =

zlapmt(l)

rearranges columns of M by N matrix X as specified by permutation K,K,...,K of integers 1,...,N

zlaqgb(l)

equilibrates general M by N band matrix with KL subdiagonals/KU superdiagonals using row/scaling factors in vectors R/C

zlaqge(l)

equilibrates general M by N matrix using row/column scaling factors in vectors R/C

zlaqhb(l)

equilibrates symmetric band matrix using scaling factors in vector S

zlaqhe(l)

equilibrates Hermitian matrix using scaling factors in vector S

zlaqhp(l)

equilibrates Hermitian matrix using scaling factors in vector S

zlaqp2(l)

computes QR factorization with column pivoting of block

zlaqps(l)

computes step of QR factorization with column pivoting of complex M-by-N matrix by using Blas-3

zlaqr0(l)

ZLAQR0 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zlaqr1(l)

zlaqr2(l)

zlaqr3(l)

zlaqr4(l)

ZLAQR4 compute eigenvalues of Hessenberg matrix H and, , matrices T and Z from Schur decomposition H = Z T Z**H, where T is upper triangular matrix , and Z is ...

zlaqr5(l)

zlaqsb(l)

equilibrates symmetric band matrix using scaling factors in vector S

zlaqsp(l)

equilibrates symmetric matrix using scaling factors in vector S

zlaqsy(l)

equilibrates symmetric matrix using scaling factors in vector S

zlar1v(l)

computes r-th column of inverse of sumbmatrix in rows B1 through BN of tridiagonal matrix L D L^T - sigma I

zlar2v(l)

applies vector of complex plane rotations with real cosines from both sides to sequence of 2-by-2 complex Hermitian matrices

zlarcm(l)

performs very simple matrix-matrix multiplication

zlarf(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

zlarfb(l)

applies complex block reflector H or its transpose H' to complex M-by-N matrix C, from either left or right

zlarfg(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

zlarfp(l)

generates complex elementary reflector H of order n, such that H' * = , H' * H = I

zlarft(l)

forms triangular factor T of complex block reflector H of order n, which is defined as product of k elementary reflectors

zlarfx(l)

applies complex elementary reflector H to complex m by n matrix C, from either left or right

zlargv(l)

generates vector of complex plane rotations with real cosines, determined by elements of complex vectors x and y

zlarnv(l)

returns vector of n random complex numbers from uniform/normal distribution

zlarrv(l)

computes eigenvectors of tridiagonal matrix T = L D L^T given L, D and APPROXIMATIONS to eigenvalues of L D L^T

zlarscl2(l)

performs reciprocal diagonal scaling on vector

zlartg(l)

generates plane rotation so that [ CS SN ] [ F ] [ R ] [ __ ]

zlartv(l)

applies vector of complex plane rotations with real cosines to elements of complex vectors x/y

zlarz(l)

applies complex elementary reflector H to complex M-by-N matrix C, from either left or right

zlarzb(l)

applies complex block reflector H/its transpose H**H to complex distributed M-by-N C from left/right

zlarzt(l)

forms triangular factor T of complex block reflector H of order > n, which is defined as product of k elementary reflectors

zlascl(l)

multiplies M by N complex matrix by real scalar CTO/CFROM

zlascl2(l)

performs diagonal scaling on vector

zlaset(l)

initializes 2-D array to BETA on diagonal/ALPHA on offdiagonals

zlasr(l)

applies sequence of real plane rotations to complex matrix , from either left or right

zlassq(l)

returns values scl and ssq such that *ssq = x**2 +...+ x**2 + *sumsq

zlaswp(l)

performs series of row interchanges on matrix

zlasyf(l)

computes partial factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zlat2c(l)

converts COMPLEX*16 triangular matrix, SA, to COMPLEX triangular matrix

zlatbs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatdf(l)

computes contribution to reciprocal Dif-estimate by solving for x in Z * x = b, where b is chosen such that norm of x is as large as possible

zlatps(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatrd(l)

reduces NB rows and columns of complex Hermitian matrix to Hermitian tridiagonal form by unitary similarity transformation Q' * * Q, and returns matrices V and ...

zlatrs(l)

solves one of triangular systems * x = s*b, **T * x = s*b, or **H * x = s*b

zlatrz(l)

factors M-by- complex upper trapezoidal matrix [ A1 A2 ] = [ ] as * Z by means of unitary transformations, where Z is -by- unitary matrix and, R and A1 are ...

zlatzm(l)

routine i deprecated/has been replaced by routine ZUNMRZ

zlauu2(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

zlauum(l)

computes product U * U' or L' * L, where triangular factor U or L is stored in upper or lower triangular part of array

zpbcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPBTRF

zpbequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite band matrix/reduce its condition number

zpbrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and banded, and provides error bounds and ...

zpbstf(l)

computes split Cholesky factorization of complex Hermitian positive definite band matrix

zpbsv(l)

computes solution to complex system of linear equations * X = B

zpbsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zpbtf2(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

zpbtrf(l)

computes Cholesky factorization of complex Hermitian positive definite band matrix

zpbtrs(l)

solves system of linear equations *X = B with Hermitian positive definite band matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPBTRF

zpftrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpftri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPFTRF

zpftrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPFTRF

zpocon(l)

estimates reciprocal of condition number of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zpoequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix/reduce its condition number

zpoequb(l)

computes row/column scalings intended to equilibrate symmetric positive definite matrix/reduce its condition number

zporfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite

zporfsx(l)

ZPORFSX improve computed solution to system of linear equations when coefficient matrix is symmetric positive definite, and provides error bounds and backward ...

zposv(l)

computes solution to complex system of linear equations * X = B

zposvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zposvxx(l)

ZPOSVXX use Cholesky factorization = U**T*U or = L*L**T to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric ...

zpotf2(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpotrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix

zpotri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zpotrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPOTRF

zppcon(l)

estimates reciprocal of condition number of complex Hermitian positive definite packed matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPPTRF

zppequ(l)

computes row/column scalings intended to equilibrate Hermitian positive definite matrix in packed storage/reduce its condition number

zpprfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and packed, and provides error bounds and ...

zppsv(l)

computes solution to complex system of linear equations * X = B

zppsvx(l)

uses Cholesky factorization = U**H*U or = L*L**H to compute solution to complex system of linear equations * X = B

zpptrf(l)

computes Cholesky factorization of complex Hermitian positive definite matrix stored in packed format

zpptri(l)

computes inverse of complex Hermitian positive definite matrix using Cholesky factorization = U**H*U/= L*L**H computed by ZPPTRF

zpptrs(l)

solves system of linear equations *X = B with Hermitian positive definite matrix in packed storage using Cholesky factorization = U**H*U/= L*L**H computed by ...

zpstf2(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

zpstrf(l)

computes Cholesky factorization with complete pivoting of complex Hermitian positive semidefinite matrix

zptcon(l)

computes reciprocal of condition number of complex Hermitian positive definite tridiagonal matrix using factorization = L*D*L**H/= U**H*D*U computed by ZPTTRF

zpteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric positive definite tridiagonal matrix by first factoring matrix using DPTTRF and then calling ZBDSQR ...

zptrfs(l)

improves computed solution to system of linear equations when coefficient matrix is Hermitian positive definite and tridiagonal, and provides error bounds and ...

zptsv(l)

computes solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix, and X and B are N-by-NRHS ...

zptsvx(l)

uses factorization = L*D*L**H to compute solution to complex system of linear equations *X = B, where is N-by-N Hermitian positive definite tridiagonal matrix ...

zpttrf(l)

computes L*D*L' factorization of complex Hermitian positive definite tridiagonal matrix

zpttrs(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by ZPTTRF

zptts2(l)

solves tridiagonal system of form * X = B using factorization = U'*D*U/= L*D*L' computed by ZPTTRF

zrot(l)

applies plane rotation, where cos is real and sin is complex, and vectors CX and CY are complex

zrotg(l)

ZROTG determine double complex Givens rotation

zscal(l)

ZSCAL scale vector by constant

zspcon(l)

estimates reciprocal of condition number of complex symmetric packed matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zspmv(l)

performs matrix-vector operation y := alpha**x + beta*y

zspr(l)

performs symmetric rank 1 operation := alpha*x*conjg +

zsprfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite and packed, and provides error bounds and backward ...

zspsv(l)

computes solution to complex system of linear equations * X = B

zspsvx(l)

uses diagonal pivoting factorization = U*D*U**T or = L*D*L**T to compute solution to complex system of linear equations * X = B, where is N-by-N symmetric ...

zsptrf(l)

computes factorization of complex symmetric matrix stored in packed format using Bunch-Kaufman diagonal pivoting method

zsptri(l)

computes inverse of complex symmetric indefinite matrix in packed storage using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zsptrs(l)

solves system of linear equations *X = B with complex symmetric matrix stored in packed format using factorization = U*D*U**T/= L*D*L**T computed by ZSPTRF

zstedc(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using divide and conquer method

zstegr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

zstein(l)

computes eigenvectors of real symmetric tridiagonal matrix T corresponding to specified eigenvalues, using inverse iteration

zstemr(l)

computes selected eigenvalues and, , eigenvectors of real symmetric tridiagonal matrix T

zsteqr(l)

computes all eigenvalues and, , eigenvectors of symmetric tridiagonal matrix using implicit QL or QR method

zswap(l)

ZSWAP interchange two vectors

zsycon(l)

estimates reciprocal of condition number of complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

zsyequb(l)

computes row/column scalings intended to equilibrate symmetric matrix/reduce its condition number

zsymm(l)

performs one of matrix-matrix operations C := alpha**B + beta*C

zsymv(l)

performs matrix-vector operation y := alpha**x + beta*y

zsyr(l)

performs symmetric rank 1 operation := alpha*x* +

zsyr2k(l)

performs one of symmetric rank 2k operations C := alpha**B' + alpha*B*' + beta*C

zsyrfs(l)

improves computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

zsyrfsx(l)

ZSYRFSX improve computed solution to system of linear equations when coefficient matrix is symmetric indefinite, and provides error bounds and backward error ...

zsyrk(l)

performs one of symmetric rank k operations C := alpha**' + beta*C

zsysv(l)

computes solution to complex system of linear equations * X = B

zsysvx(l)

uses diagonal pivoting factorization to compute solution to complex system of linear equations * X = B

zsysvxx(l)

ZSYSVXX use diagonal pivoting factorization to compute solution to complex*16 system of linear equations * X = B, where is N-by-N symmetric matrix and X and B ...

zsytf2(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zsytrf(l)

computes factorization of complex symmetric matrix using Bunch-Kaufman diagonal pivoting method

zsytri(l)

computes inverse of complex symmetric indefinite matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

zsytrs(l)

solves system of linear equations *X = B with complex symmetric matrix using factorization = U*D*U**T/= L*D*L**T computed by ZSYTRF

ztbcon(l)

estimates reciprocal of condition number of triangular band matrix , in either 1-norm or infinity-norm

ztbmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztbrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular band coefficient matrix

ztbsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztbtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztfsm(l)

3 BLAS like routine for in RFP Format

ztftri(l)

computes inverse of triangular matrix stored in RFP format

ztfttp(l)

copies triangular matrix from rectangular full packed format to standard packed format

ztfttr(l)

copies triangular matrix from rectangular full packed format to standard full format

ztgevc(l)

computes some or all of right/left eigenvectors of pair of complex matrices , where S and P are upper triangular

ztgex2(l)

swaps adjacent diagonal 1 by 1 blocks/

ztgexc(l)

reorders generalized Schur decomposition of complex matrix pair , using unitary equivalence transformation := Q * * Z', so that diagonal block of with row ...

ztgsen(l)

reorders generalized Schur decomposition of complex matrix pair (in terms of unitary equivalence trans- formation Q' * * Z), so that selected cluster of ...

ztgsja(l)

computes generalized singular value decomposition of two complex upper triangular matrices/B

ztgsna(l)

estimates reciprocal condition numbers for specified eigenvalues/eigenvectors of matrix pair

ztgsy2(l)

solves generalized Sylvester equation * R - L * B = scale D * R - L * E = scale * F using Level 1 and 2 BLAS, where R and L are unknown M-by-N matrices

ztgsyl(l)

solves generalized Sylvester equation

ztpcon(l)

estimates reciprocal of condition number of packed triangular matrix , in either 1-norm or infinity-norm

ztpmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztprfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular packed coefficient matrix

ztpsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztptri(l)

computes inverse of complex upper/lower triangular matrix stored in packed format

ztptrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztpttf(l)

copies triangular matrix from standard packed format to rectangular full packed format

ztpttr(l)

copies triangular matrix from standard packed format to standard full format

ztrcon(l)

estimates reciprocal of condition number of triangular matrix , in either 1-norm or infinity-norm

ztrevc(l)

computes some/all of right/left eigenvectors of complex upper triangular matrix T

ztrexc(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that diagonal element of T with row index IFST is moved to row ILST

ztrmm(l)

performs one of matrix-matrix operations B := alpha*op*B, or B := alpha*B*op where alpha is scalar, B is m by n matrix, is unit, or non-unit, upper or lower ...

ztrmv(l)

performs one of matrix-vector operations x := *x, or x := '*x, or x := conjg*x

ztrrfs(l)

provides error bounds/backward error estimates for solution to system of linear equations with triangular coefficient matrix

ztrsen(l)

reorders Schur factorization of complex matrix = Q*T*Q**H, so that selected cluster of eigenvalues appears in leading positions on diagonal of upper triangular ...

ztrsm(l)

solves one of matrix equations op*X = alpha*B, or X*op = alpha*B

ztrsna(l)

estimates reciprocal condition numbers for specified eigenvalues/right eigenvectors of complex upper triangular matrix T

ztrsv(l)

solves one of systems of equations *x = b, or '*x = b, or conjg*x = b

ztrsyl(l)

solves complex Sylvester matrix equation

ztrti2(l)

computes inverse of complex upper/lower triangular matrix

ztrtri(l)

computes inverse of complex upper/lower triangular matrix

ztrtrs(l)

solves triangular system of form * X = B, **T * X = B, or **H * X = B

ztrttf(l)

copies triangular matrix from standard full format to rectangular full packed format

ztrttp(l)

copies triangular matrix from full format to standard packed format

ztzrqf(l)

routine i deprecated/has been replaced by routine ZTZRZF

ztzrzf(l)

reduces M-by-N complex upper trapezoidal matrix to upper triangular form by means of unitary transformations

zung2l(l)

generates m by n complex matrix Q with orthonormal columns

zung2r(l)

generates m by n complex matrix Q with orthonormal columns

zungbr(l)

generates one of complex unitary matrices Q/P**H determined by ZGEBRD when reducing complex matrix to bidiagonal form

zunghr(l)

generates complex unitary matrix Q which is defined as product of IHI-ILO elementary reflectors of order N, as returned by ZGEHRD

zungl2(l)

generates m-by-n complex matrix Q with orthonormal rows

zunglq(l)

generates M-by-N complex matrix Q with orthonormal rows

zungql(l)

generates M-by-N complex matrix Q with orthonormal columns

zungqr(l)

generates M-by-N complex matrix Q with orthonormal columns

zungr2(l)

generates m by n complex matrix Q with orthonormal rows

zungrq(l)

generates M-by-N complex matrix Q with orthonormal rows

zungtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors of order N, as returned by ZHETRD

zunm2l(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunm2r(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmbr(l)

VECT = 'Q', ZUNMBR overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmhr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunml2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmlq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmql(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmqr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmr2(l)

overwrites general complex m-by-n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmr3(l)

overwrites general complex m by n matrix C with Q * C if SIDE = 'L' and TRANS = 'N', or Q'* C if SIDE = 'L' and TRANS = 'C', or C * Q if SIDE = 'R' and TRANS = ...

zunmrq(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmrz(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zunmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'

zupgtr(l)

generates complex unitary matrix Q which is defined as product of n-1 elementary reflectors H of order n, as returned by ZHPTRD using packed storage

zupmtr(l)

overwrites general complex M-by-N matrix C with SIDE = 'L' SIDE = 'R' TRANS = 'N'