Section L: math library functions - Linux man pages

caxpy(l)

constant times vector plus vector

cbdsqr(l)

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

ccopy(l)

copie vector x to vector y

cdotc(l)

dot product of two vectors, conjugating first vector

cdotu(l)

form dot product of two vectors

cgbbrd(l)

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

cgbcon(l)

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

cgbequ(l)

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

cgbmv(l)

perform 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)

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

cgbsv(l)

compute 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)

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

cgbtf2(l)

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

cgbtrf(l)

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

cgbtrs(l)

solve 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)

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

cgebal(l)

balance general complex matrix

cgebd2(l)

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

cgebrd(l)

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

cgecon(l)

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

cgeequ(l)

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

cgees(l)

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

cgeesx(l)

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

cgeev(l)

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

cgeevx(l)

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

cgegs(l)

routine is deprecated/has been replaced by routine CGGES

cgegv(l)

routine is deprecated/has been replaced by routine CGGEV

cgehd2(l)

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

cgehrd(l)

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

cgelq2(l)

compute LQ factorization of complex m by n matrix

cgelqf(l)

compute LQ factorization of complex M-by-N matrix

cgels(l)

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

cgelsd(l)

compute minimum-norm solution to real linear least squares problem

cgelss(l)

compute minimum norm solution to complex linear least squares problem

cgelsx(l)

routine is deprecated/has been replaced by routine CGELSY

cgelsy(l)

compute minimum-norm solution to complex linear least squares problem

cgemm(l)

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

cgemv(l)

perform 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)

compute QL factorization of complex m by n matrix

cgeqlf(l)

compute QL factorization of complex M-by-N matrix

cgeqp3(l)

compute QR factorization with column pivoting of matrix

cgeqpf(l)

routine is deprecated/has been replaced by routine CGEQP3

cgeqr2(l)

compute QR factorization of complex m by n matrix

cgeqrf(l)

compute QR factorization of complex M-by-N matrix

cgerc(l)

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

cgerfs(l)

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

cgerq2(l)

compute RQ factorization of complex m by n matrix

cgerqf(l)

compute RQ factorization of complex M-by-N matrix

cgeru(l)

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

cgesc2(l)

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

cgesdd(l)

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

cgesv(l)

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

cgesvd(l)

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

cgesvx(l)

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

cgetc2(l)

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

cgetf2(l)

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

cgetrf(l)

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

cgetri(l)

compute inverse of matrix using LU factorization computed by CGETRF

cgetrs(l)

solve 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)

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

cggbal(l)

balance pair of general complex matrices

cgges(l)

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

cggesx(l)

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

cggev(l)

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

cggevx(l)

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

cggglm(l)

solve general Gauss-Markov linear model problem

cgghrd(l)

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

cgglse(l)

solve linear equality-constrained least squares problem

cggqrf(l)

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

cggrqf(l)

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

cggsvd(l)

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

cggsvp(l)

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

cgtcon(l)

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

cgtrfs(l)

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

cgtsv(l)

solve equation *X = B

cgtsvx(l)

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

cgttrf(l)

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

cgttrs(l)

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

cgtts2(l)

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

chbev(l)

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

chbevd(l)

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

chbevx(l)

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

chbgst(l)

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

chbgv(l)

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

chbgvd(l)

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

chbgvx(l)

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

chbmv(l)

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

chbtrd(l)

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

checon(l)

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

cheev(l)

compute all eigenvalues and, , eigenvectors of complex Hermitian matrix

cheevd(l)

compute all eigenvalues and, , eigenvectors of complex Hermitian matrix

cheevr(l)

compute selected eigenvalues and, , eigenvectors of complex Hermitian matrix T

cheevx(l)

compute selected eigenvalues and, , eigenvectors of complex Hermitian matrix

chegs2(l)

reduce complex Hermitian-definite generalized eigenproblem to standard form

chegst(l)

reduce complex Hermitian-definite generalized eigenproblem to standard form

chegv(l)

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

chegvd(l)

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

chegvx(l)

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

chemm(l)

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

chemv(l)

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

cher(l)

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

cher2(l)

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

cher2k(l)

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

cherfs(l)

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

cherk(l)

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

chesv(l)

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

chesvx(l)

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

chetd2(l)

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

chetf2(l)

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

chetrd(l)

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

chetrf(l)

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

chetri(l)

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

chetrs(l)

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

chgeqz(l)

