 LAPACK  3.6.1 LAPACK: Linear Algebra PACKage
 subroutine cgbtf2 ( integer M, integer N, integer KL, integer KU, complex, dimension( ldab, * ) AB, integer LDAB, integer, dimension( * ) IPIV, integer INFO )

CGBTF2 computes the LU factorization of a general band matrix using the unblocked version of the algorithm.

Purpose:
``` CGBTF2 computes an LU factorization of a complex m-by-n band matrix
A using partial pivoting with row interchanges.

This is the unblocked version of the algorithm, calling Level 2 BLAS.```
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 COMPLEX array, dimension (LDAB,N) On entry, the matrix A in band storage, in rows KL+1 to 2*KL+KU+1; rows 1 to KL of the array need not be set. The j-th column of A is stored in the j-th column of the array AB as follows: AB(kl+ku+1+i-j,j) = A(i,j) for max(1,j-ku)<=i<=min(m,j+kl) On exit, details of the factorization: U is stored as an upper triangular band matrix with KL+KU superdiagonals in rows 1 to KL+KU+1, and the multipliers used during the factorization are stored in rows KL+KU+2 to 2*KL+KU+1. See below for further details.``` [in] LDAB ``` LDAB is INTEGER The leading dimension of the array AB. LDAB >= 2*KL+KU+1.``` [out] IPIV ``` IPIV is INTEGER array, dimension (min(M,N)) The pivot indices; for 1 <= i <= min(M,N), row i of the matrix was interchanged with row IPIV(i).``` [out] INFO ``` INFO is INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value > 0: if INFO = +i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.```
Date
September 2012
Further Details:
```  The band storage scheme is illustrated by the following example, when
M = N = 6, KL = 2, KU = 1:

On entry:                       On exit:

*    *    *    +    +    +       *    *    *   u14  u25  u36
*    *    +    +    +    +       *    *   u13  u24  u35  u46
*   a12  a23  a34  a45  a56      *   u12  u23  u34  u45  u56
a11  a22  a33  a44  a55  a66     u11  u22  u33  u44  u55  u66
a21  a32  a43  a54  a65   *      m21  m32  m43  m54  m65   *
a31  a42  a53  a64   *    *      m31  m42  m53  m64   *    *

Array elements marked * are not used by the routine; elements marked
+ need not be set on entry, but are required by the routine to store
elements of U, because of fill-in resulting from the row
interchanges.```

Definition at line 147 of file cgbtf2.f.

147 *
148 * -- LAPACK computational routine (version 3.4.2) --
149 * -- LAPACK is a software package provided by Univ. of Tennessee, --
150 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
151 * September 2012
152 *
153 * .. Scalar Arguments ..
154  INTEGER info, kl, ku, ldab, m, n
155 * ..
156 * .. Array Arguments ..
157  INTEGER ipiv( * )
158  COMPLEX ab( ldab, * )
159 * ..
160 *
161 * =====================================================================
162 *
163 * .. Parameters ..
164  COMPLEX one, zero
165  parameter ( one = ( 1.0e+0, 0.0e+0 ),
166  \$ zero = ( 0.0e+0, 0.0e+0 ) )
167 * ..
168 * .. Local Scalars ..
169  INTEGER i, j, jp, ju, km, kv
170 * ..
171 * .. External Functions ..
172  INTEGER icamax
173  EXTERNAL icamax
174 * ..
175 * .. External Subroutines ..
176  EXTERNAL cgeru, cscal, cswap, xerbla
177 * ..
178 * .. Intrinsic Functions ..
179  INTRINSIC max, min
180 * ..
181 * .. Executable Statements ..
182 *
183 * KV is the number of superdiagonals in the factor U, allowing for
184 * fill-in.
185 *
186  kv = ku + kl
187 *
188 * Test the input parameters.
189 *
190  info = 0
191  IF( m.LT.0 ) THEN
192  info = -1
193  ELSE IF( n.LT.0 ) THEN
194  info = -2
195  ELSE IF( kl.LT.0 ) THEN
196  info = -3
197  ELSE IF( ku.LT.0 ) THEN
198  info = -4
199  ELSE IF( ldab.LT.kl+kv+1 ) THEN
200  info = -6
201  END IF
202  IF( info.NE.0 ) THEN
203  CALL xerbla( 'CGBTF2', -info )
204  RETURN
205  END IF
206 *
207 * Quick return if possible
208 *
209  IF( m.EQ.0 .OR. n.EQ.0 )
210  \$ RETURN
211 *
212 * Gaussian elimination with partial pivoting
213 *
214 * Set fill-in elements in columns KU+2 to KV to zero.
215 *
216  DO 20 j = ku + 2, min( kv, n )
217  DO 10 i = kv - j + 2, kl
218  ab( i, j ) = zero
219  10 CONTINUE
220  20 CONTINUE
221 *
222 * JU is the index of the last column affected by the current stage
223 * of the factorization.
224 *
225  ju = 1
226 *
227  DO 40 j = 1, min( m, n )
228 *
229 * Set fill-in elements in column J+KV to zero.
230 *
231  IF( j+kv.LE.n ) THEN
232  DO 30 i = 1, kl
233  ab( i, j+kv ) = zero
234  30 CONTINUE
235  END IF
236 *
237 * Find pivot and test for singularity. KM is the number of
238 * subdiagonal elements in the current column.
239 *
240  km = min( kl, m-j )
241  jp = icamax( km+1, ab( kv+1, j ), 1 )
242  ipiv( j ) = jp + j - 1
243  IF( ab( kv+jp, j ).NE.zero ) THEN
244  ju = max( ju, min( j+ku+jp-1, n ) )
245 *
246 * Apply interchange to columns J to JU.
247 *
248  IF( jp.NE.1 )
249  \$ CALL cswap( ju-j+1, ab( kv+jp, j ), ldab-1,
250  \$ ab( kv+1, j ), ldab-1 )
251  IF( km.GT.0 ) THEN
252 *
253 * Compute multipliers.
254 *
255  CALL cscal( km, one / ab( kv+1, j ), ab( kv+2, j ), 1 )
256 *
257 * Update trailing submatrix within the band.
258 *
259  IF( ju.GT.j )
260  \$ CALL cgeru( km, ju-j, -one, ab( kv+2, j ), 1,
261  \$ ab( kv, j+1 ), ldab-1, ab( kv+1, j+1 ),
262  \$ ldab-1 )
263  END IF
264  ELSE
265 *
266 * If pivot is zero, set INFO to the index of the pivot
267 * unless a zero pivot has already been found.
268 *
269  IF( info.EQ.0 )
270  \$ info = j
271  END IF
272  40 CONTINUE
273  RETURN
274 *
275 * End of CGBTF2
276 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
subroutine cscal(N, CA, CX, INCX)
CSCAL
Definition: cscal.f:54
integer function icamax(N, CX, INCX)
ICAMAX
Definition: icamax.f:53
subroutine cswap(N, CX, INCX, CY, INCY)
CSWAP
Definition: cswap.f:52
subroutine cgeru(M, N, ALPHA, X, INCX, Y, INCY, A, LDA)
CGERU
Definition: cgeru.f:132

Here is the call graph for this function:

Here is the caller graph for this function: