LAPACK  3.6.0 LAPACK: Linear Algebra PACKage
double
Collaboration diagram for double:


This browser is not able to show SVG: try Firefox, Chrome, Safari, or Opera instead.

## Functions

double precision function dasum (N, DX, INCX)
DASUM More...

subroutine daxpy (N, DA, DX, INCX, DY, INCY)
DAXPY More...

double precision function dcabs1 (Z)
DCABS1 More...

subroutine dcopy (N, DX, INCX, DY, INCY)
DCOPY More...

double precision function ddot (N, DX, INCX, DY, INCY)
DDOT More...

double precision function dnrm2 (N, X, INCX)
DNRM2 More...

subroutine drot (N, DX, INCX, DY, INCY, C, S)
DROT More...

subroutine drotg (DA, DB, C, S)
DROTG More...

subroutine drotm (N, DX, INCX, DY, INCY, DPARAM)
DROTM More...

subroutine drotmg (DD1, DD2, DX1, DY1, DPARAM)
DROTMG More...

subroutine dscal (N, DA, DX, INCX)
DSCAL More...

double precision function dsdot (N, SX, INCX, SY, INCY)
DSDOT More...

subroutine dswap (N, DX, INCX, DY, INCY)
DSWAP More...

subroutine dtrsv (UPLO, TRANS, DIAG, N, A, LDA, X, INCX)
DTRSV More...

double precision function dzasum (N, ZX, INCX)
DZASUM More...

double precision function dznrm2 (N, X, INCX)
DZNRM2 More...

## Detailed Description

This is the group of double LEVEL 1 BLAS routines.

## Function Documentation

 double precision function dasum ( integer N, double precision, dimension(*) DX, integer INCX )

DASUM

Purpose:
`    DASUM takes the sum of the absolute values.`
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 3/93 to return if incx .le. 0.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 53 of file dasum.f.

53 *
54 * -- Reference BLAS level1 routine (version 3.4.0) --
55 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
56 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
57 * November 2011
58 *
59 * .. Scalar Arguments ..
60  INTEGER incx,n
61 * ..
62 * .. Array Arguments ..
63  DOUBLE PRECISION dx(*)
64 * ..
65 *
66 * =====================================================================
67 *
68 * .. Local Scalars ..
69  DOUBLE PRECISION dtemp
70  INTEGER i,m,mp1,nincx
71 * ..
72 * .. Intrinsic Functions ..
73  INTRINSIC dabs,mod
74 * ..
75  dasum = 0.0d0
76  dtemp = 0.0d0
77  IF (n.LE.0 .OR. incx.LE.0) RETURN
78  IF (incx.EQ.1) THEN
79 * code for increment equal to 1
80 *
81 *
82 * clean-up loop
83 *
84  m = mod(n,6)
85  IF (m.NE.0) THEN
86  DO i = 1,m
87  dtemp = dtemp + dabs(dx(i))
88  END DO
89  IF (n.LT.6) THEN
90  dasum = dtemp
91  RETURN
92  END IF
93  END IF
94  mp1 = m + 1
95  DO i = mp1,n,6
96  dtemp = dtemp + dabs(dx(i)) + dabs(dx(i+1)) +
97  \$ dabs(dx(i+2)) + dabs(dx(i+3)) +
98  \$ dabs(dx(i+4)) + dabs(dx(i+5))
99  END DO
100  ELSE
101 *
102 * code for increment not equal to 1
103 *
104  nincx = n*incx
105  DO i = 1,nincx,incx
106  dtemp = dtemp + dabs(dx(i))
107  END DO
108  END IF
109  dasum = dtemp
110  RETURN
double precision function dasum(N, DX, INCX)
DASUM
Definition: dasum.f:53

Here is the caller graph for this function:

 subroutine daxpy ( integer N, double precision DA, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY )

DAXPY

Purpose:
```    DAXPY constant times a vector plus a vector.
uses unrolled loops for increments equal to one.```
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 54 of file daxpy.f.

54 *
55 * -- Reference BLAS level1 routine (version 3.4.0) --
56 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
57 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
58 * November 2011
59 *
60 * .. Scalar Arguments ..
61  DOUBLE PRECISION da
62  INTEGER incx,incy,n
63 * ..
64 * .. Array Arguments ..
65  DOUBLE PRECISION dx(*),dy(*)
66 * ..
67 *
68 * =====================================================================
69 *
70 * .. Local Scalars ..
71  INTEGER i,ix,iy,m,mp1
72 * ..
73 * .. Intrinsic Functions ..
74  INTRINSIC mod
75 * ..
76  IF (n.LE.0) RETURN
77  IF (da.EQ.0.0d0) RETURN
78  IF (incx.EQ.1 .AND. incy.EQ.1) THEN
79 *
80 * code for both increments equal to 1
81 *
82 *
83 * clean-up loop
84 *
85  m = mod(n,4)
86  IF (m.NE.0) THEN
87  DO i = 1,m
88  dy(i) = dy(i) + da*dx(i)
89  END DO
90  END IF
91  IF (n.LT.4) RETURN
92  mp1 = m + 1
93  DO i = mp1,n,4
94  dy(i) = dy(i) + da*dx(i)
95  dy(i+1) = dy(i+1) + da*dx(i+1)
96  dy(i+2) = dy(i+2) + da*dx(i+2)
97  dy(i+3) = dy(i+3) + da*dx(i+3)
98  END DO
99  ELSE
100 *
101 * code for unequal increments or equal increments
102 * not equal to 1
103 *
104  ix = 1
105  iy = 1
106  IF (incx.LT.0) ix = (-n+1)*incx + 1
107  IF (incy.LT.0) iy = (-n+1)*incy + 1
108  DO i = 1,n
109  dy(iy) = dy(iy) + da*dx(ix)
110  ix = ix + incx
111  iy = iy + incy
112  END DO
113  END IF
114  RETURN
 double precision function dcabs1 ( complex*16 Z )

DCABS1

Purpose:
` DCABS1 computes |Re(.)| + |Im(.)| of a double complex number `
Date
November 2015

Definition at line 41 of file dcabs1.f.

