class TGraphSmooth: public TNamed

Default GraphSmooth constructor *-*-

GraphSmooth constructor *-*-*-*-*-*-

GraphSmooth destructor*-*-*-*-*-*-*-

Sort input data points*-*-*-*-*-*-*-

Smooth data with Kernel smoother*-*-


 Smooth grin with the Nadaraya-Watson kernel regression estimate.

 Arguments:
 grin:      input graph

 option:    the kernel to be used: "box", "normal"
 bandwidth: the bandwidth. The kernels are scaled so that their quartiles
            (viewed as probability densities) are at +/- 0.25*bandwidth.
 nout:      If xout is not specified, interpolation takes place at equally
            spaced points spanning the interval [min(x), max(x)], where
            nout = max(nout, number of input data).
 xout:      an optional set of values at which to evaluate the fit

Smooth data with specified kernel*-*-
*-*              =================================

   Based on R function ksmooth: Translated to C++ by C. Stratowa
   (R source file: ksmooth.c by B.D.Ripley Copyright (C) 1998)

-

Smooth data with Lowess smoother*-*-


 This function performs the computations for the LOWESS smoother
 (see the reference below). Lowess returns the output points
 x and y which give the coordinates of the smooth.

 Arguments:
 grin:  Input graph

 span:  the smoother span. This gives the proportion of points in the plot
        which influence the smooth at each value.
        Larger values give more smoothness.
 iter:  the number of robustifying iterations which should be performed.
        Using smaller values of iter will make lowess run faster.
 delta: values of x which lie within delta of each other replaced by a
        single value in the output from lowess.
        For delta = 0, delta will be calculated.

 References:
 Cleveland, W. S. (1979) Robust locally weighted regression and smoothing
        scatterplots. J. Amer. Statist. Assoc. 74, 829-836.
 Cleveland, W. S. (1981) LOWESS: A program for smoothing scatterplots
        by robust locally weighted regression.
        The American Statistician, 35, 54.

Lowess regression smoother*-*-*-*-*-

   Based on R function clowess: Translated to C++ by C. Stratowa
   (R source file: lowess.c by R Development Core Team (C) 1999-2001)

-

Fit value at x[i] *-*-*-*-*-*-*-*-*-

  Based on R function lowest: Translated to C++ by C. Stratowa
  (R source file: lowess.c by R Development Core Team (C) 1999-2001)

-

Smooth data with Super smoother*-*-*-


 Smooth the (x, y) values by Friedman's ``super smoother''.

 Arguments:
 grin: graph for smoothing

 span: the fraction of the observations in the span of the running lines
        smoother, or 0 to choose this by leave-one-out cross-validation.
 bass: controls the smoothness of the fitted curve.
        Values of up to 10 indicate increasing smoothness.
 isPeriodic: if TRUE, the x values are assumed to be in [0, 1]
        and of period 1.
 w:     case weights

 Details:
 supsmu is a running lines smoother which chooses between three spans for
 the lines. The running lines smoothers are symmetric, with k/2 data points
 each side of the predicted point, and values of k as 0.5 * n, 0.2 * n and
 0.05 * n, where n is the number of data points. If span is specified,
 a single smoother with span span * n is used.

 The best of the three smoothers is chosen by cross-validation for each
 prediction. The best spans are then smoothed by a running lines smoother
 and the final prediction chosen by linear interpolation.

 The FORTRAN code says: ``For small samples (n < 40) or if there are
 substantial serial correlations between observations close in x - value,
 then a prespecified fixed span smoother (span > 0) should be used.
 Reasonable span values are 0.2 to 0.4.''

 References:
 Friedman, J. H. (1984) SMART User's Guide.
           Laboratory for Computational Statistics,
           Stanford University Technical Report No. 1.

 Friedman, J. H. (1984) A variable span scatterplot smoother.
           Laboratory for Computational Statistics,
           Stanford University Technical Report No. 5.

Friedmann´s super smoother *-*-*-*-*-


  super smoother (Friedman, 1984).

  version 10/10/84

  coded  and copywrite (c) 1984 by:

                         Jerome H. Friedman
                      department of statistics
                                and
                 stanford linear accelerator center
                         stanford university

  all rights reserved.


  input:
     n : number of observations (x,y - pairs).
     x(n) : ordered abscissa values.
     y(n) : corresponding ordinate (response) values.
     w(n) : weight for each (x,y) observation.
     iper : periodic variable flag.
        iper=1 => x is ordered interval variable.
        iper=2 => x is a periodic variable with values
                  in the range (0.0,1.0) and period 1.0.
     span : smoother span (fraction of observations in window).
            span=0.0 => automatic (variable) span selection.
     alpha : controls high frequency (small span) penality
             used with automatic span selection (bass tone control).
             (alpha.le.0.0 or alpha.gt.10.0 => no effect.)
  output:
    smo(n) : smoothed ordinate (response) values.
  scratch:
    sc(n,7) : internal working storage.

  note:
     for small samples (n < 40) or if there are substantial serial
     correlations between observations close in x - value, then
     a prespecified fixed span smoother (span > 0) should be
     used. reasonable span values are 0.2 to 0.4.

 current implementation:
   Based on R function supsmu: Translated to C++ by C. Stratowa
   (R source file: ppr.f by B.D.Ripley Copyright (C) 1994-97)

-

 Function for super smoother *-*-*-


   Based on R function supsmu: Translated to C++ by C. Stratowa
   (R source file: ppr.f by B.D.Ripley Copyright (C) 1994-97)

-

-*-*-*-*-*Sort data points and eliminate double x values

Approximate data points*-*-*-*-*-*-*-


 Arguments:
 grin:  graph giving the coordinates of the points to be interpolated.
        Alternatively a single plotting structure can be specified:

 option: specifies the interpolation method to be used.
        Choices are "linear" (iKind = 1) or "constant" (iKind = 2).
 nout:  If xout is not specified, interpolation takes place at n equally
        spaced points spanning the interval [min(x), max(x)], where
        nout = max(nout, number of input data).
 xout:  an optional set of values specifying where interpolation is to
        take place.
 yleft: the value to be returned when input x values less than min(x).
        The default is defined by the value of rule given below.
 yright: the value to be returned when input x values greater than max(x).
        The default is defined by the value of rule given below.
 rule:  an integer describing how interpolation is to take place outside
        the interval [min(x), max(x)]. If rule is 0 then the given yleft
        and yright values are returned, if it is 1 then 0 is returned
        for such points and if it is 2, the value at the closest data
        extreme is used.
 f:     For method="constant" a number between 0 and 1 inclusive,
        indicating a compromise between left- and right-continuous step
        functions. If y0 and y1 are the values to the left and right of
        the point then the value is y0*f+y1*(1-f) so that f=0 is
        right-continuous and f=1 is left-continuous
 ties:  Handling of tied x values. An integer describing a function with
        a single vector argument returning a single number result:
        ties = "ordered" (iTies = 0): input x are "ordered"
        ties = "mean"    (iTies = 1): function "mean"
        ties = "min"     (iTies = 2): function "min"
        ties = "max"     (iTies = 3): function "max"

 Details:
 At least two complete (x, y) pairs are required.
 If there are duplicated (tied) x values and ties is a function it is
 applied to the y values for each distinct x value. Useful functions in
 this context include mean, min, and max.
 If ties="ordered" the x values are assumed to be already ordered. The
 first y value will be used for interpolation to the left and the last
 one for interpolation to the right.

 Value:
 approx returns a graph with components x and y, containing n coordinates
 which interpolate the given data points according to the method (and rule)
 desired.

Approximate one data point*-*-*-*-*-
*-*              ==========================

   Approximate  y(v),  given (x,y)[i], i = 0,..,n-1
   Based on R function approx1: Translated to C++ by Christian Stratowa
   (R source file: approx.c by R Development Core Team (C) 1999-2001)

   static function
   if (ISNAN(x))   return 1;
   if (ISNAN(y))   return -1;

   static function
   based on R function rPsort: adapted to C++ by Christian Stratowa
   (R source file: R_sort.c by R Development Core Team (C) 1999-2001)

   static function