262 UTL_NLA
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:
262.1 UTL_NLA Overview
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 one-to-one.
-
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 one-to-one.
-
Also in the PL/SQL interface for LAPACK, all
/work/
arguments have been removed. TheUTL_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.
262.2 UTL_NLA Rules and Limits
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.
262.3 UTL_NLA Security Model
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).
262.4 Subprogram Groups
The UTL_NLA
package contains subprogram groups for BLAS and LAPACK operations.
262.4.1 UTL_NLA BLAS Level 1 (Vector-Vector Operations) Subprograms
This table lists and briefly describes the UTL_NLA BLAS Level 1 Vector-Vector Operations subprograms.
Table 262-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 |
262.4.2 UTL_NLA BLAS Level 2 (Matrix-Vector Operations) Subprograms
This table lists and briefly describes the UTL_NLA BLAS Level 2 Matrix-Vector Operations subprograms.
Table 262-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 |
262.4.3 UTL_NLA BLAS Level 3 (Matrix-Matrix Operations) Subprograms
This table lists and briefly describes the UTL_NLA BLAS Level 3 Matrix-Matrix Operations subprograms.
Table 262-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 |
262.4.4 UTL_NLA LAPACK Driver Routines (Linear Equations) Subprograms
This table lists and briefly describes the LAPACK Driver Routines (Linear Equations) subprograms.
Table 262-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 |
262.4.5 UTL_NLA LAPACK Driver Routines (LLS and Eigenvalue Problems) Subprograms
This table lists and briefly describes the LAPACK Driver Routines (LLS and Eigenvalue) subprograms.
Table 262-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 |
262.5 Summary of UTL_NLA Subprograms
This table lists the UTL_NLA
subprograms and briefly describes them.
Table 262-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 |
|
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 |
262.5.1 BLAS_ASUM Functions
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 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 262-7 BLAS_ASUM Function Parameters
Parameter | Description |
---|---|
|
Specifies the number of elements of the vectors |
|
( 1 + ( n - 1 )*abs( |
|
Specifies the increment for the elements of |
262.5.2 BLAS_AXPY Procedures
This procedure copies alpha
*X
+ Y
into vector Y
.
See Also:
BLAS Level 1 (Vector-Vector 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 262-8 BLAS_AXPY Procedure Parameters
Parameter | Description |
---|---|
|
Specifies the number of elements of the vectors |
|
Specifies the scalar alpha. |
|
( 1 + ( n - 1 )*abs( |
|
Specifies the increment for the elements of |
|
( 1 + ( n - 1 )*abs( incy) ) |
|
Specifies the increment for the elements of |
262.5.3 BLAS_COPY Procedures
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 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 262-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 |
262.5.4 BLAS_DOT Functions
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 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 262-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 |
262.5.5 BLAS_GBMV Procedures
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 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 262-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:
|
262.5.6 BLAS_GEMM Procedures
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 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 262-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:
|
262.5.7 BLAS_GEMV Procedures
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 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 262-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 + ( 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:
|
262.5.8 BLAS_GER Procedures
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 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 262-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
|
|
(Optional) Flags the packing of the matrices:
|
262.5.9 BLAS_IAMAX Functions
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 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 262-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 |
262.5.10 BLAS_NRM2 Functions
This function computes the vector 2-norm (Euclidean norm).
See Also:
BLAS Level 1 (Vector-Vector 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 262-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 |
262.5.11 BLAS_ROT Procedures
This procedure returns the plane rotation of points.
See Also:
BLAS Level 1 (Vector-Vector 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 262-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 |
|
|
|
|
262.5.12 BLAS_ROTG Procedures
This procedure returns the Givens rotation of points.
See Also:
BLAS Level 1 (Vector-Vector 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 262-18 BLAS_ROTG Procedure Parameters
Parameter | Description |
---|---|
|
|
|
|
|
|
|
|
262.5.13 BLAS_SCAL Procedures
This procedure scales a vector by a constant.
See Also:
BLAS Level 1 (Vector-Vector 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 262-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 |
262.5.14 BLAS_SPMV Procedures
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 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 262-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+( Before entry, the incremented array |
|
Specifies the increment for the elements of |
|
(Optional) Flags the packing of the matrices:
|
262.5.15 BLAS_SPR Procedures
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 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 262-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:
|
262.5.16 BLAS_SPR2 Procedures
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 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 262-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:
|
262.5.17 BLAS_SBMV Procedures
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 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 262-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:
|
262.5.18 BLAS_SWAP Procedures
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 262-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 |
262.5.19 BLAS_SYMM Procedures
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 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 262-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:
|
262.5.20 BLAS_SYMV Procedures
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 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 262-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:
|
262.5.21 BLAS_SYR Procedures
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 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 262-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
|
|
(Optional) Flags the packing of the matrices:
|
262.5.22 BLAS_SYR2 Procedures
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 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 262-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
|
|
(Optional) Flags the packing of the matrices:
|
262.5.23 BLAS_SYR2K Procedures
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 (Matrix-Matrix 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 262-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:
|
262.5.24 BLAS_SYRK Procedures
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 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 262-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:
|
262.5.25 BLAS_TBMV Procedures
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 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 262-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:
|
262.5.26 BLAS_TBSV Procedures
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 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 262-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 + ( 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 near-singularity is included in this routine. Such tests must be performed before calling this routine.
262.5.27 BLAS_TPMV Procedures
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 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 262-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:
|
262.5.28 BLAS_TPSV Procedures
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 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 262-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 + ( 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 near-singularity is included in this routine. Such tests must be performed before calling this routine.
262.5.29 BLAS_TRMM Procedures
This procedure performs a matrix-matrix operation.
It performs one of the following 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 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 262-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:
|
262.5.30 BLAS_TRMV Procedures
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 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 262-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:
|
262.5.31 BLAS_TRSM Procedures
This procedure performs a matrix-matrix operation.
It 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 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 262-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:
|
262.5.32 BLAS_TRSV Procedures
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 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 262-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:
|
Usage Notes
No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
262.5.33 LAPACK_GBSV Procedures
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 262-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:
|
262.5.34 LAPACK_GEES Procedures
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 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 262-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 matrices:
|
262.5.35 LAPACK_GELS Procedures
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'
andm >= n
: find the least squares solution of an overdetermined system, that is, solve the least squares problem.minimize || B - A*X ||
-
If
TRANS = 'N'
andm < n
: find the minimum norm solution of an underdetermined systemA * X = B
. -
If
TRANS = 'T'
andm >= n
: find the minimum norm solution of an undetermined systemA**T * X = B
. -
If
TRANS = 'T'
andm < n
: find the least squares solution of an overdetermined system, that is, solve the least squares problemminimize || 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 262-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 matrices:
|
262.5.36 LAPACK_GESDD Procedures
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 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 262-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 matrices:
|
262.5.37 LAPACK_GESV Procedure
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 262-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:
|
262.5.38 LAPACK_GESVD Procedures
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 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 262-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 matrices:
|
262.5.39 LAPACK_GEEV Procedures
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)
ofA
satisfiesA * v(j) = lambda(j) * v(j)
wherelambda(j)
is its eigenvalue. -
The left eigenvector
u(j)
ofA
satisfiesu(j)**H * A = lambda(j) * u(j)**H
whereu(j)**H
denotes the conjugate transpose ofu(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 262-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 matrices:
|
262.5.40 LAPACK_GTSV Procedure
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 262-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:
|
262.5.41 LAPACK_PBSV Procedures
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 262-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:
|
262.5.42 LAPACK_POSV Procedures
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 262-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:
|
262.5.43 LAPACK_PPSV Procedures
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 262-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:
|
262.5.44 LAPACK_PTSV Procedures
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 262-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:
|
262.5.45 LAPACK_SBEV Procedures
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 262-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 matrices:
|
262.5.46 LAPACK_SBEVD Procedures
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 262-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 matrices:
|
262.5.47 LAPACK_SPEV Procedures
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 262-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 matrices:
|
262.5.48 LAPACK_SPEVD Procedures
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 262-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 matrices:
|
262.5.49 LAPACK_SPSV Procedures
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 262-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:
|
262.5.50 LAPACK_STEV Procedures
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 262-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 matrices:
|
262.5.51 LAPACK_STEVD Procedures
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 262-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 matrices:
|
262.5.52 LAPACK_SYEV Procedures
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 262-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 matrices:
|
262.5.53 LAPACK_SYEVD Procedures
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 262-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 matrices:
|
262.5.54 LAPACK_SYSV Procedures
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 262-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:
|