====================================================================
zaxpy examples
====================================================================

a:PRIMARR(COMPLEX(DFLOAT)):=_
     [[3.0+4.0*%i, -4.0+5.0*%i, 5.0+6.0*%i, 7.0-8.0*%i, -9.0-2.0*%i]]
  [3. + 4. %i,- 4. + 5. %i,5. + 6. %i,7. - 8. %i,- 9. - 2. %i]

b:PRIMARR(COMPLEX(DFLOAT)):=_
     [[3.0+4.0*%i, -4.0+5.0*%i, 5.0+6.0*%i, 7.0-8.0*%i, -9.0-2.0*%i]]

  [3. + 4. %i,- 4. + 5. %i,5. + 6. %i,7. - 8. %i,- 9. - 2. %i]

zaxpy(3,2.0,a,1,b,1)

  [9. + 12. %i,- 12. + 15. %i,15. + 18. %i,7. - 8. %i,- 9. - 2. %i]

NOTE: We reset b to the above value before every execution

zaxpy(5,2.0,a,1,b,1)

  [9. + 12. %i,- 12. + 15. %i,15. + 18. %i,21. - 24. %i,- 27. - 6. %i]

zaxpy(3,2.0,a,3,b,3)

  [9. + 12. %i,- 4. + 5. %i,5. + 6. %i,21. - 24. %i,- 9. - 2. %i]

zaxpy(4,2.0,a,2,b,2)

  [9. + 12. %i,- 4. + 5. %i,15. + 18. %i,7. - 8. %i,- 27. - 6. %i]

zaxpy(3,2.0,a,2,b,2)

  [9. + 12. %i,- 4. + 5. %i,15. + 18. %i,7. - 8. %i,- 27. - 6. %i]

zaxpy(3,-2.0,a,1,b,2)

  [- 3. - 4. %i,- 4. + 5. %i,13. - 4. %i,7. - 8. %i,- 19. - 14. %i]

zaxpy(3,2.0,a,1,b,2)

  [9. + 12. %i,- 4. + 5. %i,- 3. + 16. %i,7. - 8. %i,1. + 10. %i]

zaxpy(-3,2.0,a,1,b,2)

  [3. + 4. %i,- 4. + 5. %i,5. + 6. %i,7. - 8. %i,- 9. - 2. %i]

zaxpy(3,2.0,a,-1,b,2)

  [13. + 16. %i,- 4. + 5. %i,- 3. + 16. %i,7. - 8. %i,- 3. + 6. %i]

zaxpy(3,2.0,a,1,b,-2)

  [13. + 16. %i,- 4. + 5. %i,- 3. + 16. %i,7. - 8. %i,- 3. + 6. %i]

zaxpy(3,2.0,a,-1,b,-2)

  [9. + 12. %i,- 4. + 5. %i,- 3. + 16. %i,7. - 8. %i,1. + 10. %i]

zaxpy(3,0.0,a,1,b,1)

  [3. + 4. %i,- 4. + 5. %i,5. + 6. %i,7. - 8. %i,- 9. - 2. %i]

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

NAME
       ZAXPY - BLAS level one axpy subroutine

SYNOPSIS
       SUBROUTINE ZAXPY    ( n, alpha, x, incx, y, incy )

           INTEGER           n, incx, incy

           DOUBLE COMPLEX    alpha, x, y


DESCRIPTION
       ZAXPY adds a scalar multiple of a double complex vector to another dou-
       ble complex vector.

       ZAXPY computes a constant alpha times a vector x plus a vector y.   The
       result overwrites the initial values of vector y.

       This routine performs the following vector operation:

            y  <--  alpha*x + y

       incx and incy specify the increment between two consecutive
       elements of respectively vector x and y.

ARGUMENTS
       n       INTEGER. (input)
               Number  of  elements in the vectors.  If n <= 0, these routines
               return without any computation.

       alpha   DOUBLE COMPLEX. (input)
               If alpha = 0 this routine returns without any computation.

       x       DOUBLE COMPLEX. (input)
               Array of dimension (n-1) * |incx| + 1.  Contains the vector  to
               be scaled before summation.

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

       y       DOUBLE COMPLEX. (input and output)
               array of dimension (n-1) * |incy| + 1.
               Before calling the routine, y contains the vector to be summed.
               After the routine ends, y contains the result of the summation.

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

NOTES
       This  routine  is  Level  1  Basic  Linear Algebra Subprograms (Level 1
       BLAS).

       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)

RETURN VALUES
       When  n  <=  0, double complex alpha = 0 = 0.+0.i, this routine returns
       immediately with no change in its arguments.