implement single-shift version of QZ method for finding generalized eigenvalues w=ALPHA/BETA of equation det( - w B ) = 0 If JOB='S', then pair is ...

chpcon(l)

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

chpev(l)

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

chpevd(l)

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

chpevx(l)

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

chpgst(l)

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

chpgv(l)

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

chpgvd(l)

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

chpgvx(l)

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

chpmv(l)

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

chpr(l)

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

chpr2(l)

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

chprfs(l)

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

chpsv(l)

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

chpsvx(l)

use 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)

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

chptrf(l)

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

chptri(l)

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

chptrs(l)

solve 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)

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

chseqr(l)

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

cisnan(l)

.TRUE

clabrd(l)

reduce 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)

conjugate complex vector of length N

clacn2(l)

1-norm of square, complex matrix

clacon(l)

estimate 1-norm of square, complex matrix

clacp2(l)

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

clacpy(l)

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

clacrm(l)

perform very simple matrix-matrix multiplication

clacrt(l)

perform 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)

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

claed8(l)

merge two sets of eigenvalues together into single sorted set

claein(l)

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

claesy(l)

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

claev2(l)

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

clags2(l)

compute 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)

perform 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)

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

clahqr(l)

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

clahrd(l)

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

claic1(l)

applie one step of incremental condition estimation in its simplest version

clals0(l)

applie 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)

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

clalsd(l)

use 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)

return 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)

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

clangt(l)

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

clanhb(l)

return 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)

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

clanhp(l)

return 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)

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

clanht(l)

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

clansb(l)

return 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)

return 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)

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

clantb(l)

return 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)

return 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)

return 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)

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

claqgb(l)

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

claqge(l)

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

claqhb(l)

equilibrate symmetric band matrix using scaling factors in vector S

claqhe(l)

equilibrate Hermitian matrix using scaling factors in vector S

claqhp(l)

equilibrate Hermitian matrix using scaling factors in vector S

claqp2(l)

compute QR factorization with column pivoting of block

claqps(l)

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

claqr0(l)

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 unitary ...

claqr1(l)

claqr2(l)

claqr3(l)

claqr4(l)

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 unitary ...

claqr5(l)

claqsb(l)

equilibrate symmetric band matrix using scaling factors in vector S

claqsp(l)

equilibrate symmetric matrix using scaling factors in vector S

claqsy(l)

equilibrate symmetric matrix using scaling factors in vector S

clar1v(l)

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

clar2v(l)

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

clarcm(l)

perform very simple matrix-matrix multiplication

clarf(l)

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

clarfb(l)

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

clarfg(l)

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

clarft(l)

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

clarfx(l)

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

clargv(l)

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

clarnv(l)

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

clarrv(l)

compute eigenvectors of tridiagonal matrix T = L D L^T given L, D and eigenvalues of L D L^T

clartg(l)

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

clartv(l)

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

clarz(l)

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

clarzb(l)

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

clarzt(l)

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

clascl(l)

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

claset(l)

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

clasr(l)

perform transformation := P*, when SIDE = 'L' or 'l' := *P', when SIDE = 'R' or 'r' where is m by n complex matrix and P is orthogonal matrix

classq(l)

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

claswp(l)

perform series of row interchanges on matrix

clasyf(l)

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

clatbs(l)

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

clatdf(l)

compute 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)

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

clatrd(l)

reduce 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)

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

clatrz(l)

factor 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 is deprecated/has been replaced by routine CUNMRZ

clauu2(l)

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

clauum(l)

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

cpbcon(l)

estimate 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)

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

cpbrfs(l)

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

cpbstf(l)

compute split Cholesky factorization of complex Hermitian positive definite band matrix

cpbsv(l)

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

cpbsvx(l)

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

cpbtf2(l)

compute Cholesky factorization of complex Hermitian positive definite band matrix

cpbtrf(l)

compute Cholesky factorization of complex Hermitian positive definite band matrix

cpbtrs(l)

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

cpocon(l)

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

cpoequ(l)

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

cporfs(l)

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

cposv(l)

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

cposvx(l)

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

cpotf2(l)

compute Cholesky factorization of complex Hermitian positive definite matrix

cpotrf(l)

compute Cholesky factorization of complex Hermitian positive definite matrix

cpotri(l)

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

cpotrs(l)

solve 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)

estimate 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)

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

cpprfs(l)

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

cppsv(l)

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

cppsvx(l)

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

cpptrf(l)

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

cpptri(l)

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

cpptrs(l)

solve 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 ...

cptcon(l)

compute 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)

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

cptrfs(l)

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

cptsv(l)

compute 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)

use 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)

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

cpttrs(l)

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

cptts2(l)

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

crot(l)

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

crotg(l)

complex Givens rotation

cscal(l)

vector by constant

cspcon(l)

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

cspmv(l)

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

cspr(l)

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

csprfs(l)

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

cspsv(l)

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

cspsvx(l)

use 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)

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

csptri(l)

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

csptrs(l)

solve 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)

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

csscal(l)

complex vector by real constant

cstedc(l)

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

cstegr(l)

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

cstein(l)

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

csteqr(l)

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

cswap(l)

two vectors

csycon(l)

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

csymm(l)

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

csymv(l)

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

csyr(l)

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

csyr2k(l)

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

csyrfs(l)

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

csyrk(l)

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

csysv(l)

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

csysvx(l)

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

csytf2(l)

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

csytrf(l)

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

csytri(l)

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

csytrs(l)

solve 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)

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

ctbmv(l)

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

ctbrfs(l)

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

ctbsv(l)

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

ctbtrs(l)

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

ctgevc(l)

compute some/all of right/left generalized eigenvectors of pair of complex upper triangular matrices

ctgex2(l)

swap adjacent diagonal 1 by 1 blocks/

ctgexc(l)

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

ctgsen(l)

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

ctgsja(l)

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

ctgsna(l)

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

ctgsy2(l)

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

ctgsyl(l)

solve generalized Sylvester equation

ctpcon(l)

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

ctpmv(l)

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

ctprfs(l)

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

ctpsv(l)

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

ctptri(l)

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

ctptrs(l)

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

ctrcon(l)

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

ctrevc(l)

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

ctrexc(l)

reorder 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)

perform 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)

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

ctrrfs(l)

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

ctrsen(l)

reorder 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)

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

ctrsna(l)

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

ctrsv(l)

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

ctrsyl(l)

solve complex Sylvester matrix equation

ctrti2(l)

compute inverse of complex upper/lower triangular matrix

ctrtri(l)

compute inverse of complex upper/lower triangular matrix

ctrtrs(l)

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

ctzrqf(l)

routine is deprecated/has been replaced by routine CTZRZF

ctzrzf(l)

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

cung2l(l)

make m by n complex matrix Q with orthonormal columns

cung2r(l)

make m by n complex matrix Q with orthonormal columns

cungbr(l)

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

cunghr(l)

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

cungl2(l)

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

cunglq(l)

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

cungql(l)

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

cungqr(l)

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

cungr2(l)

make m by n complex matrix Q with orthonormal rows

cungrq(l)

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

cungtr(l)

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

cunm2l(l)

overwrite 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)

overwrite 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)

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

cunml2(l)

overwrite 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)

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

cunmql(l)

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

cunmqr(l)

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

cunmr2(l)

overwrite 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)

overwrite 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)

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

cunmrz(l)

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

cunmtr(l)

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

cupgtr(l)

make 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)

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

dasum(l)

sum of absolute values

daxpy(l)

time vector plus vector

dbdsdc(l)

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

dbdsqr(l)

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

dcabs1(l)

absolute value of double complex number

dcopy(l)

vector, x, to vector, y

ddisna(l)

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

ddot(l)

dot product of two vectors

dgbbrd(l)

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

dgbcon(l)

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

dgbequ(l)

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

dgbmv(l)

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

dgbrfs(l)

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

dgbsv(l)

compute 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)

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

dgbtf2(l)

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

dgbtrf(l)

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

dgbtrs(l)

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

dgebak(l)

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

dgebal(l)

balance general real matrix

dgebd2(l)

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

dgebrd(l)

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

dgecon(l)

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

dgeequ(l)

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

dgees(l)

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

dgeesx(l)

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

dgeev(l)

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

dgeevx(l)

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

dgegs(l)

routine is deprecated/has been replaced by routine DGGES

dgegv(l)

routine is deprecated/has been replaced by routine DGGEV

dgehd2(l)

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

dgehrd(l)

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

dgelq2(l)

compute LQ factorization of real m by n matrix

dgelqf(l)

compute LQ factorization of real M-by-N matrix

dgels(l)

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

dgelsd(l)

compute minimum-norm solution to real linear least squares problem