41 *
42 * -- Reference BLAS level1 routine (version 3.6.0) --
43 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
44 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
45 * November 2015
46 *
47 * .. Scalar Arguments ..
48  COMPLEX*16 z
49 * ..
50 * ..
51 * =====================================================================
52 *
53 * .. Intrinsic Functions ..
54  INTRINSIC abs,dble,dimag
55 *
56  dcabs1 = abs(dble(z)) + abs(dimag(z))
57  RETURN
double precision function dcabs1(Z)
DCABS1
Definition: dcabs1.f:41
 subroutine dcopy ( integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY )

DCOPY

Purpose:
```    DCOPY copies a vector, x, to a vector, y.
uses unrolled loops for increments equal to one.```
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 53 of file dcopy.f.

53 *
54 * -- Reference BLAS level1 routine (version 3.4.0) --
55 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
56 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
57 * November 2011
58 *
59 * .. Scalar Arguments ..
60  INTEGER incx,incy,n
61 * ..
62 * .. Array Arguments ..
63  DOUBLE PRECISION dx(*),dy(*)
64 * ..
65 *
66 * =====================================================================
67 *
68 * .. Local Scalars ..
69  INTEGER i,ix,iy,m,mp1
70 * ..
71 * .. Intrinsic Functions ..
72  INTRINSIC mod
73 * ..
74  IF (n.LE.0) RETURN
75  IF (incx.EQ.1 .AND. incy.EQ.1) THEN
76 *
77 * code for both increments equal to 1
78 *
79 *
80 * clean-up loop
81 *
82  m = mod(n,7)
83  IF (m.NE.0) THEN
84  DO i = 1,m
85  dy(i) = dx(i)
86  END DO
87  IF (n.LT.7) RETURN
88  END IF
89  mp1 = m + 1
90  DO i = mp1,n,7
91  dy(i) = dx(i)
92  dy(i+1) = dx(i+1)
93  dy(i+2) = dx(i+2)
94  dy(i+3) = dx(i+3)
95  dy(i+4) = dx(i+4)
96  dy(i+5) = dx(i+5)
97  dy(i+6) = dx(i+6)
98  END DO
99  ELSE
100 *
101 * code for unequal increments or equal increments
102 * not equal to 1
103 *
104  ix = 1
105  iy = 1
106  IF (incx.LT.0) ix = (-n+1)*incx + 1
107  IF (incy.LT.0) iy = (-n+1)*incy + 1
108  DO i = 1,n
109  dy(iy) = dx(ix)
110  ix = ix + incx
111  iy = iy + incy
112  END DO
113  END IF
114  RETURN
 double precision function ddot ( integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY )

DDOT

Purpose:
```    DDOT forms the dot product of two vectors.
uses unrolled loops for increments equal to one.```
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 53 of file ddot.f.

53 *
54 * -- Reference BLAS level1 routine (version 3.4.0) --
55 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
56 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
57 * November 2011
58 *
59 * .. Scalar Arguments ..
60  INTEGER incx,incy,n
61 * ..
62 * .. Array Arguments ..
63  DOUBLE PRECISION dx(*),dy(*)
64 * ..
65 *
66 * =====================================================================
67 *
68 * .. Local Scalars ..
69  DOUBLE PRECISION dtemp
70  INTEGER i,ix,iy,m,mp1
71 * ..
72 * .. Intrinsic Functions ..
73  INTRINSIC mod
74 * ..
75  ddot = 0.0d0
76  dtemp = 0.0d0
77  IF (n.LE.0) RETURN
78  IF (incx.EQ.1 .AND. incy.EQ.1) THEN
79 *
80 * code for both increments equal to 1
81 *
82 *
83 * clean-up loop
84 *
85  m = mod(n,5)
86  IF (m.NE.0) THEN
87  DO i = 1,m
88  dtemp = dtemp + dx(i)*dy(i)
89  END DO
90  IF (n.LT.5) THEN
91  ddot=dtemp
92  RETURN
93  END IF
94  END IF
95  mp1 = m + 1
96  DO i = mp1,n,5
97  dtemp = dtemp + dx(i)*dy(i) + dx(i+1)*dy(i+1) +
98  \$ dx(i+2)*dy(i+2) + dx(i+3)*dy(i+3) + dx(i+4)*dy(i+4)
99  END DO
100  ELSE
101 *
102 * code for unequal increments or equal increments
103 * not equal to 1
104 *
105  ix = 1
106  iy = 1
107  IF (incx.LT.0) ix = (-n+1)*incx + 1
108  IF (incy.LT.0) iy = (-n+1)*incy + 1
109  DO i = 1,n
110  dtemp = dtemp + dx(ix)*dy(iy)
111  ix = ix + incx
112  iy = iy + incy
113  END DO
114  END IF
115  ddot = dtemp
116  RETURN
double precision function ddot(N, DX, INCX, DY, INCY)
DDOT
Definition: ddot.f:53

Here is the caller graph for this function:

 double precision function dnrm2 ( integer N, double precision, dimension(*) X, integer INCX )

DNRM2

Purpose:
``` DNRM2 returns the euclidean norm of a vector via the function
name, so that

DNRM2 := sqrt( x'*x )```
Date
November 2011
Further Details:
```  -- This version written on 25-October-1982.
Modified on 14-October-1993 to inline the call to DLASSQ.
Sven Hammarling, Nag Ltd.```

Definition at line 56 of file dnrm2.f.

56 *
57 * -- Reference BLAS level1 routine (version 3.4.0) --
58 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
59 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
60 * November 2011
61 *
62 * .. Scalar Arguments ..
63  INTEGER incx,n
64 * ..
65 * .. Array Arguments ..
66  DOUBLE PRECISION x(*)
67 * ..
68 *
69 * =====================================================================
70 *
71 * .. Parameters ..
72  DOUBLE PRECISION one,zero
73  parameter(one=1.0d+0,zero=0.0d+0)
74 * ..
75 * .. Local Scalars ..
76  DOUBLE PRECISION absxi,norm,scale,ssq
77  INTEGER ix
78 * ..
79 * .. Intrinsic Functions ..
80  INTRINSIC abs,sqrt
81 * ..
82  IF (n.LT.1 .OR. incx.LT.1) THEN
83  norm = zero
84  ELSE IF (n.EQ.1) THEN
85  norm = abs(x(1))
86  ELSE
87  scale = zero
88  ssq = one
89 * The following loop is equivalent to this call to the LAPACK
90 * auxiliary routine:
91 * CALL DLASSQ( N, X, INCX, SCALE, SSQ )
92 *
93  DO 10 ix = 1,1 + (n-1)*incx,incx
94  IF (x(ix).NE.zero) THEN
95  absxi = abs(x(ix))
96  IF (scale.LT.absxi) THEN
97  ssq = one + ssq* (scale/absxi)**2
98  scale = absxi
99  ELSE
100  ssq = ssq + (absxi/scale)**2
101  END IF
102  END IF
103  10 CONTINUE
104  norm = scale*sqrt(ssq)
105  END IF
106 *
107  dnrm2 = norm
108  RETURN
109 *
110 * End of DNRM2.
111 *
double precision function dnrm2(N, X, INCX)
DNRM2
Definition: dnrm2.f:56

Here is the caller graph for this function:

 subroutine drot ( integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY, double precision C, double precision S )

DROT

Purpose:
`    DROT applies a plane rotation.`
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 53 of file drot.f.

53 *
54 * -- Reference BLAS level1 routine (version 3.4.0) --
55 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
56 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
57 * November 2011
58 *
59 * .. Scalar Arguments ..
60  DOUBLE PRECISION c,s
61  INTEGER incx,incy,n
62 * ..
63 * .. Array Arguments ..
64  DOUBLE PRECISION dx(*),dy(*)
65 * ..
66 *
67 * =====================================================================
68 *
69 * .. Local Scalars ..
70  DOUBLE PRECISION dtemp
71  INTEGER i,ix,iy
72 * ..
73  IF (n.LE.0) RETURN
74  IF (incx.EQ.1 .AND. incy.EQ.1) THEN
75 *
76 * code for both increments equal to 1
77 *
78  DO i = 1,n
79  dtemp = c*dx(i) + s*dy(i)
80  dy(i) = c*dy(i) - s*dx(i)
81  dx(i) = dtemp
82  END DO
83  ELSE
84 *
85 * code for unequal increments or equal increments not equal
86 * to 1
87 *
88  ix = 1
89  iy = 1
90  IF (incx.LT.0) ix = (-n+1)*incx + 1
91  IF (incy.LT.0) iy = (-n+1)*incy + 1
92  DO i = 1,n
93  dtemp = c*dx(ix) + s*dy(iy)
94  dy(iy) = c*dy(iy) - s*dx(ix)
95  dx(ix) = dtemp
96  ix = ix + incx
97  iy = iy + incy
98  END DO
99  END IF
100  RETURN

Here is the caller graph for this function:

 subroutine drotg ( double precision DA, double precision DB, double precision C, double precision S )

DROTG

Purpose:
`    DROTG construct givens plane rotation.`
Date
November 2011
Further Details:
`     jack dongarra, linpack, 3/11/78.`

Definition at line 48 of file drotg.f.

48 *
49 * -- Reference BLAS level1 routine (version 3.4.0) --
50 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
51 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
52 * November 2011
53 *
54 * .. Scalar Arguments ..
55  DOUBLE PRECISION c,da,db,s
56 * ..
57 *
58 * =====================================================================
59 *
60 * .. Local Scalars ..
61  DOUBLE PRECISION r,roe,scale,z
62 * ..
63 * .. Intrinsic Functions ..
64  INTRINSIC dabs,dsign,dsqrt
65 * ..
66  roe = db
67  IF (dabs(da).GT.dabs(db)) roe = da
68  scale = dabs(da) + dabs(db)
69  IF (scale.EQ.0.0d0) THEN
70  c = 1.0d0
71  s = 0.0d0
72  r = 0.0d0
73  z = 0.0d0
74  ELSE
75  r = scale*dsqrt((da/scale)**2+ (db/scale)**2)
76  r = dsign(1.0d0,roe)*r
77  c = da/r
78  s = db/r
79  z = 1.0d0
80  IF (dabs(da).GT.dabs(db)) z = s
81  IF (dabs(db).GE.dabs(da) .AND. c.NE.0.0d0) z = 1.0d0/c
82  END IF
83  da = r
84  db = z
85  RETURN

Here is the caller graph for this function:

 subroutine drotm ( integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY, double precision, dimension(5) DPARAM )

DROTM

Purpose:
```    APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX

(DX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN
(DY**T)

DX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX .GE. 0, ELSE
LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY.
WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS..

DFLAG=-1.D0     DFLAG=0.D0        DFLAG=1.D0     DFLAG=-2.D0

(DH11  DH12)    (1.D0  DH12)    (DH11  1.D0)    (1.D0  0.D0)
H=(          )    (          )    (          )    (          )
(DH21  DH22),   (DH21  1.D0),   (-1.D0 DH22),   (0.D0  1.D0).
SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.```
Parameters
 [in] N ``` N is INTEGER number of elements in input vector(s)``` [in,out] DX ``` DX is DOUBLE PRECISION array, dimension N double precision vector with N elements``` [in] INCX ``` INCX is INTEGER storage spacing between elements of DX``` [in,out] DY ``` DY is DOUBLE PRECISION array, dimension N double precision vector with N elements``` [in] INCY ``` INCY is INTEGER storage spacing between elements of DY``` [in,out] DPARAM ``` DPARAM is DOUBLE PRECISION array, dimension 5 DPARAM(1)=DFLAG DPARAM(2)=DH11 DPARAM(3)=DH21 DPARAM(4)=DH12 DPARAM(5)=DH22```
Date
November 2011

Definition at line 100 of file drotm.f.

