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:
Overview
Rules and Limits
BLAS Level 1 (Vector-Vector Operations) Subprograms
BLAS Level 2 (Matrix-Vector Operations) Subprograms
BLAS Level 3 (Matrix-Matrix Operations) Subprograms
LAPACK Driver Routines (Linear Equations) Subprograms
LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms
This section contains topics which relate to using the UTL_NLA
package.
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.
For more information on the BLAS and LAPACK standards see
http://www.netlib.org/blas/
http://www.netlib.org/lapack/
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.
The mapping between BLAS and LAPACK procedures and their corresponding PL/SQL calls is one-to-one.
All BLAS functions have the BLAS_
prefix (for example, theBLAS_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 one-to-one.
Also in the PL/SQL interface for LAPACK, all /work/
arguments have been removed. The UTL_NLA
package manages the allocation and de-allocation 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 row-major or column-major (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.
Table 174-1 BLAS Level 1 (Vector-Vector 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 2-norm (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 |
Table 174-2 BLAS Level 2 (Matrix-Vector Operations) Subprograms
Subprogram | Description |
---|---|
Performs the matrix-vector operation |
|
Performs the matrix-vector operations |
|
Performs a rank 1 operation |
|
Performs a matrix-vector operation |
|
Performs a matrix-vector operation |
|
Performs a symmetric rank 1 operation |
|
Performs a symmetric rank 2 operation |
|
Performs a matrix-vector operation |
|
Performs a matrix-vector operation |
|
Performs a symmetric rank 1 operation |
|
Performs a symmetric rank 2 operation |
|
Performs a matrix-vector operation |
|
Solves one of the systems of equation |
|
Performs a matrix-vector operation |
|
Solves one of the systems of equation |
|
Performs a matrix-vector operation |
|
Solves one of the systems of equation |
Table 174-3 BLAS Level 3 (Matrix-Matrix Operations) Subprograms
Subprogram | Description |
---|---|
Performs one of the matrix-vector operations |
|
Performs one of the matrix-vector operations |
|
Performs one of the symmetric rank2 k operations |
|
Performs one of the symmetric rank |
|
Performs one of the matrix-vector operations |
|
Performs one of the matrix-vector operations |
Table 174-4 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 |
Table 174-5 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 |
Table 174-6 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 matrix-vector operation |
||
Performs one of the matrix-vector operations where |
||
Performs the matrix-vector 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 2-norm (Euclidean norm) |
||
Returns the plane rotation of points |
||
Returns the Givens rotation of points |
||
Performs a matrix-vector operation |
||
Scales a vector by a constant |
||
Performs a matrix-vector 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 matrix-vector operations where |
||
Performs a matrix-vector 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 matrix-vector operation where |
||
Solves one of the systems of equation where |
||
Performs a matrix-vector operation where |
||
Solves one of the systems of equation where |
||
Performs one of the matrix-vector operations where |
||
Performs a matrix-vector operation where |
||
Performs one of the matrix-vector 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 |
|
Ccomputes 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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
Table 174-7 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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);
Table 174-8 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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);
Table 174-9 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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;
Table 174-10 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 matrix-vector 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
sub-diagonals and ku
super-diagonals.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_NLA.BLAS_GEMV ( 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_GEMV ( 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');
Table 174-11 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 sub-diagonals of the matrix |
ku |
Specifies the number of super-diagonals 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+(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 one of the matrix-matrix 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 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-12 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 matrix-vector 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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-13 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+(m-1)*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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-14 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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;
Table 174-15 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 2-norm (Euclidean norm).
See Also:
BLAS Level 1 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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;
Table 174-16 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 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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);
Table 174-17 BLAS_ROT 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 procedure returns the Givens rotation of points.
See Also:
BLAS Level 1 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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);
Table 174-18 BLAS_ROT G Procedure Parameters
Parameter | Description |
---|---|
|
|
|
|
|
|
|
|
This procedure scales a vector by a constant.
See Also:
BLAS Level 1 (Vector-Vector Operations) Subprograms for other subprograms in this groupUTL_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);
Table 174-19 BLAS_SCAL 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 |
This procedure performs the matrix-vector 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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-20 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+(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 |
|
(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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-21 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+(n-1)*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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-22 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+(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 |
|
((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 matrix-vector 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
super-diagonals.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-23 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 super-diagonals of the matrix |
|
|
|
Before entry with Before entry with Unchanged on exit |
|
Specifies the first dimension of |
|
(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 |
|
(Optional) Flags the packing of the matrices:
|
This procedure swaps the contents of two vectors each of size n.
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);
Table 174-24 BLAS_SWAP 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 procedure performs one of the matrix-matrix 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 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-25 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 matrix-vector 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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-26 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+(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 |
|
(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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-27 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+(n-1)*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 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-28 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:
|
This procedure 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 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-29 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 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-30 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 matrix-vector operations
x := A*x
or
x := A'*x
where x
is an n
element vector and A
is an n
by n
unit, or non-unit, upper or lower triangular band matrix, with (k+1)
diagonals.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-31 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 non-unit, upper or lower triangular band matrix, with (k+1)
diagonals.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-32 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:
|
No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
This procedure performs the matrix-vector operations
x := A*x
or
x := A'*x
where x
is an n
element vector and A
is an n
by n
unit, or non-unit, upper or lower triangular matrix, supplied in packed form.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-33 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 non-unit, upper or lower triangular matrix, supplied in packed form.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-34 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:
|
No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
This procedure performs one of the matrix-matrix 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 non-unit, upper or lower triangular matrix and op(A)
is one of
op( A ) = A
or
op( A ) = A'
See Also:
BLAS Level 3 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-35 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 matrix-vector operations
x := A*x
or
x := A'*x
where x
is an n
element vector and A
is an n
by n
unit, or non-unit, upper or lower triangular matrix.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-36 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 one of the matrix-matrix 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 non-unit, 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 (Matrix-Matrix Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-37 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 non-unit, upper or lower triangular matrix.
See Also:
BLAS Level 2 (Matrix-Vector Operations) Subprograms for other subprograms in this groupUTL_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');
Table 174-38 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:
|
No test for singularity or near-singularity 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 groupUTL_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');
Table 174-39 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 right-hand 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 quasi-triangular 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 groupUTL_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');
Table 174-40 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 matricies:
|
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 groupUTL_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');
Table 174-41 LAPACK_GELS Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The number of rows of the matrix |
|
The number of columns of the matrix |
|
The number of right-hand 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 matricies:
|
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 divide-and-conquer 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 non-negative, 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 groupUTL_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');
Table 174-42 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 matricies:
|
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 groupUTL_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');
Table 174-43 LAPACK_GESV Procedure Parameters
Parameter | Description |
---|---|
|
The number of linear equations, equivalent to the order of the matrix |
|
The number of right-hand 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 non-negative, 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 groupUTL_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');
Table 174-44 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 matricies:
|
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 groupUTL_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');
Table 174-45 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 matricies:
|
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 groupUTL_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');
Table 174-46 LAPACK_GTSV Procedure Parameters
Parameter | Description |
---|---|
|
The order of the matrix |
|
The number of right-hand 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 groupUTL_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');
Table 174-47 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 right-hand 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 groupUTL_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');
Table 174-48 LAPACK_POSV Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The number of linear equations, that is, the order of the matrix |
|
The number of right-hand 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 groupUTL_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');
Table 174-49 LAPACK_PPSV Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The number of linear equations, that is, the order of the matrix |
|
The number of right-hand 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 groupUTL_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');
Table 174-50 LAPACK_PTSV Procedure Parameters
Parameter | Description |
---|---|
|
The order of the matrix |
|
The number of right-hand 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 groupUTL_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');
Table 174-51 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 matricies:
|
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 groupUTL_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');
Table 174-52 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 matricies:
|
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 groupUTL_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');
Table 174-53 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 matricies:
|
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 groupUTL_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');
Table 174-54 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 matricies:
|
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 groupUTL_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');
Table 174-55 LAPACK_SPSV Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The number of linear equations, which is the order of the matrix |
|
The number of right-hand 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 groupUTL_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');
Table 174-56 LAPACK_STEV Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The order of the matrix |
|
|
e |
|
|
|
|
The leading dimension of the array |
|
|
|
(Optional) Flags the packing of the matricies:
|
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 groupUTL_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');
Table 174-57 LAPACK_STEVD Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The order of the matrix |
|
|
e |
|
|
|
|
The leading dimension of the array |
|
|
|
(Optional) Flags the packing of the matricies:
|
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 groupUTL_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');
Table 174-58 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 matricies:
|
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 groupUTL_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');
Table 174-59 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 matricies:
|
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 groupUTL_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');
Table 174-60 LAPACK_SYSV Procedure Parameters
Parameter | Description |
---|---|
|
|
|
The number of linear equations, which is the order of the matrix |
|
The number of right-hand 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:
|