dgelss(l)

compute minimum norm solution to real linear least squares problem

dgelsx(l)

routine is deprecated/has been replaced by routine DGELSY

dgelsy(l)

compute minimum-norm solution to real linear least squares problem

dgemm(l)

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

dgemv(l)

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

dgeql2(l)

compute QL factorization of real m by n matrix

dgeqlf(l)

compute QL factorization of real M-by-N matrix

dgeqp3(l)

compute QR factorization with column pivoting of matrix

dgeqpf(l)

routine is deprecated/has been replaced by routine DGEQP3

dgeqr2(l)

compute QR factorization of real m by n matrix

dgeqrf(l)

compute QR factorization of real M-by-N matrix

dger(l)

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

dgerfs(l)

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

dgerq2(l)

compute RQ factorization of real m by n matrix

dgerqf(l)

compute RQ factorization of real M-by-N matrix

dgesc2(l)

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

dgesdd(l)

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

dgesv(l)

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

dgesvd(l)

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

dgesvx(l)

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

dgetc2(l)

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

dgetf2(l)

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

dgetrf(l)

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

dgetri(l)

compute inverse of matrix using LU factorization computed by DGETRF

dgetrs(l)

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

dggbak(l)

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

dggbal(l)

balance pair of general real matrices

dgges(l)

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

dggesx(l)

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

dggev(l)

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

dggevx(l)

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

dggglm(l)

solve general Gauss-Markov linear model problem

dgghrd(l)

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

dgglse(l)

solve linear equality-constrained least squares problem

dggqrf(l)

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

dggrqf(l)

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

dggsvd(l)

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

dggsvp(l)

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

dgtcon(l)

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

dgtrfs(l)

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

dgtsv(l)

solve equation *X = B

dgtsvx(l)

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

dgttrf(l)

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

dgttrs(l)

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

dgtts2(l)

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

dhgeqz(l)

implement single-/double-shift version of QZ method for finding generalized eigenvalues w=(ALPHAR + i*ALPHAI)/BETAR of equation det( - w B ) = 0 In addition ...

dhsein(l)

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

dhseqr(l)

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

disnan(l)

.TRUE

dlabad(l)

take as 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)

reduce 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)

1-norm of square, real matrix

dlacon(l)

estimate 1-norm of square, real matrix

dlacpy(l)

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

dladiv(l)

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

dlae2(l)

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

dlaebz(l)

contain 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)

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

dlaed1(l)

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

dlaed2(l)

merge two sets of eigenvalues together into single sorted set

dlaed3(l)

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

dlaed4(l)

subroutine computes 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 computes I-th eigenvalue of symmetric rank-one modification of 2-by-2 diagonal matrix diag + RHO * Z * transpose

dlaed6(l)

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

dlaed7(l)

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

dlaed8(l)

merge two sets of eigenvalues together into single sorted set

dlaed9(l)

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

dlaeda(l)

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

dlaein(l)

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

dlaev2(l)

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

dlaexc(l)

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

dlag2(l)

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

dlags2(l)

compute 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)

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

dlagtm(l)

perform 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)

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

dlahqr(l)

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

dlahrd(l)

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

dlaic1(l)

applie one step of incremental condition estimation in its simplest version

dlaisnan(l)

i not for general use

dlaln2(l)

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

dlals0(l)

applie 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)

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

dlalsd(l)

use 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)

determine double precision machine parameters

dlamrg(l)

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

dlaneg(l)

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

dlangb(l)

return 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)

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

dlangt(l)

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

dlanhs(l)

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

dlansb(l)

return 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

dlansp(l)

return 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)

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

dlansy(l)

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

dlantb(l)

return 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)

return 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)

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

dlanv2(l)

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

dlapll(l)

two column vectors X and Y, let =

dlapmt(l)

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

dlapy2(l)

return sqrt, taking care not to cause unnecessary overflow

dlapy3(l)

return sqrt, taking care not to cause unnecessary overflow

dlaqgb(l)

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

dlaqge(l)

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

dlaqp2(l)

compute QR factorization with column pivoting of block

dlaqps(l)

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

dlaqr0(l)

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 Z is ...

dlaqr1(l)

dlaqr2(l)

dlaqr3(l)

dlaqr4(l)

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 Z is ...

dlaqr5(l)

dlaqsb(l)

equilibrate symmetric band matrix using scaling factors in vector S

