 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ dlaqgb()

 subroutine dlaqgb ( integer M, integer N, integer KL, integer KU, double precision, dimension( ldab, * ) AB, integer LDAB, double precision, dimension( * ) R, double precision, dimension( * ) C, double precision ROWCND, double precision COLCND, double precision AMAX, character EQUED )

DLAQGB scales a general band matrix, using row and column scaling factors computed by sgbequ.

Purpose:
``` DLAQGB equilibrates a general M by N band matrix A with KL
subdiagonals and KU superdiagonals using the row and scaling factors
in the vectors R and C.```
Parameters
 [in] M ``` M is INTEGER The number of rows of the matrix A. M >= 0.``` [in] N ``` N is INTEGER The number of columns of the matrix A. N >= 0.``` [in] KL ``` KL is INTEGER The number of subdiagonals within the band of A. KL >= 0.``` [in] KU ``` KU is INTEGER The number of superdiagonals within the band of A. KU >= 0.``` [in,out] AB ``` AB is DOUBLE PRECISION array, dimension (LDAB,N) On entry, the matrix A in band storage, in rows 1 to KL+KU+1. The j-th column of A is stored in the j-th column of the array AB as follows: AB(ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl) On exit, the equilibrated matrix, in the same storage format as A. See EQUED for the form of the equilibrated matrix.``` [in] LDAB ``` LDAB is INTEGER The leading dimension of the array AB. LDA >= KL+KU+1.``` [in] R ``` R is DOUBLE PRECISION array, dimension (M) The row scale factors for A.``` [in] C ``` C is DOUBLE PRECISION array, dimension (N) The column scale factors for A.``` [in] ROWCND ``` ROWCND is DOUBLE PRECISION Ratio of the smallest R(i) to the largest R(i).``` [in] COLCND ``` COLCND is DOUBLE PRECISION Ratio of the smallest C(i) to the largest C(i).``` [in] AMAX ``` AMAX is DOUBLE PRECISION Absolute value of largest matrix entry.``` [out] EQUED ``` EQUED is CHARACTER*1 Specifies the form of equilibration that was done. = 'N': No equilibration = 'R': Row equilibration, i.e., A has been premultiplied by diag(R). = 'C': Column equilibration, i.e., A has been postmultiplied by diag(C). = 'B': Both row and column equilibration, i.e., A has been replaced by diag(R) * A * diag(C).```
Internal Parameters:
```  THRESH is a threshold value used to decide if row or column scaling
should be done based on the ratio of the row or column scaling
factors.  If ROWCND < THRESH, row scaling is done, and if
COLCND < THRESH, column scaling is done.

LARGE and SMALL are threshold values used to decide if row scaling
should be done based on the absolute size of the largest matrix
element.  If AMAX > LARGE or AMAX < SMALL, row scaling is done.```

Definition at line 157 of file dlaqgb.f.

159 *
160 * -- LAPACK auxiliary routine --
161 * -- LAPACK is a software package provided by Univ. of Tennessee, --
162 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
163 *
164 * .. Scalar Arguments ..
165  CHARACTER EQUED
166  INTEGER KL, KU, LDAB, M, N
167  DOUBLE PRECISION AMAX, COLCND, ROWCND
168 * ..
169 * .. Array Arguments ..
170  DOUBLE PRECISION AB( LDAB, * ), C( * ), R( * )
171 * ..
172 *
173 * =====================================================================
174 *
175 * .. Parameters ..
176  DOUBLE PRECISION ONE, THRESH
177  parameter( one = 1.0d+0, thresh = 0.1d+0 )
178 * ..
179 * .. Local Scalars ..
180  INTEGER I, J
181  DOUBLE PRECISION CJ, LARGE, SMALL
182 * ..
183 * .. External Functions ..
184  DOUBLE PRECISION DLAMCH
185  EXTERNAL dlamch
186 * ..
187 * .. Intrinsic Functions ..
188  INTRINSIC max, min
189 * ..
190 * .. Executable Statements ..
191 *
192 * Quick return if possible
193 *
194  IF( m.LE.0 .OR. n.LE.0 ) THEN
195  equed = 'N'
196  RETURN
197  END IF
198 *
199 * Initialize LARGE and SMALL.
200 *
201  small = dlamch( 'Safe minimum' ) / dlamch( 'Precision' )
202  large = one / small
203 *
204  IF( rowcnd.GE.thresh .AND. amax.GE.small .AND. amax.LE.large )
205  \$ THEN
206 *
207 * No row scaling
208 *
209  IF( colcnd.GE.thresh ) THEN
210 *
211 * No column scaling
212 *
213  equed = 'N'
214  ELSE
215 *
216 * Column scaling
217 *
218  DO 20 j = 1, n
219  cj = c( j )
220  DO 10 i = max( 1, j-ku ), min( m, j+kl )
221  ab( ku+1+i-j, j ) = cj*ab( ku+1+i-j, j )
222  10 CONTINUE
223  20 CONTINUE
224  equed = 'C'
225  END IF
226  ELSE IF( colcnd.GE.thresh ) THEN
227 *
228 * Row scaling, no column scaling
229 *
230  DO 40 j = 1, n
231  DO 30 i = max( 1, j-ku ), min( m, j+kl )
232  ab( ku+1+i-j, j ) = r( i )*ab( ku+1+i-j, j )
233  30 CONTINUE
234  40 CONTINUE
235  equed = 'R'
236  ELSE
237 *
238 * Row and column scaling
239 *
240  DO 60 j = 1, n
241  cj = c( j )
242  DO 50 i = max( 1, j-ku ), min( m, j+kl )
243  ab( ku+1+i-j, j ) = cj*r( i )*ab( ku+1+i-j, j )
244  50 CONTINUE
245  60 CONTINUE
246  equed = 'B'
247  END IF
248 *
249  RETURN
250 *
251 * End of DLAQGB
252 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
Here is the caller graph for this function: