smooth.basisPar  R Documentation 
Smooth Data Using a Directly Specified Roughness Penalty
Description
Smooth (argvals, y) data with roughness penalty defined by the
remaining arguments. This function acts as a wrapper for those who want
to bypass the step of setting up a functional parameter object before invoking
function smooth.basis
. This function simply does this setup for the
user. See the help file for functions smooth.basis
and fdPar
for further details, and more complete descriptions of the arguments.
Usage
smooth.basisPar(argvals, y, fdobj=NULL, Lfdobj=NULL,
lambda=0, estimate=TRUE, penmat=NULL,
wtvec=NULL, fdnames=NULL, covariates=NULL,
method="chol", dfscale=1)
Arguments
argvals 
a set of argument values corresponding to the observations in array
y . In most applications these values will be common to all curves
and all variables, and therefore be defined as a vector or as a matrix
with a single column. But it is possible that these argument values
will vary from one curve to another, and in this case argvals will
be input as a matrix with rows corresponding to observation points and
columns corresponding to curves. Argument values can even vary from one
variable to another, in which case they are input as an array with
dimensions corresponding to observation points, curves and variables,
respectively. Note, however, that the number of observation points per
curve and per variable may NOT vary. If it does, then curves and variables
must be smoothed individually rather than by a single call to this function.
The default value for argvals are the integers 1 to n , where
n is the size of the first dimension in argument y .

y 
an set of values of curves at discrete sampling points or
argument values. If the set is supplied as a matrix object, the rows must
correspond to argument values and columns to replications, and it will be
assumed that there is only one variable per observation. If
y is a threedimensional array, the first dimension
corresponds to argument values, the second to replications, and the
third to variables within replications. If y is a vector,
only one replicate and variable are assumed. If the data
come from a single replication but multiple vectors, such as data
on coordinates for a single space curve, then be sure to coerce
the data into an array object by using the as.array function
with one as the central dimension length.

fdobj 
One of the following:
 fd

a functional data object (class fd )
 basisfd

a functional basis object (class basisfd ), which is
converted to a functional data object with the identity matrix
as the coefficient matrix.
 fdPar

a functional parameter object (class fdPar )
 integer

a positive integer giving the order of a Bspline basis, which is
further converted to a functional data object with the identity
matrix as the coefficient matrix.
 matrix or array
replaced by fd(fdobj)
 NULL

Defaults to fdobj = create.bspline.basis(argvals).

Lfdobj 
either a nonnegative integer or a linear differential operator
object.
If NULL , Lfdobj depends on fdobj[['basis']][['type']]:
 bspline

Lfdobj < int2Lfd(max(0, norder2)), where norder =
norder(fdobj).
 fourier

Lfdobj = a harmonic acceleration operator:
Lfdobj < vec2Lfd(c(0,(2*pi/diff(rng))^2,0), rng)
where rng = fdobj[['basis']][['rangeval']].
 anything else
Lfdobj < int2Lfd(0)

lambda 
a nonnegative real number specifying the amount of smoothing
to be applied to the estimated functional parameter.

estimate 
a logical value: if TRUE , the functional parameter is
estimated, otherwise, it is held fixed.

penmat 
a roughness penalty matrix. Including this can eliminate the need
to compute this matrix over and over again in some types of
calculations.

wtvec 
typically a vector of length n that is the length of argvals
containing weights for the values to be smoothed, However, it may also
be a symmetric matrix of order n . If wtvec is a vector,
all values must be positive, and if it is a symmetric matrix, this must
be positive definite. Defaults to all weights equal to 1.

fdnames 
a list of length 3 containing character vectors of names for the
following:
 args

name for each observation or point in time at which data are
collected for each 'rep', unit or subject.
 reps

name for each 'rep', unit or subject.
 fun

name for each 'fun' or (response) variable measured repeatedly
(per 'args') for each 'rep'.

covariates 
the observed values in y are assumed to be primarily determined
the the height of the curve being estimates, but from time to time
certain values can also be influenced by other known variables. For
example, multiyear sets of climate variables may be also determined by
the presence of absence of an El Nino event, or a volcanic eruption.
One or more of these covariates can be supplied as an n by
p matrix, where p is the number of such covariates. When
such covariates are available, the smoothing is called "semiparametric."
Matrices or arrays of regression coefficients are then estimated that
define the impacts of each of these covariates for each cueve and each
variable.

method 
by default the function uses the usual textbook equations for computing
the coefficients of the basis function expansions. But, as in regression
analysis, a price is paid in terms of rounding error for such
computations since they involved crossproducts of basis function
values. Optionally, if method is set equal to the string "qr",
the computation uses an algorithm based on the qrdecomposition which
is more accurate, but will require substantially more computing time
when n is large, meaning more than 500 or so. The default
is "chol", referring the Choleski decomposition of a symmetric positive
definite matrix.

dfscale 
the generalized crossvalidation or "gcv" criterion that is often used
to determine the size of the smoothing parameter involves the
subtraction of an measue of degrees of freedom from n . Chong
Gu has argued that multiplying this degrees of freedom measure by
a constant slightly greater than 1, such as 1.2, can produce better
decisions about the level of smoothing to be used. The default value
is, however, 1.0.

Details
1. if(is.null(fdobj))fdobj < create.bspline.basis(argvals). Else
if(is.integer(fdobj)) fdobj < create.bspline.basis(argvals, norder =
fdobj)
2. fdPar
3. smooth.basis
Value
The output of a call to smooth.basis
, which is an object of
class fdSmooth
, being a list of length 8 with the following
components:
fd 
a functional data object that smooths the data.

df 
a degrees of freedom measure of the smooth

gcv 
the value of the generalized crossvalidation or GCV criterion. If
there are multiple curves, this is a vector of values, one per
curve. If the smooth is multivariate, the result is a matrix of gcv
values, with columns corresponding to variables.

SSE 
the error sums of squares. SSE is a vector or a matrix of the same
size as 'gcv'.

penmat 
the penalty matrix.

y2cMap 
the matrix mapping the data to the coefficients.

argvals , y 
input arguments

References
Ramsay, James O., and Silverman, Bernard W. (2006), Functional
Data Analysis, 2nd ed., Springer, New York.
Ramsay, James O., and Silverman, Bernard W. (2002), Applied
Functional Data Analysis, Springer, New York.
See Also
df2lambda
,
fdPar
,
lambda2df
,
lambda2gcv
,
plot.fd
,
project.basis
,
smooth.basis
,
smooth.fd
,
smooth.monotone
,
smooth.pos
Examples
# see smooth.basis