====================================================================
ddot examples
====================================================================

a:PRIMARR(DFLOAT):=[ [ 1.0, 2.0, 3.0, 4.0, 5.0] ]

  [1.,2.,3.,4.,5.]

b:PRIMARR(DFLOAT):=[ [ 5.0, 6.0, 7.0, 8.0, 9.0] ]

  [5.,6.,7.,8.,9.]

ddot(0,a,1,b,1)

  0.

ddot(3,a,1,b,1)

 38. ( = 1.0*5.0 + 2.0*6.0 + 3.0*7.0 )

ddot(3,a,1,b,2)

 46. ( = 1.0*5.0 + 2.0*7.0 + 3.0*9.0 )

ddot(3,a,2,b,1)

 58. ( = 1.0*5.0 + 3.0*6.0 + 5.0*7.0 )

ddot(3,a,1,b,-2)

 38. ( = 1.0*9.0 + 2.0*7.0 + 3.0*5.0 )

ddot(3,a,-2,b,1)

 50. ( = 5.0*5.0 + 3.0*6.0 + 1.0*7.0 )

ddot(3,a,-2,b,-2)

 71. ( = 5.0*9.0 + 3.0*7.0 + 1.0*5.0 )

====================================================================
Man Page Details
====================================================================

NAME
       DDOT  -  BLAS  level one, computes a dot product (inner product) of two
       double precision vectors

SYNOPSIS
       DOUBLE PRECISION FUNCTION DDOT ( n, x, incx, y, incy )

           INTEGER                      n, incx, incy

           DOUBLE PRECISION             x, y


DESCRIPTION
       DDOT computes a dot product of two double precision vectors  (l  double
       precision inner product).
         2

       This routine performs the following vector operation:

                                                    n
               DDOT  <--  (transpose of x) * y  =  Sum  x(i)*y(i)
                                                   i=1
       where x and y are double precision vectors.

       If n <= 0, DDOT is set to 0.

ARGUMENTS
       n       INTEGER. (input)
               Number of elements in each vector.

       x       DOUBLE PRECISION. (input)
               Array of dimension (n-1) * |incx| + 1.
               Array x contains the first vector operand.

       incx    INTEGER. (input)
               Increment between elements of x.
               If incx = 0, the results will be unpredictable.

       y       DOUBLE PRECISION, (input)
               Array of dimension (n-1) * |incy| + 1.
               Array y contains the second vector operand.

       incy    INTEGER. (input)
               Increment between elements of y.  If incy = 0, the results will
               be unpredictable.

RETURN VALUES
       DDOT    DOUBLE PRECISION. Result (dot product). (output)

NOTES
       When  working  backward  (incx < 0 or incy < 0), each routine starts at
       the end of the vector and moves backward, as follows:

            x(1-incx * (n-1)), x(1-incx * (n-2)), ..., x(1)

            y(1-incy * (n-1)), y(1-incy * (n-2)), ..., y(1)