dlaqsp(l)

equilibrate symmetric matrix using scaling factors in vector S

dlaqsy(l)

equilibrate symmetric matrix using scaling factors in vector S

dlaqtr(l)

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

dlar1v(l)

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

dlar2v(l)

applie 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)

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

dlarfb(l)

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

dlarfg(l)

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

dlarft(l)

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

dlarfx(l)

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

dlargv(l)

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

dlarnv(l)

return 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 locate 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)

eigenvalues of symmetric tridiagonal matrix T to suitable accuracy

dlarre(l)

sigma_i I = L_i D_i L_i^T representations/eigenvalues of each L_i D_i L_i^T

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)

one eigenvalue of symmetric tridiagonal matrix T to suitable accuracy

dlarrr(l)

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

dlarrv(l)

compute eigenvectors of tridiagonal matrix T = L D L^T given L, D and eigenvalues of L D L^T

dlartg(l)

make plane rotation so that [ CS SN ]

dlartv(l)

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

dlaruv(l)

return vector of n random real numbers from uniform

dlarz(l)

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

dlarzb(l)

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

dlarzt(l)

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

dlas2(l)

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

dlascl(l)

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

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)

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

dlasd2(l)

merge two sets of singular values together into single sorted set

dlasd3(l)

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

dlasd4(l)

subroutine computes 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 computes square root of I-th eigenvalue of positive symmetric rank-one modification of 2-by-2 diagonal matrix diag * diag + RHO * Z * transpose

dlasd6(l)

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

dlasd7(l)

merge two sets of singular values together into single sorted set

dlasd8(l)

find 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)

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

dlasdt(l)

create tree of subproblems for bidiagonal divide/conquer

dlaset(l)

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

dlasq1(l)

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

dlasq2(l)

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

dlasq3(l)

check for deflation, computes shift and calls dqds

dlasq4(l)

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

dlasq5(l)

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

dlasq6(l)

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

dlasr(l)

perform transformation := P*, when SIDE = 'L' or 'l' := *P', when SIDE = 'R' or 'r' where is m by n real matrix and P is orthogonal matrix

dlasrt(l)

numbers in D in increasing order/in decreasing order

dlassq(l)

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

dlasv2(l)

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

dlaswp(l)

perform series of row interchanges on matrix

dlasy2(l)

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

dlasyf(l)

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

dlatbs(l)

solve 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)

use 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)

solve 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)

reduce 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)

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

dlatrz(l)

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

dlatzm(l)

routine is deprecated/has been replaced by routine DORMRZ

dlauu2(l)

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

dlauum(l)

compute 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)

make 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)

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

dorg2l(l)

make m by n real matrix Q with orthonormal columns

dorg2r(l)

make m by n real matrix Q with orthonormal columns

dorgbr(l)

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

dorghr(l)

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

dorgl2(l)

make m by n real matrix Q with orthonormal rows

dorglq(l)

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

dorgql(l)

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

dorgqr(l)

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

dorgr2(l)

make m by n real matrix Q with orthonormal rows

dorgrq(l)

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

dorgtr(l)

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

dorm2l(l)

overwrite 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)

overwrite 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)

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

dorml2(l)

overwrite 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)

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

dormql(l)

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

dormqr(l)

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

dormr2(l)

overwrite 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)

overwrite 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)

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

dormrz(l)

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

dormtr(l)

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

dpbcon(l)

estimate 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)

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

dpbrfs(l)

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

dpbstf(l)

compute split Cholesky factorization of real symmetric positive definite band matrix

dpbsv(l)

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

dpbsvx(l)

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

dpbtf2(l)

compute Cholesky factorization of real symmetric positive definite band matrix

dpbtrf(l)

compute Cholesky factorization of real symmetric positive definite band matrix

dpbtrs(l)

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

dpocon(l)

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

dpoequ(l)

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

dporfs(l)

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

dposv(l)

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

dposvx(l)

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

dpotf2(l)

compute Cholesky factorization of real symmetric positive definite matrix

dpotrf(l)

compute Cholesky factorization of real symmetric positive definite matrix

dpotri(l)

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

dpotrs(l)

solve 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)

estimate 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)

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

dpprfs(l)

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

dppsv(l)

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

dppsvx(l)

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

dpptrf(l)

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

dpptri(l)

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

dpptrs(l)

solve 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 ...

dptcon(l)

compute 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)

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

dptrfs(l)

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

dptsv(l)

compute 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)

use 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)

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

dpttrs(l)

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

dptts2(l)

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

drot(l)

plane rotation

drotg(l)

given plane rotation

drotm(l)

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

drotmg(l)

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

drscl(l)

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

dsbev(l)

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

dsbevd(l)

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

dsbevx(l)

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

dsbgst(l)

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

dsbgv(l)

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

dsbgvd(l)

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

dsbgvx(l)

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

dsbmv(l)

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

dsbtrd(l)

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

dscal(l)

vector by constant

dsdot(l)

and result

dsecnd(l)

return 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

dspcon(l)

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

dspev(l)

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

dspevd(l)

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

dspevx(l)

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

dspgst(l)

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

dspgv(l)

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

dspgvd(l)

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

dspgvx(l)

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

dspmv(l)

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

dspr(l)

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

dspr2(l)

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

dsprfs(l)

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

dspsv(l)

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

dspsvx(l)

use 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)

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

dsptrf(l)

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

dsptri(l)

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

dsptrs(l)

solve 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)

compute eigenvalues of symmetric tridiagonal matrix T

dstedc(l)

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

dstegr(l)

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

dstein(l)

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

dstemr(l)

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

dsteqr(l)

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

dsterf(l)

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

dstev(l)

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

dstevd(l)

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

dstevr(l)

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

dstevx(l)

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

dswap(l)

two vectors

dsycon(l)

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

dsyev(l)

compute all eigenvalues and, , eigenvectors of real symmetric matrix

dsyevd(l)

compute all eigenvalues and, , eigenvectors of real symmetric matrix

dsyevr(l)

compute selected eigenvalues and, , eigenvectors of real symmetric matrix T

dsyevx(l)

compute selected eigenvalues and, , eigenvectors of real symmetric matrix

dsygs2(l)

reduce real symmetric-definite generalized eigenproblem to standard form

dsygst(l)

reduce real symmetric-definite generalized eigenproblem to standard form

dsygv(l)

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

dsygvd(l)

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

dsygvx(l)

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

dsymm(l)

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

dsymv(l)

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

dsyr(l)

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

dsyr2(l)

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

dsyr2k(l)

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

dsyrfs(l)

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

dsyrk(l)

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

dsysv(l)

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

dsysvx(l)

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

dsytd2(l)

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

dsytf2(l)

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

dsytrd(l)

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

dsytrf(l)

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

dsytri(l)

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

dsytrs(l)

solve 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)

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

dtbmv(l)

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

dtbrfs(l)

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

dtbsv(l)

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

dtbtrs(l)

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

dtgevc(l)

compute some/all of right/left generalized eigenvectors of pair of real upper triangular matrices

dtgex2(l)

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

dtgexc(l)

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

dtgsen(l)

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

dtgsja(l)

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

dtgsna(l)

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

dtgsy2(l)

solve generalized Sylvester equation

dtgsyl(l)

solve generalized Sylvester equation

dtpcon(l)

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

dtpmv(l)

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

dtprfs(l)

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

dtpsv(l)

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

dtptri(l)

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

dtptrs(l)

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

dtrcon(l)

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

dtrevc(l)

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

dtrexc(l)

reorder 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)

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

dtrmv(l)

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

dtrrfs(l)

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

dtrsen(l)

reorder 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)

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

dtrsna(l)

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

dtrsv(l)

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

dtrsyl(l)

solve real Sylvester matrix equation

dtrti2(l)

compute inverse of real upper/lower triangular matrix

dtrtri(l)

compute inverse of real upper/lower triangular matrix

dtrtrs(l)

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

dtzrqf(l)

routine is deprecated/has been replaced by routine DTZRZF

dtzrzf(l)

reduce 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)

sum of absolute values

dznrm2(l)

This version written on 25-October-1982

dzsum1(l)

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

icamax(l)

index of element having max

icmax1(l)

find index of element whose real part has maximum absolute value

idamax(l)

index of element having max

ieeeck(l)

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

ilaenv(l)

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

ilaver(l)

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

intro_blas1(l)

Introduction to vector-vector linear algebra subprograms

iparmq(l)

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

isamax(l)

index of element having max

izamax(l)

index of element having max

izmax1(l)

find index of element whose real part has maximum absolute value

lapack(l)

lsame(l)

return .TRUE

lsamen(l)

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

lsametst(l)

plasticfs_chroot(l)

change root of file system

plasticfs_dos(l)

DOS-like file system

plasticfs_downcase(l)

lower-case file system

plasticfs_log(l)

log file system accesses

plasticfs_nocase(l)

case-insensitive file system

plasticfs_shortname(l)

shorten file names

plasticfs_smartlink(l)

smart symbolic link filter

plasticfs_titlecase(l)

capitalized file system

plasticfs_upcase(l)

upper-case file system

plasticfs_viewpath(l)

viewpath union file system

sasum(l)

sum of absolute values

saxpy(l)

constant times vector plus vector

sbdsdc(l)

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

sbdsqr(l)

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

scabs1(l)

absolute value of complex number

scasum(l)

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

scnrm2(l)

This version written on 25-October-1982

scopy(l)

vector, x, to vector, y

scsum1(l)

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

sdisna(l)

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

sdot(l)

dot product of two vectors

sdsdot(l)

second(l)

return 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

sgbbrd(l)

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

sgbcon(l)

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

sgbequ(l)

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

sgbmv(l)

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

sgbrfs(l)

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

sgbsv(l)

compute 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)

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

sgbtf2(l)

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

sgbtrf(l)

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

sgbtrs(l)

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

sgebak(l)

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

sgebal(l)

balance general real matrix

sgebd2(l)

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

sgebrd(l)

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

sgecon(l)

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

sgeequ(l)

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

sgees(l)

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

sgeesx(l)

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

sgeev(l)

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

sgeevx(l)

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

sgegs(l)

routine is deprecated/has been replaced by routine SGGES

sgegv(l)

routine is deprecated/has been replaced by routine SGGEV

sgehd2(l)

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

sgehrd(l)

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

sgelq2(l)

compute LQ factorization of real m by n matrix

sgelqf(l)

compute LQ factorization of real M-by-N matrix

sgels(l)

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

sgelsd(l)

compute minimum-norm solution to real linear least squares problem

sgelss(l)

compute minimum norm solution to real linear least squares problem

sgelsx(l)

routine is deprecated/has been replaced by routine SGELSY

sgelsy(l)

compute minimum-norm solution to real linear least squares problem

sgemm(l)

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

sgemv(l)

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

sgeql2(l)

compute QL factorization of real m by n matrix

sgeqlf(l)

compute QL factorization of real M-by-N matrix

sgeqp3(l)

compute QR factorization with column pivoting of matrix

sgeqpf(l)

routine is deprecated/has been replaced by routine SGEQP3

sgeqr2(l)

compute QR factorization of real m by n matrix

sgeqrf(l)

compute QR factorization of real M-by-N matrix

sger(l)

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

sgerfs(l)

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

sgerq2(l)

compute RQ factorization of real m by n matrix

sgerqf(l)

compute RQ factorization of real M-by-N matrix

sgesc2(l)

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

sgesdd(l)

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

sgesv(l)

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

sgesvd(l)

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

sgesvx(l)

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

sgetc2(l)

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

sgetf2(l)

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

sgetrf(l)

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

sgetri(l)

compute inverse of matrix using LU factorization computed by SGETRF

sgetrs(l)

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

sggbak(l)

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

sggbal(l)

balance pair of general real matrices

sgges(l)

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

sggesx(l)

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

sggev(l)

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

sggevx(l)

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

sggglm(l)

solve general Gauss-Markov linear model problem

sgghrd(l)

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

sgglse(l)

solve linear equality-constrained least squares problem

sggqrf(l)

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

sggrqf(l)

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

sggsvd(l)

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

sggsvp(l)

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

sgtcon(l)

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

sgtrfs(l)

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

sgtsv(l)

solve equation *X = B

sgtsvx(l)

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

sgttrf(l)

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

sgttrs(l)

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

sgtts2(l)

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

shgeqz(l)

implement single-/double-shift version of QZ method for finding generalized eigenvalues w=(ALPHAR + i*ALPHAI)/BETAR of equation det( - w B ) = 0 In addition ...

shsein(l)

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

shseqr(l)

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

sisnan(l)

.TRUE

slabad(l)

take as 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)

reduce 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)

1-norm of square, real matrix

slacon(l)

estimate 1-norm of square, real matrix

slacpy(l)

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

sladiv(l)

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

slae2(l)

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

slaebz(l)

contain 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)

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

slaed1(l)

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

slaed2(l)

merge two sets of eigenvalues together into single sorted set

slaed3(l)

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

slaed4(l)

subroutine computes 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 computes I-th eigenvalue of symmetric rank-one modification of 2-by-2 diagonal matrix diag + RHO * Z * transpose

slaed6(l)

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

slaed7(l)

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

slaed8(l)

merge two sets of eigenvalues together into single sorted set

slaed9(l)

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

slaeda(l)

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

slaein(l)

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

slaev2(l)

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

slaexc(l)

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

slag2(l)

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

slags2(l)

compute 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)

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

slagtm(l)

perform 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)

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

slahqr(l)

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

slahrd(l)

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

slaic1(l)

applie one step of incremental condition estimation in its simplest version

slaisnan(l)

i not for general use

slaln2(l)

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

slals0(l)

applie 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)

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

slalsd(l)

use 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)

determine single precision machine parameters

slamrg(l)

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

slaneg(l)

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

slangb(l)

return 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)

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

slangt(l)

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

slanhs(l)

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

slansb(l)

return 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

slansp(l)

return 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)

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

slansy(l)

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

slantb(l)

return 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)

return 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)

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

slanv2(l)

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

slapll(l)

two column vectors X and Y, let =

slapmt(l)

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

slapy2(l)

return sqrt, taking care not to cause unnecessary overflow

slapy3(l)

return sqrt, taking care not to cause unnecessary overflow

slaqgb(l)

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

slaqge(l)

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

slaqp2(l)

compute QR factorization with column pivoting of block

slaqps(l)

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

slaqr0(l)

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 Z is ...

slaqr1(l)

slaqr2(l)

slaqr3(l)

slaqr4(l)

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 Z is ...

slaqr5(l)

slaqsb(l)

equilibrate symmetric band matrix using scaling factors in vector S

slaqsp(l)

equilibrate symmetric matrix using scaling factors in vector S

slaqsy(l)

equilibrate symmetric matrix using scaling factors in vector S

slaqtr(l)

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

slar1v(l)

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

slar2v(l)

applie 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)

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

slarfb(l)

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

slarfg(l)

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

slarft(l)

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

slarfx(l)

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

slargv(l)

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

slarnv(l)

return 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 locate 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)

eigenvalues of symmetric tridiagonal matrix T to suitable accuracy

slarre(l)

sigma_i I = L_i D_i L_i^T representations/eigenvalues of each L_i D_i L_i^T

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)

one eigenvalue of symmetric tridiagonal matrix T to suitable accuracy

slarrr(l)

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

slarrv(l)

compute eigenvectors of tridiagonal matrix T = L D L^T given L, D and eigenvalues of L D L^T

slartg(l)

make plane rotation so that [ CS SN ]

slartv(l)

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

slaruv(l)

return vector of n random real numbers from uniform

slarz(l)

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

slarzb(l)

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

slarzt(l)

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

slas2(l)

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

slascl(l)

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

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)

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

slasd2(l)

merge two sets of singular values together into single sorted set

slasd3(l)

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

slasd4(l)

subroutine computes 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 computes square root of I-th eigenvalue of positive symmetric rank-one modification of 2-by-2 diagonal matrix diag * diag + RHO * Z * transpose

slasd6(l)

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

slasd7(l)

merge two sets of singular values together into single sorted set

slasd8(l)

find 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)

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

slasdt(l)

create tree of subproblems for bidiagonal divide/conquer

slaset(l)

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

slasq1(l)

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

slasq2(l)

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

slasq3(l)

check for deflation, computes shift and calls dqds

slasq4(l)

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

slasq5(l)

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

slasq6(l)

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

slasr(l)

perform transformation := P*, when SIDE = 'L' or 'l' := *P', when SIDE = 'R' or 'r' where is m by n real matrix and P is orthogonal matrix

slasrt(l)

numbers in D in increasing order/in decreasing order

slassq(l)

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

slasv2(l)

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

slaswp(l)

perform series of row interchanges on matrix

slasy2(l)

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

slasyf(l)

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

slatbs(l)

solve 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)

use 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)

solve 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)

reduce 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)

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

slatrz(l)

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

slatzm(l)

routine is deprecated/has been replaced by routine SORMRZ

slauu2(l)

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

slauum(l)

compute 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)

euclidean norm of vector via function name, so that SNRM2 := sqrt

sopgtr(l)

make 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)

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

sorg2l(l)

make m by n real matrix Q