/*****************************************************************************
*                                                                            *
*   IDXTOX.SPL  Copyright (C) 2003 DSP Development Corporation               *
*                               All Rights Reserved                          *
*                                                                            *
*   Author:      Randy Race                                                  *
*                                                                            *
*   Synopsis:    Converts an index to an x value                             *
*                                                                            *
*   Revisions:   30 Jan 2003  RRR  Creation                                  *
*                                                                            *
*****************************************************************************/

#include 


#if @HELP_IDXTOX

    IDXTOX

    Purpose: Converts index values of a series to X values.

    Syntax:  IDXTOX(series, idx)

             series    - input series

              idx      - An integer or series of integers. The indices
                         ranging from 1 to length(s)

    Returns: A real or series.

    Example:
             W1: 1..0.1..10
             W2: idxtox(w1, 1..5)

             W2 contains the series {1, 1.1, 1.2, 1.3, 1.4}, the first 5
             X values of W1.

    Remarks:
             For XY or XYZ series, the actual X values are looked up.

             For interval series, the X values are computed as follows:

                 x = (idx - start) * deltax(s) + xoffset(s)

             where start is the value of SPL_START_INDEX.

    See Also:
             Idx
             Xtoidx
             Xvals

#endif



/* convert index to x value */
idxtox(s, idx)
{
        local x, ptype, isnum;

        if (argc < 2)
        {
                error("idxtox - input series and index value required");
        }

        /* check if scalar */
        isnum = isscalar(idx);

        if (isxy(s) || isxyz(s))
        {
                /* lookup actual x values */
                x = idxtox_lookup(s, idx);
        }
        else if (numcols(s) > 1)
        {
                ptype = getplottype(s);

                if (itemtype(s) == 2 && ptype >= 1 && ptype <= 5)
                {
                        /* waterfall, contour, density, Z surface, image */
                        x = idxtox_interval(s, idx);
                }
                else
                {
                        /* multi-column series */
                        x = idxtox_interval_iterate(s, idx);
                }
        }
        else
        {
                /* interval series */
                x = idxtox_interval(s, idx);
        }

        /* convert back to scalar if necessary */
        if (isnum)
        {
                x = castreal(x);
        }

        return(x);
}


/* xy or xyz lookup */
ITERATE idxtox_lookup(s, idx)
{
        local x;

        /* lookup actual x values */
        x = xvals(s);
        x = x[idx];

        return(x);
}
        
        

/* 2D interval */
idxtox_interval(s, idx)
{
        local start, scale, x;

        /* starting index */
        start = castint(getconf("SPL_START_INDEX"));

        scale = gethunitsscale(s);

        /* interval series - use faster computation */
        x = (idx - start) * (deltax(s) / scale) +  xoffset(s);

        return(x);
}


/* multi-column interval */
ITERATE idxtox_interval_iterate(s, idx)
{
        local x;

        x = idxtox_interval(s, idx);

        return(x);
}