org.netlib.lapack
Class DLATPS
java.lang.Object
org.netlib.lapack.DLATPS
public class DLATPS
 extends java.lang.Object
DLATPS is a simplified interface to the JLAPACK routine dlatps.
This interface converts Javastyle 2D rowmajor arrays into
the 1D columnmajor linearized arrays expected by the lower
level JLAPACK routines. Using this interface also allows you
to omit offset and leading dimension arguments. However, because
of these conversions, these routines will be slower than the low
level ones. Following is the description from the original Fortran
source. Contact seymour@cs.utk.edu with any questions.
* ..
*
* Purpose
* =======
*
* DLATPS solves one of the triangular systems
*
* A *x = s*b or A'*x = s*b
*
* with scaling to prevent overflow, where A is an upper or lower
* triangular matrix stored in packed form. Here 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
* DTPSV 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.
*
* AP (input) DOUBLE PRECISION array, dimension (N*(N+1)/2)
* The upper or lower triangular matrix A, packed columnwise in
* a linear array. The jth column of A is stored in the array
* AP as follows:
* if UPLO = 'U', AP(i + (j1)*j/2) = A(i,j) for 1<=i<=j;
* if UPLO = 'L', AP(i + (j1)*(2nj)/2) = A(i,j) for j<=i<=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, DTPSV
* 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 DTPSV 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 DTPSV if 1/M(n) and 1/G(n) are both greater
* than max(underflow, 1/overflow).
*
* =====================================================================
*
* .. Parameters ..
Method Summary 
static void 
DLATPS(java.lang.String uplo,
java.lang.String trans,
java.lang.String diag,
java.lang.String normin,
int n,
double[] ap,
double[] x,
doubleW scale,
double[] cnorm,
intW info)

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