

I like what smooth.spline does but I am unclear on the output. I can see from the documentation that there are fit.coef but I am unclear what those coeficients are applied to.With spline I understand the "noraml" coefficients applied to a cubic polynomial. But these coefficients I am not sure how to interpret. If I had a description of the algorithm maybe I could figure it out but as it is I have this question. Any help?
Kevin
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


I believe that a short answer to your question is that the
"smooth" is a linear combination of Bspline basis functions, and the
coefficients are the weights assigned to the different Bsplines in that
basis.
Before offering a much longer answer, I would want to know what
problem you are trying to solve and why you want to know. For a brief
description of Bsplines, see " http://en.wikipedia.org/wiki/Bspline".
For a slightly longer commentary on them I suggest the "scripts\ch01.R"
in the DierckxSpline package: That script computes and displays some
Bsplines using "splineDesign", "spline.des" in the 'splines' package
plus comparable functions in the 'fda' package. For more info on this,
I found the first chapter of Paul Dierckx (1993) Curve and Surface
Fitting with Splines (Oxford U. Pr.). Beyond that, I've learned a lot
from the 'fda' package and the two companion volumes by Ramsay and
Silverman (2006) Functional Data Analysis, 2nd ed. and (2002) Applied
Functional Data Analysis (both Springer).
If you'd like more help from this listserve, PLEASE do read the
posting guide http://www.Rproject.org/postingguide.html and provide
commented, minimal, selfcontained, reproducible code.
Hope this helps.
Spencer Graves
[hidden email] wrote:
> I like what smooth.spline does but I am unclear on the output. I can see from the documentation that there are fit.coef but I am unclear what those coeficients are applied to.With spline I understand the "noraml" coefficients applied to a cubic polynomial. But these coefficients I am not sure how to interpret. If I had a description of the algorithm maybe I could figure it out but as it is I have this question. Any help?
>
> Kevin
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/rhelp> PLEASE do read the posting guide http://www.Rproject.org/postingguide.html> and provide commented, minimal, selfcontained, reproducible code.
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


Spencer Graves wrote:
> I found the first chapter of Paul Dierckx (1993) Curve and Surface
> Fitting with Splines (Oxford U. Pr.). Beyond that, I've learned a lot
> from the 'fda' package and the two companion volumes by Ramsay and
> Silverman (2006) Functional Data Analysis, 2nd ed. and (2002) Applied
> Functional Data Analysis (both Springer).
If I may add my 2 cents:
Section 2 ("BSplines in a Nutshell") in the article listed below, is in
my opinion, a good and compact outline of BSplines.
* Flexible Smoothing with $B$splines and Penalties
* Paul H. C. Eilers, Brian D. Marx
* Statistical Science, Vol. 11, No. 2 (May, 1996), pp. 89102
I hope this helps,
Roland
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


PLEASE do read the posting guide
http://www.Rproject.org/postingguide.html and provide commented,
minimal, selfcontained, reproducible code.
I do NOT know how to do what you want, but with a selfcontained
example, I suspect many people on this list  probably including me 
could easily solve the problem. Without such an example, there is a
high probability that any answer might (a) not respond to your need, and
(b) take more time to develop, just because we don't know enough of what
you are asking.
Spencer
[hidden email] wrote:
> Like I indicated. I understand the coefficients in a Bspline context. If I use the the 'spline' or 'splinefun' I can get the coefficients and they are grouped as 'a', 'b', 'c', and 'd' coefficients. But the coefficients for smooth.spline is just an array. I basically want to take these coefficients and outside of 'R' use them to form an interpolation. In other words I want 'R' to do the hard work and then export the results so they can be used else where.
>
> Thank you.
>
> Kevin
>
Spencer Graves wrote:
> I believe that a short answer to your question is that the
> "smooth" is a linear combination of Bspline basis functions, and the
> coefficients are the weights assigned to the different Bsplines in
> that basis.
> Before offering a much longer answer, I would want to know what
> problem you are trying to solve and why you want to know. For a brief
> description of Bsplines, see
> " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
> commentary on them I suggest the "scripts\ch01.R" in the DierckxSpline
> package: That script computes and displays some Bsplines using
> "splineDesign", "spline.des" in the 'splines' package plus comparable
> functions in the 'fda' package. For more info on this, I found the
> first chapter of Paul Dierckx (1993) Curve and Surface Fitting with
> Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
> 'fda' package and the two companion volumes by Ramsay and Silverman
> (2006) Functional Data Analysis, 2nd ed. and (2002) Applied Functional
> Data Analysis (both Springer).
> If you'd like more help from this listserve, PLEASE do read the
> posting guide http://www.Rproject.org/postingguide.html and provide
> commented, minimal, selfcontained, reproducible code.
> Hope this helps. Spencer Graves
>
> [hidden email] wrote:
>> I like what smooth.spline does but I am unclear on the output. I can
>> see from the documentation that there are fit.coef but I am unclear
>> what those coeficients are applied to.With spline I understand the
>> "noraml" coefficients applied to a cubic polynomial. But these
>> coefficients I am not sure how to interpret. If I had a description
>> of the algorithm maybe I could figure it out but as it is I have this
>> question. Any help?
>>
>> Kevin
>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/rhelp>> PLEASE do read the posting guide
>> http://www.Rproject.org/postingguide.html>> and provide commented, minimal, selfcontained, reproducible code.
>>
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


Fair enough. FOr a spline interpolation I can do the following:
> n < 9
> x < 1:n
> y < rnorm(n)
> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> lines(spline(x, y))
Then look at the coefficients generated as:
> f < splinefun(x, y)
> ls(envir = environment(f))
[1] "ties" "ux" "z"
> splinecoef < get("z", envir = environment(f))
> slinecoef
$method
[1] 3
$n
[1] 9
$x
[1] 1 2 3 4 5 6 7 8 9
$y
[1] 0.93571604 0.44240485 0.45451903 0.96207396 1.13246522 0.60032698
[7] 1.77506105 0.09171419 0.23262573
$b
[1] 1.53673409 0.22775629 0.81788209 1.16966436 0.73558677 0.68744178
[7] 0.08639287 1.86770869 2.92992167
$c
[1] 1.3657783 0.3987121 1.4443504 1.0925682 0.8126830 2.2357115 3.0095462
[8] 1.2282303 3.5694000
$d
[1] 0.32235542 0.61435416 0.84563953 0.09329507 1.01613149 1.74841922
[7] 1.41259217 0.78038989 0.78038989
WHen I look at ?spline there is even an example of "manually" using these coefficeients:
## Manual spline evaluation  demo the coefficients :
.x < get("ux", envir = environment(f))
u < seq(3,6, by = 0.25)
(ii < findInterval(u, .x))
dx < u  .x[ii]
f.u < with(splinecoef,
y[ii] + dx*(b[ii] + dx*(c[ii] + dx* d[ii])))
stopifnot(all.equal(f(u), f.u))
For the smooth.spline as
spl < smooth.spline(x,y)
I can also look at the coefficients:
spl$fit
$knot
[1] 0.000 0.000 0.000 0.000 0.125 0.250 0.375 0.500 0.625 0.750 0.875 1.000
[13] 1.000 1.000 1.000
$nk
[1] 11
$min
[1] 1
$range
[1] 8
$coef
[1] 0.90345898 0.73823276 0.40777431 0.08046715 0.54625461 0.85205147
[7] 0.96233408 0.91373830 0.66529714 0.47674774 0.38246971
attr(,"class")
[1] "smooth.spline.fit"
But there isn't an example on how to "manual" use these coefficients. This is what I was asking about. Once I hae the coefficients how do I "manually" interpolate using the coefficients given and x.
Thank you.
Kevin
 Spencer Graves < [hidden email]> wrote:
> PLEASE do read the posting guide
> http://www.Rproject.org/postingguide.html and provide commented,
> minimal, selfcontained, reproducible code.
>
> I do NOT know how to do what you want, but with a selfcontained
> example, I suspect many people on this list  probably including me 
> could easily solve the problem. Without such an example, there is a
> high probability that any answer might (a) not respond to your need, and
> (b) take more time to develop, just because we don't know enough of what
> you are asking.
>
> Spencer
>
> [hidden email] wrote:
> > Like I indicated. I understand the coefficients in a Bspline context. If I use the the 'spline' or 'splinefun' I can get the coefficients and they are grouped as 'a', 'b', 'c', and 'd' coefficients. But the coefficients for smooth.spline is just an array. I basically want to take these coefficients and outside of 'R' use them to form an interpolation. In other words I want 'R' to do the hard work and then export the results so they can be used else where.
> >
> > Thank you.
> >
> > Kevin
> >
>
> Spencer Graves wrote:
> > I believe that a short answer to your question is that the
> > "smooth" is a linear combination of Bspline basis functions, and the
> > coefficients are the weights assigned to the different Bsplines in
> > that basis.
> > Before offering a much longer answer, I would want to know what
> > problem you are trying to solve and why you want to know. For a brief
> > description of Bsplines, see
> > " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
> > commentary on them I suggest the "scripts\ch01.R" in the DierckxSpline
> > package: That script computes and displays some Bsplines using
> > "splineDesign", "spline.des" in the 'splines' package plus comparable
> > functions in the 'fda' package. For more info on this, I found the
> > first chapter of Paul Dierckx (1993) Curve and Surface Fitting with
> > Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
> > 'fda' package and the two companion volumes by Ramsay and Silverman
> > (2006) Functional Data Analysis, 2nd ed. and (2002) Applied Functional
> > Data Analysis (both Springer).
> > If you'd like more help from this listserve, PLEASE do read the
> > posting guide http://www.Rproject.org/postingguide.html and provide
> > commented, minimal, selfcontained, reproducible code.
> > Hope this helps. Spencer Graves
> >
> > [hidden email] wrote:
> >> I like what smooth.spline does but I am unclear on the output. I can
> >> see from the documentation that there are fit.coef but I am unclear
> >> what those coeficients are applied to.With spline I understand the
> >> "noraml" coefficients applied to a cubic polynomial. But these
> >> coefficients I am not sure how to interpret. If I had a description
> >> of the algorithm maybe I could figure it out but as it is I have this
> >> question. Any help?
> >>
> >> Kevin
> >>
> >> ______________________________________________
> >> [hidden email] mailing list
> >> https://stat.ethz.ch/mailman/listinfo/rhelp> >> PLEASE do read the posting guide
> >> http://www.Rproject.org/postingguide.html> >> and provide commented, minimal, selfcontained, reproducible code.
> >>
> >
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


On Fri, Jul 18, 2008 at 10:15 PM, Roland Rau < [hidden email]> wrote:
> Spencer Graves wrote:
>>
>> I found the first chapter of Paul Dierckx (1993) Curve and Surface Fitting
>> with Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
>> 'fda' package and the two companion volumes by Ramsay and Silverman (2006)
>> Functional Data Analysis, 2nd ed. and (2002) Applied Functional Data
>> Analysis (both Springer).
>
> If I may add my 2 cents:
> Section 2 ("BSplines in a Nutshell") in the article listed below, is in my
> opinion, a good and compact outline of BSplines.
>
> * Flexible Smoothing with $B$splines and Penalties
> * Paul H. C. Eilers, Brian D. Marx
> * Statistical Science, Vol. 11, No. 2 (May, 1996), pp. 89102
And it is (freely) available at:
http://projecteuclid.org/handle/euclid.ss/1038425655Hadley

http://had.co.nz/______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


