dlatrs.f man page on DragonFly

Man page or keyword search:  
man Server   44335 pages
apropos Keyword Search (all sections)
Output format
DragonFly logo
[printable version]

dlatrs.f(3)			    LAPACK			   dlatrs.f(3)

NAME
       dlatrs.f -

SYNOPSIS
   Functions/Subroutines
       subroutine dlatrs (UPLO, TRANS, DIAG, NORMIN, N, A, LDA, X, SCALE,
	   CNORM, INFO)
	   DLATRS solves a triangular system of equations with the scale
	   factor set to prevent overflow.

Function/Subroutine Documentation
   subroutine dlatrs (characterUPLO, characterTRANS, characterDIAG,
       characterNORMIN, integerN, double precision, dimension( lda, * )A,
       integerLDA, double precision, dimension( * )X, double precisionSCALE,
       double precision, dimension( * )CNORM, integerINFO)
       DLATRS solves a triangular system of equations with the scale factor
       set to prevent overflow.

       Purpose:

	    DLATRS solves one of the triangular systems

	       A *x = s*b  or  A**T *x = s*b

	    with scaling to prevent overflow.  Here A is an upper or lower
	    triangular matrix, A**T denotes the transpose of A, x and b are
	    n-element 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
	    non-trivial solution to A*x = 0 is returned.

       Parameters:
	   UPLO

		     UPLO is CHARACTER*1
		     Specifies whether the matrix A is upper or lower triangular.
		     = 'U':  Upper triangular
		     = 'L':  Lower triangular

	   TRANS

		     TRANS is CHARACTER*1
		     Specifies the operation applied to A.
		     = 'N':  Solve A * x = s*b	(No transpose)
		     = 'T':  Solve A**T* x = s*b  (Transpose)
		     = 'C':  Solve A**T* x = s*b  (Conjugate transpose = Transpose)

	   DIAG

		     DIAG is CHARACTER*1
		     Specifies whether or not the matrix A is unit triangular.
		     = 'N':  Non-unit triangular
		     = 'U':  Unit triangular

	   NORMIN

		     NORMIN is 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

		     N is INTEGER
		     The order of the matrix A.	 N >= 0.

	   A

		     A is 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

		     LDA is INTEGER
		     The leading dimension of the array A.  LDA >= max (1,N).

	   X

		     X is 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

		     SCALE is DOUBLE PRECISION
		     The scaling factor s for the triangular system
			A * x = s*b  or	 A**T* 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

		     CNORM is DOUBLE PRECISION array, dimension (N)

		     If NORMIN = 'Y', CNORM is an input argument and CNORM(j)
		     contains the norm of the off-diagonal part of the j-th column
		     of A.  If TRANS = 'N', CNORM(j) must be greater than or equal
		     to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)
		     must be greater than or equal to the 1-norm.

		     If NORMIN = 'N', CNORM is an output argument and CNORM(j)
		     returns the 1-norm of the offdiagonal part of the j-th column
		     of A.

	   INFO

		     INFO is INTEGER
		     = 0:  successful exit
		     < 0:  if INFO = -k, the k-th argument had an illegal value

       Author:
	   Univ. of Tennessee

	   Univ. of California Berkeley

	   Univ. of Colorado Denver

	   NAG Ltd.

       Date:
	   September 2012

       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 divide-by-zero 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 infinity-norm 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 non-trivial solution to A*x = 0 is found.

	     Similarly, a row-wise scheme is used to solve A**T*x = b.	The basic
	     algorithm for A upper triangular is

		  for j = 1, ..., n
		       x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)
		  end

	     We simultaneously compute two bounds
		  G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 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(j-1) and M(j) >= M(j-1) for j >= 1.
	     Then the bound on x(j) is

		  M(j) <= M(j-1) * ( 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).

       Definition at line 238 of file dlatrs.f.

Author
       Generated automatically by Doxygen for LAPACK from the source code.

Version 3.4.2			Sat Nov 16 2013			   dlatrs.f(3)
[top]

List of man pages available for DragonFly

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net