

   FFiitt aa SSmmooootthhiinngg SSpplliinnee

        smooth.spline(x, y, w=rep(1, length(x)), df=5, spar=0, cv=FALSE,
                      all.knots=FALSE, df.offset=0, penalty=1)

   AArrgguummeennttss::

          x: a vector giving the values of the predictor vari-
             able, or  a list or a two-column matrix specifying
             x and y.

          y: responses. If `y' is missing, the responses are
             assumed to be specified by `x'.

          w: optional vector of weights

         df: the desired equivalent number of degrees of free-
             dom (trace of the smoother matrix).

       spar: the coefficient lambda of the integral of the
             squared second derivative in the fit (penalized
             log lik.) criterion.

         cv: ordinary (TRUE) or `generalized' (FALSE) cross-
             validation.

   all.knots: if TRUE, all points in `x' are uses as knots. If
             FAlSE, a suitably fine grid of knots is used.

   df.offset: allows the degrees of freedom to be increased by
             `df.offset' in the GCV criterion.

    penalty: the coefficient of the penalty for degrees of
             freedom in the GCV criterion.

   DDeessccrriippttiioonn::

        Fits a cubic smoothing spline to the supplied data.

   DDeettaaiillss::

        The `x' vextor should contain at lest ten distinct val-
        ues.

        If `spar' is missing or 0, the value of `df' is used to
        determine the degree of smoothing. If both are missing,
        leave-one-out cross-validation is used to determine
        lambda.

   VVaalluuee::

        An object of class `"smooth.spline"' with components

          x: the distinct `x' values in increasing order.

          y: the fitted values corresponding to `x'.

          w: the weights used at the unique values of `x'.

        yin: the y values used at the unique `y' values.

        lev: leverages, the diagonal values of the smoother
             matrix.

    cv.crit: (generalized) cross-validation score.

   pen.crit: penalized criterion

         df: equivalent degrees of freedom used.

       spar: the value of lambda chosen.

        fit: list for use by `predict.smooth.spline'.

       call:

   AAuutthhoorr((ss))::

        B.D. Ripley

   SSeeee AAllssoo::

        `predict.smooth.spline'

   EExxaammpplleess::

        data(cars)
        attach(cars)
        plot(speed, dist, main = "data(cars)  &  smoothing splines")
        cars.spl <- smooth.spline(speed, dist)
        (cars.spl)
        all(cars.spl $ w == table(speed)) # TRUE (weights = multiplicities)

        data(cars)
        attach(cars)
        plot(speed, dist, main = "data(cars)  &  smoothing splines")
        cars.spl <- smooth.spline(speed, dist)
        (cars.spl)
        all(cars.spl $ w == table(speed)) # TRUE (weights = multiplicities)

        lines(cars.spl, col = "blue")
        lines(smooth.spline(speed, dist, df=10), lty=2, col = "red")
        legend(5,120,c(paste("default [C.V.] => df =",round(cars.spl$df,1)),
                       "s( * , df = 10)"), col = c("blue","red"), lty = 1:2,
             bg='bisque')
        detach()

        lines(cars.spl, col = "blue")
        lines(smooth.spline(speed, dist, df=10), lty=2, col = "red")
        legend(5,120,c(paste("default [C.V.] => df =",round(cars.spl$df,1)),
                       "s( * , df = 10)"), col = c("blue","red"), lty = 1:2,
             bg='bisque')
        detach()