Are you aware that there are many different kinds of splines?
With "spline" and "splinefun", you can use method = "fmm" (Forsyth,
Malcolm and Moler), "natural", or "periodic". I'm not familiar with
"fmm", but it seems to be adequately explained by the "Manual spline
evaluation" you quoted from the documentation.
Natural splines are perhaps the simplest: I(xx0)*(xx0)^j, where
x0 is a knot, and I(z) = 1 if z>0 and 0 otherwise.
However, computations using natural splines are numerically
unstable. The standard solution to this problem is to use Bsplines,
which are 0 outside a finite interval.
Let's look at your example:
n < 9
x < 1:n
y < rnorm(n)
plot(x, y, main = paste("spline[fun](.) through", n, "points"))
spl < smooth.spline(x,y)
lines(spl)
The 'smooth.spline' function uses Bsplines. To see what they
look like, let's do the following:
library(fda)
Bspl.basis < create.bspline.basis(unique(spl$fit$knot))
# Check to make sure:
all.equal(knots(Bspl.basis, interior=FALSE), spl$fit$knot)
# TRUE
# What do Bsplines look like?
plot(Bspl.basis)
abline(v=knots(Bspl.basis), lty='dotted', col='red')
# 7 interior knots, 2 end knots replicated 4 times each, for a spline
of order 4, degree 3 (cubic splines)
# total of 15 knots
# Each spline uses 5 consecutive knots, which means there will be 11
basis functions.
# NOTE: 'smooth.spline' rescaled the interval [1, 9] to [0, 1].
# Evaluate the 11 Bsplines at 'x'
Bspl.basis.x < eval.basis((x1)/8, Bspl.basis)
round(Bspl.basis.x, 4)
# Now the manual computation:
y.spl < Bspl.basis.x %*% spl$fit$coef
# Plot to confirm:
plot(x, y, main = paste("spline[fun](.) through", n, "points"))
spl.xy < spline(x, y)
lines(spl.xy)
points(x, y.spl, pch=2, col='red')
Hope this helps.
Spencer
[hidden email] wrote:
> Fair enough. FOr a spline interpolation I can do the following:
>
>
>> n < 9
>> x < 1:n
>> y < rnorm(n)
>> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
>> lines(spline(x, y))
>>
>
> Then look at the coefficients generated as:
>
>
>> f < splinefun(x, y)
>> ls(envir = environment(f))
>>
> [1] "ties" "ux" "z"
>
>> splinecoef < get("z", envir = environment(f))
>> slinecoef
>>
> $method
> [1] 3
>
> $n
> [1] 9
>
> $x
> [1] 1 2 3 4 5 6 7 8 9
>
> $y
> [1] 0.93571604 0.44240485 0.45451903 0.96207396 1.13246522 0.60032698
> [7] 1.77506105 0.09171419 0.23262573
>
> $b
> [1] 1.53673409 0.22775629 0.81788209 1.16966436 0.73558677 0.68744178
> [7] 0.08639287 1.86770869 2.92992167
>
> $c
> [1] 1.3657783 0.3987121 1.4443504 1.0925682 0.8126830 2.2357115 3.0095462
> [8] 1.2282303 3.5694000
>
> $d
> [1] 0.32235542 0.61435416 0.84563953 0.09329507 1.01613149 1.74841922
> [7] 1.41259217 0.78038989 0.78038989
>
> WHen I look at ?spline there is even an example of "manually" using these coefficeients:
>
> ## Manual spline evaluation  demo the coefficients :
> .x < get("ux", envir = environment(f))
> u < seq(3,6, by = 0.25)
> (ii < findInterval(u, .x))
> dx < u  .x[ii]
> f.u < with(splinecoef,
> y[ii] + dx*(b[ii] + dx*(c[ii] + dx* d[ii])))
> stopifnot(all.equal(f(u), f.u))
>
>
> For the smooth.spline as
>
> spl < smooth.spline(x,y)
>
> I can also look at the coefficients:
>
> spl$fit
> $knot
> [1] 0.000 0.000 0.000 0.000 0.125 0.250 0.375 0.500 0.625 0.750 0.875 1.000
> [13] 1.000 1.000 1.000
>
> $nk
> [1] 11
>
> $min
> [1] 1
>
> $range
> [1] 8
>
> $coef
> [1] 0.90345898 0.73823276 0.40777431 0.08046715 0.54625461 0.85205147
> [7] 0.96233408 0.91373830 0.66529714 0.47674774 0.38246971
>
> attr(,"class")
> [1] "smooth.spline.fit"
>
> But there isn't an example on how to "manual" use these coefficients. This is what I was asking about. Once I hae the coefficients how do I "manually" interpolate using the coefficients given and x.
>
> Thank you.
>
> Kevin
>
>
>  Spencer Graves < [hidden email]> wrote:
>
>> PLEASE do read the posting guide
>> http://www.Rproject.org/postingguide.html and provide commented,
>> minimal, selfcontained, reproducible code.
>>
>> I do NOT know how to do what you want, but with a selfcontained
>> example, I suspect many people on this list  probably including me 
>> could easily solve the problem. Without such an example, there is a
>> high probability that any answer might (a) not respond to your need, and
>> (b) take more time to develop, just because we don't know enough of what
>> you are asking.
>>
>> Spencer
>>
>> [hidden email] wrote:
>>
>>> Like I indicated. I understand the coefficients in a Bspline context. If I use the the 'spline' or 'splinefun' I can get the coefficients and they are grouped as 'a', 'b', 'c', and 'd' coefficients. But the coefficients for smooth.spline is just an array. I basically want to take these coefficients and outside of 'R' use them to form an interpolation. In other words I want 'R' to do the hard work and then export the results so they can be used else where.
>>>
>>> Thank you.
>>>
>>> Kevin
>>>
>>>
>> Spencer Graves wrote:
>>
>>> I believe that a short answer to your question is that the
>>> "smooth" is a linear combination of Bspline basis functions, and the
>>> coefficients are the weights assigned to the different Bsplines in
>>> that basis.
>>> Before offering a much longer answer, I would want to know what
>>> problem you are trying to solve and why you want to know. For a brief
>>> description of Bsplines, see
>>> " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
>>> commentary on them I suggest the "scripts\ch01.R" in the DierckxSpline
>>> package: That script computes and displays some Bsplines using
>>> "splineDesign", "spline.des" in the 'splines' package plus comparable
>>> functions in the 'fda' package. For more info on this, I found the
>>> first chapter of Paul Dierckx (1993) Curve and Surface Fitting with
>>> Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
>>> 'fda' package and the two companion volumes by Ramsay and Silverman
>>> (2006) Functional Data Analysis, 2nd ed. and (2002) Applied Functional
>>> Data Analysis (both Springer).
>>> If you'd like more help from this listserve, PLEASE do read the
>>> posting guide http://www.Rproject.org/postingguide.html and provide
>>> commented, minimal, selfcontained, reproducible code.
>>> Hope this helps. Spencer Graves
>>>
>>> [hidden email] wrote:
>>>
>>>> I like what smooth.spline does but I am unclear on the output. I can
>>>> see from the documentation that there are fit.coef but I am unclear
>>>> what those coeficients are applied to.With spline I understand the
>>>> "noraml" coefficients applied to a cubic polynomial. But these
>>>> coefficients I am not sure how to interpret. If I had a description
>>>> of the algorithm maybe I could figure it out but as it is I have this
>>>> question. Any help?
>>>>
>>>> Kevin
>>>>
>>>> ______________________________________________
>>>> [hidden email] mailing list
>>>> https://stat.ethz.ch/mailman/listinfo/rhelp>>>> PLEASE do read the posting guide
>>>> http://www.Rproject.org/postingguide.html>>>> and provide commented, minimal, selfcontained, reproducible code.
>>>>
>>>>
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/rhelp> PLEASE do read the posting guide http://www.Rproject.org/postingguide.html> and provide commented, minimal, selfcontained, reproducible code.
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


