LAPACK 3.11.0 LAPACK: Linear Algebra PACKage
Searching...
No Matches
sort03.f
Go to the documentation of this file.
1*> \brief \b SORT03
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 SORT03( RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK,
12* RESULT, INFO )
13*
14* .. Scalar Arguments ..
15* CHARACTER*( * ) RC
16* INTEGER INFO, K, LDU, LDV, LWORK, MU, MV, N
17* REAL RESULT
18* ..
19* .. Array Arguments ..
20* REAL U( LDU, * ), V( LDV, * ), WORK( * )
21* ..
22*
23*
24*> \par Purpose:
25* =============
26*>
27*> \verbatim
28*>
29*> SORT03 compares two orthogonal matrices U and V to see if their
30*> corresponding rows or columns span the same spaces. The rows are
31*> checked if RC = 'R', and the columns are checked if RC = 'C'.
32*>
33*> RESULT is the maximum of
34*>
35*> | V*V' - I | / ( MV ulp ), if RC = 'R', or
36*>
37*> | V'*V - I | / ( MV ulp ), if RC = 'C',
38*>
39*> and the maximum over rows (or columns) 1 to K of
40*>
41*> | U(i) - S*V(i) |/ ( N ulp )
42*>
43*> where S is +-1 (chosen to minimize the expression), U(i) is the i-th
44*> row (column) of U, and V(i) is the i-th row (column) of V.
45*> \endverbatim
46*
47* Arguments:
48* ==========
49*
50*> \param[in] RC
51*> \verbatim
52*> RC is CHARACTER*1
53*> If RC = 'R' the rows of U and V are to be compared.
54*> If RC = 'C' the columns of U and V are to be compared.
55*> \endverbatim
56*>
57*> \param[in] MU
58*> \verbatim
59*> MU is INTEGER
60*> The number of rows of U if RC = 'R', and the number of
61*> columns if RC = 'C'. If MU = 0 SORT03 does nothing.
62*> MU must be at least zero.
63*> \endverbatim
64*>
65*> \param[in] MV
66*> \verbatim
67*> MV is INTEGER
68*> The number of rows of V if RC = 'R', and the number of
69*> columns if RC = 'C'. If MV = 0 SORT03 does nothing.
70*> MV must be at least zero.
71*> \endverbatim
72*>
73*> \param[in] N
74*> \verbatim
75*> N is INTEGER
76*> If RC = 'R', the number of columns in the matrices U and V,
77*> and if RC = 'C', the number of rows in U and V. If N = 0
78*> SORT03 does nothing. N must be at least zero.
79*> \endverbatim
80*>
81*> \param[in] K
82*> \verbatim
83*> K is INTEGER
84*> The number of rows or columns of U and V to compare.
85*> 0 <= K <= max(MU,MV).
86*> \endverbatim
87*>
88*> \param[in] U
89*> \verbatim
90*> U is REAL array, dimension (LDU,N)
91*> The first matrix to compare. If RC = 'R', U is MU by N, and
92*> if RC = 'C', U is N by MU.
93*> \endverbatim
94*>
95*> \param[in] LDU
96*> \verbatim
97*> LDU is INTEGER
98*> The leading dimension of U. If RC = 'R', LDU >= max(1,MU),
99*> and if RC = 'C', LDU >= max(1,N).
100*> \endverbatim
101*>
102*> \param[in] V
103*> \verbatim
104*> V is REAL array, dimension (LDV,N)
105*> The second matrix to compare. If RC = 'R', V is MV by N, and
106*> if RC = 'C', V is N by MV.
107*> \endverbatim
108*>
109*> \param[in] LDV
110*> \verbatim
111*> LDV is INTEGER
112*> The leading dimension of V. If RC = 'R', LDV >= max(1,MV),
113*> and if RC = 'C', LDV >= max(1,N).
114*> \endverbatim
115*>
116*> \param[out] WORK
117*> \verbatim
118*> WORK is REAL array, dimension (LWORK)
119*> \endverbatim
120*>
121*> \param[in] LWORK
122*> \verbatim
123*> LWORK is INTEGER
124*> The length of the array WORK. For best performance, LWORK
125*> should be at least N*N if RC = 'C' or M*M if RC = 'R', but
126*> the tests will be done even if LWORK is 0.
127*> \endverbatim
128*>
129*> \param[out] RESULT
130*> \verbatim
131*> RESULT is REAL
132*> The value computed by the test described above. RESULT is
133*> limited to 1/ulp to avoid overflow.
134*> \endverbatim
135*>
136*> \param[out] INFO
137*> \verbatim
138*> INFO is INTEGER
139*> 0 indicates a successful exit
140*> -k indicates the k-th parameter had an illegal value
141*> \endverbatim
142*
143* Authors:
144* ========
145*
146*> \author Univ. of Tennessee
147*> \author Univ. of California Berkeley
148*> \author Univ. of Colorado Denver
149*> \author NAG Ltd.
150*
151*> \ingroup single_eig
152*
153* =====================================================================
154 SUBROUTINE sort03( RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK,
155 \$ RESULT, INFO )
156*
157* -- LAPACK test routine --
158* -- LAPACK is a software package provided by Univ. of Tennessee, --
159* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
160*
161* .. Scalar Arguments ..
162 CHARACTER*( * ) RC
163 INTEGER INFO, K, LDU, LDV, LWORK, MU, MV, N
164 REAL RESULT
165* ..
166* .. Array Arguments ..
167 REAL U( LDU, * ), V( LDV, * ), WORK( * )
168* ..
169*
170* =====================================================================
171*
172* .. Parameters ..
173 REAL ZERO, ONE
174 parameter( zero = 0.0e0, one = 1.0e0 )
175* ..
176* .. Local Scalars ..
177 INTEGER I, IRC, J, LMX
178 REAL RES1, RES2, S, ULP
179* ..
180* .. External Functions ..
181 LOGICAL LSAME
182 INTEGER ISAMAX
183 REAL SLAMCH
184 EXTERNAL lsame, isamax, slamch
185* ..
186* .. Intrinsic Functions ..
187 INTRINSIC abs, max, min, real, sign
188* ..
189* .. External Subroutines ..
190 EXTERNAL sort01, xerbla
191* ..
192* .. Executable Statements ..
193*
194* Check inputs
195*
196 info = 0
197 IF( lsame( rc, 'R' ) ) THEN
198 irc = 0
199 ELSE IF( lsame( rc, 'C' ) ) THEN
200 irc = 1
201 ELSE
202 irc = -1
203 END IF
204 IF( irc.EQ.-1 ) THEN
205 info = -1
206 ELSE IF( mu.LT.0 ) THEN
207 info = -2
208 ELSE IF( mv.LT.0 ) THEN
209 info = -3
210 ELSE IF( n.LT.0 ) THEN
211 info = -4
212 ELSE IF( k.LT.0 .OR. k.GT.max( mu, mv ) ) THEN
213 info = -5
214 ELSE IF( ( irc.EQ.0 .AND. ldu.LT.max( 1, mu ) ) .OR.
215 \$ ( irc.EQ.1 .AND. ldu.LT.max( 1, n ) ) ) THEN
216 info = -7
217 ELSE IF( ( irc.EQ.0 .AND. ldv.LT.max( 1, mv ) ) .OR.
218 \$ ( irc.EQ.1 .AND. ldv.LT.max( 1, n ) ) ) THEN
219 info = -9
220 END IF
221 IF( info.NE.0 ) THEN
222 CALL xerbla( 'SORT03', -info )
223 RETURN
224 END IF
225*
226* Initialize result
227*
228 result = zero
229 IF( mu.EQ.0 .OR. mv.EQ.0 .OR. n.EQ.0 )
230 \$ RETURN
231*
232* Machine constants
233*
234 ulp = slamch( 'Precision' )
235*
236 IF( irc.EQ.0 ) THEN
237*
238* Compare rows
239*
240 res1 = zero
241 DO 20 i = 1, k
242 lmx = isamax( n, u( i, 1 ), ldu )
243 s = sign( one, u( i, lmx ) )*sign( one, v( i, lmx ) )
244 DO 10 j = 1, n
245 res1 = max( res1, abs( u( i, j )-s*v( i, j ) ) )
246 10 CONTINUE
247 20 CONTINUE
248 res1 = res1 / ( real( n )*ulp )
249*
250* Compute orthogonality of rows of V.
251*
252 CALL sort01( 'Rows', mv, n, v, ldv, work, lwork, res2 )
253*
254 ELSE
255*
256* Compare columns
257*
258 res1 = zero
259 DO 40 i = 1, k
260 lmx = isamax( n, u( 1, i ), 1 )
261 s = sign( one, u( lmx, i ) )*sign( one, v( lmx, i ) )
262 DO 30 j = 1, n
263 res1 = max( res1, abs( u( j, i )-s*v( j, i ) ) )
264 30 CONTINUE
265 40 CONTINUE
266 res1 = res1 / ( real( n )*ulp )
267*
268* Compute orthogonality of columns of V.
269*
270 CALL sort01( 'Columns', n, mv, v, ldv, work, lwork, res2 )
271 END IF
272*
273 result = min( max( res1, res2 ), one / ulp )
274 RETURN
275*
276* End of SORT03
277*
278 END
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
subroutine sort01(ROWCOL, M, N, U, LDU, WORK, LWORK, RESID)
SORT01
Definition: sort01.f:116
subroutine sort03(RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK, RESULT, INFO)
SORT03
Definition: sort03.f:156