/*****************************************************************************
*                                                                            *
*   XMOVMAXIMUM.SPL  Copyright (C) 2023 DSP Development Corporation              *
*                               All Rights Reserved                          *
*                                                                            *
*   Author:      Randy Race                                                  *
*                                                                            *
*   Synopsis:    Calculates the moving maximum with a duration               *
*                                                                            *
*   Revisions:    1 Aug 2023  RRR  Creation                                  *
*                                                                            *
*****************************************************************************/

#if @HELP_XMOVMAXIMUM

    XMOVMAXIMUM

    Purpose: Calculates the moving maximum of a series given a duration.

    Syntax:  XMOVMAXIMUM(series, xdur, rampflag, "naflag", "edgeflag")

                series   - A series, the input series

                xdur     - A real, the X duration used to compute the integer
                           number of samples for the moving interval.

                rampflag - Optional. An integer, the endpoint averaging flag.
                         
                              0: do not ramp

                              1: ramp up (default)


                "naflag" - Optional. A string, the NA handling method.

                             "includenan" : include NA values (default)

                                "omitnan" : ignore NA values

              "edgeflag" - Optional. A string, the edge processing flag.

                                "full" : process all segments (default)

                              "center" : center the result within the
                                         overlapping N point segments
 
                             "discard" : ignore partial segments 

                              "shrink" : shrink the segment size to actual
                                         number of samples at the edge
                                         segments  


    Returns: A series or table.

    Example:
             W1: {1, 2, -1, 3};setdeltax(1/100)
             W2: movmaximum(w1, 3)
             W3: xmovmaximum(w1, 0.02)

             W1 contains the input data with a sample rate of 100 Hz.

             W2 computes a 3 point moving maximum.
             
             W3 computes the same moving maximum except the block size is
             specified in terms of seconds. Since a 0.02 interval equates
             to 3 samples, both functions return the series:
             
             {1, 2, 2, 3, 3, 3}

    Example:
             W1: integ(gnorm(10000, 1/10000)) * 1000
             W2: movmaximum(w1, 51)
             W3: xmovmaximum(w1, 0.005)
             W4: W2 - W3

             W1 synthesizes 10000 samples of data with a sample rate of 10kHz.

             W2 computes a 51 point moving maximum.

             W3 computes a moving maximum with a moving interval of 0.005
             seconds.

             Since a 0.005 interval equates to 51 samples, the two moving
             maximum results are equal.

    Remarks:
             The interval duration XDUR is converted to the integer sample
             interval N with:

               N = XDUR / deltax(s) + 1

             where XDUR >= deltax(s)

             See XMOVMAX to compute a centered moving maximium given a
             duration.

             See MOVAVG for more details on RAMPFLAG, NAFLAG and EDGEFLAG.

    See Also:
             Max
             Min
             Movmax
             Movmaximum
             Movmin
             Movminimum
             Xmovavg
             Xmovmax
             Xmovmin
             Xmovminimum
#endif


/* moving maximum given a duration used to compute the integer sample interval */
ITERATE xmovmaximum(s, xdur, ramp = 1, flag1 = "", flag2 = "", flag3 = "")
{
        local y;

        /* call common driver function */
        y = xmovfun(s, __FUNC__, strextract(__FUNC__, 2, -1), xdur, ramp, nan, flag1, flag2, flag3);

        return(y);
}