LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ dlaqtr()

subroutine dlaqtr ( logical  LTRAN,
logical  LREAL,
integer  N,
double precision, dimension( ldt, * )  T,
integer  LDT,
double precision, dimension( * )  B,
double precision  W,
double precision  SCALE,
double precision, dimension( * )  X,
double precision, dimension( * )  WORK,
integer  INFO 
)

DLAQTR solves a real quasi-triangular system of equations, or a complex quasi-triangular system of special form, in real arithmetic.

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

Purpose:
 DLAQTR solves the real quasi-triangular system

              op(T)*p = scale*c,               if LREAL = .TRUE.

 or the complex quasi-triangular systems

            op(T + iB)*(p+iq) = scale*(c+id),  if LREAL = .FALSE.

 in real arithmetic, where T is upper quasi-triangular.
 If LREAL = .FALSE., then the first diagonal block of T must be
 1 by 1, B is the specially structured matrix

                B = [ b(1) b(2) ... b(n) ]
                    [       w            ]
                    [           w        ]
                    [              .     ]
                    [                 w  ]

 op(A) = A or A**T, A**T denotes the transpose of
 matrix A.

 On input, X = [ c ].  On output, X = [ p ].
               [ d ]                  [ q ]

 This subroutine is designed for the condition number estimation
 in routine DTRSNA.
Parameters
[in]LTRAN
          LTRAN is LOGICAL
          On entry, LTRAN specifies the option of conjugate transpose:
             = .FALSE.,    op(T+i*B) = T+i*B,
             = .TRUE.,     op(T+i*B) = (T+i*B)**T.
[in]LREAL
          LREAL is LOGICAL
          On entry, LREAL specifies the input matrix structure:
             = .FALSE.,    the input is complex
             = .TRUE.,     the input is real
[in]N
          N is INTEGER
          On entry, N specifies the order of T+i*B. N >= 0.
[in]T
          T is DOUBLE PRECISION array, dimension (LDT,N)
          On entry, T contains a matrix in Schur canonical form.
          If LREAL = .FALSE., then the first diagonal block of T mu
          be 1 by 1.
[in]LDT
          LDT is INTEGER
          The leading dimension of the matrix T. LDT >= max(1,N).
[in]B
          B is DOUBLE PRECISION array, dimension (N)
          On entry, B contains the elements to form the matrix
          B as described above.
          If LREAL = .TRUE., B is not referenced.
[in]W
          W is DOUBLE PRECISION
          On entry, W is the diagonal element of the matrix B.
          If LREAL = .TRUE., W is not referenced.
[out]SCALE
          SCALE is DOUBLE PRECISION
          On exit, SCALE is the scale factor.
[in,out]X
          X is DOUBLE PRECISION array, dimension (2*N)
          On entry, X contains the right hand side of the system.
          On exit, X is overwritten by the solution.
[out]WORK
          WORK is DOUBLE PRECISION array, dimension (N)
[out]INFO
          INFO is INTEGER
          On exit, INFO is set to
             0: successful exit.
               1: the some diagonal 1 by 1 block has been perturbed by
                  a small number SMIN to keep nonsingularity.
               2: the some diagonal 2 by 2 block has been perturbed by
                  a small number in DLALN2 to keep nonsingularity.
          NOTE: In the interests of speed, this routine does not
                check the inputs for errors.
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 163 of file dlaqtr.f.

165 *
166 * -- LAPACK auxiliary routine --
167 * -- LAPACK is a software package provided by Univ. of Tennessee, --
168 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
169 *
170 * .. Scalar Arguments ..
171  LOGICAL LREAL, LTRAN
172  INTEGER INFO, LDT, N
173  DOUBLE PRECISION SCALE, W
174 * ..
175 * .. Array Arguments ..
176  DOUBLE PRECISION B( * ), T( LDT, * ), WORK( * ), X( * )
177 * ..
178 *
179 * =====================================================================
180 *
181 * .. Parameters ..
182  DOUBLE PRECISION ZERO, ONE
183  parameter( zero = 0.0d+0, one = 1.0d+0 )
184 * ..
185 * .. Local Scalars ..
186  LOGICAL NOTRAN
187  INTEGER I, IERR, J, J1, J2, JNEXT, K, N1, N2
188  DOUBLE PRECISION BIGNUM, EPS, REC, SCALOC, SI, SMIN, SMINW,
189  $ SMLNUM, SR, TJJ, TMP, XJ, XMAX, XNORM, Z
190 * ..
191 * .. Local Arrays ..
192  DOUBLE PRECISION D( 2, 2 ), V( 2, 2 )
193 * ..
194 * .. External Functions ..
195  INTEGER IDAMAX
196  DOUBLE PRECISION DASUM, DDOT, DLAMCH, DLANGE
197  EXTERNAL idamax, dasum, ddot, dlamch, dlange
198 * ..
199 * .. External Subroutines ..
200  EXTERNAL daxpy, dladiv, dlaln2, dscal
201 * ..
202 * .. Intrinsic Functions ..
203  INTRINSIC abs, max
204 * ..
205 * .. Executable Statements ..
206 *
207 * Do not test the input parameters for errors
208 *
209  notran = .NOT.ltran
210  info = 0
211 *
212 * Quick return if possible
213 *
214  IF( n.EQ.0 )
215  $ RETURN
216 *
217 * Set constants to control overflow
218 *
219  eps = dlamch( 'P' )
220  smlnum = dlamch( 'S' ) / eps
221  bignum = one / smlnum
222 *
223  xnorm = dlange( 'M', n, n, t, ldt, d )
224  IF( .NOT.lreal )
225  $ xnorm = max( xnorm, abs( w ), dlange( 'M', n, 1, b, n, d ) )
226  smin = max( smlnum, eps*xnorm )
227 *
228 * Compute 1-norm of each column of strictly upper triangular
229 * part of T to control overflow in triangular solver.
230 *
231  work( 1 ) = zero
232  DO 10 j = 2, n
233  work( j ) = dasum( j-1, t( 1, j ), 1 )
234  10 CONTINUE
235 *
236  IF( .NOT.lreal ) THEN
237  DO 20 i = 2, n
238  work( i ) = work( i ) + abs( b( i ) )
239  20 CONTINUE
240  END IF
241 *
242  n2 = 2*n
243  n1 = n
244  IF( .NOT.lreal )
245  $ n1 = n2
246  k = idamax( n1, x, 1 )
247  xmax = abs( x( k ) )
248  scale = one
249 *
250  IF( xmax.GT.bignum ) THEN
251  scale = bignum / xmax
252  CALL dscal( n1, scale, x, 1 )
253  xmax = bignum
254  END IF
255 *
256  IF( lreal ) THEN
257 *
258  IF( notran ) THEN
259 *
260 * Solve T*p = scale*c
261 *
262  jnext = n
263  DO 30 j = n, 1, -1
264  IF( j.GT.jnext )
265  $ GO TO 30
266  j1 = j
267  j2 = j
268  jnext = j - 1
269  IF( j.GT.1 ) THEN
270  IF( t( j, j-1 ).NE.zero ) THEN
271  j1 = j - 1
272  jnext = j - 2
273  END IF
274  END IF
275 *
276  IF( j1.EQ.j2 ) THEN
277 *
278 * Meet 1 by 1 diagonal block
279 *
280 * Scale to avoid overflow when computing
281 * x(j) = b(j)/T(j,j)
282 *
283  xj = abs( x( j1 ) )
284  tjj = abs( t( j1, j1 ) )
285  tmp = t( j1, j1 )
286  IF( tjj.LT.smin ) THEN
287  tmp = smin
288  tjj = smin
289  info = 1
290  END IF
291 *
292  IF( xj.EQ.zero )
293  $ GO TO 30
294 *
295  IF( tjj.LT.one ) THEN
296  IF( xj.GT.bignum*tjj ) THEN
297  rec = one / xj
298  CALL dscal( n, rec, x, 1 )
299  scale = scale*rec
300  xmax = xmax*rec
301  END IF
302  END IF
303  x( j1 ) = x( j1 ) / tmp
304  xj = abs( x( j1 ) )
305 *
306 * Scale x if necessary to avoid overflow when adding a
307 * multiple of column j1 of T.
308 *
309  IF( xj.GT.one ) THEN
310  rec = one / xj
311  IF( work( j1 ).GT.( bignum-xmax )*rec ) THEN
312  CALL dscal( n, rec, x, 1 )
313  scale = scale*rec
314  END IF
315  END IF
316  IF( j1.GT.1 ) THEN
317  CALL daxpy( j1-1, -x( j1 ), t( 1, j1 ), 1, x, 1 )
318  k = idamax( j1-1, x, 1 )
319  xmax = abs( x( k ) )
320  END IF
321 *
322  ELSE
323 *
324 * Meet 2 by 2 diagonal block
325 *
326 * Call 2 by 2 linear system solve, to take
327 * care of possible overflow by scaling factor.
328 *
329  d( 1, 1 ) = x( j1 )
330  d( 2, 1 ) = x( j2 )
331  CALL dlaln2( .false., 2, 1, smin, one, t( j1, j1 ),
332  $ ldt, one, one, d, 2, zero, zero, v, 2,
333  $ scaloc, xnorm, ierr )
334  IF( ierr.NE.0 )
335  $ info = 2
336 *
337  IF( scaloc.NE.one ) THEN
338  CALL dscal( n, scaloc, x, 1 )
339  scale = scale*scaloc
340  END IF
341  x( j1 ) = v( 1, 1 )
342  x( j2 ) = v( 2, 1 )
343 *
344 * Scale V(1,1) (= X(J1)) and/or V(2,1) (=X(J2))
345 * to avoid overflow in updating right-hand side.
346 *
347  xj = max( abs( v( 1, 1 ) ), abs( v( 2, 1 ) ) )
348  IF( xj.GT.one ) THEN
349  rec = one / xj
350  IF( max( work( j1 ), work( j2 ) ).GT.
351  $ ( bignum-xmax )*rec ) THEN
352  CALL dscal( n, rec, x, 1 )
353  scale = scale*rec
354  END IF
355  END IF
356 *
357 * Update right-hand side
358 *
359  IF( j1.GT.1 ) THEN
360  CALL daxpy( j1-1, -x( j1 ), t( 1, j1 ), 1, x, 1 )
361  CALL daxpy( j1-1, -x( j2 ), t( 1, j2 ), 1, x, 1 )
362  k = idamax( j1-1, x, 1 )
363  xmax = abs( x( k ) )
364  END IF
365 *
366  END IF
367 *
368  30 CONTINUE
369 *
370  ELSE
371 *
372 * Solve T**T*p = scale*c
373 *
374  jnext = 1
375  DO 40 j = 1, n
376  IF( j.LT.jnext )
377  $ GO TO 40
378  j1 = j
379  j2 = j
380  jnext = j + 1
381  IF( j.LT.n ) THEN
382  IF( t( j+1, j ).NE.zero ) THEN
383  j2 = j + 1
384  jnext = j + 2
385  END IF
386  END IF
387 *
388  IF( j1.EQ.j2 ) THEN
389 *
390 * 1 by 1 diagonal block
391 *
392 * Scale if necessary to avoid overflow in forming the
393 * right-hand side element by inner product.
394 *
395  xj = abs( x( j1 ) )
396  IF( xmax.GT.one ) THEN
397  rec = one / xmax
398  IF( work( j1 ).GT.( bignum-xj )*rec ) THEN
399  CALL dscal( n, rec, x, 1 )
400  scale = scale*rec
401  xmax = xmax*rec
402  END IF
403  END IF
404 *
405  x( j1 ) = x( j1 ) - ddot( j1-1, t( 1, j1 ), 1, x, 1 )
406 *
407  xj = abs( x( j1 ) )
408  tjj = abs( t( j1, j1 ) )
409  tmp = t( j1, j1 )
410  IF( tjj.LT.smin ) THEN
411  tmp = smin
412  tjj = smin
413  info = 1
414  END IF
415 *
416  IF( tjj.LT.one ) THEN
417  IF( xj.GT.bignum*tjj ) THEN
418  rec = one / xj
419  CALL dscal( n, rec, x, 1 )
420  scale = scale*rec
421  xmax = xmax*rec
422  END IF
423  END IF
424  x( j1 ) = x( j1 ) / tmp
425  xmax = max( xmax, abs( x( j1 ) ) )
426 *
427  ELSE
428 *
429 * 2 by 2 diagonal block
430 *
431 * Scale if necessary to avoid overflow in forming the
432 * right-hand side elements by inner product.
433 *
434  xj = max( abs( x( j1 ) ), abs( x( j2 ) ) )
435  IF( xmax.GT.one ) THEN
436  rec = one / xmax
437  IF( max( work( j2 ), work( j1 ) ).GT.( bignum-xj )*
438  $ rec ) THEN
439  CALL dscal( n, rec, x, 1 )
440  scale = scale*rec
441  xmax = xmax*rec
442  END IF
443  END IF
444 *
445  d( 1, 1 ) = x( j1 ) - ddot( j1-1, t( 1, j1 ), 1, x,
446  $ 1 )
447  d( 2, 1 ) = x( j2 ) - ddot( j1-1, t( 1, j2 ), 1, x,
448  $ 1 )
449 *
450  CALL dlaln2( .true., 2, 1, smin, one, t( j1, j1 ),
451  $ ldt, one, one, d, 2, zero, zero, v, 2,
452  $ scaloc, xnorm, ierr )
453  IF( ierr.NE.0 )
454  $ info = 2
455 *
456  IF( scaloc.NE.one ) THEN
457  CALL dscal( n, scaloc, x, 1 )
458  scale = scale*scaloc
459  END IF
460  x( j1 ) = v( 1, 1 )
461  x( j2 ) = v( 2, 1 )
462  xmax = max( abs( x( j1 ) ), abs( x( j2 ) ), xmax )
463 *
464  END IF
465  40 CONTINUE
466  END IF
467 *
468  ELSE
469 *
470  sminw = max( eps*abs( w ), smin )
471  IF( notran ) THEN
472 *
473 * Solve (T + iB)*(p+iq) = c+id
474 *
475  jnext = n
476  DO 70 j = n, 1, -1
477  IF( j.GT.jnext )
478  $ GO TO 70
479  j1 = j
480  j2 = j
481  jnext = j - 1
482  IF( j.GT.1 ) THEN
483  IF( t( j, j-1 ).NE.zero ) THEN
484  j1 = j - 1
485  jnext = j - 2
486  END IF
487  END IF
488 *
489  IF( j1.EQ.j2 ) THEN
490 *
491 * 1 by 1 diagonal block
492 *
493 * Scale if necessary to avoid overflow in division
494 *
495  z = w
496  IF( j1.EQ.1 )
497  $ z = b( 1 )
498  xj = abs( x( j1 ) ) + abs( x( n+j1 ) )
499  tjj = abs( t( j1, j1 ) ) + abs( z )
500  tmp = t( j1, j1 )
501  IF( tjj.LT.sminw ) THEN
502  tmp = sminw
503  tjj = sminw
504  info = 1
505  END IF
506 *
507  IF( xj.EQ.zero )
508  $ GO TO 70
509 *
510  IF( tjj.LT.one ) THEN
511  IF( xj.GT.bignum*tjj ) THEN
512  rec = one / xj
513  CALL dscal( n2, rec, x, 1 )
514  scale = scale*rec
515  xmax = xmax*rec
516  END IF
517  END IF
518  CALL dladiv( x( j1 ), x( n+j1 ), tmp, z, sr, si )
519  x( j1 ) = sr
520  x( n+j1 ) = si
521  xj = abs( x( j1 ) ) + abs( x( n+j1 ) )
522 *
523 * Scale x if necessary to avoid overflow when adding a
524 * multiple of column j1 of T.
525 *
526  IF( xj.GT.one ) THEN
527  rec = one / xj
528  IF( work( j1 ).GT.( bignum-xmax )*rec ) THEN
529  CALL dscal( n2, rec, x, 1 )
530  scale = scale*rec
531  END IF
532  END IF
533 *
534  IF( j1.GT.1 ) THEN
535  CALL daxpy( j1-1, -x( j1 ), t( 1, j1 ), 1, x, 1 )
536  CALL daxpy( j1-1, -x( n+j1 ), t( 1, j1 ), 1,
537  $ x( n+1 ), 1 )
538 *
539  x( 1 ) = x( 1 ) + b( j1 )*x( n+j1 )
540  x( n+1 ) = x( n+1 ) - b( j1 )*x( j1 )
541 *
542  xmax = zero
543  DO 50 k = 1, j1 - 1
544  xmax = max( xmax, abs( x( k ) )+
545  $ abs( x( k+n ) ) )
546  50 CONTINUE
547  END IF
548 *
549  ELSE
550 *
551 * Meet 2 by 2 diagonal block
552 *
553  d( 1, 1 ) = x( j1 )
554  d( 2, 1 ) = x( j2 )
555  d( 1, 2 ) = x( n+j1 )
556  d( 2, 2 ) = x( n+j2 )
557  CALL dlaln2( .false., 2, 2, sminw, one, t( j1, j1 ),
558  $ ldt, one, one, d, 2, zero, -w, v, 2,
559  $ scaloc, xnorm, ierr )
560  IF( ierr.NE.0 )
561  $ info = 2
562 *
563  IF( scaloc.NE.one ) THEN
564  CALL dscal( 2*n, scaloc, x, 1 )
565  scale = scaloc*scale
566  END IF
567  x( j1 ) = v( 1, 1 )
568  x( j2 ) = v( 2, 1 )
569  x( n+j1 ) = v( 1, 2 )
570  x( n+j2 ) = v( 2, 2 )
571 *
572 * Scale X(J1), .... to avoid overflow in
573 * updating right hand side.
574 *
575  xj = max( abs( v( 1, 1 ) )+abs( v( 1, 2 ) ),
576  $ abs( v( 2, 1 ) )+abs( v( 2, 2 ) ) )
577  IF( xj.GT.one ) THEN
578  rec = one / xj
579  IF( max( work( j1 ), work( j2 ) ).GT.
580  $ ( bignum-xmax )*rec ) THEN
581  CALL dscal( n2, rec, x, 1 )
582  scale = scale*rec
583  END IF
584  END IF
585 *
586 * Update the right-hand side.
587 *
588  IF( j1.GT.1 ) THEN
589  CALL daxpy( j1-1, -x( j1 ), t( 1, j1 ), 1, x, 1 )
590  CALL daxpy( j1-1, -x( j2 ), t( 1, j2 ), 1, x, 1 )
591 *
592  CALL daxpy( j1-1, -x( n+j1 ), t( 1, j1 ), 1,
593  $ x( n+1 ), 1 )
594  CALL daxpy( j1-1, -x( n+j2 ), t( 1, j2 ), 1,
595  $ x( n+1 ), 1 )
596 *
597  x( 1 ) = x( 1 ) + b( j1 )*x( n+j1 ) +
598  $ b( j2 )*x( n+j2 )
599  x( n+1 ) = x( n+1 ) - b( j1 )*x( j1 ) -
600  $ b( j2 )*x( j2 )
601 *
602  xmax = zero
603  DO 60 k = 1, j1 - 1
604  xmax = max( abs( x( k ) )+abs( x( k+n ) ),
605  $ xmax )
606  60 CONTINUE
607  END IF
608 *
609  END IF
610  70 CONTINUE
611 *
612  ELSE
613 *
614 * Solve (T + iB)**T*(p+iq) = c+id
615 *
616  jnext = 1
617  DO 80 j = 1, n
618  IF( j.LT.jnext )
619  $ GO TO 80
620  j1 = j
621  j2 = j
622  jnext = j + 1
623  IF( j.LT.n ) THEN
624  IF( t( j+1, j ).NE.zero ) THEN
625  j2 = j + 1
626  jnext = j + 2
627  END IF
628  END IF
629 *
630  IF( j1.EQ.j2 ) THEN
631 *
632 * 1 by 1 diagonal block
633 *
634 * Scale if necessary to avoid overflow in forming the
635 * right-hand side element by inner product.
636 *
637  xj = abs( x( j1 ) ) + abs( x( j1+n ) )
638  IF( xmax.GT.one ) THEN
639  rec = one / xmax
640  IF( work( j1 ).GT.( bignum-xj )*rec ) THEN
641  CALL dscal( n2, rec, x, 1 )
642  scale = scale*rec
643  xmax = xmax*rec
644  END IF
645  END IF
646 *
647  x( j1 ) = x( j1 ) - ddot( j1-1, t( 1, j1 ), 1, x, 1 )
648  x( n+j1 ) = x( n+j1 ) - ddot( j1-1, t( 1, j1 ), 1,
649  $ x( n+1 ), 1 )
650  IF( j1.GT.1 ) THEN
651  x( j1 ) = x( j1 ) - b( j1 )*x( n+1 )
652  x( n+j1 ) = x( n+j1 ) + b( j1 )*x( 1 )
653  END IF
654  xj = abs( x( j1 ) ) + abs( x( j1+n ) )
655 *
656  z = w
657  IF( j1.EQ.1 )
658  $ z = b( 1 )
659 *
660 * Scale if necessary to avoid overflow in
661 * complex division
662 *
663  tjj = abs( t( j1, j1 ) ) + abs( z )
664  tmp = t( j1, j1 )
665  IF( tjj.LT.sminw ) THEN
666  tmp = sminw
667  tjj = sminw
668  info = 1
669  END IF
670 *
671  IF( tjj.LT.one ) THEN
672  IF( xj.GT.bignum*tjj ) THEN
673  rec = one / xj
674  CALL dscal( n2, rec, x, 1 )
675  scale = scale*rec
676  xmax = xmax*rec
677  END IF
678  END IF
679  CALL dladiv( x( j1 ), x( n+j1 ), tmp, -z, sr, si )
680  x( j1 ) = sr
681  x( j1+n ) = si
682  xmax = max( abs( x( j1 ) )+abs( x( j1+n ) ), xmax )
683 *
684  ELSE
685 *
686 * 2 by 2 diagonal block
687 *
688 * Scale if necessary to avoid overflow in forming the
689 * right-hand side element by inner product.
690 *
691  xj = max( abs( x( j1 ) )+abs( x( n+j1 ) ),
692  $ abs( x( j2 ) )+abs( x( n+j2 ) ) )
693  IF( xmax.GT.one ) THEN
694  rec = one / xmax
695  IF( max( work( j1 ), work( j2 ) ).GT.
696  $ ( bignum-xj ) / xmax ) THEN
697  CALL dscal( n2, rec, x, 1 )
698  scale = scale*rec
699  xmax = xmax*rec
700  END IF
701  END IF
702 *
703  d( 1, 1 ) = x( j1 ) - ddot( j1-1, t( 1, j1 ), 1, x,
704  $ 1 )
705  d( 2, 1 ) = x( j2 ) - ddot( j1-1, t( 1, j2 ), 1, x,
706  $ 1 )
707  d( 1, 2 ) = x( n+j1 ) - ddot( j1-1, t( 1, j1 ), 1,
708  $ x( n+1 ), 1 )
709  d( 2, 2 ) = x( n+j2 ) - ddot( j1-1, t( 1, j2 ), 1,
710  $ x( n+1 ), 1 )
711  d( 1, 1 ) = d( 1, 1 ) - b( j1 )*x( n+1 )
712  d( 2, 1 ) = d( 2, 1 ) - b( j2 )*x( n+1 )
713  d( 1, 2 ) = d( 1, 2 ) + b( j1 )*x( 1 )
714  d( 2, 2 ) = d( 2, 2 ) + b( j2 )*x( 1 )
715 *
716  CALL dlaln2( .true., 2, 2, sminw, one, t( j1, j1 ),
717  $ ldt, one, one, d, 2, zero, w, v, 2,
718  $ scaloc, xnorm, ierr )
719  IF( ierr.NE.0 )
720  $ info = 2
721 *
722  IF( scaloc.NE.one ) THEN
723  CALL dscal( n2, scaloc, x, 1 )
724  scale = scaloc*scale
725  END IF
726  x( j1 ) = v( 1, 1 )
727  x( j2 ) = v( 2, 1 )
728  x( n+j1 ) = v( 1, 2 )
729  x( n+j2 ) = v( 2, 2 )
730  xmax = max( abs( x( j1 ) )+abs( x( n+j1 ) ),
731  $ abs( x( j2 ) )+abs( x( n+j2 ) ), xmax )
732 *
733  END IF
734 *
735  80 CONTINUE
736 *
737  END IF
738 *
739  END IF
740 *
741  RETURN
742 *
743 * End of DLAQTR
744 *
double precision function dlamch(CMACH)
DLAMCH
Definition: dlamch.f:69
integer function idamax(N, DX, INCX)
IDAMAX
Definition: idamax.f:71
double precision function dasum(N, DX, INCX)
DASUM
Definition: dasum.f:71
double precision function ddot(N, DX, INCX, DY, INCY)
DDOT
Definition: ddot.f:82
subroutine dscal(N, DA, DX, INCX)
DSCAL
Definition: dscal.f:79
subroutine daxpy(N, DA, DX, INCX, DY, INCY)
DAXPY
Definition: daxpy.f:89
double precision function dlange(NORM, M, N, A, LDA, WORK)
DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: dlange.f:114
subroutine dlaln2(LTRANS, NA, NW, SMIN, CA, A, LDA, D1, D2, B, LDB, WR, WI, X, LDX, SCALE, XNORM, INFO)
DLALN2 solves a 1-by-1 or 2-by-2 linear system of equations of the specified form.
Definition: dlaln2.f:218
subroutine dladiv(A, B, C, D, P, Q)
DLADIV performs complex division in real arithmetic, avoiding unnecessary overflow.
Definition: dladiv.f:91
Here is the call graph for this function:
Here is the caller graph for this function: