The UTL_NLA
package exposes a subset of the BLAS and LAPACK (Version 3.0) operations on vectors and matrices represented as VARRAY
s.
This chapter contains the following topics:
The UTL_NLA
package exposes a subset of the BLAS (Basic Linear Algebra Subprograms) and LAPACK (Linear Algebra PACKage) (Version 3.0) operations on vectors and matrices represented as VARRAY
s.
Standards
For more information on the BLAS and LAPACK standards see
Required Expertise
Users of this package are expected to have a sound grasp of linear algebra in general and of the BLAS and LAPACK libraries in particular.
Implementation
The mapping between BLAS and LAPACK procedures and their corresponding PL/SQL calls is onetoone.
All BLAS functions have the BLAS_
prefix (for example, the BLAS_ASUM Functions). The subroutines and functions in BLAS are mapped to PL/SQL procedures and functions, respectively.
All LAPACK functions have the LAPACK_
prefix (for example, the LAPACK_GBSV Procedures). The subroutines in LAPACK are mapped to PL/SQL procedures. Procedures that perform the same operation but differ only on the datatype of the arguments have the same overloaded names.
The mapping between BLAS and LAPACK procedure parameters and those of their corresponding PL/SQL subprograms is almost onetoone.
Also in the PL/SQL interface for LAPACK, all /work/
arguments have been removed. The UTL_NLA
package manages the allocation and deallocation of all work areas required by the libraries.
A new optional parameter, pack
, has been added to the end of each LAPACK procedure that specifies if the matrix has been linearized in the rowmajor or columnmajor (default) format.
Vectors and matrices are stored in VARRAY
s with a maximum size of one million entries. Given this restriction, UTL_NLA
vectors can be up to one million entries but matrices need to be of size RxC <= 1,000,000.
The UTL_NLA
package is owned by user SYS
and is installed as part of database installation. Execution privilege on the package is granted to public. The routines in the package are run with invokers' rights (run with the privileges of the current user).
The UTL_NLA
package contains subprogram groups for BLAS and LAPACK operations.
This table lists and briefly describes the UTL_NLA BLAS Level 1 VectorVector Operations subprograms.
Table 2691 BLAS Level 1 (VectorVector Operations) Subprograms
Subprogram  Description 

Computes the sum of the absolute values of the vector components 

Copies 

Copies the contents of vector 

Returns the dot (scalar) product of two vectors 

Computes the index of the first element of a vector that has the largest absolute value 

Computes the vector 2norm (Euclidean norm) 

Returns the plane rotation of points 

Returns the Givens rotation of points 

Scales a vector by a constant 

Swaps the contents of two vectors each of size n 
This table lists and briefly describes the UTL_NLA BLAS Level 2 MatrixVector Operations subprograms.
Table 2692 BLAS Level 2 (MatrixVector Operations) Subprograms
Subprogram  Description 

Performs the matrixvector operation 

Performs the matrixvector operations 

Performs a rank 1 operation 

Performs a matrixvector operation 

Performs a matrixvector operation 

Performs a symmetric rank 1 operation 

Performs a symmetric rank 2 operation 

Performs a matrixvector operation 

Performs a matrixvector operation 

Performs a symmetric rank 1 operation 

Performs a symmetric rank 2 operation 

Performs a matrixvector operation 

Solves one of the systems of equation 

Performs a matrixvector operation 

Solves one of the systems of equation 

Performs a matrixvector operation 

Solves one of the systems of equation 
This table lists and briefly describes the UTL_NLA BLAS Level 3 MatrixMatrix Operations subprograms.
Table 2693 BLAS Level 3 (MatrixMatrix Operations) Subprograms
Subprogram  Description 

Performs one of the matrixvector operations 

Performs one of the matrixvector operations 

Performs one of the symmetric rank2 k operations 

Performs one of the symmetric rank 

Performs one of the matrixvector operations 

Performs one of the matrixvector operations 
This table lists and briefly describes the LAPACK Driver Routines (Linear Equations) subprograms.
Table 2694 LAPACK Driver Routines (Linear Equations) Subprograms
Subprogram  Description 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure solves the equation 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 
This table lists and briefly describes the LAPACK Driver Routines (LLS and Eigenvalue) subprograms.
Table 2695 LAPACK Driver Routines (LLS and Eigenvalue Problems)
Subprogram  Description 

Computes for an 

Computes for an 

Solves overdetermined or underdetermined real linear systems involving an 

Computes the singular value decomposition (SVD) of a real 

Computes the singular value decomposition (SVD) of a real 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix 

Ccomputes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix 

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix 

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 
This table lists the UTL_NLA
subprograms and briefly describes them.
Table 2696 UTL_NLA Package Subprograms
Subprogram  Description  Group 

Computes the sum of the absolute values of the vector components 

Copies 

Copies the contents of vector 

Returns the dot (scalar) product of two vectors 

Performs the matrixvector operation 

Performs one of the matrixvector operations where 

Performs the matrixvector operations 

Performs a rank 1 operation 

Computes the index of the first element of a vector that has the largest absolute value 

Computes the vector 2norm (Euclidean norm) 

Returns the plane rotation of points 

Returns the Givens rotation of points 

Performs a matrixvector operation 

Scales a vector by a constant 

Performs a matrixvector operation 

Performs a symmetric rank 1 operation 

Performs a symmetric rank 2 operation where 

Swaps the contents of two vectors each of size n 

Performs one of the matrixvector operations where 

Performs a matrixvector operation where 

Performs a symmetric rank 1 operation where 

Performs a symmetric rank 2 operation where 

Performs one of the symmetric rank2 k operations where 

Performs one of the symmetric rank 

Performs a matrixvector operation where 

Solves one of the systems of equation where 

Performs a matrixvector operation where 

Solves one of the systems of equation where 

Performs one of the matrixvector operations where 

Performs a matrixvector operation where 

