====================================================================
izamax examples
====================================================================

a:PRIMARR(COMPLEX(DFLOAT)):=[[3.+4.*%i,-4.+5.*%i,5.+6.*%i,7.-8.*%i,-9.-2.*%i]]

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

izamax(5,a,1)

  3

izamax(0,a,1)

  - 1

izamax(5,a,-1)

  - 1

izamax(3,a,1) 

  2

izamax(3,a,2) 

  1

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

NAME
       IZAMAX - BLAS level one, maximum index function

SYNOPSIS
       INTEGER FUNCTION IZAMAX ( n, x, incx )

           INTEGER               n, incx

           DOUBLE COMPLEX        x


DESCRIPTION
       IZAMAX searches a double complex vector for the first occurrence of the
       maximum absolute value.

       IZAMAX determines the first index i such that

       |Real(x )|+ |Imag(x ) | = MAX(|Real(x )| + | Imag(x )|): j = 1, ..., n
              i           i                 j             j
               where x  is an element of a double complex vector.
                      j

ARGUMENTS
       n       INTEGER. (input)
               Number of elements to process in the vector to be searched.  If
               n <= 0, these routines return 0.

       x       DOUBLE COMPLEX. (input)
               Array of dimension (n-1) * |incx| + 1.
               Array x contains the vector to be searched.

       incx    INTEGER. (input)
               Increment between elements of x.

RETURN VALUES
       IZAMAX  INTEGER. (output)
               Return  the first index of the maximum absolute value of vector
               x.  The vector x has length n and increment incx.

NOTES
       When working backward (incx < 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)

       The largest absolute value is:

            ABS (x(1+(index-1) * incx)) when incx > 0

            ABS (x(1+(n-index) * |incx|)) when incx < 0