100 *
101 * -- Reference BLAS level1 routine (version 3.4.0) --
102 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
103 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
104 * November 2011
105 *
106 * .. Scalar Arguments ..
107  INTEGER incx,incy,n
108 * ..
109 * .. Array Arguments ..
110  DOUBLE PRECISION dparam(5),dx(*),dy(*)
111 * ..
112 *
113 * =====================================================================
114 *
115 * .. Local Scalars ..
116  DOUBLE PRECISION dflag,dh11,dh12,dh21,dh22,two,w,z,zero
117  INTEGER i,kx,ky,nsteps
118 * ..
119 * .. Data statements ..
120  DATA zero,two/0.d0,2.d0/
121 * ..
122 *
123  dflag = dparam(1)
124  IF (n.LE.0 .OR. (dflag+two.EQ.zero)) RETURN
125  IF (incx.EQ.incy.AND.incx.GT.0) THEN
126 *
127  nsteps = n*incx
128  IF (dflag.LT.zero) THEN
129  dh11 = dparam(2)
130  dh12 = dparam(4)
131  dh21 = dparam(3)
132  dh22 = dparam(5)
133  DO i = 1,nsteps,incx
134  w = dx(i)
135  z = dy(i)
136  dx(i) = w*dh11 + z*dh12
137  dy(i) = w*dh21 + z*dh22
138  END DO
139  ELSE IF (dflag.EQ.zero) THEN
140  dh12 = dparam(4)
141  dh21 = dparam(3)
142  DO i = 1,nsteps,incx
143  w = dx(i)
144  z = dy(i)
145  dx(i) = w + z*dh12
146  dy(i) = w*dh21 + z
147  END DO
148  ELSE
149  dh11 = dparam(2)
150  dh22 = dparam(5)
151  DO i = 1,nsteps,incx
152  w = dx(i)
153  z = dy(i)
154  dx(i) = w*dh11 + z
155  dy(i) = -w + dh22*z
156  END DO
157  END IF
158  ELSE
159  kx = 1
160  ky = 1
161  IF (incx.LT.0) kx = 1 + (1-n)*incx
162  IF (incy.LT.0) ky = 1 + (1-n)*incy
163 *
164  IF (dflag.LT.zero) THEN
165  dh11 = dparam(2)
166  dh12 = dparam(4)
167  dh21 = dparam(3)
168  dh22 = dparam(5)
169  DO i = 1,n
170  w = dx(kx)
171  z = dy(ky)
172  dx(kx) = w*dh11 + z*dh12
173  dy(ky) = w*dh21 + z*dh22
174  kx = kx + incx
175  ky = ky + incy
176  END DO
177  ELSE IF (dflag.EQ.zero) THEN
178  dh12 = dparam(4)
179  dh21 = dparam(3)
180  DO i = 1,n
181  w = dx(kx)
182  z = dy(ky)
183  dx(kx) = w + z*dh12
184  dy(ky) = w*dh21 + z
185  kx = kx + incx
186  ky = ky + incy
187  END DO
188  ELSE
189  dh11 = dparam(2)
190  dh22 = dparam(5)
191  DO i = 1,n
192  w = dx(kx)
193  z = dy(ky)
194  dx(kx) = w*dh11 + z
195  dy(ky) = -w + dh22*z
196  kx = kx + incx
197  ky = ky + incy
198  END DO
199  END IF
200  END IF
201  RETURN

Here is the caller graph for this function:

 subroutine drotmg ( double precision DD1, double precision DD2, double precision DX1, double precision DY1, double precision, dimension(5) DPARAM )

DROTMG

Purpose:
```    CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS
THE SECOND COMPONENT OF THE 2-VECTOR  (DSQRT(DD1)*DX1,DSQRT(DD2)*>    DY2)**T.
WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS..

DFLAG=-1.D0     DFLAG=0.D0        DFLAG=1.D0     DFLAG=-2.D0

(DH11  DH12)    (1.D0  DH12)    (DH11  1.D0)    (1.D0  0.D0)
H=(          )    (          )    (          )    (          )
(DH21  DH22),   (DH21  1.D0),   (-1.D0 DH22),   (0.D0  1.D0).
LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22
RESPECTIVELY. (VALUES OF 1.D0, -1.D0, OR 0.D0 IMPLIED BY THE
VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.)

THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE
INEXACT.  THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE
OF DD1 AND DD2.  ALL ACTUAL SCALING OF DATA IS DONE USING GAM.```
Parameters
 [in,out] DD1 ` DD1 is DOUBLE PRECISION` [in,out] DD2 ` DD2 is DOUBLE PRECISION` [in,out] DX1 ` DX1 is DOUBLE PRECISION` [in] DY1 ` DY1 is DOUBLE PRECISION` [in,out] DPARAM ``` DPARAM is DOUBLE PRECISION array, dimension 5 DPARAM(1)=DFLAG DPARAM(2)=DH11 DPARAM(3)=DH21 DPARAM(4)=DH12 DPARAM(5)=DH22```
Date
November 2011

Definition at line 92 of file drotmg.f.

