 LAPACK  3.10.1 LAPACK: Linear Algebra PACKage

## ◆ slasv2()

 subroutine slasv2 ( real F, real G, real H, real SSMIN, real SSMAX, real SNR, real CSR, real SNL, real CSL )

SLASV2 computes the singular value decomposition of a 2-by-2 triangular matrix.

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

Purpose:
``` SLASV2 computes the singular value decomposition of a 2-by-2
triangular matrix
[  F   G  ]
[  0   H  ].
On return, abs(SSMAX) is the larger singular value, abs(SSMIN) is the
smaller singular value, and (CSL,SNL) and (CSR,SNR) are the left and
right singular vectors for abs(SSMAX), giving the decomposition

[ CSL  SNL ] [  F   G  ] [ CSR -SNR ]  =  [ SSMAX   0   ]
[-SNL  CSL ] [  0   H  ] [ SNR  CSR ]     [  0    SSMIN ].```
Parameters
 [in] F ``` F is REAL The (1,1) element of the 2-by-2 matrix.``` [in] G ``` G is REAL The (1,2) element of the 2-by-2 matrix.``` [in] H ``` H is REAL The (2,2) element of the 2-by-2 matrix.``` [out] SSMIN ``` SSMIN is REAL abs(SSMIN) is the smaller singular value.``` [out] SSMAX ``` SSMAX is REAL abs(SSMAX) is the larger singular value.``` [out] SNL ` SNL is REAL` [out] CSL ``` CSL is REAL The vector (CSL, SNL) is a unit left singular vector for the singular value abs(SSMAX).``` [out] SNR ` SNR is REAL` [out] CSR ``` CSR is REAL The vector (CSR, SNR) is a unit right singular vector for the singular value abs(SSMAX).```
Further Details:
```  Any input parameter may be aliased with any output parameter.

Barring over/underflow and assuming a guard digit in subtraction, all
output quantities are correct to within a few units in the last
place (ulps).

In IEEE arithmetic, the code works correctly if one matrix element is
infinite.

Overflow will not occur unless the largest singular value itself
overflows or is within a few ulps of overflow. (On machines with
partial overflow, like the Cray, overflow may occur if the largest
singular value is within a factor of 2 of overflow.)

Underflow is harmless if underflow is gradual. Otherwise, results
may correspond to a matrix modified by perturbations of size near
the underflow threshold.```

Definition at line 137 of file slasv2.f.

138 *
139 * -- LAPACK auxiliary routine --
140 * -- LAPACK is a software package provided by Univ. of Tennessee, --
141 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
142 *
143 * .. Scalar Arguments ..
144  REAL CSL, CSR, F, G, H, SNL, SNR, SSMAX, SSMIN
145 * ..
146 *
147 * =====================================================================
148 *
149 * .. Parameters ..
150  REAL ZERO
151  parameter( zero = 0.0e0 )
152  REAL HALF
153  parameter( half = 0.5e0 )
154  REAL ONE
155  parameter( one = 1.0e0 )
156  REAL TWO
157  parameter( two = 2.0e0 )
158  REAL FOUR
159  parameter( four = 4.0e0 )
160 * ..
161 * .. Local Scalars ..
162  LOGICAL GASMAL, SWAP
163  INTEGER PMAX
164  REAL A, CLT, CRT, D, FA, FT, GA, GT, HA, HT, L, M,
165  \$ MM, R, S, SLT, SRT, T, TEMP, TSIGN, TT
166 * ..
167 * .. Intrinsic Functions ..
168  INTRINSIC abs, sign, sqrt
169 * ..
170 * .. External Functions ..
171  REAL SLAMCH
172  EXTERNAL slamch
173 * ..
174 * .. Executable Statements ..
175 *
176  ft = f
177  fa = abs( ft )
178  ht = h
179  ha = abs( h )
180 *
181 * PMAX points to the maximum absolute element of matrix
182 * PMAX = 1 if F largest in absolute values
183 * PMAX = 2 if G largest in absolute values
184 * PMAX = 3 if H largest in absolute values
185 *
186  pmax = 1
187  swap = ( ha.GT.fa )
188  IF( swap ) THEN
189  pmax = 3
190  temp = ft
191  ft = ht
192  ht = temp
193  temp = fa
194  fa = ha
195  ha = temp
196 *
197 * Now FA .ge. HA
198 *
199  END IF
200  gt = g
201  ga = abs( gt )
202  IF( ga.EQ.zero ) THEN
203 *
204 * Diagonal matrix
205 *
206  ssmin = ha
207  ssmax = fa
208  clt = one
209  crt = one
210  slt = zero
211  srt = zero
212  ELSE
213  gasmal = .true.
214  IF( ga.GT.fa ) THEN
215  pmax = 2
216  IF( ( fa / ga ).LT.slamch( 'EPS' ) ) THEN
217 *
218 * Case of very large GA
219 *
220  gasmal = .false.
221  ssmax = ga
222  IF( ha.GT.one ) THEN
223  ssmin = fa / ( ga / ha )
224  ELSE
225  ssmin = ( fa / ga )*ha
226  END IF
227  clt = one
228  slt = ht / gt
229  srt = one
230  crt = ft / gt
231  END IF
232  END IF
233  IF( gasmal ) THEN
234 *
235 * Normal case
236 *
237  d = fa - ha
238  IF( d.EQ.fa ) THEN
239 *
240 * Copes with infinite F or H
241 *
242  l = one
243  ELSE
244  l = d / fa
245  END IF
246 *
247 * Note that 0 .le. L .le. 1
248 *
249  m = gt / ft
250 *
251 * Note that abs(M) .le. 1/macheps
252 *
253  t = two - l
254 *
255 * Note that T .ge. 1
256 *
257  mm = m*m
258  tt = t*t
259  s = sqrt( tt+mm )
260 *
261 * Note that 1 .le. S .le. 1 + 1/macheps
262 *
263  IF( l.EQ.zero ) THEN
264  r = abs( m )
265  ELSE
266  r = sqrt( l*l+mm )
267  END IF
268 *
269 * Note that 0 .le. R .le. 1 + 1/macheps
270 *
271  a = half*( s+r )
272 *
273 * Note that 1 .le. A .le. 1 + abs(M)
274 *
275  ssmin = ha / a
276  ssmax = fa*a
277  IF( mm.EQ.zero ) THEN
278 *
279 * Note that M is very tiny
280 *
281  IF( l.EQ.zero ) THEN
282  t = sign( two, ft )*sign( one, gt )
283  ELSE
284  t = gt / sign( d, ft ) + m / t
285  END IF
286  ELSE
287  t = ( m / ( s+t )+m / ( r+l ) )*( one+a )
288  END IF
289  l = sqrt( t*t+four )
290  crt = two / l
291  srt = t / l
292  clt = ( crt+srt*m ) / a
293  slt = ( ht / ft )*srt / a
294  END IF
295  END IF
296  IF( swap ) THEN
297  csl = srt
298  snl = crt
299  csr = slt
300  snr = clt
301  ELSE
302  csl = clt
303  snl = slt
304  csr = crt
305  snr = srt
306  END IF
307 *
308 * Correct signs of SSMAX and SSMIN
309 *
310  IF( pmax.EQ.1 )
311  \$ tsign = sign( one, csr )*sign( one, csl )*sign( one, f )
312  IF( pmax.EQ.2 )
313  \$ tsign = sign( one, snr )*sign( one, csl )*sign( one, g )
314  IF( pmax.EQ.3 )
315  \$ tsign = sign( one, snr )*sign( one, snl )*sign( one, h )
316  ssmax = sign( ssmax, tsign )
317  ssmin = sign( ssmin, tsign*sign( one, f )*sign( one, h ) )
318  RETURN
319 *
320 * End of SLASV2
321 *
real function slamch(CMACH)
SLAMCH
Definition: slamch.f:68
Here is the caller graph for this function: