====================================================================
dcopy examples
====================================================================

Assume we have two arrays which we initialize to these values:
a:PRIMARR(DFLOAT):=[ [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] ]

b:PRIMARR(DFLOAT):=[ [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] ]

Note that after each call to dcopy the b array is modified.
The changed value is shown. We reset it after each bcopy but we
do not show that here.

dcopy(3,a,1,b,1) ==> [1.,2.,3.,0.,0.,0.,0.]

dcopy(7,a,1,b,1) ==> [1.,2.,3.,4.,5.,6.,7.]

dcopy(8,a,1,b,1) ==> [0.,0.,0.,0.,0.,0.,0.]

dcopy(3,a,3,b,3) ==> [1.,0.,0.,4.,0.,0.,7.]

dcopy(4,a,2,b,2) ==> [1.,0.,3.,0.,5.,0.,7.]

dcopy(5,a,2,b,2) ==> [0.,0.,0.,0.,0.,0.,0.]

dcopy(3,a,2,b,2) ==> [1.,0.,3.,0.,5.,0.,0.]

The arrays can be of different lengths:

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

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

dcopy(3,a,1,b,1) ==>  [1.,2.,3.,4.,5.]

dcopy(3,a,1,b,2) ==>  [1.,2.,2.,4.,3.]

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

b:PRIMARR(DFLOAT):=[ [ 1.0, 2.0, 3.0] ]

dcopy(5,a,1,b,1) ==> [1.,2.,3.]

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

NAME
       DCOPY  -  BLAS level one, copies a double precision vector into another
       double precision vector

SYNOPSIS
       SUBROUTINE DCOPY    ( n, x, incx, y, incy )

           INTEGER           n, incx, incy

           DOUBLE PRECISION  x, y


DESCRIPTION
       DCOPY copies a double precision vector into  another  double  precision
       vector.  DCOPY copies a vector x, whose length is n to a vector y. incx
       and incy specify the increment  between  two  consecutive  elements  of
       respectively vector x and y.

       This routine performs the following vector operation:

            y  <--  x

       where x and y are double precision vectors.

ARGUMENTS
       n       INTEGER. (input)
               Number of vector elements to be copied.
               If n <= 0, this routine returns without computation.

       x       DOUBLE PRECISION, (input)
               Vector from which to copy.

       incx    INTEGER. (input)
               Increment between elements of x.
               If incx = 0, the y vector is unchanged

       y       DOUBLE PRECISION, (output)
               array of dimension (n-1) * |incy| + 1, result vector.

       incy    INTEGER. (input)
               Increment between elements of y.  
               If incy = 0, the y vector is unchanged