92 *
93 * -- Reference BLAS level1 routine (version 3.4.0) --
94 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
95 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
96 * November 2011
97 *
98 * .. Scalar Arguments ..
99  DOUBLE PRECISION dd1,dd2,dx1,dy1
100 * ..
101 * .. Array Arguments ..
102  DOUBLE PRECISION dparam(5)
103 * ..
104 *
105 * =====================================================================
106 *
107 * .. Local Scalars ..
108  DOUBLE PRECISION dflag,dh11,dh12,dh21,dh22,dp1,dp2,dq1,dq2,dtemp,
109  \$ du,gam,gamsq,one,rgamsq,two,zero
110 * ..
111 * .. Intrinsic Functions ..
112  INTRINSIC dabs
113 * ..
114 * .. Data statements ..
115 *
116  DATA zero,one,two/0.d0,1.d0,2.d0/
117  DATA gam,gamsq,rgamsq/4096.d0,16777216.d0,5.9604645d-8/
118 * ..
119
120  IF (dd1.LT.zero) THEN
121 * GO ZERO-H-D-AND-DX1..
122  dflag = -one
123  dh11 = zero
124  dh12 = zero
125  dh21 = zero
126  dh22 = zero
127 *
128  dd1 = zero
129  dd2 = zero
130  dx1 = zero
131  ELSE
132 * CASE-DD1-NONNEGATIVE
133  dp2 = dd2*dy1
134  IF (dp2.EQ.zero) THEN
135  dflag = -two
136  dparam(1) = dflag
137  RETURN
138  END IF
139 * REGULAR-CASE..
140  dp1 = dd1*dx1
141  dq2 = dp2*dy1
142  dq1 = dp1*dx1
143 *
144  IF (dabs(dq1).GT.dabs(dq2)) THEN
145  dh21 = -dy1/dx1
146  dh12 = dp2/dp1
147 *
148  du = one - dh12*dh21
149 *
150  IF (du.GT.zero) THEN
151  dflag = zero
152  dd1 = dd1/du
153  dd2 = dd2/du
154  dx1 = dx1*du
155  END IF
156  ELSE
157
158  IF (dq2.LT.zero) THEN
159 * GO ZERO-H-D-AND-DX1..
160  dflag = -one
161  dh11 = zero
162  dh12 = zero
163  dh21 = zero
164  dh22 = zero
165 *
166  dd1 = zero
167  dd2 = zero
168  dx1 = zero
169  ELSE
170  dflag = one
171  dh11 = dp1/dp2
172  dh22 = dx1/dy1
173  du = one + dh11*dh22
174  dtemp = dd2/du
175  dd2 = dd1/du
176  dd1 = dtemp
177  dx1 = dy1*du
178  END IF
179  END IF
180
181 * PROCEDURE..SCALE-CHECK
182  IF (dd1.NE.zero) THEN
183  DO WHILE ((dd1.LE.rgamsq) .OR. (dd1.GE.gamsq))
184  IF (dflag.EQ.zero) THEN
185  dh11 = one
186  dh22 = one
187  dflag = -one
188  ELSE
189  dh21 = -one
190  dh12 = one
191  dflag = -one
192  END IF
193  IF (dd1.LE.rgamsq) THEN
194  dd1 = dd1*gam**2
195  dx1 = dx1/gam
196  dh11 = dh11/gam
197  dh12 = dh12/gam
198  ELSE
199  dd1 = dd1/gam**2
200  dx1 = dx1*gam
201  dh11 = dh11*gam
202  dh12 = dh12*gam
203  END IF
204  ENDDO
205  END IF
206
207  IF (dd2.NE.zero) THEN
208  DO WHILE ( (dabs(dd2).LE.rgamsq) .OR. (dabs(dd2).GE.gamsq) )
209  IF (dflag.EQ.zero) THEN
210  dh11 = one
211  dh22 = one
212  dflag = -one
213  ELSE
214  dh21 = -one
215  dh12 = one
216  dflag = -one
217  END IF
218  IF (dabs(dd2).LE.rgamsq) THEN
219  dd2 = dd2*gam**2
220  dh21 = dh21/gam
221  dh22 = dh22/gam
222  ELSE
223  dd2 = dd2/gam**2
224  dh21 = dh21*gam
225  dh22 = dh22*gam
226  END IF
227  END DO
228  END IF
229
230  END IF
231
232  IF (dflag.LT.zero) THEN
233  dparam(2) = dh11
234  dparam(3) = dh21
235  dparam(4) = dh12
236  dparam(5) = dh22
237  ELSE IF (dflag.EQ.zero) THEN
238  dparam(3) = dh21
239  dparam(4) = dh12
240  ELSE
241  dparam(2) = dh11
242  dparam(5) = dh22
243  END IF
244
245  dparam(1) = dflag
246  RETURN

Here is the caller graph for this function:

 subroutine dscal ( integer N, double precision DA, double precision, dimension(*) DX, integer INCX )

DSCAL

Purpose:
```    DSCAL scales a vector by a constant.
uses unrolled loops for increment equal to one.```
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 3/93 to return if incx .le. 0.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 55 of file dscal.f.

55 *
56 * -- Reference BLAS level1 routine (version 3.4.0) --
57 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
58 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
59 * November 2011
60 *
61 * .. Scalar Arguments ..
62  DOUBLE PRECISION da
63  INTEGER incx,n
64 * ..
65 * .. Array Arguments ..
66  DOUBLE PRECISION dx(*)
67 * ..
68 *
69 * =====================================================================
70 *
71 * .. Local Scalars ..
72  INTEGER i,m,mp1,nincx
73 * ..
74 * .. Intrinsic Functions ..
75  INTRINSIC mod
76 * ..
77  IF (n.LE.0 .OR. incx.LE.0) RETURN
78  IF (incx.EQ.1) THEN
79 *
80 * code for increment equal to 1
81 *
82 *
83 * clean-up loop
84 *
85  m = mod(n,5)
86  IF (m.NE.0) THEN
87  DO i = 1,m
88  dx(i) = da*dx(i)
89  END DO
90  IF (n.LT.5) RETURN
91  END IF
92  mp1 = m + 1
93  DO i = mp1,n,5
94  dx(i) = da*dx(i)
95  dx(i+1) = da*dx(i+1)
96  dx(i+2) = da*dx(i+2)
97  dx(i+3) = da*dx(i+3)
98  dx(i+4) = da*dx(i+4)
99  END DO
100  ELSE
101 *
102 * code for increment not equal to 1
103 *
104  nincx = n*incx
105  DO i = 1,nincx,incx
106  dx(i) = da*dx(i)
107  END DO
108  END IF
109  RETURN
 double precision function dsdot ( integer N, real, dimension(*) SX, integer INCX, real, dimension(*) SY, integer INCY )

DSDOT

Purpose:
``` Compute the inner product of two vectors with extended
precision accumulation and result.

Returns D.P. dot product accumulated in D.P., for S.P. SX and SY
DSDOT = sum for I = 0 to N-1 of  SX(LX+I*INCX) * SY(LY+I*INCY),
where LX = 1 if INCX .GE. 0, else LX = 1+(1-N)*INCX, and LY is
defined in a similar way using INCY.```
Parameters
 [in] N ``` N is INTEGER number of elements in input vector(s)``` [in] SX ``` SX is REAL array, dimension(N) single precision vector with N elements``` [in] INCX ``` INCX is INTEGER storage spacing between elements of SX``` [in] SY ``` SY is REAL array, dimension(N) single precision vector with N elements``` [in] INCY ``` INCY is INTEGER storage spacing between elements of SY```
