Provided by: liblapack-doc_3.10.0-2ubuntu1_all 
      
    
NAME
       double_blas_level1 - double
SYNOPSIS
   Functions
       double precision function dasum (N, DX, INCX)
           DASUM
       subroutine daxpy (N, DA, DX, INCX, DY, INCY)
           DAXPY
       double precision function dcabs1 (Z)
           DCABS1
       subroutine dcopy (N, DX, INCX, DY, INCY)
           DCOPY
       double precision function ddot (N, DX, INCX, DY, INCY)
           DDOT
       subroutine drot (N, DX, INCX, DY, INCY, C, S)
           DROT
       subroutine drotm (N, DX, INCX, DY, INCY, DPARAM)
           DROTM
       subroutine drotmg (DD1, DD2, DX1, DY1, DPARAM)
           DROTMG
       subroutine dscal (N, DA, DX, INCX)
           DSCAL
       double precision function dsdot (N, SX, INCX, SY, INCY)
           DSDOT
       subroutine dswap (N, DX, INCX, DY, INCY)
           DSWAP
       subroutine dtrsv (UPLO, TRANS, DIAG, N, A, LDA, X, INCX)
           DTRSV
       double precision function dzasum (N, ZX, INCX)
           DZASUM
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.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       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(*)
   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.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DA
                     DA is DOUBLE PRECISION
                      On entry, DA specifies the scalar alpha.
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       Further Details:
                jack dongarra, linpack, 3/11/78.
                modified 12/3/93, array(1) declarations changed to array(*)
   double precision function dcabs1 (complex*16 Z)
       DCABS1
       Purpose:
            DCABS1 computes |Re(.)| + |Im(.)| of a double complex number
       Parameters
           Z
                     Z is COMPLEX*16
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
   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 1.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       Further Details:
                jack dongarra, linpack, 3/11/78.
                modified 12/3/93, array(1) declarations changed to array(*)
   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.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       Further Details:
                jack dongarra, linpack, 3/11/78.
                modified 12/3/93, array(1) declarations changed to array(*)
   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.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
           C
                     C is DOUBLE PRECISION
           S
                     S is DOUBLE PRECISION
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       Further Details:
                jack dongarra, linpack, 3/11/78.
                modified 12/3/93, array(1) declarations changed to array(*)
   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
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
           DPARAM
                     DPARAM is DOUBLE PRECISION array, dimension (5)
                DPARAM(1)=DFLAG
                DPARAM(2)=DH11
                DPARAM(3)=DH21
                DPARAM(4)=DH12
                DPARAM(5)=DH22
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
   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
           DD1
                     DD1 is DOUBLE PRECISION
           DD2
                     DD2 is DOUBLE PRECISION
           DX1
                     DX1 is DOUBLE PRECISION
           DY1
                     DY1 is DOUBLE PRECISION
           DPARAM
                     DPARAM is DOUBLE PRECISION array, dimension (5)
                DPARAM(1)=DFLAG
                DPARAM(2)=DH11
                DPARAM(3)=DH21
                DPARAM(4)=DH12
                DPARAM(5)=DH22
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
   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 1.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DA
                     DA is DOUBLE PRECISION
                      On entry, DA specifies the scalar alpha.
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       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(*)
   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
           N
                     N is INTEGER
                    number of elements in input vector(s)
           SX
                     SX is REAL array, dimension(N)
                    single precision vector with N elements
           INCX
                     INCX is INTEGER
                     storage spacing between elements of SX
           SY
                     SY is REAL array, dimension(N)
                    single precision vector with N elements
           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)
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       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)
   subroutine dswap (integer N, double precision, dimension(*) DX, integer INCX, double precision, dimension(*)
       DY, integer INCY)
       DSWAP
       Purpose:
               DSWAP interchanges two vectors.
               uses unrolled loops for increments equal to 1.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           DX
                     DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of DX
           DY
                     DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
           INCY
                     INCY is INTEGER
                    storage spacing between elements of DY
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       Further Details:
                jack dongarra, linpack, 3/11/78.
                modified 12/3/93, array(1) declarations changed to array(*)
   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
           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.
           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.
           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.
           N
                     N is INTEGER
                      On entry, N specifies the order of the matrix A.
                      N must be at least zero.
           A
                     A is DOUBLE PRECISION array, 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.
           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 ).
           X
                     X is DOUBLE PRECISION array, 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.
           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.
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
   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 double precision result.
       Parameters
           N
                     N is INTEGER
                    number of elements in input vector(s)
           ZX
                     ZX is COMPLEX*16 array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
           INCX
                     INCX is INTEGER
                    storage spacing between elements of ZX
       Author
           Univ. of Tennessee
           Univ. of California Berkeley
           Univ. of Colorado Denver
           NAG Ltd.
       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(*)
Author
       Generated automatically by Doxygen for LAPACK from the source code.
Version 3.10.0                                   Wed Jan 12 2022                           double_blas_level1(3)