org.netlib.lapack
Class Dlatrs
java.lang.Object
org.netlib.lapack.Dlatrs
public class Dlatrs
 extends java.lang.Object
Following is the description from the original
Fortran source. For each array argument, the Java
version will include an integer offset parameter, so
the arguments may not match the description exactly.
Contact seymour@cs.utk.edu with any questions.
* ..
*
* Purpose
* =======
*
* DLATRS solves one of the triangular systems
*
* A *x = s*b or A'*x = s*b
*
* with scaling to prevent overflow. Here A is an upper or lower
* triangular matrix, A' denotes the transpose of A, x and b are
* nelement vectors, and s is a scaling factor, usually less than
* or equal to 1, chosen so that the components of x will be less than
* the overflow threshold. If the unscaled problem will not cause
* overflow, the Level 2 BLAS routine DTRSV is called. If the matrix A
* is singular (A(j,j) = 0 for some j), then s is set to 0 and a
* nontrivial solution to A*x = 0 is returned.
*
* Arguments
* =========
*
* UPLO (input) CHARACTER*1
* Specifies whether the matrix A is upper or lower triangular.
* = 'U': Upper triangular
* = 'L': Lower triangular
*
* TRANS (input) CHARACTER*1
* Specifies the operation applied to A.
* = 'N': Solve A * x = s*b (No transpose)
* = 'T': Solve A'* x = s*b (Transpose)
* = 'C': Solve A'* x = s*b (Conjugate transpose = Transpose)
*
* DIAG (input) CHARACTER*1
* Specifies whether or not the matrix A is unit triangular.
* = 'N': Nonunit triangular
* = 'U': Unit triangular
*
* NORMIN (input) CHARACTER*1
* Specifies whether CNORM has been set or not.
* = 'Y': CNORM contains the column norms on entry
* = 'N': CNORM is not set on entry. On exit, the norms will
* be computed and stored in CNORM.
*
* N (input) INTEGER
* The order of the matrix A. N >= 0.
*
* A (input) DOUBLE PRECISION array, dimension (LDA,N)
* The triangular matrix A. If UPLO = 'U', the leading n by n
* upper triangular part of the array A contains the upper
* triangular matrix, and the strictly lower triangular part of
* A is not referenced. If UPLO = 'L', the leading n by n lower
* triangular part of the array A contains the lower triangular
* matrix, and the strictly upper triangular part of A is not
* referenced. If DIAG = 'U', the diagonal elements of A are
* also not referenced and are assumed to be 1.
*
* LDA (input) INTEGER
* The leading dimension of the array A. LDA >= max (1,N).
*
* X (input/output) DOUBLE PRECISION array, dimension (N)
* On entry, the right hand side b of the triangular system.
* On exit, X is overwritten by the solution vector x.
*
* SCALE (output) DOUBLE PRECISION
* The scaling factor s for the triangular system
* A * x = s*b or A'* x = s*b.
* If SCALE = 0, the matrix A is singular or badly scaled, and
* the vector x is an exact or approximate solution to A*x = 0.
*
* CNORM (input or output) DOUBLE PRECISION array, dimension (N)
*
* If NORMIN = 'Y', CNORM is an input argument and CNORM(j)
* contains the norm of the offdiagonal part of the jth column
* of A. If TRANS = 'N', CNORM(j) must be greater than or equal
* to the infinitynorm, and if TRANS = 'T' or 'C', CNORM(j)
* must be greater than or equal to the 1norm.
*
* If NORMIN = 'N', CNORM is an output argument and CNORM(j)
* returns the 1norm of the offdiagonal part of the jth column
* of A.
*
* INFO (output) INTEGER
* = 0: successful exit
* < 0: if INFO = k, the kth argument had an illegal value
*
* Further Details
* ======= =======
*
* A rough bound on x is computed; if that is less than overflow, DTRSV
* is called, otherwise, specific code is used which checks for possible
* overflow or dividebyzero at every operation.
*
* A columnwise scheme is used for solving A*x = b. The basic algorithm
* if A is lower triangular is
*
* x[1:n] := b[1:n]
* for j = 1, ..., n
* x(j) := x(j) / A(j,j)
* x[j+1:n] := x[j+1:n]  x(j) * A[j+1:n,j]
* end
*
* Define bounds on the components of x after j iterations of the loop:
* M(j) = bound on x[1:j]
* G(j) = bound on x[j+1:n]
* Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.
*
* Then for iteration j+1 we have
* M(j+1) <= G(j) /  A(j+1,j+1) 
* G(j+1) <= G(j) + M(j+1) *  A[j+2:n,j+1] 
* <= G(j) ( 1 + CNORM(j+1) /  A(j+1,j+1)  )
*
* where CNORM(j+1) is greater than or equal to the infinitynorm of
* column j+1 of A, not counting the diagonal. Hence
*
* G(j) <= G(0) product ( 1 + CNORM(i) /  A(i,i)  )
* 1<=i<=j
* and
*
* x(j) <= ( G(0) / A(j,j) ) product ( 1 + CNORM(i) / A(i,i) )
* 1<=i< j
*
* Since x(j) <= M(j), we use the Level 2 BLAS routine DTRSV if the
* reciprocal of the largest M(j), j=1,..,n, is larger than
* max(underflow, 1/overflow).
*
* The bound on x(j) is also used to determine when a step in the
* columnwise method can be performed without fear of overflow. If
* the computed bound is greater than a large constant, x is scaled to
* prevent overflow, but if the bound overflows, x is set to 0, x(j) to
* 1, and scale to 0, and a nontrivial solution to A*x = 0 is found.
*
* Similarly, a rowwise scheme is used to solve A'*x = b. The basic
* algorithm for A upper triangular is
*
* for j = 1, ..., n
* x(j) := ( b(j)  A[1:j1,j]' * x[1:j1] ) / A(j,j)
* end
*
* We simultaneously compute two bounds
* G(j) = bound on ( b(i)  A[1:i1,i]' * x[1:i1] ), 1<=i<=j
* M(j) = bound on x(i), 1<=i<=j
*
* The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we
* add the constraint G(j) >= G(j1) and M(j) >= M(j1) for j >= 1.
* Then the bound on x(j) is
*
* M(j) <= M(j1) * ( 1 + CNORM(j) ) /  A(j,j) 
*
* <= M(0) * product ( ( 1 + CNORM(i) ) / A(i,i) )
* 1<=i<=j
*
* and we can safely call DTRSV if 1/M(n) and 1/G(n) are both greater
* than max(underflow, 1/overflow).
*
* =====================================================================
*
* .. Parameters ..
Method Summary 
static void 
dlatrs(java.lang.String uplo,
java.lang.String trans,
java.lang.String diag,
java.lang.String normin,
int n,
double[] a,
int _a_offset,
int lda,
double[] x,
int _x_offset,
doubleW scale,
double[] cnorm,
int _cnorm_offset,
intW info)

Methods inherited from class java.lang.Object 
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Dlatrs
public Dlatrs()
dlatrs
public static void dlatrs(java.lang.String uplo,
java.lang.String trans,
java.lang.String diag,
java.lang.String normin,
int n,
double[] a,
int _a_offset,
int lda,
double[] x,
int _x_offset,
doubleW scale,
double[] cnorm,
int _cnorm_offset,
intW info)