On 20/07/2008 11:11 AM, Spencer Graves wrote:
> Are you aware that there are many different kinds of splines?
> With "spline" and "splinefun", you can use method = "fmm" (Forsyth,
> Malcolm and Moler), "natural", or "periodic". I'm not familiar with
> "fmm", but it seems to be adequately explained by the "Manual spline
> evaluation" you quoted from the documentation.
>
> Natural splines are perhaps the simplest: I(xx0)*(xx0)^j, where
> x0 is a knot, and I(z) = 1 if z>0 and 0 otherwise.
That's not what R means by "natural spline" in this context. Here it
means that the function becomes linear outside the range of the knots.
I would call the I(xx0)*(xx0)^j splines the "truncated power basis"
for polynomial splines; Bsplines are a different basis for the same set
of splines (assuming the knots and degrees match). Natural splines are
a subspace of these (since linear functions are a subspace of
polynomials). I don't know of a simple basis for them.
Duncan Murdoch
>
> However, computations using natural splines are numerically
> unstable. The standard solution to this problem is to use Bsplines,
> which are 0 outside a finite interval.
>
> Let's look at your example:
>
> n < 9
> x < 1:n
> y < rnorm(n)
> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> spl < smooth.spline(x,y)
> lines(spl)
>
> The 'smooth.spline' function uses Bsplines. To see what they
> look like, let's do the following:
>
> library(fda)
> Bspl.basis < create.bspline.basis(unique(spl$fit$knot))
>
> # Check to make sure:
> all.equal(knots(Bspl.basis, interior=FALSE), spl$fit$knot)
> # TRUE
>
> # What do Bsplines look like?
> plot(Bspl.basis)
> abline(v=knots(Bspl.basis), lty='dotted', col='red')
> # 7 interior knots, 2 end knots replicated 4 times each, for a spline
> of order 4, degree 3 (cubic splines)
> # total of 15 knots
> # Each spline uses 5 consecutive knots, which means there will be 11
> basis functions.
>
> # NOTE: 'smooth.spline' rescaled the interval [1, 9] to [0, 1].
> # Evaluate the 11 Bsplines at 'x'
> Bspl.basis.x < eval.basis((x1)/8, Bspl.basis)
>
> round(Bspl.basis.x, 4)
>
> # Now the manual computation:
> y.spl < Bspl.basis.x %*% spl$fit$coef
>
> # Plot to confirm:
> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> spl.xy < spline(x, y)
> lines(spl.xy)
> points(x, y.spl, pch=2, col='red')
>
> Hope this helps.
> Spencer
>
> [hidden email] wrote:
>> Fair enough. FOr a spline interpolation I can do the following:
>>
>>
>>> n < 9
>>> x < 1:n
>>> y < rnorm(n)
>>> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
>>> lines(spline(x, y))
>>>
>> Then look at the coefficients generated as:
>>
>>
>>> f < splinefun(x, y)
>>> ls(envir = environment(f))
>>>
>> [1] "ties" "ux" "z"
>>
>>> splinecoef < get("z", envir = environment(f))
>>> slinecoef
>>>
>> $method
>> [1] 3
>>
>> $n
>> [1] 9
>>
>> $x
>> [1] 1 2 3 4 5 6 7 8 9
>>
>> $y
>> [1] 0.93571604 0.44240485 0.45451903 0.96207396 1.13246522 0.60032698
>> [7] 1.77506105 0.09171419 0.23262573
>>
>> $b
>> [1] 1.53673409 0.22775629 0.81788209 1.16966436 0.73558677 0.68744178
>> [7] 0.08639287 1.86770869 2.92992167
>>
>> $c
>> [1] 1.3657783 0.3987121 1.4443504 1.0925682 0.8126830 2.2357115 3.0095462
>> [8] 1.2282303 3.5694000
>>
>> $d
>> [1] 0.32235542 0.61435416 0.84563953 0.09329507 1.01613149 1.74841922
>> [7] 1.41259217 0.78038989 0.78038989
>>
>> WHen I look at ?spline there is even an example of "manually" using these coefficeients:
>>
>> ## Manual spline evaluation  demo the coefficients :
>> .x < get("ux", envir = environment(f))
>> u < seq(3,6, by = 0.25)
>> (ii < findInterval(u, .x))
>> dx < u  .x[ii]
>> f.u < with(splinecoef,
>> y[ii] + dx*(b[ii] + dx*(c[ii] + dx* d[ii])))
>> stopifnot(all.equal(f(u), f.u))
>>
>>
>> For the smooth.spline as
>>
>> spl < smooth.spline(x,y)
>>
>> I can also look at the coefficients:
>>
>> spl$fit
>> $knot
>> [1] 0.000 0.000 0.000 0.000 0.125 0.250 0.375 0.500 0.625 0.750 0.875 1.000
>> [13] 1.000 1.000 1.000
>>
>> $nk
>> [1] 11
>>
>> $min
>> [1] 1
>>
>> $range
>> [1] 8
>>
>> $coef
>> [1] 0.90345898 0.73823276 0.40777431 0.08046715 0.54625461 0.85205147
>> [7] 0.96233408 0.91373830 0.66529714 0.47674774 0.38246971
>>
>> attr(,"class")
>> [1] "smooth.spline.fit"
>>
>> But there isn't an example on how to "manual" use these coefficients. This is what I was asking about. Once I hae the coefficients how do I "manually" interpolate using the coefficients given and x.
>>
>> Thank you.
>>
>> Kevin
>>
>>
>>  Spencer Graves < [hidden email]> wrote:
>>
>>> PLEASE do read the posting guide
>>> http://www.Rproject.org/postingguide.html and provide commented,
>>> minimal, selfcontained, reproducible code.
>>>
>>> I do NOT know how to do what you want, but with a selfcontained
>>> example, I suspect many people on this list  probably including me 
>>> could easily solve the problem. Without such an example, there is a
>>> high probability that any answer might (a) not respond to your need, and
>>> (b) take more time to develop, just because we don't know enough of what
>>> you are asking.
>>>
>>> Spencer
>>>
>>> [hidden email] wrote:
>>>
>>>> Like I indicated. I understand the coefficients in a Bspline context. If I use the the 'spline' or 'splinefun' I can get the coefficients and they are grouped as 'a', 'b', 'c', and 'd' coefficients. But the coefficients for smooth.spline is just an array. I basically want to take these coefficients and outside of 'R' use them to form an interpolation. In other words I want 'R' to do the hard work and then export the results so they can be used else where.
>>>>
>>>> Thank you.
>>>>
>>>> Kevin
>>>>
>>>>
>>> Spencer Graves wrote:
>>>
>>>> I believe that a short answer to your question is that the
>>>> "smooth" is a linear combination of Bspline basis functions, and the
>>>> coefficients are the weights assigned to the different Bsplines in
>>>> that basis.
>>>> Before offering a much longer answer, I would want to know what
>>>> problem you are trying to solve and why you want to know. For a brief
>>>> description of Bsplines, see
>>>> " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
>>>> commentary on them I suggest the "scripts\ch01.R" in the DierckxSpline
>>>> package: That script computes and displays some Bsplines using
>>>> "splineDesign", "spline.des" in the 'splines' package plus comparable
>>>> functions in the 'fda' package. For more info on this, I found the
>>>> first chapter of Paul Dierckx (1993) Curve and Surface Fitting with
>>>> Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
>>>> 'fda' package and the two companion volumes by Ramsay and Silverman
>>>> (2006) Functional Data Analysis, 2nd ed. and (2002) Applied Functional
>>>> Data Analysis (both Springer).
>>>> If you'd like more help from this listserve, PLEASE do read the
>>>> posting guide http://www.Rproject.org/postingguide.html and provide
>>>> commented, minimal, selfcontained, reproducible code.
>>>> Hope this helps. Spencer Graves
>>>>
>>>> [hidden email] wrote:
>>>>
>>>>> I like what smooth.spline does but I am unclear on the output. I can
>>>>> see from the documentation that there are fit.coef but I am unclear
>>>>> what those coeficients are applied to.With spline I understand the
>>>>> "noraml" coefficients applied to a cubic polynomial. But these
>>>>> coefficients I am not sure how to interpret. If I had a description
>>>>> of the algorithm maybe I could figure it out but as it is I have this
>>>>> question. Any help?
>>>>>
>>>>> Kevin
>>>>>
>>>>> ______________________________________________
>>>>> [hidden email] mailing list
>>>>> https://stat.ethz.ch/mailman/listinfo/rhelp>>>>> PLEASE do read the posting guide
>>>>> http://www.Rproject.org/postingguide.html>>>>> and provide commented, minimal, selfcontained, reproducible code.
>>>>>
>>>>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/rhelp>> PLEASE do read the posting guide http://www.Rproject.org/postingguide.html>> and provide commented, minimal, selfcontained, reproducible code.
>>
>
> ______________________________________________
> [hidden email] mailing list
> https://stat.ethz.ch/mailman/listinfo/rhelp> PLEASE do read the posting guide http://www.Rproject.org/postingguide.html> and provide commented, minimal, selfcontained, reproducible code.
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


<in line>
Duncan Murdoch wrote:
> On 20/07/2008 11:11 AM, Spencer Graves wrote:
>> Are you aware that there are many different kinds of splines?
>> With "spline" and "splinefun", you can use method = "fmm" (Forsyth,
>> Malcolm and Moler), "natural", or "periodic". I'm not familiar with
>> "fmm", but it seems to be adequately explained by the "Manual spline
>> evaluation" you quoted from the documentation.
>> Natural splines are perhaps the simplest: I(xx0)*(xx0)^j,
>> where x0 is a knot, and I(z) = 1 if z>0 and 0 otherwise.
>
> That's not what R means by "natural spline" in this context. Here it
> means that the function becomes linear outside the range of the knots.
>
> I would call the I(xx0)*(xx0)^j splines the "truncated power basis"
> for polynomial splines; Bsplines are a different basis for the same
> set of splines (assuming the knots and degrees match). Natural
> splines are a subspace of these (since linear functions are a subspace
> of polynomials). I don't know of a simple basis for them.
Thanks for the correction. I erred by writing this from memory.
Dierckx (1993, p. 4) says, "A natural spline function is a spline of odd
degree k = 2*m1 (m>=2) which satisfies the additional constraints
(D^(m+j))s(a) = (D^(m+j))s(b) = 0, j = 0, 1, ..., m2.
He further (p. 5) defines the "truncated power functions", which
is what I mistakenly called "natural splines".
Thanks again for the correction.
Spencer
>
> Duncan Murdoch
>
>>
>> However, computations using natural splines are numerically
>> unstable. The standard solution to this problem is to use Bsplines,
>> which are 0 outside a finite interval.
>> Let's look at your example:
>> n < 9
>> x < 1:n
>> y < rnorm(n)
>> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
>> spl < smooth.spline(x,y)
>> lines(spl)
>>
>> The 'smooth.spline' function uses Bsplines. To see what they
>> look like, let's do the following:
>> library(fda)
>> Bspl.basis < create.bspline.basis(unique(spl$fit$knot))
>>
>> # Check to make sure: all.equal(knots(Bspl.basis, interior=FALSE),
>> spl$fit$knot)
>> # TRUE
>>
>> # What do Bsplines look like? plot(Bspl.basis)
>> abline(v=knots(Bspl.basis), lty='dotted', col='red')
>> # 7 interior knots, 2 end knots replicated 4 times each, for a
>> spline of order 4, degree 3 (cubic splines) # total of 15 knots
>> # Each spline uses 5 consecutive knots, which means there will be 11
>> basis functions. # NOTE: 'smooth.spline' rescaled the interval
>> [1, 9] to [0, 1]. # Evaluate the 11 Bsplines at 'x'
>> Bspl.basis.x < eval.basis((x1)/8, Bspl.basis)
>>
>> round(Bspl.basis.x, 4)
>>
>> # Now the manual computation: y.spl < Bspl.basis.x %*% spl$fit$coef
>>
>> # Plot to confirm: plot(x, y, main = paste("spline[fun](.) through",
>> n, "points"))
>> spl.xy < spline(x, y)
>> lines(spl.xy)
>> points(x, y.spl, pch=2, col='red')
>>
>> Hope this helps. Spencer
>>
>> [hidden email] wrote:
>>> Fair enough. FOr a spline interpolation I can do the following:
>>>
>>>
>>>> n < 9
>>>> x < 1:n
>>>> y < rnorm(n)
>>>> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
>>>> lines(spline(x, y))
>>>>
>>> Then look at the coefficients generated as:
>>>
>>>
>>>> f < splinefun(x, y)
>>>> ls(envir = environment(f))
>>>>
>>> [1] "ties" "ux" "z"
>>>> splinecoef < get("z", envir = environment(f))
>>>> slinecoef
>>>>
>>> $method
>>> [1] 3
>>>
>>> $n
>>> [1] 9
>>>
>>> $x
>>> [1] 1 2 3 4 5 6 7 8 9
>>>
>>> $y
>>> [1] 0.93571604 0.44240485 0.45451903 0.96207396 1.13246522
>>> 0.60032698
>>> [7] 1.77506105 0.09171419 0.23262573
>>>
>>> $b
>>> [1] 1.53673409 0.22775629 0.81788209 1.16966436 0.73558677
>>> 0.68744178
>>> [7] 0.08639287 1.86770869 2.92992167
>>>
>>> $c
>>> [1] 1.3657783 0.3987121 1.4443504 1.0925682 0.8126830
>>> 2.2357115 3.0095462
>>> [8] 1.2282303 3.5694000
>>>
>>> $d
>>> [1] 0.32235542 0.61435416 0.84563953 0.09329507 1.01613149
>>> 1.74841922
>>> [7] 1.41259217 0.78038989 0.78038989
>>>
>>> WHen I look at ?spline there is even an example of "manually" using
>>> these coefficeients:
>>>
>>> ## Manual spline evaluation  demo the coefficients :
>>> .x < get("ux", envir = environment(f))
>>> u < seq(3,6, by = 0.25)
>>> (ii < findInterval(u, .x))
>>> dx < u  .x[ii]
>>> f.u < with(splinecoef,
>>> y[ii] + dx*(b[ii] + dx*(c[ii] + dx* d[ii])))
>>> stopifnot(all.equal(f(u), f.u))
>>>
>>>
>>> For the smooth.spline as
>>>
>>> spl < smooth.spline(x,y)
>>>
>>> I can also look at the coefficients:
>>>
>>> spl$fit
>>> $knot
>>> [1] 0.000 0.000 0.000 0.000 0.125 0.250 0.375 0.500 0.625 0.750
>>> 0.875 1.000
>>> [13] 1.000 1.000 1.000
>>>
>>> $nk
>>> [1] 11
>>>
>>> $min
>>> [1] 1
>>>
>>> $range
>>> [1] 8
>>>
>>> $coef
>>> [1] 0.90345898 0.73823276 0.40777431 0.08046715 0.54625461
>>> 0.85205147
>>> [7] 0.96233408 0.91373830 0.66529714 0.47674774 0.38246971
>>>
>>> attr(,"class")
>>> [1] "smooth.spline.fit"
>>>
>>> But there isn't an example on how to "manual" use these
>>> coefficients. This is what I was asking about. Once I hae the
>>> coefficients how do I "manually" interpolate using the coefficients
>>> given and x.
>>>
>>> Thank you.
>>>
>>> Kevin
>>>
>>>
>>>  Spencer Graves < [hidden email]> wrote:
>>>> PLEASE do read the posting guide
>>>> http://www.Rproject.org/postingguide.html and provide commented,
>>>> minimal, selfcontained, reproducible code.
>>>>
>>>> I do NOT know how to do what you want, but with a
>>>> selfcontained example, I suspect many people on this list 
>>>> probably including me  could easily solve the problem. Without
>>>> such an example, there is a high probability that any answer might
>>>> (a) not respond to your need, and (b) take more time to develop,
>>>> just because we don't know enough of what you are asking.
>>>> Spencer
>>>>
>>>> [hidden email] wrote:
>>>>
>>>>> Like I indicated. I understand the coefficients in a Bspline
>>>>> context. If I use the the 'spline' or 'splinefun' I can get the
>>>>> coefficients and they are grouped as 'a', 'b', 'c', and 'd'
>>>>> coefficients. But the coefficients for smooth.spline is just an
>>>>> array. I basically want to take these coefficients and outside of
>>>>> 'R' use them to form an interpolation. In other words I want 'R'
>>>>> to do the hard work and then export the results so they can be
>>>>> used else where.
>>>>>
>>>>> Thank you.
>>>>>
>>>>> Kevin
>>>>>
>>>> Spencer Graves wrote:
>>>>
>>>>> I believe that a short answer to your question is that the
>>>>> "smooth" is a linear combination of Bspline basis functions, and
>>>>> the coefficients are the weights assigned to the different
>>>>> Bsplines in that basis.
>>>>> Before offering a much longer answer, I would want to know
>>>>> what problem you are trying to solve and why you want to know.
>>>>> For a brief description of Bsplines, see
>>>>> " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
>>>>> commentary on them I suggest the "scripts\ch01.R" in the
>>>>> DierckxSpline package: That script computes and displays some
>>>>> Bsplines using "splineDesign", "spline.des" in the 'splines'
>>>>> package plus comparable functions in the 'fda' package. For more
>>>>> info on this, I found the first chapter of Paul Dierckx (1993)
>>>>> Curve and Surface Fitting with Splines (Oxford U. Pr.). Beyond
>>>>> that, I've learned a lot from the 'fda' package and the two
>>>>> companion volumes by Ramsay and Silverman (2006) Functional Data
>>>>> Analysis, 2nd ed. and (2002) Applied Functional Data Analysis
>>>>> (both Springer).
>>>>> If you'd like more help from this listserve, PLEASE do read
>>>>> the posting guide http://www.Rproject.org/postingguide.html and
>>>>> provide commented, minimal, selfcontained, reproducible code.
>>>>> Hope this helps. Spencer Graves
>>>>>
>>>>> [hidden email] wrote:
>>>>>
>>>>>> I like what smooth.spline does but I am unclear on the output. I
>>>>>> can see from the documentation that there are fit.coef but I am
>>>>>> unclear what those coeficients are applied to.With spline I
>>>>>> understand the "noraml" coefficients applied to a cubic
>>>>>> polynomial. But these coefficients I am not sure how to
>>>>>> interpret. If I had a description of the algorithm maybe I could
>>>>>> figure it out but as it is I have this question. Any help?
>>>>>>
>>>>>> Kevin
>>>>>>
>>>>>> ______________________________________________
>>>>>> [hidden email] mailing list
>>>>>> https://stat.ethz.ch/mailman/listinfo/rhelp>>>>>> PLEASE do read the posting guide
>>>>>> http://www.Rproject.org/postingguide.html>>>>>> and provide commented, minimal, selfcontained, reproducible code.
>>>>>>
>>> ______________________________________________
>>> [hidden email] mailing list
>>> https://stat.ethz.ch/mailman/listinfo/rhelp>>> PLEASE do read the posting guide
>>> http://www.Rproject.org/postingguide.html>>> and provide commented, minimal, selfcontained, reproducible code.
>>>
>>
>> ______________________________________________
>> [hidden email] mailing list
>> https://stat.ethz.ch/mailman/listinfo/rhelp>> PLEASE do read the posting guide
>> http://www.Rproject.org/postingguide.html>> and provide commented, minimal, selfcontained, reproducible code.
>
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.


Actually that was my next question. From the books that I have I see a "natural spline" and a clamped spline. I am assuming that "natural" (Umerical Analysis, Burden, et. all.) cooresponds to 'R''s "natural" method. I am not clear on what a clamped spline cooresponds to (fmm or perodic). Or what the difference between fmm and periodic.
Thank you.
Kevin
 Spencer Graves < [hidden email]> wrote:
> Are you aware that there are many different kinds of splines?
> With "spline" and "splinefun", you can use method = "fmm" (Forsyth,
> Malcolm and Moler), "natural", or "periodic". I'm not familiar with
> "fmm", but it seems to be adequately explained by the "Manual spline
> evaluation" you quoted from the documentation.
>
> Natural splines are perhaps the simplest: I(xx0)*(xx0)^j, where
> x0 is a knot, and I(z) = 1 if z>0 and 0 otherwise.
>
> However, computations using natural splines are numerically
> unstable. The standard solution to this problem is to use Bsplines,
> which are 0 outside a finite interval.
>
> Let's look at your example:
>
> n < 9
> x < 1:n
> y < rnorm(n)
> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> spl < smooth.spline(x,y)
> lines(spl)
>
> The 'smooth.spline' function uses Bsplines. To see what they
> look like, let's do the following:
>
> library(fda)
> Bspl.basis < create.bspline.basis(unique(spl$fit$knot))
>
> # Check to make sure:
> all.equal(knots(Bspl.basis, interior=FALSE), spl$fit$knot)
> # TRUE
>
> # What do Bsplines look like?
> plot(Bspl.basis)
> abline(v=knots(Bspl.basis), lty='dotted', col='red')
> # 7 interior knots, 2 end knots replicated 4 times each, for a spline
> of order 4, degree 3 (cubic splines)
> # total of 15 knots
> # Each spline uses 5 consecutive knots, which means there will be 11
> basis functions.
>
> # NOTE: 'smooth.spline' rescaled the interval [1, 9] to [0, 1].
> # Evaluate the 11 Bsplines at 'x'
> Bspl.basis.x < eval.basis((x1)/8, Bspl.basis)
>
> round(Bspl.basis.x, 4)
>
> # Now the manual computation:
> y.spl < Bspl.basis.x %*% spl$fit$coef
>
> # Plot to confirm:
> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> spl.xy < spline(x, y)
> lines(spl.xy)
> points(x, y.spl, pch=2, col='red')
>
> Hope this helps.
> Spencer
>
> [hidden email] wrote:
> > Fair enough. FOr a spline interpolation I can do the following:
> >
> >
> >> n < 9
> >> x < 1:n
> >> y < rnorm(n)
> >> plot(x, y, main = paste("spline[fun](.) through", n, "points"))
> >> lines(spline(x, y))
> >>
> >
> > Then look at the coefficients generated as:
> >
> >
> >> f < splinefun(x, y)
> >> ls(envir = environment(f))
> >>
> > [1] "ties" "ux" "z"
> >
> >> splinecoef < get("z", envir = environment(f))
> >> slinecoef
> >>
> > $method
> > [1] 3
> >
> > $n
> > [1] 9
> >
> > $x
> > [1] 1 2 3 4 5 6 7 8 9
> >
> > $y
> > [1] 0.93571604 0.44240485 0.45451903 0.96207396 1.13246522 0.60032698
> > [7] 1.77506105 0.09171419 0.23262573
> >
> > $b
> > [1] 1.53673409 0.22775629 0.81788209 1.16966436 0.73558677 0.68744178
> > [7] 0.08639287 1.86770869 2.92992167
> >
> > $c
> > [1] 1.3657783 0.3987121 1.4443504 1.0925682 0.8126830 2.2357115 3.0095462
> > [8] 1.2282303 3.5694000
> >
> > $d
> > [1] 0.32235542 0.61435416 0.84563953 0.09329507 1.01613149 1.74841922
> > [7] 1.41259217 0.78038989 0.78038989
> >
> > WHen I look at ?spline there is even an example of "manually" using these coefficeients:
> >
> > ## Manual spline evaluation  demo the coefficients :
> > .x < get("ux", envir = environment(f))
> > u < seq(3,6, by = 0.25)
> > (ii < findInterval(u, .x))
> > dx < u  .x[ii]
> > f.u < with(splinecoef,
> > y[ii] + dx*(b[ii] + dx*(c[ii] + dx* d[ii])))
> > stopifnot(all.equal(f(u), f.u))
> >
> >
> > For the smooth.spline as
> >
> > spl < smooth.spline(x,y)
> >
> > I can also look at the coefficients:
> >
> > spl$fit
> > $knot
> > [1] 0.000 0.000 0.000 0.000 0.125 0.250 0.375 0.500 0.625 0.750 0.875 1.000
> > [13] 1.000 1.000 1.000
> >
> > $nk
> > [1] 11
> >
> > $min
> > [1] 1
> >
> > $range
> > [1] 8
> >
> > $coef
> > [1] 0.90345898 0.73823276 0.40777431 0.08046715 0.54625461 0.85205147
> > [7] 0.96233408 0.91373830 0.66529714 0.47674774 0.38246971
> >
> > attr(,"class")
> > [1] "smooth.spline.fit"
> >
> > But there isn't an example on how to "manual" use these coefficients. This is what I was asking about. Once I hae the coefficients how do I "manually" interpolate using the coefficients given and x.
> >
> > Thank you.
> >
> > Kevin
> >
> >
> >  Spencer Graves < [hidden email]> wrote:
> >
> >> PLEASE do read the posting guide
> >> http://www.Rproject.org/postingguide.html and provide commented,
> >> minimal, selfcontained, reproducible code.
> >>
> >> I do NOT know how to do what you want, but with a selfcontained
> >> example, I suspect many people on this list  probably including me 
> >> could easily solve the problem. Without such an example, there is a
> >> high probability that any answer might (a) not respond to your need, and
> >> (b) take more time to develop, just because we don't know enough of what
> >> you are asking.
> >>
> >> Spencer
> >>
> >> [hidden email] wrote:
> >>
> >>> Like I indicated. I understand the coefficients in a Bspline context. If I use the the 'spline' or 'splinefun' I can get the coefficients and they are grouped as 'a', 'b', 'c', and 'd' coefficients. But the coefficients for smooth.spline is just an array. I basically want to take these coefficients and outside of 'R' use them to form an interpolation. In other words I want 'R' to do the hard work and then export the results so they can be used else where.
> >>>
> >>> Thank you.
> >>>
> >>> Kevin
> >>>
> >>>
> >> Spencer Graves wrote:
> >>
> >>> I believe that a short answer to your question is that the
> >>> "smooth" is a linear combination of Bspline basis functions, and the
> >>> coefficients are the weights assigned to the different Bsplines in
> >>> that basis.
> >>> Before offering a much longer answer, I would want to know what
> >>> problem you are trying to solve and why you want to know. For a brief
> >>> description of Bsplines, see
> >>> " http://en.wikipedia.org/wiki/Bspline". For a slightly longer
> >>> commentary on them I suggest the "scripts\ch01.R" in the DierckxSpline
> >>> package: That script computes and displays some Bsplines using
> >>> "splineDesign", "spline.des" in the 'splines' package plus comparable
> >>> functions in the 'fda' package. For more info on this, I found the
> >>> first chapter of Paul Dierckx (1993) Curve and Surface Fitting with
> >>> Splines (Oxford U. Pr.). Beyond that, I've learned a lot from the
> >>> 'fda' package and the two companion volumes by Ramsay and Silverman
> >>> (2006) Functional Data Analysis, 2nd ed. and (2002) Applied Functional
> >>> Data Analysis (both Springer).
> >>> If you'd like more help from this listserve, PLEASE do read the
> >>> posting guide http://www.Rproject.org/postingguide.html and provide
> >>> commented, minimal, selfcontained, reproducible code.
> >>> Hope this helps. Spencer Graves
> >>>
> >>> [hidden email] wrote:
> >>>
> >>>> I like what smooth.spline does but I am unclear on the output. I can
> >>>> see from the documentation that there are fit.coef but I am unclear
> >>>> what those coeficients are applied to.With spline I understand the
> >>>> "noraml" coefficients applied to a cubic polynomial. But these
> >>>> coefficients I am not sure how to interpret. If I had a description
> >>>> of the algorithm maybe I could figure it out but as it is I have this
> >>>> question. Any help?
> >>>>
> >>>> Kevin
> >>>>
> >>>> ______________________________________________
> >>>> [hidden email] mailing list
> >>>> https://stat.ethz.ch/mailman/listinfo/rhelp> >>>> PLEASE do read the posting guide
> >>>> http://www.Rproject.org/postingguide.html> >>>> and provide commented, minimal, selfcontained, reproducible code.
> >>>>
> >>>>
> >
> > ______________________________________________
> > [hidden email] mailing list
> > https://stat.ethz.ch/mailman/listinfo/rhelp> > PLEASE do read the posting guide http://www.Rproject.org/postingguide.html> > and provide commented, minimal, selfcontained, reproducible code.
> >
______________________________________________
[hidden email] mailing list
https://stat.ethz.ch/mailman/listinfo/rhelpPLEASE do read the posting guide http://www.Rproject.org/postingguide.htmland provide commented, minimal, selfcontained, reproducible code.

