LAPACK  3.6.0
LAPACK: Linear Algebra PACKage
Collaboration diagram for real:

Functions

real function slangb (NORM, N, KL, KU, AB, LDAB, WORK)
 SLANGB returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of general band matrix. More...
 
subroutine slaqgb (M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, AMAX, EQUED)
 SLAQGB scales a general band matrix, using row and column scaling factors computed by sgbequ. More...
 

Detailed Description

This is the group of real auxiliary functions for GB matrices

Function Documentation

real function slangb ( character  NORM,
integer  N,
integer  KL,
integer  KU,
real, dimension( ldab, * )  AB,
integer  LDAB,
real, dimension( * )  WORK 
)

SLANGB returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of general band matrix.

Download SLANGB + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 SLANGB  returns the value of the one norm,  or the Frobenius norm, or
 the  infinity norm,  or the element of  largest absolute value  of an
 n by n band matrix  A,  with kl sub-diagonals and ku super-diagonals.
Returns
SLANGB
    SLANGB = ( max(abs(A(i,j))), NORM = 'M' or 'm'
             (
             ( norm1(A),         NORM = '1', 'O' or 'o'
             (
             ( normI(A),         NORM = 'I' or 'i'
             (
             ( normF(A),         NORM = 'F', 'f', 'E' or 'e'

 where  norm1  denotes the  one norm of a matrix (maximum column sum),
 normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
 normF  denotes the  Frobenius norm of a matrix (square root of sum of
 squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.
Parameters
[in]NORM
          NORM is CHARACTER*1
          Specifies the value to be returned in SLANGB as described
          above.
[in]N
          N is INTEGER
          The order of the matrix A.  N >= 0.  When N = 0, SLANGB is
          set to zero.
[in]KL
          KL is INTEGER
          The number of sub-diagonals of the matrix A.  KL >= 0.
[in]KU
          KU is INTEGER
          The number of super-diagonals of the matrix A.  KU >= 0.
[in]AB
          AB is REAL array, dimension (LDAB,N)
          The band matrix A, stored 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(n,j+kl).
[in]LDAB
          LDAB is INTEGER
          The leading dimension of the array AB.  LDAB >= KL+KU+1.
[out]WORK
          WORK is REAL array, dimension (MAX(1,LWORK)),
          where LWORK >= N when NORM = 'I'; otherwise, WORK is not
          referenced.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
September 2012

Definition at line 126 of file slangb.f.

126 *
127 * -- LAPACK auxiliary routine (version 3.4.2) --
128 * -- LAPACK is a software package provided by Univ. of Tennessee, --
129 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
130 * September 2012
131 *
132 * .. Scalar Arguments ..
133  CHARACTER norm
134  INTEGER kl, ku, ldab, n
135 * ..
136 * .. Array Arguments ..
137  REAL ab( ldab, * ), work( * )
138 * ..
139 *
140 * =====================================================================
141 *
142 *
143 * .. Parameters ..
144  REAL one, zero
145  parameter( one = 1.0e+0, zero = 0.0e+0 )
146 * ..
147 * .. Local Scalars ..
148  INTEGER i, j, k, l
149  REAL scale, sum, VALUE, temp
150 * ..
151 * .. External Subroutines ..
152  EXTERNAL slassq
153 * ..
154 * .. External Functions ..
155  LOGICAL lsame, sisnan
156  EXTERNAL lsame, sisnan
157 * ..
158 * .. Intrinsic Functions ..
159  INTRINSIC abs, max, min, sqrt
160 * ..
161 * .. Executable Statements ..
162 *
163  IF( n.EQ.0 ) THEN
164  VALUE = zero
165  ELSE IF( lsame( norm, 'M' ) ) THEN
166 *
167 * Find max(abs(A(i,j))).
168 *
169  VALUE = zero
170  DO 20 j = 1, n
171  DO 10 i = max( ku+2-j, 1 ), min( n+ku+1-j, kl+ku+1 )
172  temp = abs( ab( i, j ) )
173  IF( VALUE.LT.temp .OR. sisnan( temp ) ) VALUE = temp
174  10 CONTINUE
175  20 CONTINUE
176  ELSE IF( ( lsame( norm, 'O' ) ) .OR. ( norm.EQ.'1' ) ) THEN
177 *
178 * Find norm1(A).
179 *
180  VALUE = zero
181  DO 40 j = 1, n
182  sum = zero
183  DO 30 i = max( ku+2-j, 1 ), min( n+ku+1-j, kl+ku+1 )
184  sum = sum + abs( ab( i, j ) )
185  30 CONTINUE
186  IF( VALUE.LT.sum .OR. sisnan( sum ) ) VALUE = sum
187  40 CONTINUE
188  ELSE IF( lsame( norm, 'I' ) ) THEN
189 *
190 * Find normI(A).
191 *
192  DO 50 i = 1, n
193  work( i ) = zero
194  50 CONTINUE
195  DO 70 j = 1, n
196  k = ku + 1 - j
197  DO 60 i = max( 1, j-ku ), min( n, j+kl )
198  work( i ) = work( i ) + abs( ab( k+i, j ) )
199  60 CONTINUE
200  70 CONTINUE
201  VALUE = zero
202  DO 80 i = 1, n
203  temp = work( i )
204  IF( VALUE.LT.temp .OR. sisnan( temp ) ) VALUE = temp
205  80 CONTINUE
206  ELSE IF( ( lsame( norm, 'F' ) ) .OR. ( lsame( norm, 'E' ) ) ) THEN
207 *
208 * Find normF(A).
209 *
210  scale = zero
211  sum = one
212  DO 90 j = 1, n
213  l = max( 1, j-ku )
214  k = ku + 1 - j + l
215  CALL slassq( min( n, j+kl )-l+1, ab( k, j ), 1, scale, sum )
216  90 CONTINUE
217  VALUE = scale*sqrt( sum )
218  END IF
219 *
220  slangb = VALUE
221  RETURN
222 *
223 * End of SLANGB
224 *
logical function sisnan(SIN)
SISNAN tests input for NaN.
Definition: sisnan.f:61
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55
subroutine slassq(N, X, INCX, SCALE, SUMSQ)
SLASSQ updates a sum of squares represented in scaled form.
Definition: slassq.f:105
real function slangb(NORM, N, KL, KU, AB, LDAB, WORK)
SLANGB returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: slangb.f:126

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Download SLAQGB + dependencies [TGZ] [ZIP] [TXT]

Purpose:
 SLAQGB 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 REAL 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 REAL array, dimension (M)
          The row scale factors for A.
[in]C
          C is REAL array, dimension (N)
          The column scale factors for A.
[in]ROWCND
          ROWCND is REAL
          Ratio of the smallest R(i) to the largest R(i).
[in]COLCND
          COLCND is REAL
          Ratio of the smallest C(i) to the largest C(i).
[in]AMAX
          AMAX is REAL
          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.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.
Date
September 2012

Definition at line 161 of file slaqgb.f.

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

Here is the caller graph for this function: