====================================================================
idamax examples
====================================================================

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

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

Note that Axiom arrays are 0-based.

idamax(5,a,1)  -- should be 3

  3

idamax(3,a,1)  -- should be 1

  1

The count and increment must both be positive numbers

idamax(0,a,1)  -- should be -1

  - 1

idamax(-5,a,1) -- should be -1

  - 1

idamax(5,a,-1) -- should be -1 

  - 1

idamax(5,a,2)  -- should be 0

  0

idamax(1,a,0)  -- should be -1 

  - 1

idamax(1,a,-1) -- should be -1 

  - 1

The comparison for maximum uses the absolute value

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

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

idamax(5,a,1)  -- should be 3

  3

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

NAME
       IDAMAX - BLAS level one, maximum index function

SYNOPSIS
       INTEGER FUNCTION IDAMAX ( n, x, incx )

           INTEGER               n, incx

           DOUBLE PRECISION      x


DESCRIPTION
       IDAMAX  searches  a double precision vector for the first occurrence of
       the the maximum absolute value. The vector x has length n and increment
       incx.

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

       x       DOUBLE PRECISION. (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
       IDAMAX  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

