LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches
dgetrf2.f
Go to the documentation of this file.
1*> \brief \b DGETRF2
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8* Definition:
9* ===========
10*
11* RECURSIVE SUBROUTINE DGETRF2( M, N, A, LDA, IPIV, INFO )
12*
13* .. Scalar Arguments ..
14* INTEGER INFO, LDA, M, N
15* ..
16* .. Array Arguments ..
17* INTEGER IPIV( * )
18* DOUBLE PRECISION A( LDA, * )
19* ..
20*
21*
22*> \par Purpose:
23* =============
24*>
25*> \verbatim
26*>
27*> DGETRF2 computes an LU factorization of a general M-by-N matrix A
28*> using partial pivoting with row interchanges.
29*>
30*> The factorization has the form
31*> A = P * L * U
32*> where P is a permutation matrix, L is lower triangular with unit
33*> diagonal elements (lower trapezoidal if m > n), and U is upper
34*> triangular (upper trapezoidal if m < n).
35*>
36*> This is the recursive version of the algorithm. It divides
37*> the matrix into four submatrices:
38*>
39*> [ A11 | A12 ] where A11 is n1 by n1 and A22 is n2 by n2
40*> A = [ -----|----- ] with n1 = min(m,n)/2
41*> [ A21 | A22 ] n2 = n-n1
42*>
43*> [ A11 ]
44*> The subroutine calls itself to factor [ --- ],
45*> [ A12 ]
46*> [ A12 ]
47*> do the swaps on [ --- ], solve A12, update A22,
48*> [ A22 ]
49*>
50*> then calls itself to factor A22 and do the swaps on A21.
51*>
52*> \endverbatim
53*
54* Arguments:
55* ==========
56*
57*> \param[in] M
58*> \verbatim
59*> M is INTEGER
60*> The number of rows of the matrix A. M >= 0.
61*> \endverbatim
62*>
63*> \param[in] N
64*> \verbatim
65*> N is INTEGER
66*> The number of columns of the matrix A. N >= 0.
67*> \endverbatim
68*>
69*> \param[in,out] A
70*> \verbatim
71*> A is DOUBLE PRECISION array, dimension (LDA,N)
72*> On entry, the M-by-N matrix to be factored.
73*> On exit, the factors L and U from the factorization
74*> A = P*L*U; the unit diagonal elements of L are not stored.
75*> \endverbatim
76*>
77*> \param[in] LDA
78*> \verbatim
79*> LDA is INTEGER
80*> The leading dimension of the array A. LDA >= max(1,M).
81*> \endverbatim
82*>
83*> \param[out] IPIV
84*> \verbatim
85*> IPIV is INTEGER array, dimension (min(M,N))
86*> The pivot indices; for 1 <= i <= min(M,N), row i of the
87*> matrix was interchanged with row IPIV(i).
88*> \endverbatim
89*>
90*> \param[out] INFO
91*> \verbatim
92*> INFO is INTEGER
93*> = 0: successful exit
94*> < 0: if INFO = -i, the i-th argument had an illegal value
95*> > 0: if INFO = i, U(i,i) is exactly zero. The factorization
96*> has been completed, but the factor U is exactly
97*> singular, and division by zero will occur if it is used
98*> to solve a system of equations.
99*> \endverbatim
100*
101* Authors:
102* ========
103*
104*> \author Univ. of Tennessee
105*> \author Univ. of California Berkeley
106*> \author Univ. of Colorado Denver
107*> \author NAG Ltd.
108*
109*> \ingroup doubleGEcomputational
110*
111* =====================================================================
112 RECURSIVE SUBROUTINE dgetrf2( M, N, A, LDA, IPIV, INFO )
113*
114* -- LAPACK computational routine --
115* -- LAPACK is a software package provided by Univ. of Tennessee, --
116* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
117*
118* .. Scalar Arguments ..
119 INTEGER info, lda, m, n
120* ..
121* .. Array Arguments ..
122 INTEGER ipiv( * )
123 DOUBLE PRECISION a( lda, * )
124* ..
125*
126* =====================================================================
127*
128* .. Parameters ..
129 DOUBLE PRECISION one, zero
130 parameter( one = 1.0d+0, zero = 0.0d+0 )
131* ..
132* .. Local Scalars ..
133 DOUBLE PRECISION sfmin, temp
134 INTEGER i, iinfo, n1, n2
135* ..
136* .. External Functions ..
137 DOUBLE PRECISION dlamch
138 INTEGER idamax
139 EXTERNAL dlamch, idamax
140* ..
141* .. External Subroutines ..
142 EXTERNAL dgemm, dscal, dlaswp, dtrsm, xerbla
143* ..
144* .. Intrinsic Functions ..
145 INTRINSIC max, min
146* ..
147* .. Executable Statements ..
148*
149* Test the input parameters
150*
151 info = 0
152 IF( m.LT.0 ) THEN
153 info = -1
154 ELSE IF( n.LT.0 ) THEN
155 info = -2
156 ELSE IF( lda.LT.max( 1, m ) ) THEN
157 info = -4
158 END IF
159 IF( info.NE.0 ) THEN
160 CALL xerbla( 'DGETRF2', -info )
161 RETURN
162 END IF
163*
164* Quick return if possible
165*
166 IF( m.EQ.0 .OR. n.EQ.0 )
167 \$ RETURN
168
169 IF ( m.EQ.1 ) THEN
170*
171* Use unblocked code for one row case
172* Just need to handle IPIV and INFO
173*
174 ipiv( 1 ) = 1
175 IF ( a(1,1).EQ.zero )
176 \$ info = 1
177*
178 ELSE IF( n.EQ.1 ) THEN
179*
180* Use unblocked code for one column case
181*
182*
183* Compute machine safe minimum
184*
185 sfmin = dlamch('S')
186*
187* Find pivot and test for singularity
188*
189 i = idamax( m, a( 1, 1 ), 1 )
190 ipiv( 1 ) = i
191 IF( a( i, 1 ).NE.zero ) THEN
192*
193* Apply the interchange
194*
195 IF( i.NE.1 ) THEN
196 temp = a( 1, 1 )
197 a( 1, 1 ) = a( i, 1 )
198 a( i, 1 ) = temp
199 END IF
200*
201* Compute elements 2:M of the column
202*
203 IF( abs(a( 1, 1 )) .GE. sfmin ) THEN
204 CALL dscal( m-1, one / a( 1, 1 ), a( 2, 1 ), 1 )
205 ELSE
206 DO 10 i = 1, m-1
207 a( 1+i, 1 ) = a( 1+i, 1 ) / a( 1, 1 )
208 10 CONTINUE
209 END IF
210*
211 ELSE
212 info = 1
213 END IF
214*
215 ELSE
216*
217* Use recursive code
218*
219 n1 = min( m, n ) / 2
220 n2 = n-n1
221*
222* [ A11 ]
223* Factor [ --- ]
224* [ A21 ]
225*
226 CALL dgetrf2( m, n1, a, lda, ipiv, iinfo )
227
228 IF ( info.EQ.0 .AND. iinfo.GT.0 )
229 \$ info = iinfo
230*
231* [ A12 ]
232* Apply interchanges to [ --- ]
233* [ A22 ]
234*
235 CALL dlaswp( n2, a( 1, n1+1 ), lda, 1, n1, ipiv, 1 )
236*
237* Solve A12
238*
239 CALL dtrsm( 'L', 'L', 'N', 'U', n1, n2, one, a, lda,
240 \$ a( 1, n1+1 ), lda )
241*
242* Update A22
243*
244 CALL dgemm( 'N', 'N', m-n1, n2, n1, -one, a( n1+1, 1 ), lda,
245 \$ a( 1, n1+1 ), lda, one, a( n1+1, n1+1 ), lda )
246*
247* Factor A22
248*
249 CALL dgetrf2( m-n1, n2, a( n1+1, n1+1 ), lda, ipiv( n1+1 ),
250 \$ iinfo )
251*
252* Adjust INFO and the pivot indices
253*
254 IF ( info.EQ.0 .AND. iinfo.GT.0 )
255 \$ info = iinfo + n1
256 DO 20 i = n1+1, min( m, n )
257 ipiv( i ) = ipiv( i ) + n1
258 20 CONTINUE
259*
260* Apply interchanges to A21
261*
262 CALL dlaswp( n1, a( 1, 1 ), lda, n1+1, min( m, n), ipiv, 1 )
263*
264 END IF
265 RETURN
266*
267* End of DGETRF2
268*
269 END
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
integer function idamax(N, DX, INCX)
IDAMAX
Definition: idamax.f:71
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine dscal(N, DA, DX, INCX)
DSCAL
Definition: dscal.f:79
subroutine dtrsm(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B, LDB)
DTRSM
Definition: dtrsm.f:181
subroutine dgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
DGEMM
Definition: dgemm.f:187
recursive subroutine dgetrf2(M, N, A, LDA, IPIV, INFO)
DGETRF2
Definition: dgetrf2.f:113
subroutine dlaswp(N, A, LDA, K1, K2, IPIV, INCX)
DLASWP performs a series of row interchanges on a general rectangular matrix.
Definition: dlaswp.f:115