Returns
DSDOT
```          DSDOT is DOUBLE PRECISION
DSDOT  double precision dot product (zero if N.LE.0)```
Date
November 2011
Further Details:
` `
References:
```  C. L. Lawson, R. J. Hanson, D. R. Kincaid and F. T.
Krogh, Basic linear algebra subprograms for Fortran
usage, Algorithm No. 539, Transactions on Mathematical
Software 5, 3 (September 1979), pp. 308-323.

REVISION HISTORY  (YYMMDD)

791001  DATE WRITTEN
890831  Modified array declarations.  (WRB)
890831  REVISION DATE from Version 3.2
891214  Prologue converted to Version 4.0 format.  (BAB)
920310  Corrected definition of LX in DESCRIPTION.  (WRB)
920501  Reformatted the REFERENCES section.  (WRB)
070118  Reformat to LAPACK style (JL)```

Definition at line 121 of file dsdot.f.

121 *
122 * -- Reference BLAS level1 routine (version 3.4.0) --
123 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
124 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
125 * November 2011
126 *
127 * .. Scalar Arguments ..
128  INTEGER incx,incy,n
129 * ..
130 * .. Array Arguments ..
131  REAL sx(*),sy(*)
132 * ..
133 *
134 * Authors:
135 * ========
136 * Lawson, C. L., (JPL), Hanson, R. J., (SNLA),
137 * Kincaid, D. R., (U. of Texas), Krogh, F. T., (JPL)
138 *
139 * =====================================================================
140 *
141 * .. Local Scalars ..
142  INTEGER i,kx,ky,ns
143 * ..
144 * .. Intrinsic Functions ..
145  INTRINSIC dble
146 * ..
147  dsdot = 0.0d0
148  IF (n.LE.0) RETURN
149  IF (incx.EQ.incy .AND. incx.GT.0) THEN
150 *
151 * Code for equal, positive, non-unit increments.
152 *
153  ns = n*incx
154  DO i = 1,ns,incx
155  dsdot = dsdot + dble(sx(i))*dble(sy(i))
156  END DO
157  ELSE
158 *
159 * Code for unequal or nonpositive increments.
160 *
161  kx = 1
162  ky = 1
163  IF (incx.LT.0) kx = 1 + (1-n)*incx
164  IF (incy.LT.0) ky = 1 + (1-n)*incy
165  DO i = 1,n
166  dsdot = dsdot + dble(sx(kx))*dble(sy(ky))
167  kx = kx + incx
168  ky = ky + incy
169  END DO
170  END IF
171  RETURN
double precision function dsdot(N, SX, INCX, SY, INCY)
DSDOT
Definition: dsdot.f:121

Here is the caller graph for this function:

 subroutine dswap ( integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*) DY, integer INCY )

DSWAP

Purpose:
```    interchanges two vectors.
uses unrolled loops for increments equal one.```
Date
November 2011
Further Details:
```     jack dongarra, linpack, 3/11/78.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 53 of file dswap.f.

53 *
54 * -- Reference BLAS level1 routine (version 3.4.0) --
55 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
56 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
57 * November 2011
58 *
59 * .. Scalar Arguments ..
60  INTEGER incx,incy,n
61 * ..
62 * .. Array Arguments ..
63  DOUBLE PRECISION dx(*),dy(*)
64 * ..
65 *
66 * =====================================================================
67 *
68 * .. Local Scalars ..
69  DOUBLE PRECISION dtemp
70  INTEGER i,ix,iy,m,mp1
71 * ..
72 * .. Intrinsic Functions ..
73  INTRINSIC mod
74 * ..
75  IF (n.LE.0) RETURN
76  IF (incx.EQ.1 .AND. incy.EQ.1) THEN
77 *
78 * code for both increments equal to 1
79 *
80 *
81 * clean-up loop
82 *
83  m = mod(n,3)
84  IF (m.NE.0) THEN
85  DO i = 1,m
86  dtemp = dx(i)
87  dx(i) = dy(i)
88  dy(i) = dtemp
89  END DO
90  IF (n.LT.3) RETURN
91  END IF
92  mp1 = m + 1
93  DO i = mp1,n,3
94  dtemp = dx(i)
95  dx(i) = dy(i)
96  dy(i) = dtemp
97  dtemp = dx(i+1)
98  dx(i+1) = dy(i+1)
99  dy(i+1) = dtemp
100  dtemp = dx(i+2)
101  dx(i+2) = dy(i+2)
102  dy(i+2) = dtemp
103  END DO
104  ELSE
105 *
106 * code for unequal increments or equal increments not equal
107 * to 1
108 *
109  ix = 1
110  iy = 1
111  IF (incx.LT.0) ix = (-n+1)*incx + 1
112  IF (incy.LT.0) iy = (-n+1)*incy + 1
113  DO i = 1,n
114  dtemp = dx(ix)
115  dx(ix) = dy(iy)
116  dy(iy) = dtemp
117  ix = ix + incx
118  iy = iy + incy
119  END DO
120  END IF
121  RETURN
 subroutine dtrsv ( character UPLO, character TRANS, character DIAG, integer N, double precision, dimension(lda,*) A, integer LDA, double precision, dimension(*) X, integer INCX )

DTRSV

Purpose:
``` DTRSV  solves one of the systems of equations

A*x = b,   or   A**T*x = b,

where b and x are n element vectors and A is an n by n unit, or
non-unit, upper or lower triangular matrix.

No test for singularity or near-singularity is included in this
routine. Such tests must be performed before calling this routine.```
Parameters
 [in] UPLO ``` UPLO is CHARACTER*1 On entry, UPLO specifies whether the matrix is an upper or lower triangular matrix as follows: UPLO = 'U' or 'u' A is an upper triangular matrix. UPLO = 'L' or 'l' A is a lower triangular matrix.``` [in] TRANS ``` TRANS is CHARACTER*1 On entry, TRANS specifies the equations to be solved as follows: TRANS = 'N' or 'n' A*x = b. TRANS = 'T' or 't' A**T*x = b. TRANS = 'C' or 'c' A**T*x = b.``` [in] DIAG ``` DIAG is CHARACTER*1 On entry, DIAG specifies whether or not A is unit triangular as follows: DIAG = 'U' or 'u' A is assumed to be unit triangular. DIAG = 'N' or 'n' A is not assumed to be unit triangular.``` [in] N ``` N is INTEGER On entry, N specifies the order of the matrix A. N must be at least zero.``` [in] A ``` A is DOUBLE PRECISION array of DIMENSION ( LDA, n ). Before entry with UPLO = 'U' or 'u', the leading n by n upper triangular part of the array A must contain the upper triangular matrix and the strictly lower triangular part of A is not referenced. Before entry with UPLO = 'L' or 'l', the leading n by n lower triangular part of the array A must contain the lower triangular matrix and the strictly upper triangular part of A is not referenced. Note that when DIAG = 'U' or 'u', the diagonal elements of A are not referenced either, but are assumed to be unity.``` [in] LDA ``` LDA is INTEGER On entry, LDA specifies the first dimension of A as declared in the calling (sub) program. LDA must be at least max( 1, n ).``` [in,out] X ``` X is DOUBLE PRECISION array of dimension at least ( 1 + ( n - 1 )*abs( INCX ) ). Before entry, the incremented array X must contain the n element right-hand side vector b. On exit, X is overwritten with the solution vector x.``` [in] INCX ``` INCX is INTEGER On entry, INCX specifies the increment for the elements of X. INCX must not be zero. Level 2 Blas routine. -- Written on 22-October-1986. Jack Dongarra, Argonne National Lab. Jeremy Du Croz, Nag Central Office. Sven Hammarling, Nag Central Office. Richard Hanson, Sandia National Labs.```
Date
November 2011

Definition at line 145 of file dtrsv.f.

145 *
146 * -- Reference BLAS level1 routine (version 3.4.0) --
147 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
148 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
149 * November 2011
150 *
151 * .. Scalar Arguments ..
152  INTEGER incx,lda,n
153  CHARACTER diag,trans,uplo
154 * ..
155 * .. Array Arguments ..
156  DOUBLE PRECISION a(lda,*),x(*)
157 * ..
158 *
159 * =====================================================================
160 *
161 * .. Parameters ..
162  DOUBLE PRECISION zero
163  parameter(zero=0.0d+0)
164 * ..
165 * .. Local Scalars ..
166  DOUBLE PRECISION temp
167  INTEGER i,info,ix,j,jx,kx
168  LOGICAL nounit
169 * ..
170 * .. External Functions ..
171  LOGICAL lsame
172  EXTERNAL lsame
173 * ..
174 * .. External Subroutines ..
175  EXTERNAL xerbla
176 * ..
177 * .. Intrinsic Functions ..
178  INTRINSIC max
179 * ..
180 *
181 * Test the input parameters.
182 *
183  info = 0
184  IF (.NOT.lsame(uplo,'U') .AND. .NOT.lsame(uplo,'L')) THEN
185  info = 1
186  ELSE IF (.NOT.lsame(trans,'N') .AND. .NOT.lsame(trans,'T') .AND.
187  + .NOT.lsame(trans,'C')) THEN
188  info = 2
189  ELSE IF (.NOT.lsame(diag,'U') .AND. .NOT.lsame(diag,'N')) THEN
190  info = 3
191  ELSE IF (n.LT.0) THEN
192  info = 4
193  ELSE IF (lda.LT.max(1,n)) THEN
194  info = 6
195  ELSE IF (incx.EQ.0) THEN
196  info = 8
197  END IF
198  IF (info.NE.0) THEN
199  CALL xerbla('DTRSV ',info)
200  RETURN
201  END IF
202 *
203 * Quick return if possible.
204 *
205  IF (n.EQ.0) RETURN
206 *
207  nounit = lsame(diag,'N')
208 *
209 * Set up the start point in X if the increment is not unity. This
210 * will be ( N - 1 )*INCX too small for descending loops.
211 *
212  IF (incx.LE.0) THEN
213  kx = 1 - (n-1)*incx
214  ELSE IF (incx.NE.1) THEN
215  kx = 1
216  END IF
217 *
218 * Start the operations. In this version the elements of A are
219 * accessed sequentially with one pass through A.
220 *
221  IF (lsame(trans,'N')) THEN
222 *
223 * Form x := inv( A )*x.
224 *
225  IF (lsame(uplo,'U')) THEN
226  IF (incx.EQ.1) THEN
227  DO 20 j = n,1,-1
228  IF (x(j).NE.zero) THEN
229  IF (nounit) x(j) = x(j)/a(j,j)
230  temp = x(j)
231  DO 10 i = j - 1,1,-1
232  x(i) = x(i) - temp*a(i,j)
233  10 CONTINUE
234  END IF
235  20 CONTINUE
236  ELSE
237  jx = kx + (n-1)*incx
238  DO 40 j = n,1,-1
239  IF (x(jx).NE.zero) THEN
240  IF (nounit) x(jx) = x(jx)/a(j,j)
241  temp = x(jx)
242  ix = jx
243  DO 30 i = j - 1,1,-1
244  ix = ix - incx
245  x(ix) = x(ix) - temp*a(i,j)
246  30 CONTINUE
247  END IF
248  jx = jx - incx
249  40 CONTINUE
250  END IF
251  ELSE
252  IF (incx.EQ.1) THEN
253  DO 60 j = 1,n
254  IF (x(j).NE.zero) THEN
255  IF (nounit) x(j) = x(j)/a(j,j)
256  temp = x(j)
257  DO 50 i = j + 1,n
258  x(i) = x(i) - temp*a(i,j)
259  50 CONTINUE
260  END IF
261  60 CONTINUE
262  ELSE
263  jx = kx
264  DO 80 j = 1,n
265  IF (x(jx).NE.zero) THEN
266  IF (nounit) x(jx) = x(jx)/a(j,j)
267  temp = x(jx)
268  ix = jx
269  DO 70 i = j + 1,n
270  ix = ix + incx
271  x(ix) = x(ix) - temp*a(i,j)
272  70 CONTINUE
273  END IF
274  jx = jx + incx
275  80 CONTINUE
276  END IF
277  END IF
278  ELSE
279 *
280 * Form x := inv( A**T )*x.
281 *
282  IF (lsame(uplo,'U')) THEN
283  IF (incx.EQ.1) THEN
284  DO 100 j = 1,n
285  temp = x(j)
286  DO 90 i = 1,j - 1
287  temp = temp - a(i,j)*x(i)
288  90 CONTINUE
289  IF (nounit) temp = temp/a(j,j)
290  x(j) = temp
291  100 CONTINUE
292  ELSE
293  jx = kx
294  DO 120 j = 1,n
295  temp = x(jx)
296  ix = kx
297  DO 110 i = 1,j - 1
298  temp = temp - a(i,j)*x(ix)
299  ix = ix + incx
300  110 CONTINUE
301  IF (nounit) temp = temp/a(j,j)
302  x(jx) = temp
303  jx = jx + incx
304  120 CONTINUE
305  END IF
306  ELSE
307  IF (incx.EQ.1) THEN
308  DO 140 j = n,1,-1
309  temp = x(j)
310  DO 130 i = n,j + 1,-1
311  temp = temp - a(i,j)*x(i)
312  130 CONTINUE
313  IF (nounit) temp = temp/a(j,j)
314  x(j) = temp
315  140 CONTINUE
316  ELSE
317  kx = kx + (n-1)*incx
318  jx = kx
319  DO 160 j = n,1,-1
320  temp = x(jx)
321  ix = kx
322  DO 150 i = n,j + 1,-1
323  temp = temp - a(i,j)*x(ix)
324  ix = ix - incx
325  150 CONTINUE
326  IF (nounit) temp = temp/a(j,j)
327  x(jx) = temp
328  jx = jx - incx
329  160 CONTINUE
330  END IF
331  END IF
332  END IF
333 *
334  RETURN
335 *
336 * End of DTRSV .
337 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:62
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:55

Here is the call graph for this function:

Here is the caller graph for this function:

 double precision function dzasum ( integer N, complex*16, dimension(*) ZX, integer INCX )

DZASUM

Purpose:
```    DZASUM takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and
returns a single precision result.```
Date
November 2015
Further Details:
```     jack dongarra, 3/11/78.
modified 3/93 to return if incx .le. 0.
modified 12/3/93, array(1) declarations changed to array(*)```

Definition at line 54 of file dzasum.f.

54 *
55 * -- Reference BLAS level1 routine (version 3.6.0) --
56 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
57 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
58 * November 2015
59 *
60 * .. Scalar Arguments ..
61  INTEGER incx,n
62 * ..
63 * .. Array Arguments ..
64  COMPLEX*16 zx(*)
65 * ..
66 *
67 * =====================================================================
68 *
69 * .. Local Scalars ..
70  DOUBLE PRECISION stemp
71  INTEGER i,nincx
72 * ..
73 * .. External Functions ..
74  DOUBLE PRECISION dcabs1
75  EXTERNAL dcabs1
76 * ..
77  dzasum = 0.0d0
78  stemp = 0.0d0
79  IF (n.LE.0 .OR. incx.LE.0) RETURN
80  IF (incx.EQ.1) THEN
81 *
82 * code for increment equal to 1
83 *
84  DO i = 1,n
85  stemp = stemp + dcabs1(zx(i))
86  END DO
87  ELSE
88 *
89 * code for increment not equal to 1
90 *
91  nincx = n*incx
92  DO i = 1,nincx,incx
93  stemp = stemp + dcabs1(zx(i))
94  END DO
95  END IF
96  dzasum = stemp
97  RETURN
double precision function dzasum(N, ZX, INCX)
DZASUM
Definition: dzasum.f:54
double precision function dcabs1(Z)
DCABS1
Definition: dcabs1.f:41

Here is the caller graph for this function:

 double precision function dznrm2 ( integer N, complex*16, dimension(*) X, integer INCX )

DZNRM2

Purpose:
``` DZNRM2 returns the euclidean norm of a vector via the function
name, so that

DZNRM2 := sqrt( x**H*x )```
Date
November 2011
Further Details:
```  -- This version written on 25-October-1982.
Modified on 14-October-1993 to inline the call to ZLASSQ.
Sven Hammarling, Nag Ltd.```

Definition at line 56 of file dznrm2.f.

56 *
57 * -- Reference BLAS level1 routine (version 3.4.0) --
58 * -- Reference BLAS is a software package provided by Univ. of Tennessee, --
59 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
60 * November 2011
61 *
62 * .. Scalar Arguments ..
63  INTEGER incx,n
64 * ..
65 * .. Array Arguments ..
66  COMPLEX*16 x(*)
67 * ..
68 *
69 * =====================================================================
70 *
71 * .. Parameters ..
72  DOUBLE PRECISION one,zero
73  parameter(one=1.0d+0,zero=0.0d+0)
74 * ..
75 * .. Local Scalars ..
76  DOUBLE PRECISION norm,scale,ssq,temp
77  INTEGER ix
78 * ..
79 * .. Intrinsic Functions ..
80  INTRINSIC abs,dble,dimag,sqrt
81 * ..
82  IF (n.LT.1 .OR. incx.LT.1) THEN
83  norm = zero
84  ELSE
85  scale = zero
86  ssq = one
87 * The following loop is equivalent to this call to the LAPACK
88 * auxiliary routine:
89 * CALL ZLASSQ( N, X, INCX, SCALE, SSQ )
90 *
91  DO 10 ix = 1,1 + (n-1)*incx,incx
92  IF (dble(x(ix)).NE.zero) THEN
93  temp = abs(dble(x(ix)))
94  IF (scale.LT.temp) THEN
95  ssq = one + ssq* (scale/temp)**2
96  scale = temp
97  ELSE
98  ssq = ssq + (temp/scale)**2
99  END IF
100  END IF
101  IF (dimag(x(ix)).NE.zero) THEN
102  temp = abs(dimag(x(ix)))
103  IF (scale.LT.temp) THEN
104  ssq = one + ssq* (scale/temp)**2
105  scale = temp
106  ELSE
107  ssq = ssq + (temp/scale)**2
108  END IF
109  END IF
110  10 CONTINUE
111  norm = scale*sqrt(ssq)
112  END IF
113 *
114  dznrm2 = norm
115  RETURN
116 *
117 * End of DZNRM2.
118 *
double precision function dznrm2(N, X, INCX)
DZNRM2
Definition: dznrm2.f:56

Here is the caller graph for this function: