LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches
zqrt04.f
Go to the documentation of this file.
1*> \brief \b ZQRT04
2*
3* =========== DOCUMENTATION ===========
4*
5* Online html documentation available at
6* http://www.netlib.org/lapack/explore-html/
7*
8* Definition:
9* ===========
10*
11* SUBROUTINE ZQRT04(M,N,NB,RESULT)
12*
13* .. Scalar Arguments ..
14* INTEGER M, N, NB, LDT
15* .. Return values ..
16* DOUBLE PRECISION RESULT(6)
17*
18*
19*> \par Purpose:
20* =============
21*>
22*> \verbatim
23*>
24*> ZQRT04 tests ZGEQRT and ZGEMQRT.
25*> \endverbatim
26*
27* Arguments:
28* ==========
29*
30*> \param[in] M
31*> \verbatim
32*> M is INTEGER
33*> Number of rows in test matrix.
34*> \endverbatim
35*>
36*> \param[in] N
37*> \verbatim
38*> N is INTEGER
39*> Number of columns in test matrix.
40*> \endverbatim
41*>
42*> \param[in] NB
43*> \verbatim
44*> NB is INTEGER
45*> Block size of test matrix. NB <= Min(M,N).
46*> \endverbatim
47*>
48*> \param[out] RESULT
49*> \verbatim
50*> RESULT is DOUBLE PRECISION array, dimension (6)
51*> Results of each of the six tests below.
52*>
53*> RESULT(1) = | A - Q R |
54*> RESULT(2) = | I - Q^H Q |
55*> RESULT(3) = | Q C - Q C |
56*> RESULT(4) = | Q^H C - Q^H C |
57*> RESULT(5) = | C Q - C Q |
58*> RESULT(6) = | C Q^H - C Q^H |
59*> \endverbatim
60*
61* Authors:
62* ========
63*
64*> \author Univ. of Tennessee
65*> \author Univ. of California Berkeley
66*> \author Univ. of Colorado Denver
67*> \author NAG Ltd.
68*
69*> \ingroup complex16_lin
70*
71* =====================================================================
72 SUBROUTINE zqrt04(M,N,NB,RESULT)
73 IMPLICIT NONE
74*
75* -- LAPACK test routine --
76* -- LAPACK is a software package provided by Univ. of Tennessee, --
77* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
78*
79* .. Scalar Arguments ..
80 INTEGER M, N, NB, LDT
81* .. Return values ..
82 DOUBLE PRECISION RESULT(6)
83*
84* =====================================================================
85*
86* ..
87* .. Local allocatable arrays
88 COMPLEX*16, ALLOCATABLE :: AF(:,:), Q(:,:),
89 \$ R(:,:), WORK( : ), T(:,:),
90 \$ CF(:,:), DF(:,:), A(:,:), C(:,:), D(:,:)
91 DOUBLE PRECISION, ALLOCATABLE :: RWORK(:)
92*
93* .. Parameters ..
94 DOUBLE PRECISION ZERO
95 COMPLEX*16 ONE, CZERO
96 parameter( zero = 0.0, one = (1.0,0.0), czero=(0.0,0.0) )
97* ..
98* .. Local Scalars ..
99 INTEGER INFO, J, K, L, LWORK
100 DOUBLE PRECISION ANORM, EPS, RESID, CNORM, DNORM
101* ..
102* .. Local Arrays ..
103 INTEGER ISEED( 4 )
104* ..
105* .. External Functions ..
106 DOUBLE PRECISION DLAMCH
107 DOUBLE PRECISION ZLANGE, ZLANSY
108 LOGICAL LSAME
109 EXTERNAL dlamch, zlange, zlansy, lsame
110* ..
111* .. Intrinsic Functions ..
112 INTRINSIC max, min
113* ..
114* .. Data statements ..
115 DATA iseed / 1988, 1989, 1990, 1991 /
116*
117 eps = dlamch( 'Epsilon' )
118 k = min(m,n)
119 l = max(m,n)
120 lwork = max(2,l)*max(2,l)*nb
121*
122* Dynamically allocate local arrays
123*
124 ALLOCATE ( a(m,n), af(m,n), q(m,m), r(m,l), rwork(l),
125 \$ work(lwork), t(nb,n), c(m,n), cf(m,n),
126 \$ d(n,m), df(n,m) )
127*
128* Put random numbers into A and copy to AF
129*
130 ldt=nb
131 DO j=1,n
132 CALL zlarnv( 2, iseed, m, a( 1, j ) )
133 END DO
134 CALL zlacpy( 'Full', m, n, a, m, af, m )
135*
136* Factor the matrix A in the array AF.
137*
138 CALL zgeqrt( m, n, nb, af, m, t, ldt, work, info )
139*
140* Generate the m-by-m matrix Q
141*
142 CALL zlaset( 'Full', m, m, czero, one, q, m )
143 CALL zgemqrt( 'R', 'N', m, m, k, nb, af, m, t, ldt, q, m,
144 \$ work, info )
145*
146* Copy R
147*
148 CALL zlaset( 'Full', m, n, czero, czero, r, m )
149 CALL zlacpy( 'Upper', m, n, af, m, r, m )
150*
151* Compute |R - Q'*A| / |A| and store in RESULT(1)
152*
153 CALL zgemm( 'C', 'N', m, n, m, -one, q, m, a, m, one, r, m )
154 anorm = zlange( '1', m, n, a, m, rwork )
155 resid = zlange( '1', m, n, r, m, rwork )
156 IF( anorm.GT.zero ) THEN
157 result( 1 ) = resid / (eps*max(1,m)*anorm)
158 ELSE
159 result( 1 ) = zero
160 END IF
161*
162* Compute |I - Q'*Q| and store in RESULT(2)
163*
164 CALL zlaset( 'Full', m, m, czero, one, r, m )
165 CALL zherk( 'U', 'C', m, m, dreal(-one), q, m, dreal(one), r, m )
166 resid = zlansy( '1', 'Upper', m, r, m, rwork )
167 result( 2 ) = resid / (eps*max(1,m))
168*
169* Generate random m-by-n matrix C and a copy CF
170*
171 DO j=1,n
172 CALL zlarnv( 2, iseed, m, c( 1, j ) )
173 END DO
174 cnorm = zlange( '1', m, n, c, m, rwork)
175 CALL zlacpy( 'Full', m, n, c, m, cf, m )
176*
177* Apply Q to C as Q*C
178*
179 CALL zgemqrt( 'L', 'N', m, n, k, nb, af, m, t, nb, cf, m,
180 \$ work, info)
181*
182* Compute |Q*C - Q*C| / |C|
183*
184 CALL zgemm( 'N', 'N', m, n, m, -one, q, m, c, m, one, cf, m )
185 resid = zlange( '1', m, n, cf, m, rwork )
186 IF( cnorm.GT.zero ) THEN
187 result( 3 ) = resid / (eps*max(1,m)*cnorm)
188 ELSE
189 result( 3 ) = zero
190 END IF
191*
192* Copy C into CF again
193*
194 CALL zlacpy( 'Full', m, n, c, m, cf, m )
195*
196* Apply Q to C as QT*C
197*
198 CALL zgemqrt( 'L', 'C', m, n, k, nb, af, m, t, nb, cf, m,
199 \$ work, info)
200*
201* Compute |QT*C - QT*C| / |C|
202*
203 CALL zgemm( 'C', 'N', m, n, m, -one, q, m, c, m, one, cf, m )
204 resid = zlange( '1', m, n, cf, m, rwork )
205 IF( cnorm.GT.zero ) THEN
206 result( 4 ) = resid / (eps*max(1,m)*cnorm)
207 ELSE
208 result( 4 ) = zero
209 END IF
210*
211* Generate random n-by-m matrix D and a copy DF
212*
213 DO j=1,m
214 CALL zlarnv( 2, iseed, n, d( 1, j ) )
215 END DO
216 dnorm = zlange( '1', n, m, d, n, rwork)
217 CALL zlacpy( 'Full', n, m, d, n, df, n )
218*
219* Apply Q to D as D*Q
220*
221 CALL zgemqrt( 'R', 'N', n, m, k, nb, af, m, t, nb, df, n,
222 \$ work, info)
223*
224* Compute |D*Q - D*Q| / |D|
225*
226 CALL zgemm( 'N', 'N', n, m, m, -one, d, n, q, m, one, df, n )
227 resid = zlange( '1', n, m, df, n, rwork )
228 IF( cnorm.GT.zero ) THEN
229 result( 5 ) = resid / (eps*max(1,m)*dnorm)
230 ELSE
231 result( 5 ) = zero
232 END IF
233*
234* Copy D into DF again
235*
236 CALL zlacpy( 'Full', n, m, d, n, df, n )
237*
238* Apply Q to D as D*QT
239*
240 CALL zgemqrt( 'R', 'C', n, m, k, nb, af, m, t, nb, df, n,
241 \$ work, info)
242*
243* Compute |D*QT - D*QT| / |D|
244*
245 CALL zgemm( 'N', 'C', n, m, m, -one, d, n, q, m, one, df, n )
246 resid = zlange( '1', n, m, df, n, rwork )
247 IF( cnorm.GT.zero ) THEN
248 result( 6 ) = resid / (eps*max(1,m)*dnorm)
249 ELSE
250 result( 6 ) = zero
251 END IF
252*
253* Deallocate all arrays
254*
255 DEALLOCATE ( a, af, q, r, rwork, work, t, c, d, cf, df)
256*
257 RETURN
258 END
259
subroutine zgemm(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC)
ZGEMM
Definition: zgemm.f:187
subroutine zherk(UPLO, TRANS, N, K, ALPHA, A, LDA, BETA, C, LDC)
ZHERK
Definition: zherk.f:173
subroutine zqrt04(M, N, NB, RESULT)
ZQRT04
Definition: zqrt04.f:73
subroutine zgemqrt(SIDE, TRANS, M, N, K, NB, V, LDV, T, LDT, C, LDC, WORK, INFO)
ZGEMQRT
Definition: zgemqrt.f:168
subroutine zgeqrt(M, N, NB, A, LDA, T, LDT, WORK, INFO)
ZGEQRT
Definition: zgeqrt.f:141
subroutine zlacpy(UPLO, M, N, A, LDA, B, LDB)
ZLACPY copies all or part of one two-dimensional array to another.
Definition: zlacpy.f:103
subroutine zlarnv(IDIST, ISEED, N, X)
ZLARNV returns a vector of random numbers from a uniform or normal distribution.
Definition: zlarnv.f:99
subroutine zlaset(UPLO, M, N, ALPHA, BETA, A, LDA)
ZLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
Definition: zlaset.f:106