Performs one of the matrixvector operations 

Solves one of the systems of equation where 

This procedure computes the solution to a real system of linear equations 

Computes for an 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes for an 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Solves overdetermined or underdetermined real linear systems involving an 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes the singular value decomposition (SVD) of a real 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

This procedure computes the solution to a real system of linear equations 

Computes the singular value decomposition (SVD) of a real 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

This procedure solves the equation 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

This procedure computes the solution to a real system of linear equations 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

This procedure computes the solution to a real system of linear equations 

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

Computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix 
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms 

This procedure computes the solution to a real system of linear equations 
This procedure computes the sum of the absolute values of the vector components.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_ASUM ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN) RETURN BINARY_DOUBLE;
UTL_NLA.BLAS_ASUM ( n IN POSITIVEN, alpha IN SCALAR_DOUBLE, x IN UTL_NLA_ARRAY_FLT) RETURN BINARY_FLOAT
Parameters
Table 2697 BLAS_ASUM Function Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 
This procedure copies alpha
*X
+ Y
into vector Y
.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_AXPY ( n IN POSITIVEN, alpha IN SCALAR_DOUBLE, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN);
UTL_NLA.BLAS_AXPY ( n IN POSITIVEN, alpha IN SCALAR_DOUBLE, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN);
Parameters
Table 2698 BLAS_AXPY Procedure Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

Specifies the scalar alpha. 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 

( 1 + ( n  1 )*abs( incy) ) 

Specifies the increment for the elements of 
This procedure copies the contents of vector X
to vector Y
.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_COPY ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN);
UTL_NLA.BLAS_COPY ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN);
Parameters
Table 2699 BLAS_COPY Procedure Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 

( 1 + ( n  1 )*abs( incy) ) 

Specifies the increment for the elements of 
This function returns the dot (scalar) product of two vectors X
and Y
.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_DOT ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_DBL, incy IN POSITIVEN) RETURN BINARY_DOUBLE;
UTL_NLA.BLAS_DOT ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_FLT, incy IN POSITIVEN) RETURN BINARY_FLOAT;
Parameters
Table 26910 BLAS_DOT Function Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 

( 1 + ( n  1 )*abs( incy) ) 

Specifies the increment for the elements of 
This procedure performs one of the matrixvector operations y := alpha*A*x + beta*y
or y := alpha*A'*x + beta*y
, where alpha
and beta
are scalars, x
and y
are vectors and A
is an m
by n
band matrix, with kl
subdiagonals and ku
superdiagonals.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_GBMV ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, kl IN NATURALN, ku IN NATURALN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, beta IN SCALAR_DOUBLE, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_GBMV ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, kl IN NATURALN, ku IN NATURALN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, beta IN SCALAR_FLOAT, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26911 BLAS_GBMV Procedure Parameters
Parameter  Description 


Specifies the operation to be performed:


Specifies the number of rows of the matrix A. 

Specifies the number of columns of the matrix A. 

Specifies the number of subdiagonals of the matrix 
ku 
Specifies the number of superdiagonals of the matrix 



Before entry, the leading Elements in the array 

Specifies the first dimension of 

( 1 + ( n  1 )*abs( incx ) ) when ( 1 + ( m  1 )*abs( incx ) ) otherwise. Before entry, the incremented array 

Specifies the increment for the elements of 



( 1 + ( m  1 )*abs( incy ) ) when (1+(n1)*abs(incy)) otherwise. Before entry with 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure performs one of the matrixmatrix operations.
C := alpha*op( A )*op( B ) + beta*C
where op(X)
is one of
op(X) = X
or
op(X) = X'
where alpha
and beta
are scalars, and A
, B
and C
are matrices, with op(A)
an m
by k
matrix, op(B)
a k
by n
matrix and C
an m
by n
matrix.
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_GEMM ( transa IN flag, transb IN flag, m IN POSITIVEN, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, beta IN SCALAR_DOUBLE, c IN OUT UTL_NLA_ARRAY_DBL, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_GEMM ( transa IN flag, transb IN flag, m IN POSITIVEN, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, beta IN SCALAR_FLOAT, c IN OUT UTL_NLA_ARRAY_FLT, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26912 BLAS_GEMM Procedure Parameters
Parameter  Description 


Specifies the form of


Specifies the form of


Specifies the number of rows of the matrix 

Specifies the number of columns of the matrix 
k 
Specifies the rows of the matrix 





Specifies the first dimension of 



Specifies the first dimension of 


c 


Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs one of the matrixvector operations: y := alpha*A*x + beta*y
or y := alpha*A'*x + beta*y
where alpha
and beta
are scalars, x
and y
are vectors and A
is an m
by n
matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_GEMV ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, beta IN SCALAR_DOUBLE, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_GEMV ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, beta IN SCALAR_FLOAT, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26913 BLAS_GEMV Procedure Parameters
Parameter  Description 


Specifies the operation to be performed:


Specifies the number of rows of the matrix A. 

Specifies the number of columns of the matrix A. 





Specifies the first dimension of 

( 1 + ( n  1 )*abs( incx ) ) when (1+(m1)*abs(incx)) otherwise. Before entry, the incremented array 

Specifies the increment for the elements of 



( 1 + ( m  1 )*abs( incy ) ) when ( 1 + ( n  1 )*abs( incy ) ) otherwise. Before entry with 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure performs the rank 1 operation: A := alpha*x*y' + A
where alpha
is a scalar, x
is an m
element vector, y
is an n element vector and A
is an m
by n
matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_GER ( m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_DBL, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_GER ( m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_FLT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26914 BLAS_GER Procedure Parameters
Parameter  Description 


Specifies the number of rows of the matrix 

Specifies the number of columns of the matrix 

Specifies the scalar alpha. 

( 1 + ( m  1 )*abs( incx ) ) Before entry, the incremented array 

Specifies the increment for the elements of 

( 1 + ( n  1 )*abs( incy ) ) Before entry, the incremented array 

Specifies the increment for the elements of 

Before entry, the leading 

Specifies the first dimension of max( 1, m ) 

(Optional) Flags the packing of the matrices:

This function computes the index of first element of a vector that has the largest absolute value.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_IAMAX ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, RETURN POSITIVEN;
UTL_NLA.BLAS_IAMAX ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, RETURN POSITIVEN;
Parameters
Table 26915 BLAS_IAMAX Function Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 
This function computes the vector 2norm (Euclidean norm).
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_NRM2 ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN) RETURN BINARY_DOUBLE;
UTL_NLA.BLAS_NRM2 ( n IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN) RETURN BINARY_FLOAT;
Parameters
Table 26916 BLAS_NRM2 Function Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

( 1 + ( n  1 )*abs( incx ) ) 

Specifies the increment for the elements of 
This procedure returns the plane rotation of points.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_ROT ( n IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, c IN SCALAR_DOUBLE, s IN SCALAR_DOUBLE);
UTL_NLA.BLAS_ROT ( n IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, c IN SCALAR_DOUBLE, s IN SCALAR_DOUBLE);
Parameters
Table 26917 BLAS_ROT Procedure Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

(1+(n1)* abs(incx)) 

Specifies the increment for the elements of 

(1+(n1)*abs(incy)) 

Specifies the increment for the elements of 




This procedure returns the Givens rotation of points.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_ROTG ( a IN OUT SCALAR_DOUBLE, b IN OUT SCALAR_DOUBLE, c IN OUT SCALAR_DOUBLE, s IN OUT SCALAR_DOUBLE);
UTL_NLA.BLAS_ROTG ( a IN OUT SCALAR_FLOAT, b IN OUT SCALAR_FLOAT, c IN OUT SCALAR_FLOAT, s IN OUT SCALAR_FLOAT);
Parameters
Table 26918 BLAS_ROTG Procedure Parameters
Parameter  Description 









This procedure scales a vector by a constant.
See Also:
BLAS Level 1 (VectorVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SCAL ( n IN POSITIVEN, alpha IN SCALAR_DOUBLE, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN);
UTL_NLA.BLAS_SCAL ( n IN POSITIVEN, alpha IN SCALAR_FLOAT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN);
Parameters
Table 26919 BLAS_SCAL Procedure Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

Specifies the scalar alpha. 

(1+(n1)*abs(incx)) 

Specifies the increment for the elements of 
This procedure performs the matrixvector operation y := alpha*A*x + beta*y
, where alpha
and beta
are scalars, x
and y
are n element vectors and A
is an n
by n
symmetric matrix, supplied in packed form.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SPMV ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, ap IN UTL_NLA_ARRAY_DBL, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, beta IN SCALAR_DOUBLE, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SPMV ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLOAT, ap IN UTL_NLA_ARRAY_FLT, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, beta IN SCALAR_FLOAT, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26920 BLAS_SPMV Procedure Parameters
Parameter  Description 


Specifies the upper or lower triangular part of the matrix A is supplied in the packed array


Specifies the order of the matrix 



((n*(n+1))/2) Before entry with Before entry with 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 



(1+(n1)*abs(incy)) Before entry, the incremented array 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure performs the rank 1 operation A := alpha*x*x' + A
, where alpha
is a real scalar, x
is an n
element vector, and A
is an n
by n
symmetric matrix, supplied in packed form.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SPR ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DBL, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_DBL, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SPR ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_FLT, pack IN flag DEFAULT 'C');
Parameters
Table 26921 BLAS_SPR Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the matrix


Specifies the order of the matrix 

Specifies the scalar alpha. 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 

((n*(n +1))/2) Before entry with Before entry with 

(Optional) Flags the packing of the matrices:

This procedure performs the rank 2 operation A := alpha*x*y' + alpha*y*x' +A
, where alpha
is a scalar, x
and y
are n
element vectors, and A
is an n
by n
symmetric matrix, supplied in packed form.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SPR2 ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DBL, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SPR2 ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLT, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26922 BLAS_SPR2 Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the matrix


Specifies the order of the matrix 

Specifies the scalar alpha. 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 

(1+(n1)*abs(incy)) Before entry, the incremented array 

Specifies the increment for the elements of 

((n*(n+1))/2) Before entry with Before entry with 

Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs the matrixvector operation y := alpha*A*x + beta*y
, where alpha
and beta
are scalars, x
and y
are n element vectors and A
is an n
by n
symmetric band matrix, with k
superdiagonals.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SBMV ( uplo IN flag, n IN POSITIVEN, k IN NATURALN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, beta IN SCALAR_DOUBLE, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SBMV ( uplo IN flag, n IN POSITIVEN, k IN NATURALN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, beta IN SCALAR_FLOAT, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26923 BLAS_SBMV Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the band matrix


Specifies the order of the matrix 

Specifies the number of superdiagonals of the matrix 



Before entry with Before entry with Unchanged on exit 

Specifies the first dimension of 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 



(1+(n1)*abs(incy)) Before entry, the incremented array 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure swaps the contents of two vectors each of size n.
Syntax
UTL_NLA.BLAS_SWAP ( n IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN);
UTL_NLA.BLAS_SWAP ( n IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN);
Parameters
Table 26924 BLAS_SWAP Procedure Parameters
Parameter  Description 


Specifies the number of elements of the vectors 

(1+(n1)*abs(incx)) 

Specifies the increment for the elements of 

(1+(n1)*abs(incy)) 

Specifies the increment for the elements of 
This procedure performs one of the matrixmatrix operations C := alpha*A*B + beta*C
or C := alpha*B*A + beta*C
, where alpha
and beta
are scalars, A
is a symmetric matrix, and B
and C
are m
by n
matrices.
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYMM ( side IN flag, uplo IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, beta IN SCALAR_DOUBLE, c IN OUT UTL_NLA_ARRAY_DBL, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYMM ( side IN flag, uplo IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, beta IN SCALAR_FLOAT, c IN OUT UTL_NLA_ARRAY_FLT, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26925 BLAS_SYMM Procedure Parameters
Parameter  Description 


Specifies whether the symmetric matrix


Specifies whether the upper or lower triangular part of the array


Specifies the number of rows of the matrix 

Specifies the number of columns of the matrix 



Before entry with Before entry with 

Specifies the first dimension of 

Before entry, the leading 

Specifies the first dimension of 


c 


Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs the matrixvector operation y := alpha*A*x + beta*y
, where alpha
and beta
are scalars, x
and y
are n
element vectors and A
is an n
by n
symmetric matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYMV ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, beta IN SCALAR_DOUBLE, y IN OUT UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYMV ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, beta IN SCALAR_FLOAT, y IN OUT UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26926 BLAS_SYMV Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the array


Specifies the order of the matrix 



Before entry with 

Specifies the first dimension of 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 



(1+(n1)*abs(incy)) Before entry, the incremented array 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure performs the rank 1 operation A := alpha*x*x' + A
, where alpha
is a real scalar, x
is an n
element vector, and A
is an n
by n
symmetric matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYR ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DBL, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYR ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26927 BLAS_SYR Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the array


Specifies the order of the matrix 

Specifies the scalar alpha. 

(1+(n1)*abs(incx)) Before entry, the incremented array 

Specifies the increment for the elements of 

Before entry with Before entry with 

Specifies the first dimension of max( 1, n ) 

(Optional) Flags the packing of the matrices:

This procedure performs the rank 2 operation A := alpha*x*y' + alpha*y*x' + A
, where alpha
is a scalar, x
and y
are n
element vectors, and A
is an n
by n
symmetric matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYR2 ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_DBL, x IN UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_DBL, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYR2 ( uplo IN flag, n IN POSITIVEN, alpha IN SCALAR_FLT, x IN UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, y IN UTL_NLA_ARRAY_FLT, incy IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26928 BLAS_SYR2 Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the array


Specifies the order of the matrix 

Specifies the scalar alpha. 

( 1 + ( n  1 )*abs( incx ) ) Before entry, the incremented array 

Specifies the increment for the elements of 

( 1 + ( n  1 )*abs( incy ) ) Before entry, the incremented array 

Specifies the increment for the elements of 

With With 

Specifies the first dimension of max( 1, n ) 

(Optional) Flags the packing of the matrices:

It performs one of the symmetric rank2 k operations C := alpha*A*B' + alpha*B*A' + beta*C
or C := alpha*A'*B + alpha*B'*A + beta*C
, where alpha
and beta
are scalars, C
is an n
by n
symmetric matrix and A
and B
are n
by k
matrices in the first case and k
by n
matrices in the second case.
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYR2K ( uplo IN flag, trans IN flag, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, beta IN SCALAR_DOUBLE, c IN OUT UTL_NLA_ARRAY_DBL, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYR2K ( uplo IN flag, trans IN flag, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, beta IN SCALAR_FLOAT, c IN OUT UTL_NLA_ARRAY_FLT, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26929 BLAS_SYR2K Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the array


Specifies the operations to be performed:


Specifies the order of matrix 

On entry with 



Before entry with 

Specifies the first dimension of 

Before entry with 

Specifies the first dimension of 


c 
Before entry with Before entry with 

Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs one of the symmetric rank k operations C := alpha*A*A' + beta*C
or C := alpha*A'*A + beta*C
, where alpha
and beta
are scalars, C
is an n
by n
symmetric matrix andA
is an n
by k
matrix in the first case and a k
byn
matrix in the second case.
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_SYRK ( uplo IN flag, trans IN flag, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, beta IN SCALAR_DOUBLE, c IN OUT UTL_NLA_ARRAY_DBL, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_SYRK ( uplo IN flag, trans IN flag, n IN POSITIVEN, k IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, beta IN SCALAR_FLOAT, c IN OUT UTL_NLA_ARRAY_DBL, ldc IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26930 BLAS_SYRK Procedure Parameters
Parameter  Description 


Specifies whether the upper or lower triangular part of the array


Specifies the operations to be performed:


Specifies the order of matrix 

On entry with 



Before entry with 

Specifies the first dimension of 


c 
Before entry with Before entry with 

Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs the matrixvector operations x := A*x
or x := A'*x
, where x
is an n
element vector and A
is an n
by n
unit, or nonunit, upper or lower triangular band matrix, with (k+1)
diagonals.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TBMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, k IN NATURALN, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TBMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, k IN NATURALN, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26931 BLAS_TBMV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the operation to be performed:


Specifies whether or not


Specifies the order of the matrix 

Specifies whether or not
K must satisfy 

Before entry with Before entry with Note that when 

Specifies the first dimension of 



Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure solves one of the systems of equations A*x = b
or A'*x = b
, where b
and x
are n
element vectors and A
is an n
by n unit, or nonunit, upper or lower triangular band matrix, with (k+1)
diagonals.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TBSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, k IN NATURALN, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_STBSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, k IN NATURALN, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26932 BLAS_TBSV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the equations to be solved:


Specifies whether or not


Specifies the order of the matrix 

Specifies whether or not
K must satisfy 

Before entry with Before entry with Note that when 

On entry, 

( 1 + ( n  1 ) *abs( incx ) ) Before entry, the incremented array On exit, 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

Usage Notes
No test for singularity or nearsingularity is included in this routine. Such tests must be performed before calling this routine.
This procedure performs the matrixvector operations x := A*x
or x := A'*x
, where x
is an n
element vector and A
is an n
by n
unit, or nonunit, upper or lower triangular matrix, supplied in packed form.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TPMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, ap IN UTL_NLA_ARRAY_DBL, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TBMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, ap IN UTL_NLA_ARRAY_FLT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26933 BLAS_TPMV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the operation to e performed:


Specifies whether or not


Specifies the order of the matrix 

Before entry with Before entry with Note that when 



Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure solves one of the systems of equations A*x = b
or A'*x = b
, where b
and x
are n
element vectors and A
is an n
by n unit, or nonunit, upper or lower triangular matrix, supplied in packed form.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TPSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, ap IN UTL_NLA_ARRAY_DBL, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TPSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, ap IN UTL_NLA_ARRAY_FLT, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26934 BLAS_TPSV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the operation to be performed:


Specifies whether or not


Specifies the order of the matrix 

((n*(n+1))/2) Before entry with Before entry with Note that when 

( 1 + ( n  1 ) *abs( incx ) ) Before entry, the incremented array 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

Usage Notes
No test for singularity or nearsingularity is included in this routine. Such tests must be performed before calling this routine.
This procedure performs a matrixmatrix operation.
It performs one of the following matrixmatrix operations:
B := alpha*op( A )*B
or
B := alpha*B*op( A )
where alpha
is a scalar, B
is an m
by n
matrix, A
is a unit, or nonunit, upper or lower triangular matrix and op(A)
is one of
op( A ) = A
or
op( A ) = A'
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TRMM ( side IN flag, uplo IN flag, transa IN flag, diag IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TRMM ( side IN flag, uplo IN flag, transa IN flag, diag IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26935 BLAS_TRMM Procedure Parameters
Parameter  Description 


Specifies whether the symmetric matrix


Specifies whether the upper or lower triangular part of the array


Specifies the form of


Specifies whether or not


Specifies the number of rows of the 

Specifies the number of columns of 



Before entry with Before entry with Note that when 

Specifies the first dimension of 

Before entry, the leading 

Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure performs the matrixvector operations x := A*x
or x := A'*x
, where x
is an n
element vector and A
is an n
by n
unit, or nonunit, upper or lower triangular matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TRMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TRMV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26936 BLAS_TRMV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the operation to be performed:


Specifies whether or not


Specifies the order of the matrix 

Before entry with Before entry with Note that when 

Specifies the first dimension of 



Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

This procedure performs a matrixmatrix operation.
It performs one of the matrixmatrix operations:
op( A )*X = alpha*B
or
X*op( A ) = alpha*B
where alpha
is a scalar, X
and B
are m
by n
matrices, A
is a unit, or nonunit, upper or lower triangular matrix and op(A)
is one of
op( A ) = A
or
op( A ) = A'
The matrix X
is overwritten on B
.
See Also:
BLAS Level 3 (MatrixMatrix Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TRSM ( side IN flag, uplo IN flag, transa IN flag, diag IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_DOUBLE, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TRSM ( side IN flag, uplo IN flag, transa IN flag, diag IN flag, m IN POSITIVEN, n IN POSITIVEN, alpha IN SCALAR_FLOAT, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26937 BLAS_TRSM Procedure Parameters
Parameter  Description 


Specifies whether the symmetric matrix


Specifies whether the upper or lower triangular part of the array


Specifies the form of


Specifies whether or not


Specifies the number of rows of the 

Specifies the number of columns of 



Before entry with Before entry with Note that when 

Specifies the first dimension of 

Before entry, the leading 

Specifies the first dimension of 

(Optional) Flags the packing of the matrices:

This procedure solves one of the systems of equations A*x = b
or A'*x = b
, where b
and x
are n
element vectors and A
is an n by n
unit, or nonunit, upper or lower triangular matrix.
See Also:
BLAS Level 2 (MatrixVector Operations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.BLAS_TRSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, a IN UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_DBL, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
UTL_NLA.BLAS_TRSV ( uplo IN flag, trans IN flag, diag IN flag, n IN POSITIVEN, a IN UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, x IN OUT UTL_NLA_ARRAY_FLT, incx IN POSITIVEN, pack IN flag DEFAULT 'C');
Parameters
Table 26938 BLAS_TRSV Procedure Parameters
Parameter  Description 


Specifies whether the matrix is an upper or lower triangular matrix:


Specifies the operation to be performed:


Specifies whether or not


Specifies the order of the matrix 

Before entry with Before entry with Note that when 

Specifies the first dimension of 

(1 + (n  1) * abs (incx)) Before entry, the incremented array 

Specifies the increment for the elements of 

(Optional) Flags the packing of the matrices:

Usage Notes
No test for singularity or nearsingularity is included in this routine. Such tests must be performed before calling this routine.
This procedure computes the solution to a real system of linear equations a * x = b
, where a
is a band matrix of order n
with kl
sub diagonals and ku
superdiagonals, and x
and b
are n
by nrhs
matrices.
The LU
decomposition with partial pivoting and row interchanges is used to factor A
as
a = L * U
where L is a product of permutation and unit lower triangular matrices with kl sub diagonals, and U
is upper triangular with kl+ku
superdiagonals. The factored form of a
is then used to solve the system of equations
a * x = b
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GBSV ( n IN POSITIVEN, kl IN NATURALN, ku IN NATURALN, nrhs IN POSITIVEN, ab IN OUT UTL_NLA_ARRAY_DBL, ldab IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GBSV ( n IN POSITIVEN, kl IN NATURALN, ku IN NATURALN, nrhs IN POSITIVEN, ab IN OUT UTL_NLA_ARRAY_FLT, ldab IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26939 LAPACK_GBSV Procedure Parameters
Parameter  Description 


The number of linear equations, equivalent to the order of the matrix 

The number of sub diagonals within the band of a. 

The number of superdiagonals within the band of 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the matrix a in band storage, in rows
On exit, details of the factorization:


The leading dimension of the array ab.


The pivot indices that define the permutation matrix 

On entry, the On exit, if 

The leading dimension of the array b.




(Optional) Flags the packing of the matrices:

This procedure computes for an n
by n
real nonsymmetric matrix A
, the eigenvalues, the real Schur form T
, and, optionally, the matrix of Schur vectors Z
.
This gives the Schur factorization A = Z*T*(Z**T)
.
A matrix is in real Schur form if it is upper quasitriangular with 1
by 1
and 2
by 2
blocks. 2
by 2
blocks will be standardized in the form
[ a b ]
[ c a ]
where b*c < 0
. The eigenvalues of such a block are a + sqrt(bc)
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GEES ( jobvs IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, wr IN OUT UTL_NLA_ARRAY_DBL, wi IN OUT UTL_NLA_ARRAY_DBL, vs IN OUT UTL_NLA_ARRAY_DBL, ldvs IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GEES ( jobvs IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, wr IN OUT UTL_NLA_ARRAY_FLT, wi IN OUT UTL_NLA_ARRAY_FLT, vs IN OUT UTL_NLA_ARRAY_FLT, ldvs IN POSITIVEN, info OUT integer, pack IN flag DEFAULT 'C');
Parameters
Table 26940 LAPACK_GEES Procedure Parameters
Parameter  Description 




The order of the matrix 
a 


The leading dimension of the array 







The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure solves overdetermined or underdetermined real linear systems involving an m
by n
matrix A
, or its transpose, using a QR
or LQ
factorization of A
. It is assumed that A
has full rank.
The following options are provided:
If TRANS = 'N'
and m >= n
: find the least squares solution of an overdetermined system, that is, solve the least squares problem.
minimize  B  A*X 
If TRANS = 'N'
and m < n
: find the minimum norm solution of an underdetermined system A * X = B
.
If TRANS = 'T'
and m >= n
: find the minimum norm solution of an undetermined system A**T * X = B
.
If TRANS = 'T'
and m < n
: find the least squares solution of an overdetermined system, that is, solve the least squares problem minimize  B  A**T * X 
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GELS ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GELS ( trans IN flag, m IN POSITIVEN, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26941 LAPACK_GELS Procedure Parameters
Parameter  Description 




The number of rows of the matrix 

The number of columns of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the matrix On exit, if 

The leading dimension of the array 

On entry, the matrix On exit,


The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedures computes the singular value decomposition (SVD) of a real m
by n
matrix A
, optionally computing the left and right singular vectors. If singular vectors are desired, it uses a divideandconquer algorithm that makes mild assumptions about floating point arithmetic.
The SVD is written
A = U * SIGMA * transpose(V)
where SIGMA is an m
by n
matrix which is zero except for its min(m,n)
diagonal elements, U
is anm
by m
orthogonal matrix, and V
is ann
by n
orthogonal matrix. The diagonal elements of SIGMA are the singular values of A
, they are real and nonnegative, and are returned in descending order. The first min(m,n)
columns of U
and V
are the left and right singular vectors of A
.
Note that the routine returns V**T
, not V
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GESDD ( jobz IN flag, m IN POSITIVEN, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, s IN OUT UTL_NLA_ARRAY_DBL, u IN OUT UTL_NLA_ARRAY_DBL, ldu IN POSITIVEN, vt IN OUT UTL_NLA_ARRAY_DBL, ldvt IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GESDD ( jobz IN flag, m IN POSITIVEN, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, s IN OUT UTL_NLA_ARRAY_FLT, u IN OUT UTL_NLA_ARRAY_FLT, ldu IN POSITIVEN, vt IN OUT UTL_NLA_ARRAY_FLT, ldvt IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26942 LAPACK_GESDD Procedure Parameters
Parameter  Description 


Specifies options for computing all or part of the matrix


The order of the matrix 

The order of the matrix 

On entry, the On exit:


The leading dimension of the array 

The singular values of 



The leading dimension of the array 



The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
matrix and x
and b
are n
by nrhs
matrices.
The LU
decomposition with partial pivoting and row interchanges is used to factor A
as
a = P * L * U
where P
is a permutation matrix, L
is unit lower triangular, and U
is upper triangular. The factored form of a
is then used to solve the system of equations
a * x = b
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GESV ( n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GESV ( n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26943 LAPACK_GESV Procedure Parameters
Parameter  Description 


The number of linear equations, equivalent to the order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the On exit, the factors 

The leading dimension of the array a.


The pivot indices that define the permutation matrix 

On entry, the On exit, if 

The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedures computes the singular value decomposition (SVD) of a real m
by n
matrix A
, optionally computing the left and/or right singular vectors.
The SVD is written
A = U * SIGMA * transpose(V)
where SIGMA is an m
by n
matrix which is zero except for its min(m,n)
diagonal elements, U
is anm
by m
orthogonal matrix, and V
is ann
by n
orthogonal matrix. The diagonal elements of SIGMA are the singular values of A
, they are real and nonnegative, and are returned in descending order. The first min(m,n)
columns of U
and V
are the left and right singular vectors of A
.
Note that the routine returns V**T
, not V
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GESVD ( jobu IN flag, jobvt IN flag, m IN POSITIVEN, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, s IN OUT UTL_NLA_ARRAY_DBL, u IN OUT UTL_NLA_ARRAY_DBL, ldu IN POSITIVEN, vt IN OUT UTL_NLA_ARRAY_DBL, ldvt IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GESVD ( jobu IN flag, jobvt IN flag, m IN POSITIVEN, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, s IN OUT UTL_NLA_ARRAY_FLT, u IN OUT UTL_NLA_ARRAY_FLT, ldu IN POSITIVEN, vt IN OUT UTL_NLA_ARRAY_FLT, ldvt IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26944 LAPACK_GESVD Procedure Parameters
Parameter  Description 


Specifies options for computing all or part of the matrix


Specifies options for computing all or part of the matrix


The order of the matrix 

The order of the matrix 

On entry, the On exit:


The leading dimension of the array 

The singular values of 



The leading dimension of the array 



The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedures computes for an n
by n
real nonsymmetric matrix A
, the eigenvalues and, optionally, the left and/or right eigenvectors.
The right eigenvector v(j)
of A
satisfies A * v(j) = lambda(j) * v(j)
where lambda(j)
is its eigenvalue.
The left eigenvector u(j)
of A
satisfies u(j)**H * A = lambda(j) * u(j)**H
where u(j)**H
denotes the conjugate transpose of u(j)
.
The computed eigenvectors are normalized to have Euclidean norm equal to 1
and largest component real.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GEEV ( jobvl IN flag, jobvr IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, wr IN OUT UTL_NLA_ARRAY_DBL, wi IN OUT UTL_NLA_ARRAY_DBL, vl IN OUT UTL_NLA_ARRAY_DBL, ldvl IN POSITIVEN, vr IN OUT UTL_NLA_ARRAY_DBL, ldvr IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GEEV ( jobvl IN flag, jobvr IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, wr IN OUT UTL_NLA_ARRAY_FLT, wi IN OUT UTL_NLA_ARRAY_FLT, vl IN OUT UTL_NLA_ARRAY_FLT, ldvl IN POSITIVEN, vr IN OUT UTL_NLA_ARRAY_FLT, ldvr IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26945 LAPACK_GEEV Procedure Parameters
Parameter  Description 






The order of the matrix 



The leading dimension of the array 







The leading dimension of the array 



The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure solves the equation a * x = b
, where a
is an n
by n
tridiagonal matrix, by Gaussian elimination with partial pivoting.
Note that the equation a'*x = b
may be solved by interchanging the order of the arguments du
and dl
.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_GTSV ( n IN POSITIVEN, nrhs IN POSITIVEN, dl IN OUT UTL_NLA_ARRAY_DBL, d IN OUT UTL_NLA_ARRAY_DBL, du IN OUT UTL_NLA_ARRAY_DBL, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_GTSV ( n IN POSITIVEN, nrhs IN POSITIVEN, dl IN OUT UTL_NLA_ARRAY_FLT, d IN OUT UTL_NLA_ARRAY_FLT, du IN OUT UTL_NLA_ARRAY_FLT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26946 LAPACK_GTSV Procedure Parameters
Parameter  Description 


The order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, On exit, 

On entry, On exit, 

On entry, On exit, 

On entry, the On exit, if 

The leading dimension of the array b.




(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
symmetric positive definite band matrix and x
and b
are n
by nrhs
matrices.
The Cholesky decomposition is used to factor A
as
A = U**T*U
if UPLO ='U'
or
A = L * L**T
if UPLO = 'L'
where U
is an upper triangular matrix and L
is a lower triangular matrix. The factored form of A
is then used to solve the system of equations A * X = B
.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_PBSV ( uplo IN flag, n IN POSITIVEN, kd IN NATURALN, nrhs IN POSITIVEN, ab IN OUT UTL_NLA_ARRAY_DBL, ldab IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_PBSV ( uplo IN flag, n IN POSITIVEN, kd IN NATURALN, nrhs IN POSITIVEN, ab IN OUT UTL_NLA_ARRAY_FLT, ldab IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26947 LAPACK_PBSV Procedure Parameters
Parameter  Description 




The number of linear equations, that is, the order of the matrix 

The number of superdiagonals of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the upper or lower triangle of the symmetric band matrix
.See below for further details.On exit, if 

The leading dimension of the array


On entry, the On exit, if 

The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
symmetric positive definite matrix and x
and b
are n
by nrhs
matrices.
The Cholesky decomposition is used to factor A
as
A = U**T* U
if uplo = 'U'
or
A = L * L**T
if UPLO = 'L'
where U
is an upper triangular matrix and L
is a lower triangular matrix. The factored form of A
is then used to solve the system of equations A * X = B
.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_POSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_POSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26948 LAPACK_POSV Procedure Parameters
Parameter  Description 




The number of linear equations, that is, the order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

If If On exit, if 

The leading dimension of the array a.


On entry, the On exit, if 

The leading dimension of the array b.




(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
where a
is an n
by n
symmetric positive definite matrix stored in packed format and x
and b
are n
by nrhs
matrices.
The Cholesky decomposition is used to factor A
as
A = U**T* U
if UPLO = 'U'
or
A = L * L**T
if UPLO = 'L'
where U is an upper triangular matrix and L
is a lower triangular matrix. The factored form of A
is then used to solve the system of equations A * X = B
.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_PPSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_DBL, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_PPSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_FLT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26949 LAPACK_PPSV Procedure Parameters
Parameter  Description 




The number of linear equations, that is, the order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the upper or lower triangle of the symmetric matrix If If On exit, if 

On entry, the On exit, if 

The leading dimension of the array b.




(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
symmetric positive definite tridiagonal matrix, and x
and b
are n
by nrhs
matrices.
a
is factored as A = L*D*L**T
, and the factored form of a is then used to solve the system of equations.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_PTSV ( n IN POSITIVEN, nrhs IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_DBL, e IN OUT UTL_NLA_ARRAY_DBL, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_PTSV ( n IN POSITIVEN, nrhs IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_FLT, e IN OUT UTL_NLA_ARRAY_FLT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26950 LAPACK_PTSV Procedure Parameters
Parameter  Description 


The order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the On exit, the 

On entry, the On exit, the 

On entry, the On exit, if 

The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedure computes all the eigenvalues and, optionally, eigenvectors of a real symmetric band matrix A
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SBEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, kd IN NATURALN, ab IN OUT UTL_NLA_ARRAY_DBL, ldab IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SBEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, kd IN NATURALN, ab IN OUT UTL_NLA_ARRAY_FLT, ldab IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26951 LAPACK_SBEV Procedure Parameters
Parameter  Description 






The order of the matrix 

The number of superdiagonals of the matrix 

On entry, the upper or lower triangle of the symmetric band matrix
On exit,


The leading dimension of the array 

If 



The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
. If eigenvectors are desired, it uses a divide and conquer algorithm that makes mild assumptions about floating point arithmetic.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SBEVD ( jobz IN flag, uplo IN flag, n IN POSITIVEN, kd IN NATURALN, ab IN OUT UTL_NLA_ARRAY_DBL, ldab IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SBEVD ( jobz IN flag, uplo IN flag, n IN POSITIVEN, kd IN NATURALN, ab IN OUT UTL_NLA_ARRAY_FLT, ldab IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26952 LAPACK_SBEVD Procedure Parameters
Parameter  Description 






The order of the matrix 

The number of superdiagonals of the matrix 

On entry, the upper or lower triangle of the symmetric band matrix
On exit,


The leading dimension of the array 

If 



The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
in packed storage.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SPEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_DBL, w IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SPEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_FLT, w IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26953 LAPACK_SPEV Procedure Parameters
Parameter  Description 






The order of the matrix 

On entry, the upper or lower triangle of the symmetric matrix
On exit,


If 



The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes all the eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. The divide and conquer algorithm makes very mild assumptions about floating point arithmetic.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SPEVD ( jobz IN flag, uplo IN flag, n IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_DBL, w IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SPEVD ( jobz IN flag, uplo IN flag, n IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_FLT, w IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26954 LAPACK_SPEVD Procedure Parameters
Parameter  Description 






The order of the matrix 

On entry, the upper or lower triangle of the symmetric matrix
On exit,


If 



The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
symmetric matrix stored in packed format, and x
and b
are n
by nrhs
matrices.
The diagonal pivoting method is used to factor A
as
A = U * D * U**T
, if UPLO = 'U'
or
A = L * D * L**T
, if UPLO = 'L'
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1 by 1 and 2 by 2 diagonal blocks. The factored form of A
is then used to solve the system of equations A * X = B.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SPSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_DBL, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SPSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, ap IN OUT UTL_NLA_ARRAY_FLT, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26955 LAPACK_SPSV Procedure Parameters
Parameter  Description 




The number of linear equations, which is the order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the upper or lower triangle of the symmetric matrix
See below for further details. On exit, the block diagonal matrix 

Details of the interchanges and the block structure of


On entry, the On exit, if 

The leading dimension of the array




(Optional) Flags the packing of the matrices:

This procedure computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix A
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_STEV ( jobz IN flag, n IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_DBL, e IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_STEV ( jobz IN flag, n IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_FLT, e IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26956 LAPACK_STEV Procedure Parameters
Parameter  Description 




The order of the matrix 


e 




The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes all eigenvalues and, optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm that makes mild assumptions about floating point arithmetic.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_STEVD ( jobz IN flag, n IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_DBL, e IN OUT UTL_NLA_ARRAY_DBL, z IN OUT UTL_NLA_ARRAY_DBL, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_STEVD( jobz IN flag, n IN POSITIVEN, d IN OUT UTL_NLA_ARRAY_FLT, e IN OUT UTL_NLA_ARRAY_FLT, z IN OUT UTL_NLA_ARRAY_FLT, ldz IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26957 LAPACK_STEVD Procedure Parameters
Parameter  Description 




The order of the matrix 


e 




The leading dimension of the array 



(Optional) Flags the packing of the matrices:

This procedure computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SYEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_DBL, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SYEV ( jobz IN flag, uplo IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_FLT, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26958 LAPACK_SYEV Procedure Parameters
Paramete  Description 






The order of the matrix 

On entry, the symmetric matrix
On exit:


The leading dimension of the array 

If 



(Optional) Flags the packing of the matrices:

This procedure computes all eigenvalues and, optionally, eigenvectors of a real symmetric matrix A
. If eigenvectors are desired, it uses a divide and conquer algorithm that makes mild assumptions about floating point arithmetic.
See Also:
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SYEVD (
jobz IN flag, uplo IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_DBL, info OUT INTEGER, pack IN flag DEFAULT 'C'); UTL_NLA.LAPACK_SYEVD ( jobz IN flag, uplo IN flag, n IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, w IN OUT UTL_NLA_ARRAY_FLT, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26959 LAPACK_SYEVD Procedure Parameters
Parameter  Description 






The order of the matrix 

On entry, the symmetric matrix
On exit:


The leading dimension of the array 

If 



(Optional) Flags the packing of the matrices:

This procedure computes the solution to a real system of linear equations a * x = b
, where a
is an n
by n
symmetric matrix, and x
and b
are n
by nrhs
matrices.
The diagonal pivoting method is used to factor A
as
A = U * D * U**T
, if UPLO = 'U'
or
A = L * D * L**T
, if UPLO = 'L'
where U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1 by 1 and 2 by 2 diagonal blocks. The factored form of A
is then used to solve the system of equations A * X = B.
See Also:
LAPACK Driver Routines (Linear Equations) Subprograms for other subprograms in this group
Syntax
UTL_NLA.LAPACK_SYSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_DBL, lda IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_DBL, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
UTL_NLA.LAPACK_SYSV ( uplo IN flag, n IN POSITIVEN, nrhs IN POSITIVEN, a IN OUT UTL_NLA_ARRAY_FLT, lda IN POSITIVEN, ipiv IN OUT UTL_NLA_ARRAY_INT, b IN OUT UTL_NLA_ARRAY_FLT, ldb IN POSITIVEN, info OUT INTEGER, pack IN flag DEFAULT 'C');
Parameters
Table 26960 LAPACK_SYSV Procedure Parameters
Parameter  Description 




The number of linear equations, which is the order of the matrix 

The number of righthand sides, which is the number of columns of the matrix 

On entry, the symmetric matrix On exit, if 

The leading dimension of the array


Details of the interchanges and the block structure of


On entry, the On exit, if 

The leading dimension of the array




(Optional) Flags the packing of the matrices:
