Ov ϒ}lg)^/ gixR?f./8 'MqeׂgNeI۩=^̑G >P_G4Ηh s3O~.~ 'O
\ nvzǓS{4/ ^'r8I:C vy6 {sY'> -,rYG 9~?Λ \'+9סo^j7&^Wd_M%=C^ Ϗ% zo-k= W]T_gOer?>Dh S^%=?/Q~z5Y ^s]O %Zv4o~1]^+Z |MZR;5C K\O _\DO>s\_)h .RSR?y qq}%Oxuv"]Y?Eu=aru;Kܞ|댫~'srx%qm :uz6 o{ Ȇ]qwh!q]]lmُl _.}||Cް?9>دWnq]nqn -~^篊xy(^o
;ab[Ű77<~vx^ݺ?ܟm]o ?[]v}e<5aUGv|aD p
knk">v䧛'" /Dne$_q)g|rS v^qr]g[lYgEħ߆3Ϫզl ~ɓ%/7e܉v%]?_km"yW7D] Q r"^n
yxCKg
Yߟӛ@?q-u7E^!b> uO}sS^\䍈m7/ZyK䕇bzK;ɉ51d#ˢȳ uuW-v)g{x摴@S/["Υ wD| <%qKﶌq^K51?6|q,Z|䪨o
^ײ"l 瀬?$!y y]b-Nrxx^!x)Y_"q[?ngG'[ D^YV "o\ݾ?-a^^}YGo{Y"E]wc
Q?\~7:{[\2|^}v='yշww>^$ <;w䝻o_r_}˴{O<_kk|Uٝ >xKwsᵷv{*N⭯|g htyG ;wrNw=3nϺ^9
4PNC9
4PNC9
4NC;
4NC;
4NC;
40N8
40N8
4ӰN:
4ӰN:
4ӰN:iN#wȝF4r;iN4zN4zN4zN4zN4zN4N4N4N4N4Nc4Nc4Nc4Nc4Nc4q;;.vv5v
v-vs.ԺPB .ԺPB .ԺPBMAMAMAMAMAMAMAMAMAMAMCMCMCMCMCMCMCMCMCMC@@@@@@@@@@BBBBBBBBBB-Z j9rPˡC-Z zPA zPA zPC>PC>PCP@m P@m (D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,Q`KX(D%
,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4X
hD%,`K4XĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,1`K XbĀ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb XĂ%,`K,Xb , , , , , , , , , , ,K~oS locfit/data/bad.rda 0000744 0001760 0000144 00000003432 12123143130 013702 0 ustar ripley users ] TSW$`g\ G=JQ!{RYJA1 ؊:-,[-*RDPEdQ ; V|ǜnyn|aqxlǀ M_\2Rlb> o8/61gJ?YKEB³ptkhc|wo
Ha7"82==ŭ3@U=s!ܳ,];mޟ@1bZ(eyx|AQ(c+_BB졂鷲R.DuP]3wm#v'd+R͚5ԐȘy Ipvu<ԚS9C~PNYwnLPfrxz{{m)SWxah`kq-+&Φ
ٸw zoܹ >|8!
y ^Z? +k*n[< 5z^eV5IXբwŠ͐ Pyژf8{r{/V7:[aƭ 4?mb0o眝so{}VNsОm|:h UoXυIБJA^^,:O%(.Agdb ]|uSA73oIfnfz jJoB3= OAރݠbHH[h*,ʾ }ae^B_qYڽ#am]㱫3Jf]yf/ӫSϬÀdL9{K0\(XCz Ri~ܱ2Jȫ%oAx>M:4e͑ @+Zȸ%c
[}
erݿ\)#ɘo71qV0SpG(C32fd'2Xz%yb=UЫs2L]Cn '}6j=IzDR8=Hf6; eYGQ3}-De{@_voPPP95D }fp@nua2_Ƞu8f
?H I7^4:{;=T?(ڰj&o BJ&[U)?/$
^:o7s<53Uc eDo&( *3C*`w& AO_v`xj ȃ ]YU C{{=`)}<ʧ%+M Gr ߹]Xb7Zjrn?MVv?ZdY;Y0ܳ}F00u7?}AC֑&jL7%/fBm2%dAb}T dL89br$$$$$$ń
>|4hG
>4h!@C
4h!DC
!B4h!BC
"4Dh!BC
1b4h!FC
14$hHА!AC
4$hHѐ!EC
)R4hHѐ!CC
24dhА!CC7 'b}z
locfit/data/insect.tab.gz 0000744 0001760 0000144 00000000104 12123143130 015051 0 ustar ripley users IKVHIM,(V+2PP0R062TP F
XD(h |݆: locfit/data/spencer.rda 0000744 0001760 0000144 00000000766 12123143130 014622 0 ustar ripley users r0b```b`cd`b2Y#s1{qAj^rj0X K90)6PJ[Bi+(m
m-PF7@hG(w|g(w]|W(w | \؝w;Z+C 'Huz9ξtk K27/ /n_}9<6'*
;.Wij}Vb_V /c_8Ve}]_BCq3zErw_d+o*ur[?4o19b}ӡS o9~ ˾3햹ٷwvgy@ 42ẢP&gn~QIbNfI%bF WJbI^ZL4EzvIA%
a #01La 3 ư1, &C82,82, 8 n# Fp;v0a Ean locfit/data/cldem.tab.gz 0000744 0001760 0000144 00000001157 12123143130 014661 0 ustar ripley users =Tɵ A;Iؗ~ުiI~'(ʰ #%NG(d)Nحc팢c>aUWNVLsJe")=S
)E%4Yʶ TEM,eKP #p*RO#t-Kr#,?>Oȱ4hKcr
␡OMºslV^+t-HTlsJ,h`fh7Gta8,H}!fy ٕ_F#F6cN #7)2*Aɚw&N}W:&1}j,ݘF--wS`XvsMўͱf !%Vѽ6mHj3.NYaWUWغm q;@JBl};Dٶ^F.ʡ%yߘz>7wi3Luc6 7z&͞DSpǁb
g/e\)ͻw{leH$o '~2 qɜuڑcxwg+q-zv'vqÕg{'!6K쁧()3K9s:-5%-'@i+HAC
\XOT glʲpѵ6 /<3iKoF\XOp~m
gl YUE e:Q5s$R;mX6PR sc pvm䴗H&RisfU-ԝ.reФYkQV4Ϧ=&TmA{ɽh AV@F|-h.,xM{QY kq
ܝʺ*z&ΝnkG^h;LmA'',K5.ǷCWk P9k2IQz憪,jpM6ki~\e E/5p BrӢ0UoB FV3I`O>S{# 'ڔECCιpQa ޡ YR %t)(5Th1\q }N!Ib#\gSLd~6}?O locfit/data/diab.tab.gz 0000744 0001760 0000144 00000000470 12123143130 014471 0 ustar ripley users =RKN1 DM=6,tXZq 떷 |$ZD&MWK.,k4v8 6 w7dE'.aE.HJ
@y&)tUa:wta#&95 pevy3w1G@-qhdrte22-`HuL $/*wseW3s<2P7WHg:(vC\@A ß{Ov>ʈd
9ș+۰eQ
locfit/data/co2.rda 0000744 0001760 0000144 00000004620 12123143130 013637 0 ustar ripley users ml^encmфc%&euWIa`[Sd"{a>L4Ʃ :&QX0`p/19N\f͊an!2=\i]y~}kpM{SoGGGWGהΎ pbWOgS~NXR/l
)v>?9n9>\s\s|xq[㎚㮚ޚok/ j57j'kk7~8]s_}Y܂wsu}A̯
}Y:!B\:
x?c)#\}8C}[݇uz} ~aݫ Mܷun@p pv+\ ]Va >:' ?QN C{ǡO|uوу+W#Wt#"oUgx-$-w |XV + >,.z_Cȷb9Bmb ｋGp^ <.n|Fu Q
Ե݆ n38Ob/aAo}(yB ŋu *㾗P&ԻǿC#75;/yz|@)/`` O}4^4z^3msJ__s<o@Ǒoߏ͋܀)Gsۼާc lvy5g;߳dhҊ#y9
NN\32an{ >W [WϺg;9 j @AP
jU$ Š1F
FBE6mb 1C!c1b 1CPc1j 5C#0F`1c#0Fh1Bc#4Fh1"cDƈ#2Fd1"cƈ#6Fl1bcƈ#1Fb1c$H#1Fj1RcH#5FjbLh̙aCP9 8 989L8$AZi
5Hk AZ4!MH҄4!MH҄4!MHSҔ4%MISҔ4%MISҔ4DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.DK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDK.QDuə 4 locfit/data/ethanol.rda 0000744 0001760 0000144 00000002353 12123143130 014607 0 ustar ripley users }hUu｛{QY,fλnhq3v#q 7^7at]/U TA]uG}>-(} 0q! A\? kWY/~F9t!곯 )p#Ҭ,r t|u i}_=OD-! Oa0uJ0q0/i<4gL ?m0Zi@}!#GQ GP46x
c<O<w; .x {=>x OS&tӦ7CqgyGovcGaqp#Ⱦ KWNnK{o+ٓۇ
bPL]LCLSLK/Vi:CtM 343434343434343434343 3 3 3 3 3 3 3 3 3 3Bf2#dFg
V locfit/data/mmsamp.tab.gz 0000744 0001760 0000144 00000000643 12123143130 015066 0 ustar ripley users -R
@i`W`Βñ,6߿?)>U N>d_bE,ifJxS pᘥjE $~h%%tY8ӯY".1ZR9H|AA<ij;,Yu
R^q-^/
B
W#61wAmlgV ;v;Sit9v'UBkyM6<>,s{t.qlS4eA9l)Ez "uhQ:.Jf뺰M/1y
zI ܆ix^+'~Z)ɝK&jl_bt"l\[/-zWmXnǔE%1ob,ǟZ locfit/data/trimod.tab.gz 0000744 0001760 0000144 00000005017 12123143130 015072 0 ustar ripley users 5k#8)rIkjk B7~~7ϧ~ {?9{guxkpeƼ|3'Ϸ#l 7^qͥ'ʷ?kSu0{湩'sc#ՅS5,C^8.#/~sZ}qvcW)9އQ H`^>~玬7C9*')D 夨 ٤F][baL m!# ;> _;t(qT}v-X| q|U9\%sPt$=ǤjP;>w= >2Έ9k~;λ
[^ ' <2jφIt '%#}}ԺZ&e]^
_,C_swç^i 떪BC~Ć44 wVl \d h.ڋk6Z͝1y(&-a^1
8]qQEFaVWm ߚqB.Ý_07nM݁#^[&ɶC9&<ȹ*Ob X
MB"oB_i$Ш+蒼N
RqB\8ރ @ Njw 7D37 %`vNM'⢎ޝ{)#Iq\K8ıJ I M%|' u+y}2_S1 (|^谡[ c;|ΐVS5q/mBj[eF43
{deS ZDQcg< {@ph<
=KCsq CWnU!/ #Y&gq }0Ȳbj!yfqzL ;]Gdu5HoF7Ur}oH )Fx٩"?K 8aO?h6
<
BBE[2awK I2g_2<-Uoy,]Udрs6<}bH'Lé zZRpk@~Ft ͍7ri+ۧV-뾣g4)
DIJ=zFc{ dkco? N+0Gn̷$_2М$XOI!tSj2m Uq(I"4c9."aq~`zu{)6' /<v업("KkIoQ[lX_1"m@Xc@1#7*?*
aBN 稒9Kx8t& a4?_'@~u M)KI
VeP
7 5Ow`%R咒fh9 'ay2"4w]mVʼ?IDNz`~ :ğ^q% ('e<ø
^x}S 7P#d/NZj# / s7+hE O28Q렲8龆j ,^ |j^gYBOlϝr Oȸڟ_=pV7cb-(k KūwNwj
:k&>Fx-Z$l4Al KXdh@5Y+#wlLv Xz^yz08R) -%f8Y3$ *D ] yS Pe9vs.16&x\8M |]m@;-B&P k9WZ L^=Ak 7t{N
rͶ
NAM[UѥYe A%Hi73/ҎRD62LE`ٻC]n=6L7ӼQhf_
xUN;??vp:~u:ҿ({kXhÌNj-P5 Bg:q2 locfit/data/penny.tab.gz 0000744 0001760 0000144 00000000450 12123143130 014721 0 ustar ripley users UKn0 D=O`H:NQHQo FCj(>>?\݊h' EW2'):ҷPpf6hGgDos* ֔YY:)8O3_L/yI QĩMIQ"v7d-u1WO@Sפ#|½5 ӘûlSӣ'Й~24W~
{u!OYobtF&6{K {e BU B~&o9 dJe[ME locfit/data/claw54.rda 0000744 0001760 0000144 00000000774 12123143130 014261 0 ustar ripley users RDX2
X
claw54 6?H.?PG@0r1y ?o&ظ?նZ?d ?4FXA?#Y%d?l}7?b])?gei?^ N~m}?@a2JU) Kcɿ Qj4bظ'
ο?t0?mB1?響bɃ X?t/|M}?v~^/?ދ;2z즇& p-?»תva?!ZSg2?Ǡz^jb?cn9n8.@/ OTҿ0 t '#@cL8?5:>/0 (ZG?x#ۧ[o"͊b?g2@DO?M.?9A݀y?ӹ' pb locfit/data/mine.rda 0000744 0001760 0000144 00000001134 12123143130 014101 0 ustar ripley users nAM(M{ /i
)3Wnmj TҥP)јy GQx| Xd}gۙQE"
(XQO K4vzm/%m%i_hUG4|:S0Jח-יzBFy
ߌS}V R}i4:ͻZxcQz5YߎuFJYs~pc 35*WDst^Ǭ}3z1'h|ko% ;GQ_7|}s|>5zRWHMgf]?' zf^hQiCgcZvq~V֡1: M-UVj qZkmK&Pz~;0
Lw;y/ ? %DဂDa.?\֕HUU _I۪܁A+~7j嚝˿zYBҐ
W~l-ACA}/Ww.@;f3TQFt[-k{;XG~ /@ u?jSէ_mA@mlx{/Q +M5C0KP)Si-*P"z ~pN}j j[o^ڞ<=닯Eݪ9s|z 7+ 6 VTC<ÏF=@8EG
>c+t>}㔧k{aDU @MOx>Yh (P/m Q |A\Ϻ:8*T:GCy{0=C6zG1*b ARz
W/4sN>*e[Pv?0g0_f'ꖨP)ϧs$*44֘[dam `5C4'Oyؖ?x<_5~PWh*WWϓۛ*. .'U??F
}QkO!_3!2 T:g
{y S5OU
,\joW;V]}Sն
~Nu Ny9JXGqQ uQPzSSoz;[硞p%5#?
Q:FR
T7?cNG% hأ9r{ #'8:R4u 7jA5 Es0MRI$W!#=Ial|~3}f8
F>|IC>VZshkKgwo$۳|ښ֜-s5,>&,m->`5Nx*>-|j+u3czr6Ӭ3 XtVYaR9 g\jtybӼ>MG[}j7;xg}l{kg%_ma|7Yhzv3os~6|3O0weNJeqQA ,XOhէkܱ|ۼYٱ.غ_תۛ$)HcYxf6 ,ȘSͼJ
xǫ4|^b0 f 3 `00a 3 f8p0a .3\fp2e 33|f3g 3f0#`F3fdaFfdaFfd1Ts,SY:te2-K_,ZJh)ZJh)ZJh 4
B@h 4#4Gh 9Bs#4Gh\Bs
+4Wh\yB '4Oh 0; prints out some debugging information.}
\item{geth}{Don't use!}
\item{sty}{ Deprecated - see \code{\link{lp}()}. }
}
\value{
An object with class "locfit". A standard set of methods for printing, ploting, etc. these objects is provided.
}
\references{
Loader, C., (1999) Local Regression and Likelihood.
}
\keyword{smooth}
locfit/man/plot.locfit.3d.Rd 0000744 0001760 0000144 00000002616 12123143131 015363 0 ustar ripley users \name{plot.locfit.3d}
\alias{plot.locfit.3d}
\title{
Plot a high-dimensional "preplot.locfit" object using trellis displays.
}
\usage{
\method{plot}{locfit.3d}(x, main="", pv, tv, type = "level", pred.lab = x$vnames,
resp.lab=x$yname, crit = 1.96, ...)
}
\description{
This function plots cross-sections of a Locfit model (usually in three
or more dimensions) using trellis displays. It is not usually called
directly, but is invoked by \code{\link{plot.locfit}}.
The R libraries \code{lattice} and \code{grid} provide a partial
(at time of writing) implementation of trellis. Currently, this works
with one panel variable.
}
\arguments{
\item{x}{\code{"preplot.locfit"} object.}
\item{main}{title for the plot.}
\item{pv}{Panel variables. These are the variables (either one or two)
that are varied within each panel of the display.}
\item{tv}{Trellis variables. These are varied from panel to panel
of the display.}
\item{type}{Type of display. When there are two panel variables,
the choices are \code{"contour"}, \code{"level"} and
\code{"persp"}.}
\item{pred.lab}{label for the predictor variable.}
\item{resp.lab}{label for the response variable.}
\item{crit}{critical value for the confidence level.}
\item{...}{graphical parameters passed to \code{xyplot} or
\code{contourplot}.}
}
\seealso{
\code{plot.locfit},
\code{preplot.locfit}
}
\keyword{methods}
locfit/man/lflim.Rd 0000744 0001760 0000144 00000000701 12123143131 013715 0 ustar ripley users \name{lflim}
\alias{lflim}
\title{
Construct Limit Vectors for Locfit fits.
}
\usage{
lflim(limits, nm, ret)
}
\description{
This function is used internally to interpret \code{xlim} and \code{flim}
arguments. It should not be called directly.
}
\arguments{
\item{limits}{
Limit argument.
}
\item{nm}{
Variable names.
}
\item{ret}{
Initial return vector.
}
}
\value{
Vector with length 2*dim.
}
\seealso{
\code{\link{locfit}}
}
\keyword{smooth}
locfit/man/formula.locfit.Rd 0000744 0001760 0000144 00000000666 12123143130 015547 0 ustar ripley users \name{formula.locfit}
\alias{formula.locfit}
\title{
Formula from a Locfit object.
}
\usage{
\method{formula}{locfit}(x, ...)
}
\description{Extract the model formula from a locfit object.}
\arguments{
\item{x}{ \code{locfit} object.}
\item{...}{Arguments passed to and from other methods.}
}
\value{
Returns the formula from the locfit object.
}
\seealso{
\code{\link{locfit}}
}
\keyword{models}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/lf.Rd 0000744 0001760 0000144 00000002433 13636446042 013240 0 ustar ripley users \name{lf}
\alias{lf}
\title{
Locfit term in Additive Model formula
}
\usage{
lf(..., alpha=0.7, deg=2, scale=1, kern="tcub", ev=rbox(), maxk=100)
}
\description{
This function is used to specify a smooth term in a \code{gam()}
model formula.
This function is designed to be used with the S-Plus
\code{gam()} function. For R users, there are at least two different
\code{gam()} functions available. Most current distributions of R
will include the \code{mgcv} library by Simon Wood; \code{lf()}
is not compatable with this function.
On CRAN, there is a \code{gam} package by Trevor Hastie, similar to
the S-Plus version. \code{lf()} should be compatable with this, although
it's untested.
}
\arguments{
\item{...}{numeric predictor variable(s)}
\item{alpha, deg, scale, kern, ev, maxk}{these are as in
\code{\link{locfit.raw}}.}
}
\examples{
\dontrun{
# fit an additive semiparametric model to the ethanol data.
stopifnot(require(gam))
# The `gam' package must be attached _before_ `locfit', otherwise
# the following will not work.
data(ethanol, package = "lattice")
fit <- gam(NOx ~ lf(E) + C, data=ethanol)
op <- par(mfrow=c(2, 1))
plot(fit)
par(op)
}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gam.lf}},
\code{gam}
}
\keyword{models}
locfit/man/insect.Rd 0000744 0001760 0000144 00000000766 12123143130 014111 0 ustar ripley users \name{insect}
\alias{insect}
\title{Insect Dataset}
\usage{data(insect)}
\format{
Data frame with \code{lconc} (dosage), \code{deaths}
(number of deaths) and \code{nins}
(number of insects) variables.
}
\description{
An experiment measuring death rates for insects, with 30 insects at
each of five treatment levels.
}
\source{
Bliss (1935).
}
\references{
Bliss (1935).
The calculation of the dosage-mortality curve.
\emph{Annals of Applied Biology} 22, 134-167.
}
\keyword{datasets}
locfit/man/aic.Rd 0000744 0001760 0000144 00000002126 12123143130 013350 0 ustar ripley users \name{aic}
\alias{aic}
\title{
Compute Akaike's Information Criterion.
}
\usage{
aic(x, \dots, pen=2)
}
\description{
The calling sequence for \code{aic} matches those for the
\code{\link{locfit}} or \code{\link{locfit.raw}} functions.
The fit is not returned; instead, the returned object contains
Akaike's information criterion for the fit.
The definition of AIC used here is -2*log-likelihood + pen*(fitted d.f.).
For quasi-likelihood, and local regression, this assumes the scale
parameter is one. Other scale parameters can effectively be used
by changing the penalty.
The AIC score is exact (up to numerical roundoff) if the
\code{ev="data"} argument is provided. Otherwise, the residual
sum-of-squares and degrees of freedom are computed using locfit's
standard interpolation based approximations.
}
\arguments{
\item{x}{model formula}
\item{...}{other arguments to locfit}
\item{pen}{penalty for the degrees of freedom term}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{aicplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/gam.lf.Rd 0000744 0001760 0000144 00000001110 12123143130 013750 0 ustar ripley users \name{gam.lf}
\alias{gam.lf}
\title{
Locfit call for Generalized Additive Models
}
\usage{
gam.lf(x, y, w, xeval, ...)
}
\description{
This is a locfit calling function used by
\code{\link{lf}()} terms in additive models. It is
not normally called directly by users.
}
\arguments{
\item{x}{numeric predictor}
\item{y}{numeric response}
\item{w}{prior weights}
\item{xeval}{evaluation points}
\item{...}{other arguments to \code{\link{locfit.raw}()}}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{lf}},
\code{gam}
}
\keyword{models}
locfit/man/plot.gcvplot.Rd 0000744 0001760 0000144 00000001512 12123143131 015246 0 ustar ripley users \name{plot.gcvplot}
\alias{plot.gcvplot}
\title{
Produce a cross-validation plot.
}
\usage{
\method{plot}{gcvplot}(x, xlab = "Fitted DF", ylab = x$cri, ...)
}
\description{
Plots the value of the GCV (or other statistic) in a \code{gcvplot} object
against the degrees of freedom of the fit.
}
\arguments{
\item{x}{ A \code{gcvplot} object, produced by \code{\link{gcvplot}},
\code{\link{aicplot}} etc.}
\item{xlab}{Text label for the x axis.}
\item{ylab}{Text label for the y axis.}
\item{...}{ Other arguments to \code{\link{plot}} .}
}
\examples{
data(ethanol)
plot(gcvplot(NOx~E,data=ethanol,alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcv}},
\code{\link{aicplot}},
\code{\link{cpplot}},
\code{\link{gcvplot}},
\code{\link{lcvplot}}
}
\keyword{methods}
locfit/man/aicplot.Rd 0000744 0001760 0000144 00000002432 12123143130 014247 0 ustar ripley users \name{aicplot}
\alias{aicplot}
\title{
Compute an AIC plot.
}
\description{
The \code{aicplot} function loops through calls to the \code{\link{aic}}
function (and hence to \code{\link{locfit}}), using a different
smoothing parameter for each call.
The returned structure contains the AIC statistic for each fit, and can
be used to produce an AIC plot.
}
\usage{
aicplot(..., alpha)
}
\arguments{
\item{...}{ arguments to the \code{\link{aic}}, \code{\link{locfit}}
functions.}
\item{alpha}{ Matrix of smoothing parameters. The \code{aicplot} function
loops through calls to \code{\link{aic}}, using each row of
\code{alpha} as the smoothing parameter in turn. If \code{alpha}
is provided as a vector, it will be converted to a one-column
matrix, thus interpreting each component as a nearest neighbor
smoothing parameter.}
}
\value{
An object with class \code{"gcvplot"}, containing the smoothing
parameters and AIC scores. The actual plot is produced using
\code{\link{plot.gcvplot}}.
}
\examples{
data(morths)
plot(aicplot(deaths~age,weights=n,data=morths,family="binomial",
alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcv}},
\code{\link{aic}},
\code{\link{plot.gcvplot}}
}
\keyword{htest}
locfit/man/lscv.exact.Rd 0000744 0001760 0000144 00000001635 12123143131 014673 0 ustar ripley users \name{lscv.exact}
\alias{lscv.exact}
\title{
Exact LSCV Calculation
}
\usage{
lscv.exact(x, h=0)
}
\description{
This function performs the exact computation of the least squares
cross validation statistic for one-dimensional kernel density estimation
and a constant bandwidth.
At the time of writing, it is implemented only for the Gaussian
kernel (with the standard deviation of 0.4; Locfit's standard).
}
\arguments{
\item{x}{Numeric data vector.}
\item{h}{The bandwidth. If \code{x} is constructed with
\code{\link{lp}()}, the bandwidth should be given there instead.}
}
\value{
A vector of the LSCV statistic and the fitted degrees of freedom.
}
\examples{
data(geyser, package="locfit")
lscv.exact(lp(geyser,h=0.25))
# equivalent form using lscv
lscv(lp(geyser, h=0.25), exact=TRUE)
}
\seealso{
\code{\link{lscv}},
\code{\link{lscvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/bad.Rd 0000744 0001760 0000144 00000000470 12123143130 013342 0 ustar ripley users \name{bad}
\alias{bad}
\title{Example dataset for bandwidth selection}
\usage{data(bad)}
\format{
Data Frame with x and y variables.
}
\description{
Example dataset from Loader (1999).
}
\references{
Loader, C. (1999). Bandwidth Selection: Classical or Plug-in?
Annals of Statistics 27.
}
\keyword{datasets}
locfit/man/points.locfit.Rd 0000744 0001760 0000144 00000001232 12123143131 015405 0 ustar ripley users \name{points.locfit}
\alias{points.locfit}
\title{
Add `locfit' points to existing plot
}
\usage{
\method{points}{locfit}(x, tr, ...)
}
\arguments{
\item{x}{
\code{"locfit"} object. Should be a model with one predictor.
}
\item{tr}{
Back transformation.
}
\item{...}{
Other arguments to the default \code{\link{points}} function.
}}
\description{This function shows the points at which the local fit
was computed directly, rather than being interpolated. This can
be useful if one is unsure of the validity of interpolation.}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}}, \code{\link{points}}
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/print.gcvplot.Rd 0000744 0001760 0000144 00000000755 12123143131 015434 0 ustar ripley users \name{print.gcvplot}
\alias{print.gcvplot}
\title{
Print method for gcvplot objects
}
\usage{
\method{print}{gcvplot}(x, ...)
}
\description{
Print method for \code{"gcvplot"} objects. Actually, equivalent to
\code{\link{plot.gcvplot}()}.
\code{\link{scb}} function.
}
\arguments{
\item{x}{ \code{gcvplot} object. }
\item{...}{Arguments passed to and from other methods.}
}
\seealso{
\code{\link{gcvplot}},
\code{\link{plot.gcvplot}}
\code{\link{summary.gcvplot}}
}
\keyword{methods}
locfit/man/crit.Rd 0000744 0001760 0000144 00000003662 12123143130 013563 0 ustar ripley users \name{crit}
\alias{crit}
\alias{crit<-}
\title{
Compute critical values for confidence intervals.
}
\usage{
crit(fit, const=c(0, 1), d=1, cov=0.95, rdf=0)
crit(fit) <- value
}
\arguments{
\item{fit}{\code{"locfit"} object. This is optional; if a fit is
provided, defaults for the other arguments are taken from the critical
value currently stored on this fit, rather than the usual values above.
\code{crit(fit)} with no other arguments will just return the current
critical value.}
\item{const}{Tube formula constants for simultaneous bands (the default,
\code{c(0,1)}, produces pointwise coverage). Usually this is generated
by the \code{\link{kappa0}} function and should not be provided by the
user.}
\item{d}{Dimension of the fit. Again, users shouldn't usually provide
it.}
\item{cov}{Coverage Probability for critical values.}
\item{rdf}{Residual degrees of freedom. If non-zero, the critical values
are based on the Student's t distribution. When \code{rdf=0}, the
normal distribution is used.}
\item{value}{Critical value object generated by \code{\link{crit}} or
\code{\link{kappa0}}.}
}
\description{
Every \code{"locfit"} object contains a critical value object to be used in
computing and ploting confidence intervals. By default, a 95\% pointwise
confidence level is used. To change the confidence level, the critical
value object must be substituted using \code{\link{crit}} and
\code{\link{crit<-}}.
}
\value{
Critical value object.
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}},
\code{\link{kappa0}}, \code{\link{crit<-}}.
}
\examples{
# compute and plot 99\% confidence intervals, with local variance estimate.
data(ethanol)
fit <- locfit(NOx~E,data=ethanol)
crit(fit) <- crit(fit,cov=0.99)
plot(fit,band="local")
# compute and plot 99\% simultaneous bands
crit(fit) <- kappa0(NOx~E,data=ethanol,cov=0.99)
plot(fit,band="local")
}
%\keyword{locfit}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/locfit.quasi.Rd 0000744 0001760 0000144 00000002451 12123143131 015217 0 ustar ripley users \name{locfit.quasi}
\alias{locfit.quasi}
\title{
Local Quasi-Likelihood with global reweighting.
}
\usage{
locfit.quasi(x, y, weights, ..., iter=3, var=abs)
}
\description{
\code{locfit.quasi} assumes a specified mean-variance relation,
and performs iterartive reweighted local regression under this
assumption. This is appropriate for local quasi-likelihood models,
and is an alternative to specifying a family such as \code{"qpoisson"}.
\code{locfit.quasi} is designed as a front end
to \code{\link{locfit.raw}} with data vectors, or as an intemediary
between \code{\link{locfit}} and \code{\link{locfit.raw}} with a
model formula. If you can stand the syntax, the second calling
sequence above will be slightly more efficient than the third.
}
\arguments{
\item{x}{
Either a \code{\link{locfit}} model formula or a numeric vector
of the predictor variable.
}
\item{y}{
If \code{x} is numeric, \code{y} gives the response variable.
}
\item{weights}{Case weights to use in the fitting.}
\item{...}{
Other arguments to \code{\link{locfit.raw}}
}
\item{iter}{Number of EM iterations to perform}
\item{var}{
Function specifying the assumed relation between the mean and variance.
}
}
\value{
\code{"locfit"} object.
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}}
}
\keyword{smooth}
locfit/man/cp.Rd 0000744 0001760 0000144 00000002203 12123143130 013212 0 ustar ripley users \name{cp}
\alias{cp}
\title{
Compute Mallows' Cp for local regression models.
}
\usage{
cp(x, \dots, sig2=1)
}
\description{
The calling sequence for \code{cp} matches those for the
\code{\link{locfit}} or \code{\link{locfit.raw}} functions.
The fit is not returned; instead, the returned object contains
Cp criterion for the fit.
Cp is usually computed using a variance estimate from the largest
model under consideration, rather than
\eqn{\sigma^2=1}. This will be done
automatically when the \code{\link{cpplot}} function is used.
The Cp score is exact (up to numerical roundoff) if the
\code{ev="data"} argument is provided. Otherwise, the residual
sum-of-squares and degrees of freedom are computed using locfit's
standard interpolation based approximations.
}
\arguments{
\item{x}{model formula or numeric vector of the independent variable.}
\item{...}{other arguments to \code{\link{locfit}} and/or
\code{\link{locfit.raw}}.}
\item{sig2}{residual variance estimate.}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{cpplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/cpplot.Rd 0000744 0001760 0000144 00000002670 12123143130 014121 0 ustar ripley users \name{cpplot}
\alias{cpplot}
\title{
Compute a Cp plot.
}
\usage{
cpplot(..., alpha, sig2)
}
\description{
The \code{cpplot} function loops through calls to the \code{\link{cp}}
function (and hence to \code{link{locfit}}), using a different
smoothing parameter for each call.
The returned structure contains the Cp statistic for each fit, and can
be used to produce an AIC plot.
}
\arguments{
\item{...}{ arguments to the \code{\link{cp}}, \code{\link{locfit}}
functions.}
\item{alpha}{ Matrix of smoothing parameters. The \code{cpplot} function
loops through calls to \code{\link{cp}}, using each row of
\code{alpha} as the smoothing parameter in turn. If \code{alpha}
is provided as a vector, it will be converted to a one-column
matrix, thus interpreting each component as a nearest neighbor
smoothing parameter.}
\item{sig2}{ Residual variance. If not specified, the residual variance
is computed using the fitted model with the fewest residual degrees
of freedom.}
}
\value{
An object with class \code{"gcvplot"}, containing the smoothing
parameters and CP scores. The actual plot is produced using
\code{\link{plot.gcvplot}}.
}
\examples{
data(ethanol)
plot(cpplot(NOx~E,data=ethanol,alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcv}},
\code{\link{aic}},
\code{\link{plot.gcvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/ais.Rd 0000744 0001760 0000144 00000000666 12123143130 013377 0 ustar ripley users \name{ais}
\alias{ais}
\title{Australian Institute of Sport Dataset}
\usage{data(ais)}
\format{
A dataframe.
}
\description{
The first two columns are the gender of the athlete
and their sport. The remaining 11 columns are various measurements
made on the athletes.
}
\source{
Cook and Weisberg (1994).
}
\references{
Cook and Weisberg (1994). An Introduction to Regression Graphics.
Wiley, New York.
}
\keyword{datasets}
locfit/man/locfit.Rd 0000744 0001760 0000144 00000004517 12123143131 014103 0 ustar ripley users \name{locfit}
\alias{locfit}
\title{
Local Regression, Likelihood and Density Estimation.
}
\usage{
locfit(formula, data=sys.frame(sys.parent()), weights=1, cens=0, base=0,
subset, geth=FALSE, \dots, lfproc=locfit.raw)
}
\description{
\code{locfit} is the model formula-based interface to the Locfit
library for fitting local regression and likelihood models.
\code{locfit} is implemented as a front-end to \code{\link{locfit.raw}}.
See that function for options to control smoothing parameters,
fitting family and other aspects of the fit.
}
\arguments{
\item{formula}{
Model Formula; e.g. \code{y~lp(x)} for a regression model; \code{~lp(x)} for a
density estimation model. Use of \code{lp()} on the RHS is recommended, especially
when non-default smoothing parameters are used.
}
\item{data}{
Data Frame.
}
\item{weights}{
Prior weights (or sample sizes) for individual observations. This is
typically used where observations have unequal variance.
}
\item{cens}{
Censoring indicator. \code{1} (or \code{TRUE}) denotes a censored observation.
\code{0} (or \code{FALSE}) denotes uncensored.
}
\item{base}{
Baseline for local fitting. For local regression models, specifying
a \code{base} is equivalent to using \code{y-base} as the reponse. But \code{base}
also works for local likelihood.
}
\item{subset}{
Subset observations in the data frame.
}
\item{geth}{
Don't use.
}
\item{...}{
Other arguments to \code{\link{locfit.raw}()} (or the \code{lfproc}).
}
\item{lfproc}{
A processing function to compute the local fit. Default is
\code{locfit.raw()}. Other choices include \code{locfit.robust()},
\code{locfit.censor()} and \code{locfit.quasi()}.
}}
\value{
An object with class \code{"locfit"}. A standard set of methods for printing,
ploting, etc. these objects is provided.
}
\seealso{
\code{\link{locfit.raw}}
}
\examples{
# fit and plot a univariate local regression
data(ethanol, package="locfit")
fit <- locfit(NOx ~ E, data=ethanol)
plot(fit, get.data=TRUE)
# a bivariate local regression with smaller smoothing parameter
fit <- locfit(NOx~lp(E,C,nn=0.5,scale=0), data=ethanol)
plot(fit)
# density estimation
data(geyser, package="locfit")
fit <- locfit( ~ lp(geyser, nn=0.1, h=0.8))
plot(fit,get.data=TRUE)
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/claw54.Rd 0000744 0001760 0000144 00000000777 12123143130 013725 0 ustar ripley users \name{claw54}
\alias{claw54}
\title{Claw Dataset}
\usage{data(claw54)}
\format{
Numeric vector with length 54.
}
\description{
A random sample of size 54 from the claw density of Marron and Wand
(1992), as used in Figure 10.5 of Loader (1999).
}
\source{
Randomly generated.
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
Marron, J. S. and Wand, M. P. (1992). Exact mean integrated squared error.
Annals of Statistics 20, 712-736.
}
\keyword{datasets}
locfit/man/predict.locfit.Rd 0000744 0001760 0000144 00000003241 12123143131 015525 0 ustar ripley users \name{predict.locfit}
\alias{predict.locfit}
\title{
Prediction from a Locfit object.
}
\usage{
\method{predict}{locfit}(object, newdata=NULL, where = "fitp",
se.fit=FALSE, band="none", what="coef", \dots)
}
\description{
The \code{\link{locfit}} function computes a local fit at a selected set
of points (as defined by the \code{ev} argument). The \code{predict.locfit}
function is used to interpolate from these points to any other points.
The method is based on cubic hermite polynomial interpolation, using the
estimates and local slopes at each fit point.
The motivation for this two-step procedure is computational speed.
Depending on the sample size, dimension and fitting procedure, the
local fitting method can be expensive, and it is desirable to keep the
number of points at which the direct fit is computed to a minimum.
The interpolation method used by \code{predict.locfit()} is usually
much faster, and can be computed at larger numbers of points.
}
\arguments{
\item{object}{Fitted object from \code{\link{locfit}()}.}
\item{newdata}{Points to predict at. Can be given in several forms:
vector/matrix; list, data frame.}
\item{se.fit}{If \code{TRUE}, standard errors are computed along with
the fitted values.}
\item{where, what, band}{arguments passed on to
\code{\link{preplot.locfit}}.}
\item{...}{Additional arguments to \code{\link{preplot.locfit}}.}
}
\value{
If \code{se.fit=F}, a numeric vector of predictors.
If \code{se.fit=T}, a list with components \code{fit}, \code{se.fit} and
\code{residual.scale}.
}
\examples{
data(ethanol, package="locfit")
fit <- locfit(NOx ~ E, data=ethanol)
predict(fit,c(0.6,0.8,1.0))
}
\keyword{smooth}
locfit/man/none.Rd 0000744 0001760 0000144 00000001040 12123143131 013546 0 ustar ripley users \name{none}
\alias{none}
\title{
Locfit Evaluation Structure
}
\usage{
none()
}
\description{
\code{none()} is an evaluation structure for \code{\link{locfit.raw}()},
specifying no evaluation points. Only the initial parametric fit is
computed - this is the easiest and most efficient way to coerce
Locfit into producing a parametric regression fit.
}
\examples{
data(ethanol, package="locfit")
# fit a fourth degree polynomial using locfit
fit <- locfit(NOx~E,data=ethanol,deg=4,ev=none())
plot(fit,get.data=TRUE)
}
\keyword{smooth}
locfit/man/store.Rd 0000744 0001760 0000144 00000000445 12123143131 013753 0 ustar ripley users \name{store}
\alias{store}
\title{
Save S functions.
}
\usage{
store(data=FALSE, grand=FALSE)
}
\description{
I've gotta keep track of this mess somehow!
}
\arguments{
\item{data}{whether data objects are to be saved.}
\item{grand}{whether everything is to be saved.}
}
\keyword{smooth}
locfit/man/lcv.Rd 0000744 0001760 0000144 00000001455 12123143130 013404 0 ustar ripley users \name{lcv}
\alias{lcv}
\title{Compute Likelihood Cross Validation Statistic.}
\usage{
lcv(x, \dots)
}
\description{
The calling sequence for \code{lcv} matches those for the
\code{\link{locfit}} or \code{\link{locfit.raw}} functions.
The fit is not returned; instead, the returned object contains
likelihood cross validation score for the fit.
The LCV score is exact (up to numerical roundoff) if the
\code{ev="cross"} argument is provided. Otherwise, the influence
and cross validated residuals
are computed using locfit's
standard interpolation based approximations.
}
\arguments{
\item{x}{model formula}
\item{...}{other arguments to locfit}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{lcvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/rva.Rd 0000744 0001760 0000144 00000001053 12123143131 013403 0 ustar ripley users \name{rva}
\alias{rv<-}
\title{
Substitute variance estimate on a locfit object.
}
\description{
By default, Locfit uses the normalized residual sum of squares as the
variance estimate when constructing confidence intervals.
In some cases, the user may like to use alternative variance
estimates; this function allows the default value to be changed.
}
\usage{
rv(fit) <- value
}
\arguments{
\item{fit}{\code{"locfit"} object.}
\item{value}{numeric replacement value.}
}
\seealso{
\link{locfit}(), \link{rv}(), \link{plot.locfit}()
}
\keyword{smooth}
locfit/man/spence.21.Rd 0000744 0001760 0000144 00000001735 12123143131 014320 0 ustar ripley users \name{spence.21}
\alias{spence.21}
\title{
Spencer's 21 point graduation rule.
}
\usage{
spence.21(y)
}
\description{
Spencer's 21 point rule is a weighted moving average operation
for a sequence of observations equally spaced in time. The
average at time t depends on the observations at times t-11,...,t+11.
Except for boundary effects, the function will reproduce
polynomials up to degree 3.
}
\arguments{
\item{y}{Data vector of observations at equally spaced points.}
}
\value{
A vector with the same length as the input vector, representing
the graduated (smoothed) values.
}
\examples{
data(spencer)
yy <- spence.21(spencer$mortality)
plot(spencer$age, spencer$mortality)
lines(spencer$age, yy)
}
\seealso{
\code{\link{spence.15}},
\code{\link{spencer}},
}
\references{
Spencer, J. (1904).
On the graduation of rates of sickness and mortality.
Journal of the Institute of Actuaries 38, 334-343.
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/print.summary.locfit.Rd 0000744 0001760 0000144 00000000614 12123143131 016724 0 ustar ripley users \name{print.summary.locfit}
\alias{print.summary.locfit}
\title{
Print a Locfit summary object.
}
\usage{
\method{print}{summary.locfit}(x, ...)
}
\description{
Print method for \code{"summary.locfit"} objects.
}
\arguments{
\item{x}{Object from \code{\link{summary.locfit}}.}
\item{...}{Arguments passed to and from methods.}
}
\seealso{
\code{\link{summary.locfit}()}
}
\keyword{methods}
locfit/man/smooth.lf.Rd 0000744 0001760 0000144 00000002761 12123143131 014533 0 ustar ripley users \name{smooth.lf}
\alias{smooth.lf}
\title{
Local Regression, Likelihood and Density Estimation.
}
\usage{
smooth.lf(x, y, xev=x, direct=FALSE, ...)
}
\description{
\code{smooth.lf} is a simple interface to the Locfit library.
The input consists of a predictor vector (or matrix) and response.
The output is a list with vectors of fitting points and fitted values.
Most \code{\link{locfit.raw}} options are valid.
}
\arguments{
\item{x}{
Vector (or matrix) of the independent variable(s).
}
\item{y}{
Response variable. If omitted, \code{x} is treated as the response and
the predictor variable is \code{1:n}.
}
\item{xev}{
Fitting Points. Default is the data vector \code{x}.
}
\item{direct}{
Logical variable. If \code{T}, local regression is performed directly
at each fitting point. If \code{F}, the standard Locfit method combining
fitting and interpolation is used.
}
\item{...}{
Other arguments to \code{\link{locfit.raw}()}.
}
}
\value{
A list with components \code{x} (fitting points) and \code{y} (fitted values).
Also has a \code{call} component, so \code{update()} will work.
}
\examples{
# using smooth.lf() to fit a local likelihood model.
data(morths)
fit <- smooth.lf(morths$age, morths$deaths, weights=morths$n,
family="binomial")
plot(fit,type="l")
# update with the direct fit
fit1 <- update(fit, direct=TRUE)
lines(fit1,col=2)
print(max(abs(fit$y-fit1$y)))
}
\seealso{
\code{\link{locfit}()},
\code{\link{locfit.raw}()},
\code{\link{density.lf}()}.
}
\keyword{smooth}
locfit/man/print.lfeval.Rd 0000744 0001760 0000144 00000000774 12123143131 015230 0 ustar ripley users \name{print.lfeval}
\alias{print.lfeval}
\title{
Print the Locfit Evaluation Points.
}
\usage{
\method{print}{lfeval}(x, ...)
}
\description{
Prints a matrix of the evaluation points from a \code{locfit}
or \code{lfeval} structure.
}
\arguments{
\item{x}{A \code{lfeval} or \code{locfit} object}
\item{...}{Arguments passed to and from other methods.}
}
\value{
Matrix of the fit points.
}
\seealso{
\code{\link{lfeval}},
\code{\link{locfit}},
\code{\link{plot.lfeval}}
}
\keyword{smooth}
locfit/man/spence.15.Rd 0000744 0001760 0000144 00000001732 12123143131 014320 0 ustar ripley users \name{spence.15}
\alias{spence.15}
\title{
Spencer's 15 point graduation rule.
}
\usage{
spence.15(y)
}
\description{
Spencer's 15 point rule is a weighted moving average operation
for a sequence of observations equally spaced in time. The
average at time t depends on the observations at times t-7,...,t+7.
Except for boundary effects, the function will reproduce
polynomials up to degree 3.
}
\arguments{
\item{y}{Data vector of observations at equally spaced points.}
}
\value{
A vector with the same length as the input vector, representing
the graduated (smoothed) values.
}
\examples{
data(spencer)
yy <- spence.15(spencer$mortality)
plot(spencer$age, spencer$mortality)
lines(spencer$age, yy)
}
\seealso{
\code{\link{spence.21}},
\code{\link{spencer}},
}
\references{
Spencer, J. (1904).
On the graduation of rates of sickness and mortality.
Journal of the Institute of Actuaries 38, 334-343.
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/lfmarg.Rd 0000744 0001760 0000144 00000001150 12123143131 014061 0 ustar ripley users \name{lfmarg}
\alias{lfmarg}
\title{
Generate grid margins.
}
\usage{
lfmarg(xlim, m = 40)
}
\arguments{
\item{xlim}{
Vector of limits for the grid. Should be of length 2*d;
the first d components represent the lower left corner,
and the next d components the upper right corner.
Can also be a \code{"locfit"} object.
}
\item{m}{
Number of points for each grid margin. Can be a vector of length d.
}
}
\value{
A list, whose components are the d grid margins.
}
\description{
This function is usually called by \code{\link{plot.locfit}}.
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}}
}
\keyword{smooth}
locfit/man/lines.locfit.Rd 0000744 0001760 0000144 00000001445 12123143131 015211 0 ustar ripley users \name{lines.locfit}
\alias{lines.locfit}
\alias{llines.locfit}
\title{
Add locfit line to existing plot
}
\usage{
\method{lines}{locfit}(x, m=100, tr=x$trans, \dots)
\method{llines}{locfit}(x, m=100, tr=x$trans, \dots)
}
\description{
Adds a Locfit line to an existing plot. \code{llines} is for use
within a panel function for Lattice.
}
\arguments{
\item{x}{\code{locfit} object. Should be a model with one predictor.}
\item{m}{Number of points to evaluate the line at.}
\item{tr}{Transformation function to use for plotting. Default is the
inverse link function, or the identity function if derivatives are
required.}
\item{...}{Other arguments to the default \code{\link{lines}} function.}
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}}, \code{\link{lines}}
}
\keyword{smooth}
locfit/man/plotbyfactor.Rd 0000744 0001760 0000144 00000002543 12123143131 015330 0 ustar ripley users \name{plotbyfactor}
\alias{plotbyfactor}
\title{
x-y scatterplot, colored by levels of a factor.
}
\usage{
plotbyfactor(x, y, f, data, col = 1:10, pch = "O", add = FALSE, lg,
xlab = deparse(substitute(x)), ylab = deparse(substitute(y)),
log = "", ...)
}
\description{
Produces a scatter plot of x-y data, with different classes given
by a factor f. The different classes are identified by different
colours and/or symbols.
}
\arguments{
\item{x}{
Variable for x axis.
}
\item{y}{
Variable for y axis.
}
\item{f}{
Factor (or variable for which as.factor() works).
}
\item{data}{
data frame for variables x, y, f. Default: sys.parent().
}
\item{col}{
Color numbers to use in plot. Will be replicated if shorter than the
number of levels of the factor f. Default: 1:10.
}
\item{pch}{
Vector of plot characters. Replicated if necessary.
Default: "O".
}
\item{add}{
If \code{TRUE}, add to existing plot. Otherwise, create new plot.
}
\item{lg}{
Coordinates to place a legend. Default: Missing (no legend).
}
\item{xlab, ylab}{Axes labels.}
\item{log}{Should the axes be in log scale? Use \code{"x"}, \code{"y"},
or \code{"xy"} to specify which axis to be in log scale.}
\item{...}{
Other graphical parameters, labels, titles e.t.c.
}}
\examples{
data(iris)
plotbyfactor(petal.wid, petal.len, species, data=iris)
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a3.
locfit/man/livmet.Rd 0000744 0001760 0000144 00000001057 14262745665 014151 0 ustar ripley users \name{livmet}
\alias{livmet}
\title{liver Metastases dataset}
\usage{data(livmet)}
\format{
Data frame with survival times (\code{t}), censoring indicator
(\code{z}) and a number of covariates.
}
\description{
Survival times for 622 patients diagnosed with Liver Metastases.
Beware, the censoring variable
is coded as 1 = uncensored, so use \code{cens=1-z} in
\code{\link{locfit}()} calls.
}
\source{
Haupt and Mansmann (1995)
}
\references{
Haupt, G. and Mansmann, U. (1995)
CART for Survival Data.
Statlib Archive.
}
\keyword{datasets}
locfit/man/plot.preplot.locfit.Rd 0000744 0001760 0000144 00000001506 12123143131 016537 0 ustar ripley users \name{plot.preplot.locfit}
\alias{plot.preplot.locfit}
\title{
Plot a "preplot.locfit" object.
}
\usage{
\method{plot}{preplot.locfit}(x, pv, tv, ...)
}
\arguments{
\item{x}{A \code{preplot.locfit} object, produced by
\code{\link{preplot.locfit}()}.
}
\item{pv, tv, ...}{
Other arguments to \code{plot.locfit.1d}, \code{plot.locfit.2d} or
\code{plot.locfit.3d} as appropriate.
}}
\description{
The \code{\link{plot.locfit}()} function is implemented, roughly, as
a call to \code{\link{preplot.locfit}()}, followed by a call to
\code{plot.locfitpred()}. For most users, there will be little
need to call \code{plot.locfitpred()} directly.
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}},
\code{\link{preplot.locfit}}, \code{\link{plot.locfit.1d}},
\code{\link{plot.locfit.2d}}, \code{\link{plot.locfit.3d}}.
}
\keyword{smooth}
locfit/man/geyser.Rd 0000744 0001760 0000144 00000001201 12123143130 014103 0 ustar ripley users \name{geyser}
\alias{geyser}
\title{Old Faithful Geyser Dataset}
\usage{data(geyser)}
\format{
A numeric vector of length 107.
}
\description{
The durations of 107 eruptions of the Old Faithful Geyser.
}
\source{
Scott (1992). Note that several different Old Faithful Geyser datasets
(including the faithful dataset in R's base library) have been used
in various places in the statistics literature. The version provided
here has been used in density estimation and bandwidth selection work.
}
\references{
Scott, D. W. (1992). Multivariate Density Estimation: Theory,
Practice and Visualization. Wiley.
}
\keyword{datasets}
locfit/man/mmsamp.Rd 0000744 0001760 0000144 00000000510 12123143131 014102 0 ustar ripley users \name{mmsamp}
\alias{mmsamp}
\title{Test dataset for minimax Local Regression}
\usage{data(cltest)}
\format{
Data Frame with x and y variables.
}
\description{
50 observations, as used in Figure 13.1 of Loader (1999).
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
}
\keyword{datasets}
locfit/man/gcvplot.Rd 0000744 0001760 0000144 00000002634 12123143130 014276 0 ustar ripley users \name{gcvplot}
\alias{gcvplot}
\title{
Compute a generalized cross-validation plot.
}
\usage{
gcvplot(..., alpha, df=2)
}
\description{
The \code{gcvplot} function loops through calls to the \code{\link{gcv}}
function (and hence to \code{link{locfit}}), using a different
smoothing parameter for each call.
The returned structure contains the GCV statistic for each fit, and can
be used to produce an GCV plot.
}
\arguments{
\item{...}{ arguments to the \code{\link{gcv}}, \code{\link{locfit}}
functions.}
\item{alpha}{ Matrix of smoothing parameters. The \code{gcvplot} function
loops through calls to \code{\link{gcv}}, using each row of
\code{alpha} as the smoothing parameter in turn. If \code{alpha}
is provided as a vector, it will be converted to a one-column
matrix, thus interpreting each component as a nearest neighbor
smoothing parameter.}
\item{df}{ Degrees of freedom to use as the x-axis. 2=trace(L),
3=trace(L'L).}
}
\value{
An object with class \code{"gcvplot"}, containing the smoothing
parameters and GCV scores. The actual plot is produced using
\code{\link{plot.gcvplot}}.
}
\examples{
data(ethanol)
plot(gcvplot(NOx~E,data=ethanol,alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcv}},
\code{\link{plot.gcvplot}},
\code{\link{summary.gcvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/cldem.Rd 0000744 0001760 0000144 00000000464 12123143130 013703 0 ustar ripley users \name{cldem}
\alias{cldem}
\title{Example data set for classification}
\usage{data(cldem)}
\format{
Data Frame with x and y variables.
}
\description{
Observations from Figure 8.7 of Loader (1999).
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
}
\keyword{datasets}
locfit/man/gam.slist.Rd 0000744 0001760 0000144 00000000613 12123143130 014514 0 ustar ripley users \name{gam.slist}
\alias{gam.slist}
\title{Vector of GAM special terms}
\format{
Character vector.
}
\description{
This vector adds \code{"lf"} to the default vector of special
terms recognized by a \code{gam()} model formula.
To ensure this is recognized, attach the Locfit library with
\code{library(locfit,first=T)}.
}
\seealso{
\code{\link{lf}},
\code{gam}
}
\keyword{datasets}
locfit/man/hatmatrix.Rd 0000744 0001760 0000144 00000002012 12123143130 014607 0 ustar ripley users \name{hatmatrix}
\alias{hatmatrix}
\title{
Weight diagrams and the hat matrix for a local regression model.
}
\usage{
hatmatrix(formula, dc=TRUE, \dots)
}
\arguments{
\item{formula}{model formula.}
\item{dc}{derivative adjustment (see \code{\link{locfit.raw}})}
\item{...}{Other arguments to \code{\link{locfit}} and
\code{\link{locfit.raw}}.
}}
\description{
\code{hatmatrix()} computes the weight diagrams (also known as
equivalent or effective kernels) for a local regression smooth.
Essentially, \code{hatmatrix()} is a front-end to \code{\link{locfit}()},
setting a flag to compute and return weight diagrams, rather than the
fit.
}
\value{
A matrix with n rows and p columns; each column being the
weight diagram for the corresponding \code{locfit} fit point.
If \code{ev="data"}, this is the transpose of the hat matrix.
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit.1d}}, \code{\link{plot.locfit.2d}},
\code{\link{plot.locfit.3d}}, \code{\link{lines.locfit}}, \code{\link{predict.locfit}}
}
\keyword{smooth}
locfit/man/iris.Rd 0000744 0001760 0000144 00000001302 12123143130 013555 0 ustar ripley users \name{iris}
\alias{iris}
\title{Fisher's Iris Data (subset)}
\usage{data(iris)}
\format{
Data frame with species, petal.wid, petal.len, sepal.wid, sepal.len.
}
\description{
Four measurements on each of fifty flowers of two species of iris
(Versicolor and Virginica) -- A classification dataset. Fisher's
original dataset contained a third species (Setosa) which is trivially
seperable.
}
\source{
Fisher (1936). Reproduced in Andrews and Herzberg (1985) Chapter 1.
}
\references{
Andrews, D. F. and Herzberg, A. M. (1985). Data. Springer-Verlag.
Fisher, R. A. (1936). The Use of Multiple Measurements in Taxonomic
Problems. Annals of Eugenics 7, Part II. 179-188.
}
\keyword{datasets}
locfit/man/locfit.censor.Rd 0000744 0001760 0000144 00000004560 12123143131 015371 0 ustar ripley users \name{locfit.censor}
\alias{locfit.censor}
\title{
Censored Local Regression
}
\usage{
locfit.censor(x, y, cens, ..., iter=3, km=FALSE)
}
\description{
\code{locfit.censor} produces local regression estimates for censored
data. The basic idea is to use an EM style algorithm, where one
alternates between estimating the regression and the true values
of censored observations.
\code{locfit.censor} is designed as a front end
to \code{\link{locfit.raw}} with data vectors, or as an intemediary
between \code{\link{locfit}} and \code{\link{locfit.raw}} with a
model formula. If you can stand the syntax, the second calling
sequence above will be slightly more efficient than the third.
}
\arguments{
\item{x}{
Either a \code{\link{locfit}} model formula or a numeric vector
of the predictor variable.
}
\item{y}{
If \code{x} is numeric, \code{y} gives the response variable.
}
\item{cens}{
Logical variable indicating censoring. The coding is \code{1}
or \code{TRUE} for censored; \code{0} or \code{FALSE} for uncensored.
}
\item{...}{
Other arguments to \code{\link{locfit.raw}}
}
\item{iter}{Number of EM iterations to perform}
\item{km}{
If \code{km=TRUE}, the estimation of censored observations uses
the Kaplan-Meier estimate, leading to a local version of the
Buckley-James estimate. If \code{km=F}, the estimation is based
on a normal model (Schmee and Hahn). Beware of claims that B-J
is nonparametric; it makes stronger assumptions on the upper tail
of survival distributions than most authors care to admit.
}
}
\value{
\code{locfit} object.
}
\seealso{
\code{\link{km.mrl}},
\code{\link{locfit}},
\code{\link{locfit.raw}}
}
\examples{
data(heart, package="locfit")
fit <- locfit.censor(log10(surv+0.5) ~ age, cens=cens, data=heart)
## Can also be written as:
\dontrun{fit <- locfit(log10(surv + 0.5) ~ age, cens=cens, data=heart, lfproc=locfit.censor)}
with(heart, plotbyfactor(age, 0.5 + surv, cens, ylim=c(0.5, 16000), log="y"))
lines(fit, tr=function(x) 10^x)
}
\references{
Buckley, J. and James, I. (1979). Linear Regression with censored data.
Biometrika 66, 429-436.
Loader, C. (1999). Local Regression and Likelihood. Springer, NY (Section 7.2).
Schmee, J. and Hahn, G. J. (1979). A simple method for linear regression
analysis with censored data (with discussion). Technometrics 21, 417-434.
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/dat.Rd 0000744 0001760 0000144 00000000625 12123143130 013366 0 ustar ripley users \name{dat}
\alias{dat}
\title{
Locfit - data evaluation structure.
}
\usage{
dat(cv=FALSE)
}
\description{
\code{dat} is used to specify evaluation on the given data points
for \code{\link{locfit.raw}()}.
}
\arguments{
\item{cv}{Whether cross-validation should be done.}
}
%\examples{
%data(ethanol, package="locfit")
%plot.eval(locfit(NOx~E+C, data=ethanol, scale=0, ev=dat()))
%}
\keyword{smooth}
locfit/man/plot.scb.Rd 0000744 0001760 0000144 00000001345 12123143131 014343 0 ustar ripley users \name{plot.scb}
\alias{plot.scb}
\alias{plot.scb.1d}
\alias{plot.scb.2d}
\title{
Plot method for simultaneous confidence bands
}
\usage{
\method{plot}{scb}(x, add=FALSE, ...)
}
\description{
Plot method for simultaneous confidence bands created by the
\code{\link{scb}} function.
}
\arguments{
\item{x}{ \code{scb} object created by \code{\link{scb}}. }
\item{add}{If \code{TRUE}, bands will be added to the existing plot.}
\item{...}{Arguments passed to and from other methods.}
}
\examples{
# corrected confidence bands for a linear logistic model
data(insect)
fit <- scb(deaths ~ lconc, type=4, w=nins, data=insect,
deg=1, family="binomial", kern="parm")
plot(fit)
}
\seealso{
\code{\link{scb}}
}
\keyword{methods}
locfit/man/summary.preplot.locfit.Rd 0000744 0001760 0000144 00000000673 12123143131 017262 0 ustar ripley users \name{summary.preplot.locfit}
\alias{summary.preplot.locfit}
\title{
Summary method for a preplot.locfit object.
}
\usage{
\method{summary}{preplot.locfit}(object, ...)
}
\description{
Prints a short summary of a \code{"preplot.locfit"} object.
}
\arguments{
\item{object}{
\code{preplot.locfit} object.
}
\item{...}{arguments passed to and from methods.}
}
\value{
The fitted values from a
\code{preplot.locfit} object.
}
\keyword{methods}
locfit/man/lfeval.Rd 0000744 0001760 0000144 00000000746 12123143131 014074 0 ustar ripley users \name{lfeval}
\alias{lfeval}
\title{
Extract Locfit Evaluation Structure.
}
\usage{
lfeval(object)
}
\description{
Extracts the evaluation structure from a \code{"locfit"} object.
This object has the class \code{"lfeval"}, and has its own set of
methods for plotting e.t.c.
}
\arguments{
\item{object}{\code{"locfit"} object}
}
\value{
\code{"lfeval"} object.
}
\seealso{
\code{\link{locfit}},
\code{\link{plot.lfeval}},
\code{\link{print.lfeval}}
}
\keyword{smooth}
locfit/man/lp.Rd 0000744 0001760 0000144 00000003435 12123143131 013234 0 ustar ripley users \name{lp}
\alias{lp}
\title{
Local Polynomial Model Term
}
\usage{
lp(..., nn, h, adpen, deg, acri, scale, style)
}
\description{
\code{lp} is a local polynomial model term for Locfit models.
Usually, it will be the only term on the RHS of the model formula.
Smoothing parameters should be provided as arguments to \code{lp()},
rather than to \code{\link{locfit}()}.
}
\arguments{
\item{...}{Predictor variables for the local regression model.
}
\item{nn}{
Nearest neighbor component of the smoothing parameter.
Default value is 0.7, unless either \code{h} or \code{adpen} are
provided, in which case the default is 0.
}
\item{h}{
The constant component of the smoothing parameter. Default: 0.
}
\item{adpen}{Penalty parameter for adaptive fitting.}
\item{deg}{Degree of polynomial to use.}
\item{acri}{Criterion for adaptive bandwidth selection.}
\item{style}{Style for special terms (\code{\link{left}},
\code{\link{ang}} e.t.c.). Do not try to set this directly;
call \code{\link{locfit}} instead. }
\item{scale}{
A scale to apply to each variable. This is especially important for
multivariate fitting, where variables may be measured in
non-comparable units. It is also used to specify the frequency
for \code{\link{ang}} terms. If \code{scale=F} (the default) no scaling
is performed. If \code{scale=T}, marginal standard deviations are used.
Alternatively, a numeric vector can provide scales for the
individual variables.
}
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}}
}
\examples{
data(ethanol, package="locfit")
# fit with 50% nearest neighbor bandwidth.
fit <- locfit(NOx~lp(E,nn=0.5),data=ethanol)
# bivariate fit.
fit <- locfit(NOx~lp(E,C,scale=TRUE),data=ethanol)
# density estimation
data(geyser, package="locfit")
fit <- locfit.raw(lp(geyser,nn=0.1,h=0.8))
}
\keyword{models}
locfit/man/scb.Rd 0000744 0001760 0000144 00000004243 12123143131 013366 0 ustar ripley users \name{scb}
\alias{scb}
\title{
Simultaneous Confidence Bands
}
\usage{
scb(x, ..., ev = lfgrid(20), simul = TRUE, type = 1)
}
\description{
\code{scb} is implemented as a front-end to \code{\link{locfit}},
to compute simultaneous confidence bands using the tube formula
method and extensions, based on Sun and Loader (1994).
}
\arguments{
\item{x}{A numeric vector or matrix of predictors (as in
\code{\link{locfit.raw}}), or a model formula (as in
\code{\link{locfit}}).}
\item{...}{Additional arguments to \code{\link{locfit.raw}}.}
\item{ev}{The evaluation structure to use. See \code{\link{locfit.raw}}.}
%\item{mg}{
% The \code{scb()} function evaluates the confidence bands on a grid
% of points, rather than the default structures used by \code{\link{locfit}}.
% \code{mg} controls the number of grid points. Default 10.
%}
%\item{flim}{As in \code{\link{locfit.raw}}, this defaults to the
% interval (or bounding box, in more than one dimension) covering
% the data. The confidence bands are simultaneous over this interval.}
\item{simul}{Should the coverage be simultaneous or pointwise?}
\item{type}{Type of confidence bands. \code{type=0} computes pointwise
95\% bands. \code{type=1} computes basic simultaneous bands with no
corrections. \code{type=2,3,4} are the centered and corrected bands
for parametric regression models listed in Table 3 of Sun, Loader and
McCormick (2000).}
}
\value{
A list containing the evaluation points, fit, standard deviations and upper
and lower confidence bounds. The class is \code{"scb"}; methods for
printing and ploting are provided.
}
\seealso{
\code{\link{locfit}}, \code{\link{print.scb}}, \code{\link{plot.scb}}.
}
\examples{
# corrected confidence bands for a linear logistic model
data(insect)
fit <- scb(deaths~lp(lconc,deg=1), type=4, w=nins,
data=insect,family="binomial",kern="parm")
plot(fit)
}
\references{
Sun J. and Loader, C. (1994).
Simultaneous confidence bands in linear regression and smoothing.
\emph{The Annals of Statistics} 22, 1328-1345.
Sun, J., Loader, C. and McCormick, W. (2000).
Confidence bands in generalized linear models.
\emph{The Annals of Statistics} 28, 429-460.
}
\keyword{smooth}
locfit/man/lcvplot.Rd 0000744 0001760 0000144 00000002515 12123143130 014301 0 ustar ripley users \name{lcvplot}
\alias{lcvplot}
\title{
Compute the likelihood cross-validation plot.
}
\usage{
lcvplot(..., alpha)
}
\description{
The \code{lcvplot} function loops through calls to the \code{\link{lcv}}
function (and hence to \code{link{locfit}}), using a different
smoothing parameter for each call.
The returned structure contains the likelihood cross validation statistic
for each fit, and can be used to produce an LCV plot.
}
\arguments{
\item{...}{ arguments to the \code{\link{lcv}}, \code{\link{locfit}}
functions.}
\item{alpha}{ Matrix of smoothing parameters. The \code{aicplot} function
loops through calls to \code{\link{lcv}}, using each row of
\code{alpha} as the smoothing parameter in turn. If \code{alpha}
is provided as a vector, it will be converted to a one-column
matrix, thus interpreting each component as a nearest neighbor
smoothing parameter.}
}
\value{
An object with class \code{"gcvplot"}, containing the smoothing
parameters and LCV scores. The actual plot is produced using
\code{\link{plot.gcvplot}}.
}
\examples{
data(ethanol)
plot(lcvplot(NOx~E,data=ethanol,alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcv}},
\code{\link{lcv}},
\code{\link{plot.gcvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/summary.gcvplot.Rd 0000744 0001760 0000144 00000001544 12123143131 015772 0 ustar ripley users \name{summary.gcvplot}
\alias{summary.gcvplot}
\title{
Summary method for a gcvplot structure.
}
\usage{
\method{summary}{gcvplot}(object, ...)
}
\description{
Computes a short summary for a generalized cross-validation plot structure
}
\arguments{
\item{object}{A \code{gcvplot} structure produced by a call to
\code{\link{gcvplot}}, \code{\link{cpplot}} e.t.c.}
\item{...}{arugments to and from other methods.}
}
\value{
A matrix with two columns; one row for each fit computed in the
\code{\link{gcvplot}} call.
The first column is the fitted degrees
of freedom; the second is the GCV or other criterion computed.
}
\examples{
data(ethanol)
summary(gcvplot(NOx~E,data=ethanol,alpha=seq(0.2,1.0,by=0.05)))
}
\seealso{
\code{\link{locfit}},
\code{\link{gcv}},
\code{\link{gcvplot}}
}
\keyword{methods}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/locfit.robust.Rd 0000744 0001760 0000144 00000002627 12123143131 015420 0 ustar ripley users \name{locfit.robust}
\alias{locfit.robust}
\title{
Robust Local Regression
}
\usage{
locfit.robust(x, y, weights, ..., iter=3)
}
\description{
\code{locfit.robust} implements a robust local regression where
outliers are iteratively identified and downweighted, similarly
to the lowess method (Cleveland, 1979). The iterations and scale
estimation are performed on a global basis.
The scale estimate is 6 times the median absolute residual, while
the robust downweighting uses the bisquare function. These are
performed in the S code so easily changed.
This can be interpreted as an extension of M estimation to local
regression. An alternative extension (implemented in locfit via
\code{family="qrgauss"}) performs the iteration and scale estimation
on a local basis.
}
\arguments{
\item{x}{
Either a \code{\link{locfit}} model formula or a numeric vector
of the predictor variable.
}
\item{y}{
If \code{x} is numeric, \code{y} gives the response variable.
}
\item{weights}{weights to use in the fitting.}
\item{...}{Other arguments to \code{\link{locfit.raw}}.}
\item{iter}{Number of iterations to perform}
}
\value{
\code{"locfit"} object.
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}}
}
\references{
Cleveland, W. S. (1979).
Robust locally weighted regression and smoothing scatterplots.
J. Amer. Statist. Assn. 74, 829-836.
}
\keyword{smooth}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/summary.locfit.Rd 0000744 0001760 0000144 00000000723 12123143131 015572 0 ustar ripley users \name{summary.locfit}
\alias{summary.locfit}
\title{
Print method for a locfit object.
}
\usage{
\method{summary}{locfit}(object, \dots)
}
\description{
Prints a short summary of a \code{"locfit"} object.
}
\arguments{
\item{object}{\code{locfit} object.}
\item{\dots}{arguments passed to and from methods.}
}
\value{
A \code{summary.locfit} object, containg a short summary of the
\code{locfit} object.
}
\keyword{methods}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/plot.eval.Rd 0000744 0001760 0000144 00000001367 12123143131 014527 0 ustar ripley users \name{plot.eval}
\alias{plot.eval}
\title{
Plot evaluation points from a 2-d locfit object.
}
\usage{
plot.eval(x, add=FALSE, text=FALSE, ...)
}
\description{
This function is used to plot the evaluation structure generated by
Locfit for a two dimensional fit. Vertices of the tree structure are
displayed as \code{O}; pseudo-vertices as \code{*}.
}
\arguments{
\item{x}{\code{"locfit"} object. }
\item{add}{If \code{TRUE}, add to existing plot.}
\item{text}{If \code{TRUE}, numbers will be added indicating the order points
were added.}
\item{...}{Arguments passed to and from other methods.}
}
\examples{
data(ethanol, package="locfit")
fit <- locfit(NOx ~ E + C, data=ethanol, scale=0)
plot.eval(fit)
}
\seealso{
\code{\link{locfit}}.
}
\keyword{smooth}
locfit/man/geyser.round.Rd 0000744 0001760 0000144 00000001417 12123143130 015242 0 ustar ripley users \name{geyser.round}
\alias{geyser.round}
\title{Discrete Old Faithful Geyser Dataset}
\usage{data(geyser.round)}
\format{
Data Frame with variables \code{duration} and \code{count}.
}
\description{
This is a variant of the \code{\link{geyser}} dataset, where
each observation is rounded to the nearest 0.05 minutes, and the
counts tallied.
}
\source{
Scott (1992). Note that several different Old Faithful Geyser datasets
(including the faithful dataset in R's base library) have been used
in various places in the statistics literature. The version provided
here has been used in density estimation and bandwidth selection work.
}
\references{
Scott, D. W. (1992). Multivariate Density Estimation: Theory,
Practice and Visualization. Wiley.
}
\keyword{datasets}
locfit/man/print.preplot.locfit.Rd 0000744 0001760 0000144 00000000720 12123143131 016712 0 ustar ripley users \name{print.preplot.locfit}
\alias{print.preplot.locfit}
\title{
Print method for preplot.locfit objects.
}
\usage{
\method{print}{preplot.locfit}(x, ...)
}
\description{
Print method for objects created by the
\code{\link{preplot.locfit}} function.
}
\arguments{
\item{x}{ \code{"preplot.locfit"} object. }
\item{...}{Arguments passed to and from other methods.}
}
\seealso{
\code{\link{preplot.locfit}},
\code{\link{predict.locfit}}
}
\keyword{methods}
locfit/man/plot.lfeval.Rd 0000744 0001760 0000144 00000001400 12123143131 015035 0 ustar ripley users \name{plot.lfeval}
\alias{plot.lfeval}
\title{
Plot a Locfit Evaluation Structure.
}
\usage{
\method{plot}{lfeval}(x, add=FALSE, txt=FALSE, ...)
}
\description{
Plots the evaluation points from a \code{locfit} or \code{lfeval}
structure, for one- or two-dimensional fits.
}
\arguments{
\item{x}{A \code{lfeval} or \code{locfit} object}
\item{add}{If \code{TRUE}, the points will be added to the existing plot.
Otherwise, a new plot is created.}
\item{txt}{If \code{TRUE}, the points are annotated with numbers in the
order they were entered into the fit.}
\item{...}{Additional graphical parameters.}
}
\value{
\code{"lfeval"} object.
}
\seealso{
\code{\link{lfeval}},
\code{\link{locfit}},
\code{\link{print.lfeval}}
}
\keyword{smooth}
locfit/man/locfit.matrix.Rd 0000744 0001760 0000144 00000001704 12123143131 015401 0 ustar ripley users \name{locfit.matrix}
\alias{locfit.matrix}
\title{
Reconstruct a Locfit model matrix.
}
\usage{
locfit.matrix(fit, data)
}
\description{
Reconstructs the model matrix, and associated variables such as
the response, prior weights and censoring indicators, from a
\code{locfit} object. This is used by functions such as
\code{\link{fitted.locfit}}; it is not normally called directly.
The function will only work properly if the data frame has not been
changed since the fit was constructed.
}
\arguments{
\item{fit}{Locfit object}
\item{data}{ Data Frame.}
}
%\item{...}{
%Other arguments to \code{\link{locfit.raw}()} (or the \code{lfproc}).
%}
\value{
A list with variables \code{x} (the model matrix); \code{y} (the response);
\code{w} (prior weights); \code{sc} (scales); \code{ce} (censoring indicator)
and \code{base} (baseline fit).
}
\seealso{
\code{\link{locfit}}, \code{\link{fitted.locfit}}, \code{\link{residuals.locfit}}
}
\keyword{models}
locfit/man/panel.xyplot.lf.Rd 0000744 0001760 0000144 00000000467 12123143131 015660 0 ustar ripley users \name{panel.xyplot.lf}
\alias{panel.xyplot.lf}
\title{
Locfit panel function
}
\usage{
panel.xyplot.lf(x, y, subscripts, clo, cup, wh, type="l", ...)
}
\description{
Panel function used by \code{\link{plot.locfit.3d}} for one dimensional
plots.
}
\seealso{
\code{\link{plot.locfit.3d}}
}
\keyword{internal}
locfit/man/spencer.Rd 0000744 0001760 0000144 00000000643 12123143131 014256 0 ustar ripley users \name{spencer}
\alias{spencer}
\title{Spencer's Mortality Dataset}
\usage{data(spencer)}
\alias{spencer}
\format{
Data frame with age and mortality variables.
}
\description{
Observed mortality rates for ages 20 to 45.
}
\source{
Spencer (1904).
}
\references{
Spencer, J. (1904).
On the graduation of rates of sickness and mortality.
Journal of the Institute of Actuaries 38, 334-343.
}
\keyword{datasets}
locfit/man/mcyc.Rd 0000744 0001760 0000144 00000000716 12123143131 013553 0 ustar ripley users \name{mcyc}
\alias{mcyc}
\title{Acc(De?)celeration of a Motorcycle Hitting a Wall}
\usage{data(mcyc)}
\format{
Data frame with time and accel variables.
}
\description{
Measurements of the acceleration of a motorcycle as it hits a wall.
Actually, rumored to be a concatenation of several such datasets.
}
\source{
H\"ardle (1990).
}
\references{
H\"ardle, W. (1990). Applied Nonparametric Regression.
Cambridge University Press.
}
\keyword{datasets}
locfit/man/regband.Rd 0000744 0001760 0000144 00000001513 12123143131 014216 0 ustar ripley users \name{regband}
\alias{regband}
\title{
Bandwidth selectors for local regression.
}
\usage{
regband(formula, what = c("CP", "GCV", "GKK", "RSW"), deg=1, ...)
}
\description{
Function to compute local regression bandwidths for local linear regression,
implemented as a front end to \code{\link{locfit}()}.
This function is included for comparative purposes only. Plug-in
selectors are based on flawed logic, make unreasonable and restrictive
assumptions
and do not use the full power of the estimates available in Locfit.
Any relation between the results produced by this function and
desirable estimates are entirely coincidental.
}
\arguments{
\item{formula}{Model Formula (one predictor).}
\item{what}{Methods to use.}
\item{deg}{Degree of fit.}
\item{...}{Other Locfit options.}
}
\value{
Vector of selected bandwidths.
}
\keyword{htest}
locfit/man/co2.Rd 0000744 0001760 0000144 00000001013 12123143130 013271 0 ustar ripley users \name{co2}
\alias{co2}
\title{Carbon Dioxide Dataset}
\usage{data(co2)}
\format{
Data frame with \code{year}, \code{month} and \code{co2} variables.
}
\description{
Monthly time series of carbon dioxide measurements at Mauna Loa,
Hawaii from 1959 to 1990.
}
\source{
Boden, Sepanski and Stoss (1992).
}
\references{
Boden, Sepanski and Stoss (1992).
Trends '91: A compedium of data on global change - Highlights.
Carbon Dioxide Information Analysis Center, Oak Ridge National Laboratory.
}
\keyword{datasets}
locfit/man/lfgrid.Rd 0000744 0001760 0000144 00000001630 12123143131 014063 0 ustar ripley users \name{lfgrid}
\alias{lfgrid}
\title{
Locfit - grid evaluation structure.
}
\usage{
lfgrid(mg=10, ll, ur)
}
\description{
\code{lfgrid()} is used to specify evaluation on a grid of points
for \code{\link{locfit.raw}()}. The structure computes
a bounding box for the data, and divides that into a grid with
specified margins.
}
\arguments{
\item{mg}{
Number of grid points along each margin. Can be a single number (which
is applied in each dimension), or a vector specifying a value for
each dimension.
}
\item{ll}{
Lower left limits for the grid. Length should be the number
of dimensions of the data provided to \code{\link{locfit.raw}()}.
}
\item{ur}{
Upper right limits for the grid. By default, \code{ll} and
\code{ur} are generated as the bounding box for the data.
}
}
\examples{
data(ethanol, package="locfit")
plot.eval(locfit(NOx ~ lp(E, C, scale=TRUE), data=ethanol, ev=lfgrid()))
}
\keyword{smooth}
locfit/man/xbar.Rd 0000744 0001760 0000144 00000000427 12123143131 013553 0 ustar ripley users \name{xbar}
\alias{xbar}
\title{
Locfit Evaluation Structure
}
\usage{
xbar()
}
\description{
\code{xbar()} is an evaluation structure for \code{\link{locfit.raw}()},
evaluating the fit at a single point, namely, the average of each predictor
variable.
}
\keyword{smooth}
locfit/man/rbox.Rd 0000744 0001760 0000144 00000002662 12123143131 013574 0 ustar ripley users \name{rbox}
\alias{rbox}
\title{
Local Regression, Likelihood and Density Estimation.
}
\usage{
rbox(cut=0.8, type="tree", ll, ur)
}
\description{
\code{rbox()} is used to specify a rectangular box evaluation
structure for \code{\link{locfit.raw}()}. The structure begins
by generating a bounding box for the data, then recursively divides
the box to a desired precision.
}
\arguments{
\item{type}{
If \code{type="tree"}, the cells are recursively divided according to
the bandwidths at each corner of the cell; see Chapter 11 of Loader (1999).
If \code{type="kdtree"}, the K-D tree structure used in Loess
(Cleveland and Grosse, 1991) is used.
}
\item{cut}{
Precision of the tree; a smaller value of \code{cut} results in a
larger tree with more nodes being generated.
}
\item{ll}{
Lower left corner of the initial cell. Length should be the number
of dimensions of the data provided to \code{\link{locfit.raw}()}.
}
\item{ur}{
Upper right corner of the initial cell. By default, \code{ll} and
\code{ur} are generated as the bounding box for the data.
}
}
\examples{
data(ethanol, package="locfit")
plot.eval(locfit(NOx~E+C,data=ethanol,scale=0,ev=rbox(cut=0.8)))
plot.eval(locfit(NOx~E+C,data=ethanol,scale=0,ev=rbox(cut=0.3)))
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
Cleveland, W. and Grosse, E. (1991). Computational Methods for Local
Regression. Statistics and Computing 1.
}
\keyword{smooth}
locfit/man/morths.Rd 0000744 0001760 0000144 00000000636 12123143131 014135 0 ustar ripley users \name{morths}
\alias{morths}
\title{Henderson and Sheppard Mortality Dataset}
\usage{data(morths)}
\format{
Data frame with age, n and number of deaths.
}
\description{
Observed mortality for 55 to 99.
}
\source{
Henderson and Sheppard (1919).
}
\references{
Henderson, R. and Sheppard, H. N. (1919). Graduation of mortality and
other tables. Actuarial Society of America, New York.
}
\keyword{datasets}
locfit/man/plot.locfit.Rd 0000744 0001760 0000144 00000006110 12123143131 015047 0 ustar ripley users \name{plot.locfit}
\alias{plot.locfit}
\title{
Plot an object of class locfit.
}
\usage{
\method{plot}{locfit}(x, xlim, pv, tv, m, mtv=6, band="none", tr=NULL,
what = "coef", get.data=FALSE, f3d=(d == 2) && (length(tv) > 0), ...)
}
\arguments{
\item{x}{
locfit object.
}
\item{xlim}{
Plotting limits. Eg. \code{xlim=c(0,0,1,1)} plots over the unit square in
two dimensions. Default is bounding box of the data.
}
\item{pv}{
Panel variables, to be varied within each panel of a plot. May be
specified as a character vector, or variable numbers. There must be
one or two panel variables; default is all variables in one or two
dimensions; Variable 1 in three or more dimensions.
May by specified using either variable numbers or names.
}
\item{tv}{
Trellis variables, to be varied from panel to panel of the plot.
}
\item{m}{
Controls the plot resolution (within panels, for trellis displays).
Default is 100 points in one dimension; 40 points (per dimension)
in two or more dimensions.
}
\item{mtv}{
Number of points for trellis variables; default 6.
}
\item{band}{
Type of confidence bands to add to the plot. Default is \code{"none"}. Other
choices include \code{"global"} for bands using a global variance estimate;
\code{"local"} for bands using a local variance estimate and \code{"pred"}
for prediction bands (at present, using a global variance estimate).
To obtain the global variance estimate for a fit, use \code{\link{rv}}.
This can be changed with \code{\link{rv<-}}. Confidence bands, by default,
are 95\%, based on normal approximations and neglecting bias.
To change the critical value or confidence level, or to obtain
simultaneous instead of pointwise confidence,
the critical value stored on the fit must be changed. See the
\code{\link{kappa0}} and \code{\link{crit}} functions.
}
\item{tr}{
Transformation function to use for plotting. Default is the inverse
link function, or the identity function if derivatives are requested.
}
\item{what}{
What to plot. See \code{\link{predict.locfit}}.
}
\item{get.data}{
If \code{TRUE}, original data is added to the plot. Default: \code{FALSE}.
}
\item{f3d}{
Force the \code{locfit.3d} class on the prediction object, thereby generating
a trellis style plot. Default: \code{FALSE}, unless a \code{tv} argument is'
provided. Not available in R.
}
\item{...}{
Other arguments to \code{plot.locfit.1d}, \code{plot.locfit.2d} or
\code{plot.locfit.3d} as appropriate.
}}
\description{
The \code{plot.locfit} function generates grids of ploting points, followed
by a call to \code{\link{preplot.locfit}}. The returned object is then
passed to \code{\link{plot.locfit.1d}}, \code{\link{plot.locfit.2d}} or
\code{\link{plot.locfit.3d}} as appropriate.
}
\examples{
x <- rnorm(100)
y <- dnorm(x) + rnorm(100) / 5
plot(locfit(y~x), band="global")
x <- cbind(rnorm(100), rnorm(100))
plot(locfit(~x), type="persp")
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit.1d}},
\code{\link{plot.locfit.2d}}, \code{\link{plot.locfit.3d}},
\code{\link{lines.locfit}}, \code{\link{predict.locfit}},
\code{\link{preplot.locfit}}
}
\keyword{methods}
locfit/man/ang.Rd 0000744 0001760 0000144 00000002237 12123143130 013364 0 ustar ripley users \name{ang}
\alias{ang}
\title{
Angular Term for a Locfit model.
}
\usage{
ang(x,...)
}
\description{
The \code{ang()} function is used in a locfit model formula
to specify that a variable should be treated as an angular
or periodic term. The \code{scale} argument is used to
set the period.
\code{ang(x)} is equivalent to \code{lp(x,style="ang")}.
}
\arguments{
\item{x}{numeric variable to be treated periodically.}
\item{...}{Other arguments to \code{\link{lp}}.}
% \item{scale}{Use to specify
% the period divided by \eqn{2\pi} of the term. The default is
% \code{scale=1}, giving a period of \eqn{2\pi}.}
}
\examples{
# generate an x variable, and a response with period 0.2
x <- seq(0,1,length=200)
y <- sin(10*pi*x)+rnorm(200)/5
# compute the periodic local fit. Note the scale argument is period/(2pi)
fit <- locfit(y~ang(x,scale=0.2/(2*pi)))
# plot the fit over a single period
plot(fit)
# plot the fit over the full range of the data
plot(fit,xlim=c(0,1))
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, NY (Section 6.2).
}
\seealso{
\code{\link{locfit}}.
}
\keyword{models}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/chemdiab.Rd 0000744 0001760 0000144 00000001047 12123143130 014351 0 ustar ripley users \name{chemdiab}
\alias{chemdiab}
\title{Chemical Diabetes Dataset}
\usage{data(chemdiab)}
\format{
Data frame with five numeric measurements and categroical response.
}
\description{
Numeric variables are \code{rw}, \code{fpg},
\code{ga}, \code{ina} and \code{sspg}. Classifier \code{cc} is the Diabetic
type.
}
\source{
Reaven and Miller (1979).
}
\references{
Reaven, G. M. and Miller, R. G. (1979).
An attempt to define the nature of chemical diabetes using a multidimensional
analysis. Diabetologia 16, 17-24.
}
\keyword{datasets}
locfit/man/penny.Rd 0000744 0001760 0000144 00000000515 12123143131 013746 0 ustar ripley users \name{penny}
\alias{penny}
\title{Penny Thickness Dataset}
\usage{data(penny)}
\format{
A dataframe.
}
\description{
For each year, 1945 to 1989, the thickness of two U.S. pennies
was recorded.
}
\source{
Scott (1992).
}
\references{
Scott (1992). Multivariate Density Estimation.
Wiley, New York.
}
\keyword{datasets}
locfit/man/gcv.Rd 0000744 0001760 0000144 00000002036 12123143130 013373 0 ustar ripley users \name{gcv}
\alias{gcv}
\title{
Compute generalized cross-validation statistic.
}
\usage{
gcv(x, \dots)
}
\arguments{
\item{x, \dots}{Arguments passed on to \code{\link{locfit}} or
\code{\link{locfit.raw}}.}
}
\description{
The calling sequence for \code{gcv} matches those for the
\code{\link{locfit}} or \code{\link{locfit.raw}} functions.
The fit is not returned; instead, the returned object contains
Wahba's generalized cross-validation score for the fit.
The GCV score is exact (up to numerical roundoff) if the
\code{ev="data"} argument is provided. Otherwise, the residual
sum-of-squares and degrees of freedom are computed using locfit's
standard interpolation based approximations.
For likelihood models, GCV is computed uses the deviance
in place of the residual sum of squares. This produces useful
results but I do not know of any theory validating
this extension.
}
\seealso{
\code{\link{locfit}},
\code{\link{locfit.raw}},
\code{\link{gcvplot}}
}
\keyword{htest}
% Converted by Sd2Rd version 0.2-a5.
locfit/man/plot.locfit.1d.Rd 0000744 0001760 0000144 00000001604 12123143131 015355 0 ustar ripley users \name{plot.locfit.1d}
\alias{plot.locfit.1d}
\title{
Plot a one dimensional preplot.locfit object.
}
\usage{
\method{plot}{locfit.1d}(x, add=FALSE, main="", xlab="default", ylab=x$yname,
type="l", ylim, lty=1, col=1, \dots)
}
\arguments{
\item{x}{One dimensional \code{preplot.locfit} object.}
\item{add}{If \code{TRUE}, the plot will be added to the existing
plot.}
\item{main, xlab, ylab, type, ylim, lty, col}{Graphical parameters
passed on to \code{\link{plot}} (only if \code{add=FALSE}).}
\item{...}{Additional graphical parameters to the \code{plot} function
(only if \code{add=FALSE}).}
}
\description{
This function is not usually called directly. It will be called automatically
when plotting a one-dimensional \code{locfit} or \code{preplot.locfit}
object.
}
\seealso{
\code{\link{locfit}}, \code{\link{plot.locfit}}, \code{\link{preplot.locfit}}
}
\keyword{methods}
locfit/man/kdeb.Rd 0000744 0001760 0000144 00000002353 12123143130 013523 0 ustar ripley users \name{kdeb}
\alias{kdeb}
\title{
Bandwidth selectors for kernel density estimation.
}
\usage{
kdeb(x, h0 = 0.01 * sd, h1 = sd, meth = c("AIC", "LCV", "LSCV", "BCV",
"SJPI", "GKK"), kern = "gauss", gf = 2.5)
}
\description{
Function to compute kernel density estimate bandwidths, as used in the
simulation results in Chapter 10 of Loader (1999).
This function is included for comparative purposes only. Plug-in
selectors are based on flawed logic, make unreasonable and restrictive
assumptions
and do not use the full power of the estimates available in Locfit.
Any relation between the results produced by this function and
desirable estimates are entirely coincidental.
}
\arguments{
\item{x}{One dimensional data vector.}
\item{h0}{Lower limit for bandwidth selection. Can be fairly small,
but h0=0 would cause problems.}
\item{h1}{Upper limit.}
\item{meth}{Required selection method(s).}
\item{kern}{Kernel. Most methods require \code{kern="gauss"}, the default
for this function only.}
\item{gf}{Standard deviation for the gaussian kernel. Default 2.5, as
Locfit's standard. Most papers use 1.
}
}
\value{
Vector of selected bandwidths.
}
\references{
Loader, C. (1999). Local Regression and Likelihood. Springer, New York.
}
\keyword{htest}
locfit/man/border.Rd 0000744 0001760 0000144 00000000725 14206713113 014104 0 ustar ripley users \name{border}
\alias{border}
\title{Cricket Batting Dataset}
\usage{data(border)}
\format{
A dataframe with day (decimalized); not out indicator and score.
The not out indicator should be used as a censoring variable.
}
\description{
Scores in 265 innings for Australian batsman Allan Border.
}
\source{
Compiled from the Cricinfo archives.
}
\references{CricInfo: The Home of Cricket on the Internet.
\url{https://www.espncricinfo.com/}
}
\keyword{datasets}
locfit/man/cltest.Rd 0000744 0001760 0000144 00000001241 12123143130 014107 0 ustar ripley users \name{cltest}
\alias{cltest}
\title{Test dataset for classification}
\usage{data(cltest)}
\format{
Data Frame. Three variables x1, x2 and y. The latter indicates
class membership.
}
\description{
200 observations from a 2 population model. Under population 0,
\eqn{x_{1,i}} has a standard normal distribution, and
\eqn{x_{2,i} = (2-x_{1,i}^2+z_i)/3}, where \eqn{z_i} is also standard normal.
Under population 1, \eqn{x_{2,i} = -(2-x_{1,i}^2+z_i)/3}.
The optimal classification regions form a checkerboard pattern,
with horizontal boundary at \eqn{x_2=0}, vertical boundaries at
\eqn{x_1 = \pm \sqrt{2}}.
This is the same model as the cltrain dataset.
}
\keyword{datasets}
locfit/DESCRIPTION 0000744 0001760 0000144 00000001545 14441412146 013277 0 ustar ripley users Package: locfit
Version: 1.5-9.8
Title: Local Regression, Likelihood and Density Estimation
Date: 2023-06-11
Authors@R: c(person("Catherine", "Loader", role = "aut"),
person("Jiayang", "Sun", role = "ctb"),
person("Lucent Technologies", role = "cph"),
person("Andy", "Liaw", role = "cre",
email="andy_liaw@merck.com"))
Author: Catherine Loader [aut],
Jiayang Sun [ctb],
Lucent Technologies [cph],
Andy Liaw [cre]
Maintainer: Andy Liaw
Description: Local regression, likelihood and density estimation methods as described in the 1999 book by Loader.
Depends: R (>= 4.1.0)
Imports: lattice
Suggests: interp, gam
License: GPL (>= 2)
SystemRequirements: USE_C17
NeedsCompilation: yes
Packaged: 2023-06-11 16:08:49 UTC; ripley
Repository: CRAN
Date/Publication: 2023-06-11 18:37:26 UTC
locfit/src/ 0000755 0001760 0000144 00000000000 14441370621 012353 5 ustar ripley users locfit/src/math.c 0000744 0001760 0000144 00000007323 12134436032 013452 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
miscellaneous functions that may not be defined in the math
libraries. The implementations are crude.
lflgamma(x) -- log(gamma(x))
lferf(x) -- erf(x)
lferfc(x) -- erfc(x)
lfdaws(x) -- dawson's function
lf_exp(x) -- exp(x), but it won't overflow.
where required, these must be #define'd in local.h.
also includes
ptail(x) -- exp(x*x/2)*int_{-\infty}^x exp(-u^2/2)du for x < -6.
logit(x) -- logistic function.
expit(x) -- inverse of logit.
*/
#include
double lf_exp(x)
double x;
{ if (x>700.0) return(1.014232054735004e+304);
return(exp(x));
}
#include "local.h"
double lferfc();
double lferf(x)
double x;
{ static double val[] = { 0.0, 0.52049987781304674,
0.84270079294971501, 0.96610514647531076, 0.99532226501895282,
0.99959304798255499, 0.99997790950300125 };
double h, xx, y, z, f0, f1, f2;
int m, j;
if (x<0) return(-lferf(-x));
if (x>3.2) return(1-lferfc(x));
m = (int) (2*x+0.5);
xx= ((double)m)/2;
h = x-xx; y = h;
f0 = val[m];
f1 = 2*exp(-xx*xx)/SQRPI;
z = f0+h*f1;
j = 0;
while (fabs(y)>1.0e-12)
{ f2 = -2*j*f0-2*xx*f1;
f0 = f1; f1 = f2;
y *= h/(j+2);
z += y*f2;
j++;
}
return(z);
}
double lferfc(x)
double x;
{ if (x<0) return(1+lferf(-x));
if (x<2.5) return(1-lferf(x));
return(exp(-x*x)/(x*SQRPI));
}
double lflgamma(x)
double x;
{ double x1;
static double ilg[] = { 0.0, 0.0, 0.69314718055994529,
1.791759469228055, 3.1780538303479458, 4.7874917427820458, 6.5792512120101012,
8.5251613610654147, 10.604602902745251, 12.801827480081469 };
static double hlg[] = { 0.57236494292470008, -0.12078223763524520,
0.28468287047291918, 1.20097360234707430, 2.45373657084244230,
3.95781396761871650, 5.66256205985714270, 7.53436423675873360,
9.54926725730099870, 11.68933342079726900 };
if (x<=0.0) return(0.0);
if (x<10)
{ if (x==(int)x) return(ilg[(int)x-1]);
if ((x-0.5)==(int)(x-0.5)) return(hlg[(int)(x-0.5)]);
}
if (x<3) return(lflgamma(x+1)-log(x));
x1 = x-1;
return(HL2PI+(x1+0.5)*log(x1)-x1+1/(12*x1));
}
double lfdaws(x)
double x;
{ static double val[] = {
0, 0.24485619356002, 0.46034428261948, 0.62399959848185, 0.72477845900708,
0.76388186132749, 0.75213621001998, 0.70541701910853, 0.63998807456541,
0.56917098836654, 0.50187821196415, 0.44274283060424, 0.39316687916687,
0.35260646480842, 0.31964847250685, 0.29271122077502, 0.27039629581340,
0.25160207761769, 0.23551176224443, 0.22153505358518, 0.20924575719548,
0.19833146819662, 0.18855782729305, 0.17974461154688, 0.17175005072385 };
double h, f0, f1, f2, y, z, xx;
int j, m;
if (x<0) return(-daws(-x));
if (x>6)
{ /* Tail series: 1/x + 1/x^3 + 1.3/x^5 + 1.3.5/x^7 + ... */
y = z = 1/x;
j = 0;
while (((f0=(2*j+1)/(x*x))<1) && (y>1.0e-10*z))
{ y *= f0;
z += y;
j++;
}
return(z);
}
m = (int) (4*x);
h = x-0.25*m;
if (h>0.125)
{ m++;
h = h-0.25;
}
xx = 0.25*m;
f0 = val[m];
f1 = 1-xx*f0;
z = f0+h*f1;
y = h;
j = 2;
while (fabs(y)>z*1.0e-10)
{ f2 = -(j-1)*f0-xx*f1;
y *= h/j;
z += y*f2;
f0 = f1; f1 = f2;
j++;
}
return(z);
}
double ptail(x) /* exp(x*x/2)*int_{-\infty}^x exp(-u^2/2)du for x < -6 */
double x;
{ double y, z, f0;
int j;
y = z = -1.0/x;
j = 0;
while ((fabs(f0= -(2*j+1)/(x*x))<1) && (fabs(y)>1.0e-10*z))
{ y *= f0;
z += y;
j++;
}
return(z);
}
double logit(x)
double x;
{ return(log(x/(1-x)));
}
double expit(x)
double x;
{ double u;
if (x<0)
{ u = exp(x);
return(u/(1+u));
}
return(1/(1+exp(-x)));
}
int factorial(n)
int n;
{ if (n<=1) return(1.0);
return(n*factorial(n-1));
}
locfit/src/lf_vari.c 0000744 0001760 0000144 00000010217 12134436032 014137 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
* Post-fitting functions to compute the local variance and
* influence functions. Also the local degrees of freedom
* calculations for adaptive smoothing.
*/
#include "local.h"
extern double robscale;
static double tr0, tr1, tr2;
/*
vmat() computes (after the local fit..) the matrix
M2 = X^T W^2 V X.
M12 = (X^T W V X)^{-1} M2
Also, for convenience, tr[0] = sum(wi) tr[1] = sum(wi^2).
*/
void vmat(lfd, sp, des, M12, M2)
lfdata *lfd;
smpar *sp;
design *des;
double *M12, *M2;
{ int i, p, nk, ok;
double link[LLEN], h, ww;
p = des->p;
setzero(M2,p*p);
nk = -1;
/* for density estimation, use integral rather than
sum form, if W^2 is programmed...
*/
if ((fam(sp)<=THAZ) && (link(sp)==LLOG))
{ switch(ker(sp))
{ case WGAUS: nk = WGAUS; h = des->h/SQRT2; break;
case WRECT: nk = WRECT; h = des->h; break;
case WEPAN: nk = WBISQ; h = des->h; break;
case WBISQ: nk = WQUQU; h = des->h; break;
case WTCUB: nk = W6CUB; h = des->h; break;
case WEXPL: nk = WEXPL; h = des->h/2; break;
}
}
tr0 = tr1 = 0.0;
if (nk != -1)
{ ok = ker(sp); ker(sp) = nk;
/* compute M2 using integration. Use M12 as work matrix. */
(des->itype)(des->xev, M2, M12, des->cf, h);
ker(sp) = ok;
if (fam(sp)==TDEN) multmatscal(M2,des->smwt,p*p);
tr0 = des->ss[0];
tr1 = M2[0]; /* n int W e^ */
}
else
{ for (i=0; in; i++)
{ stdlinks(link,lfd,sp,(int)des->ind[i],des->th[i],robscale);
ww = SQR(des->w[i])*link[ZDDLL];
tr0 += des->w[i];
tr1 += SQR(des->w[i]);
addouter(M2,d_xi(des,i),d_xi(des,i),p,ww);
}
}
memmove(M12,M2,p*p*sizeof(double));
for (i=0; ixtwx,&M12[i*p]);
}
void lf_vcov(lfd,sp,des)
lfdata *lfd;
smpar *sp;
design *des;
{ int i, j, k, p;
double *M12, *M2;
M12 = des->V; M2 = des->P; p = des->p;
vmat(lfd,sp,des,M12,M2); /* M2 = X^T W^2 V X tr0=sum(W) tr1=sum(W*W) */
tr2 = m_trace(M12,p); /* tr (XTWVX)^{-1}(XTW^2VX) */
/*
* Covariance matrix is M1^{-1} * M2 * M1^{-1}
* We compute this using the cholesky decomposition of
* M2; premultiplying by M1^{-1} and squaring. This
* is more stable than direct computation in near-singular cases.
*/
chol_dec(M2,p,p);
for (i=0; ixtwx,&M2[i*p]);
for (i=0; ismwt),p*p);
}
void comp_vari(lfd,sp,des,tr,t0)
lfdata *lfd;
smpar *sp;
design *des;
double *tr, *t0;
{ int i;
lf_vcov(lfd,sp,des);
tr[0] = tr0;
tr[1] = tr1;
tr[2] = tr2;
/* influence components */
unitvec(des->f1,0,des->p);
jacob_solve(&des->xtwx,des->f1);
for (i=0; i<=lfd->d; i++) t0[i] = des->f1[i];
}
/* local_df computes:
* tr[0] = trace(W)
* tr[1] = trace(W*W)
* tr[2] = trace( M1^{-1} M2 )
* tr[3] = trace( M1^{-1} M3 )
* tr[4] = trace( (M1^{-1} M2)^2 )
* tr[5] = var(theta-hat).
*/
void local_df(lfd,sp,des,tr)
lfdata *lfd;
smpar *sp;
design *des;
double *tr;
{ int i, j, p;
double *m2, *V, ww, link[LLEN];
tr[0] = tr[1] = tr[2] = tr[3] = tr[4] = tr[5] = 0.0;
m2 = des->V; V = des->P; p = des->p;
vmat(lfd,sp,des,m2,V); /* M = X^T W^2 V X tr0=sum(W) tr1=sum(W*W) */
tr[0] = tr1;
tr[1] = tr1;
tr[2] = m_trace(m2,p); /* tr (XTWVX)^{-1}(XTW^2VX) */
unitvec(des->f1,0,p);
jacob_solve(&des->xtwx,des->f1);
for (i=0; if1[i]*V[i*p+j]*des->f1[j]; /* var(thetahat) */
}
tr[5] = sqrt(tr[5]);
setzero(m2,p*p);
for (i=0; in; i++)
{ stdlinks(link,lfd,sp,(int)des->ind[i],des->th[i],robscale);
ww = SQR(des->w[i])*des->w[i]*link[ZDDLL];
addouter(m2,d_xi(des,i),d_xi(des,i),p,ww);
}
for (i=0; ixtwx,&m2[i*p]);
tr[3] += m2[i*(p+1)];
}
return;
}
locfit/src/fitted.c 0000744 0001760 0000144 00000004745 12134436032 014005 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
/*
Functions for computing residuals and fitted values from
the locfit object.
fitted(lf,fit,what,cv,ty) computes fitted values from the
fit structure in lf.
resid(y,c,w,th,mi,ty) converts fitted values to residuals
*/
#include "local.h"
double resid(y,w,th,fam,ty,res)
int fam, ty;
double y, w, th, *res;
{ double raw;
fam = fam & 63;
if ((fam==TGAUS) | (fam==TROBT) | (fam==TCAUC))
raw = y-res[ZMEAN];
else
raw = y-w*res[ZMEAN];
switch(ty)
{ case RDEV:
if (res[ZDLL]>0) return(sqrt(-2*res[ZLIK]));
else return(-sqrt(-2*res[ZLIK]));
case RPEAR:
if (res[ZDDLL]<=0)
{ if (res[ZDLL]==0) return(0);
return(NOSLN);
}
return(res[ZDLL]/sqrt(res[ZDDLL]));
case RRAW: return(raw);
case RLDOT: return(res[ZDLL]);
case RDEV2: return(-2*res[ZLIK]);
case RLDDT: return(res[ZDDLL]);
case RFIT: return(th);
case RMEAN: return(res[ZMEAN]);
default: ERROR(("resid: unknown residual type %d",ty));
}
return(0.0);
}
double studentize(res,inl,var,ty,link)
double res, inl, var, *link;
int ty;
{ double den;
inl *= link[ZDDLL];
var = var*var*link[ZDDLL];
if (inl>1) inl = 1;
if (var>inl) var = inl;
den = 1-2*inl+var;
if (den<0) return(0.0);
switch(ty)
{ case RDEV:
case RPEAR:
case RRAW:
case RLDOT:
return(res/sqrt(den));
case RDEV2:
return(res/den);
default: return(res);
}
}
void fitted(lf,fit,what,cv,st,ty)
lfit *lf;
double *fit;
int what, cv, st, ty;
{ int i, j, d, n, evo;
double xx[MXDIM], th, inl=0.0, var, link[LLEN];
n = lf->lfd.n;
d = lf->lfd.d;
evo = ev(&lf->evs);
cv &= (evo!=ECROS);
if ((evo==EDATA)|(evo==ECROS)) evo = EFITP;
for (i=0; ilfd,j,i);
th = dointpoint(lf,xx,what,evo,i);
if ((what==PT0)|(what==PVARI)) th = th*th;
if (what==PCOEF)
{ th += base(&lf->lfd,i);
stdlinks(link,&lf->lfd,&lf->sp,i,th,rsc(&lf->fp));
if ((cv)|(st))
{ inl = dointpoint(lf,xx,PT0,evo,i);
inl = inl*inl;
if (cv)
{ th -= inl*link[ZDLL];
stdlinks(link,&lf->lfd,&lf->sp,i,th,rsc(&lf->fp));
}
if (st) var = dointpoint(lf,xx,PNLX,evo,i);
}
fit[i] = resid(resp(&lf->lfd,i),prwt(&lf->lfd,i),th,fam(&lf->sp),ty,link);
if (st) fit[i] = studentize(fit[i],inl,var,ty,link);
} else fit[i] = th;
if (lf_error) return;
}
}
locfit/src/m_eigen.c 0000744 0001760 0000144 00000005213 12134436032 014120 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
#include
#include
#include
#include "mutil.h"
#define E_MAXIT 20
#define E_TOL 1.0e-8
#define SQR(x) ((x)*(x))
double e_tol(D,p)
double *D;
int p;
{ double mx;
int i;
if (E_TOL <= 0.0) return(0.0);
mx = D[0];
for (i=1; imx) mx = D[i*(p+1)];
return(E_TOL*mx);
}
void eig_dec(X,P,d)
double *X, *P;
int d;
{ int i, j, k, iter, ms;
double c, s, r, u, v;
for (i=0; i 1.0e-15*fabs(X[i*d+i]*X[j*d+j]))
{ c = (X[j*d+j]-X[i*d+i])/2;
s = -X[i*d+j];
r = sqrt(c*c+s*s);
c /= r;
s = sqrt((1-c)/2)*(2*(s>0)-1);
c = sqrt((1+c)/2);
for (k=0; kZ;
P = Q = J->Q;
d = J->p;
w = J->wk;
tol = e_tol(D,d);
rank = 0;
for (i=0; itol)
{ w[i] /= D[i*(d+1)];
rank++;
}
for (i=0; iZ;
Q = J->Q;
p = J->p;
w = J->wk;
tol = e_tol(D,p);
rank = 0;
for (i=0; itol)
{ v[i] = w[i]/sqrt(D[i*(p+1)]);
rank++;
}
else v[i] = 0.0;
}
return(rank);
}
double eig_qf(J,v)
jacobian *J;
double *v;
{ int i, j, p;
double sum, tol;
p = J->p;
sum = 0.0;
tol = e_tol(J->Z,p);
for (i=0; iZ[i*p+i]>tol)
{ J->wk[i] = 0.0;
for (j=0; jwk[i] += J->Q[j*p+i]*v[j];
sum += J->wk[i]*J->wk[i]/J->Z[i*p+i];
}
return(sum);
}
locfit/src/dens_odi.c 0000744 0001760 0000144 00000030707 14441366562 014324 0 ustar ripley users /*
* Copyright (c) 1996-200 Lucent Technologies.
* See README file for details.
*
*
*
* Routines for one-dimensional numerical integration
* in density estimation. The entry point is
*
* onedint(cf,mi,l0,l1,resp)
*
* which evaluates int W(u)u^j exp( P(u) ), j=0..2*deg.
* P(u) = cf[0] + cf[1]u + cf[2]u^2/2 + ... + cf[deg]u^deg/deg!
* l0 and l1 are the integration limits.
* The results are returned through the vector resp.
*
*/
#include "local.h"
static int debug;
int exbctay(b,c,n,z) /* n-term taylor series of e^(bx+cx^2) */
double b, c, *z;
int n;
{ double ec[20];
int i, j;
z[0] = 1;
for (i=1; i<=n; i++) z[i] = z[i-1]*b/i;
if (c==0.0) return(n);
if (n>=40)
{ WARN(("exbctay limit to n<40"));
n = 39;
}
ec[0] = 1;
for (i=1; 2*i<=n; i++) ec[i] = ec[i-1]*c/i;
for (i=n; i>1; i--)
for (j=1; 2*j<=i; j++)
z[i] += ec[j]*z[i-2*j];
return(n);
}
double explinjtay(l0,l1,j,cf)
/* int_l0^l1 x^j e^(a+bx+cx^2); exbctay aroud l1 */
double l0, l1, *cf;
int j;
{ double tc[40], f;
int k, n;
if ((l0!=0.0) | (l1!=1.0)) WARN(("explinjtay: invalid l0, l1"));
n = exbctay(cf[1]+2*cf[2]*l1,cf[2],20,tc);
// s = tc[0]/(j+1);
f = 1/(j+1);
for (k=1; k<=n; k++)
{ f *= -k/(j+k+1.0);
// s += tc[k]*f;
}
return(f);
}
void explint1(l0,l1,cf,I,p) /* int x^j exp(a+bx); j=0..p-1 */
double l0, l1, *cf, *I;
int p;
{ double y0, y1, f;
int j, k, k1;
y0 = lf_exp(cf[0]+l0*cf[1]);
y1 = lf_exp(cf[0]+l1*cf[1]);
if (p<2*fabs(cf[1])) k = p; else k = (int)fabs(cf[1]);
if (k>0)
{ I[0] = (y1-y0)/cf[1];
for (j=1; j1.0e-8)) /* initially Ik = diff(x^{k+1}e^{a+bx}) */
{ y1 *= l1; y0 *= l0;
I[k] = y1-y0;
if (k>=p) f *= fabs(cf[1])/(k+1);
k++;
}
if (k==50) WARN(("explint1: want k>50"));
I[k] = 0.0;
for (j=k-1; j>=k1; j--) /* now do back step recursion */
I[j] = (I[j]-cf[1]*I[j+1])/(j+1);
}
void explintyl(l0,l1,cf,I,p) /* small c, use taylor series and explint1 */
double l0, l1, *cf, *I;
int p;
{ int i;
double c;
explint1(l0,l1,cf,I,p+8);
c = cf[2];
for (i=0; i=0; i--)
{ s = X[3*i+2]/X[3*i+4];
X[3*i+2] = 0;
y[i] -= s*y[i+1];
}
for (i=0; i0)
{ if (a0>6) I[0] = (y0*ptail(-a0)-y1*ptail(-a1))/c;
else I[0] = S2PI*(mut_pnorm(-a0,0.0,1.0)-mut_pnorm(-a1,0.0,1.0))*bi;
}
else
{ if (a1< -6) I[0] = (y1*ptail(a1)-y0*ptail(a0))/c;
else I[0] = S2PI*(mut_pnorm(a1,0.0,1.0)-mut_pnorm(a0,0.0,1.0))*bi;
}
}
else
I[0] = (y1*daws(a1)-y0*daws(a0))/c;
I[1] = (y1-y0)/(2*cf[2])+d*I[0];
}
void explinsid(l0,l1,cf,I,p) /* large b; don't use fwd recursion */
double l0, l1, *cf, *I;
int p;
{ int k, k0, k1, k2;
double y0, y1, Z[150];
if (debug) printf("side: %8.5f %8.5f %8.5f limt %8.5f %8.5f p %2d\n",cf[0],cf[1],cf[2],l0,l1,p);
k0 = 2;
k1 = (int)(fabs(cf[1])+fabs(2*cf[2]));
if (k1<2) k1 = 2;
if (k1>p+20) k1 = p+20;
k2 = p+20;
if (debug) printf("k0 %2d k1 %2d k2 %2d p %2d\n",k0,k1,k2,p);
y0 = lf_exp(cf[0]+l0*(cf[1]+l0*cf[2]));
y1 = lf_exp(cf[0]+l1*(cf[1]+l1*cf[2]));
initi0i1(I,cf,y0,y1,l0,l1);
if (debug) printf("i0 %8.5f i1 %8.5f\n",I[0],I[1]);
y1 *= l1; y0 *= l0; /* should be x^(k1)*exp(..) */
if (k0=k1; k--)
I[k] = (I[k]-cf[1]*I[k+1]-2*cf[2]*I[k+2])/(k+1);
if (k0=0; k--)
I[k] = (I[k]-cf[1]*I[k+1]-2*cf[2]*I[k+2])/(k+1);
}
void explinfbk0(l0,l1,cf,I,p) /* fwd and bac recur; b=0; c<0 */
double l0, l1, *cf, *I;
int p;
{ double y0, y1, f1, f2, f, ml2;
int k, ks;
y0 = lf_exp(cf[0]+l0*l0*cf[2]);
y1 = lf_exp(cf[0]+l1*l1*cf[2]);
initi0i1(I,cf,y0,y1,l0,l1);
ml2 = MAX(l0*l0,l1*l1);
ks = 1+(int)(2*fabs(cf[2])*ml2);
if (ks<2) ks = 2;
if (ks>p-3) ks = p;
/* forward recursion for k < ks */
for (k=2; k1.0e-8)
{ y1 *= l1; y0 *= l0;
if ((k-p)%2==0) /* add to I[p-2] */
{ f2 *= -2*cf[2]/(k+1);
I[p-2] += (y1-y0)*f2;
}
else /* add to I[p-1] */
{ f1 *= -2*cf[2]/(k+1);
I[p-1] += (y1-y0)*f1;
f *= 2*fabs(cf[2])*ml2/(k+1);
}
k++;
}
/* use back recursion for I[ks..(p-3)] */
for (k=p-3; k>=ks; k--)
I[k] = (I[k]-2*cf[2]*I[k+2])/(k+1);
}
void explinfbk(l0,l1,cf,I,p) /* fwd and bac recur; b not too large */
double l0, l1, *cf, *I;
int p;
{ double y0, y1;
int k, ks, km;
y0 = lf_exp(cf[0]+l0*(cf[1]+l0*cf[2]));
y1 = lf_exp(cf[0]+l1*(cf[1]+l1*cf[2]));
initi0i1(I,cf,y0,y1,l0,l1);
ks = (int)(3*fabs(cf[2]));
if (ks<3) ks = 3;
if (ks>0.75*p) ks = p; /* stretch the forward recurs as far as poss. */
/* forward recursion for k < ks */
for (k=2; k=ks; k--)
I[k] = (I[k]-cf[1]*I[k+1]-2*cf[2]*I[k+2])/(k+1);
}
void recent(I,resp,wt,p,s,x)
double *I, *resp, *wt, x;
int p, s;
{ int i, j;
/* first, use W taylor series I -> resp */
for (i=0; i<=p; i++)
{ resp[i] = 0.0;
for (j=0; j 0 */
if (x==0) return;
for (j=0; j<=p; j++) for (i=p; i>j; i--) resp[i] += x*resp[i-1];
}
void recurint(l0,l2,cf,resp,p,ker)
double l0, l2, *cf, *resp;
int p, ker;
{ int i, s;
double l1, d0, d1, d2, dl, z0, z1, z2, wt[20], ncf[3], I[50], r1[5], r2[5];
if (debug) printf("\nrecurint: %8.5f %8.5f %8.5f %8.5f %8.5f\n",cf[0],cf[1],cf[2],l0,l2);
if (cf[2]==0) /* go straight to explint1 */
{ s = wtaylor(wt,0.0,ker);
if (debug) printf("case 1\n");
explint1(l0,l2,cf,I,p+s);
recent(I,resp,wt,p,s,0.0);
return;
}
dl = l2-l0;
d0 = cf[1]+2*l0*cf[2];
d2 = cf[1]+2*l2*cf[2];
z0 = cf[0]+l0*(cf[1]+l0*cf[2]);
z2 = cf[0]+l2*(cf[1]+l2*cf[2]);
if ((fabs(cf[1]*dl)<1) && (fabs(cf[2]*dl*dl)<1))
{ ncf[0] = z0; ncf[1] = d0; ncf[2] = cf[2];
if (debug) printf("case 2\n");
s = wtaylor(wt,l0,ker);
explinbkr(0.0,dl,ncf,I,p+s);
recent(I,resp,wt,p,s,l0);
return;
}
if (fabs(cf[2]*dl*dl)<0.001) /* small c, use explint1+tay.ser */
{ ncf[0] = z0; ncf[1] = d0; ncf[2] = cf[2];
if (debug) printf("case small c\n");
s = wtaylor(wt,l0,ker);
explintyl(0.0,l2-l0,ncf,I,p+s);
recent(I,resp,wt,p,s,l0);
return;
}
if (d0*d2<=0) /* max/min in [l0,l2] */
{ l1 = -cf[1]/(2*cf[2]);
z1 = cf[0]+l1*(cf[1]+l1*cf[2]);
d1 = 0.0;
if (cf[2]<0) /* peak, integrate around l1 */
{ s = wtaylor(wt,l1,ker);
ncf[0] = z1; ncf[1] = 0.0; ncf[2] = cf[2];
if (debug) printf("case peak p %2d s %2d\n",p,s);
explinfbk0(l0-l1,l2-l1,ncf,I,p+s);
recent(I,resp,wt,p,s,l1);
return;
}
}
if ((d0-2*cf[2]*dl)*(d2+2*cf[2]*dl)<0) /* max/min is close to [l0,l2] */
{ l1 = -cf[1]/(2*cf[2]);
z1 = cf[0]+l1*(cf[1]+l1*cf[2]);
if (l1l2) { l1 = l2; z1 = z2; }
if ((z1>=z0) & (z1>=z2)) /* peak; integrate around l1 */
{ s = wtaylor(wt,l1,ker);
if (debug) printf("case 4\n");
d1 = cf[1]+2*l1*cf[2];
ncf[0] = z1; ncf[1] = d1; ncf[2] = cf[2];
explinfbk(l0-l1,l2-l1,ncf,I,p+s);
recent(I,resp,wt,p,s,l1);
return;
}
/* trough; integrate [l0,l1] and [l1,l2] */
for (i=0; i<=p; i++) r1[i] = r2[i] = 0.0;
if (l0z0+3) /* steep increase, expand around l2 */
{ s = wtaylor(wt,l2,ker);
if (debug) printf("case 7\n");
ncf[0] = z2; ncf[1] = d2; ncf[2] = cf[2];
explinsid(l0-l2,0.0,ncf,I,p+s);
recent(I,resp,wt,p,s,l2);
if (debug) printf("7 resp: %8.5f %8.5f %8.5f %8.5f\n",resp[0],resp[1],resp[2],resp[3]);
return;
}
/* bias towards expansion around l0, because it's often 0 */
if (debug) printf("case 8\n");
s = wtaylor(wt,l0,ker);
ncf[0] = z0; ncf[1] = d0; ncf[2] = cf[2];
explinsid(0.0,l2-l0,ncf,I,p+s);
recent(I,resp,wt,p,s,l0);
return;
}
int onedexpl(cf,deg,resp)
double *cf, *resp;
int deg;
{ int i;
double f0, fr, fl;
if (deg>=2) ERROR(("onedexpl only valid for deg=0,1"));
if (fabs(cf[1])>=EFACT) return(LF_BADP);
f0 = exp(cf[0]); fl = fr = 1.0;
for (i=0; i<=2*deg; i++)
{ f0 *= i+1;
fl /=-(EFACT+cf[1]);
fr /= EFACT-cf[1];
resp[i] = f0*(fr-fl);
}
return(LF_OK);
}
int onedgaus(cf,deg,resp)
double *cf, *resp;
int deg;
{ int i;
double f0, mu, s2;
if (deg==3)
{ ERROR(("onedgaus only valid for deg=0,1,2"));
return(LF_ERR);
}
if (2*cf[2]>=GFACT*GFACT) return(LF_BADP);
s2 = 1/(GFACT*GFACT-2*cf[2]);
mu = cf[1]*s2;
resp[0] = 1.0;
if (deg>=1)
{ resp[1] = mu;
resp[2] = s2+mu*mu;
if (deg==2)
{ resp[3] = mu*(3*s2+mu*mu);
resp[4] = 3*s2*s2 + mu*mu*(6*s2+mu*mu);
}
}
f0 = S2PI * exp(cf[0]+mu*mu/(2*s2))*sqrt(s2);
for (i=0; i<=2*deg; i++) resp[i] *= f0;
return(LF_OK);
}
int onedint(sp,cf,l0,l1,resp) /* int W(u)u^j exp(..), j=0..2*deg */
smpar *sp;
double *cf, l0, l1, *resp;
{ double u, uj, y, ncf[4], rr[5];
int i, j;
if (debug) printf("onedint: %f %f %f %f %f\n",cf[0],cf[1],cf[2],l0,l1);
if (deg(sp)<=2)
{ for (i=0; i<3; i++) ncf[i] = (i>deg(sp)) ? 0.0 : cf[i];
ncf[2] /= 2;
if (ker(sp)==WEXPL) return(onedexpl(ncf,deg(sp),resp));
if (ker(sp)==WGAUS) return(onedgaus(ncf,deg(sp),resp));
if (l1>0)
recurint(MAX(l0,0.0),l1,ncf,resp,2*deg(sp),ker(sp));
else for (i=0; i<=2*deg(sp); i++) resp[i] = 0;
if (l0<0)
{ ncf[1] = -ncf[1];
l0 = -l0; l1 = -l1;
recurint(MAX(l1,0.0),l0,ncf,rr,2*deg(sp),ker(sp));
}
else for (i=0; i<=2*deg(sp); i++) rr[i] = 0.0;
for (i=0; i<=2*deg(sp); i++)
resp[i] += (i%2==0) ? rr[i] : -rr[i];
return(LF_OK);
}
/* For degree >= 3, we use Simpson's rule. */
for (j=0; j<=2*deg(sp); j++) resp[j] = 0.0;
for (i=0; i<=de_mint; i++)
{ u = l0+(l1-l0)*i/de_mint;
y = cf[0]; uj = 1;
for (j=1; j<=deg(sp); j++)
{ uj *= u;
y += cf[j]*uj/fact[j];
}
y = (4-2*(i%2==0)-(i==0)-(i==de_mint)) *
W(fabs(u),ker(sp))*exp(MIN(y,300.0));
for (j=0; j<=2*deg(sp); j++)
{ resp[j] += y;
y *= u;
}
}
for (j=0; j<=2*deg(sp); j++) resp[j] = resp[j]*(l1-l0)/(3*de_mint);
return(LF_OK);
}
locfit/src/scb_cons.c 0000744 0001760 0000144 00000030367 12134436032 014316 0 ustar ripley users /*
* Copyright (c) 1996-2004 Catherine Loader.
* This file contains functions to compute the constants
* appearing in the tube formula.
*/
#include
#include
#include
#include
#include
#include "tube.h"
static double *fd, *ft;
static int globm, (*wdf)(), use_covar, kap_terms;
int k0_reqd(d,n,uc)
int d, n, uc;
{ int m;
m = d*(d+1)+1;
if (uc) return(2*m*m);
else return(2*n*m);
}
void assignk0(z,d,n) /* z should be n*(2*d*d+2*d+2); */
double *z;
int d, n;
{ ft = z; z += n*(d*(d+1)+1);
fd = z; z += n*(d*(d+1)+1);
}
/* Residual projection of y to the columns of A,
* (I - A(R^TR)^{-1}A^T)y
* R should be from the QR-decomp. of A.
*/
void rproject(y,A,R,n,p)
double *y, *A, *R;
int n, p;
{ double v[1+TUBE_MXDIM];
int i, j;
for (i=0; i=2) & (kap_terms >= 3));
m = globm = wdf(x,ft,r);
memmove(fd,ft,m*(d+1)*sizeof(double));
if (use_covar) chol_dec(fd,m,d+1);
else qr(fd,m,d+1,NULL);
det = 1;
for (j=1; j<=d; j++)
det *= fd[j*(m+1)]/fd[0];
kap[0] = det;
if (kap_terms == 1) return(1);
kap[1] = 0.0;
if ((kap_terms == 2) | (d<=1)) return(2);
lij = &ft[(d+1)*m];
nij = &fd[(d+1)*m];
memmove(nij,lij,m*d*d*sizeof(double));
z = (use_covar) ? k2c(nij,ft,m,d,d) : k2x(nij,ft,m,d,d);
kap[2] = z*det;
if ((kap_terms == 3) | (d==2)) return(3);
kap[3] = 0;
return(4);
}
void d1c(li,ni,m,d,M)
double *li, *ni, *M;
int m, d;
{ int i, j, k, l;
double t;
fd[0] = ft[0];
for (i=0; i0)
{ t = 0.0;
for (j=0; j= 5))
warning("terms = %2d\n", kap_terms);
switch(ev)
{
case IMONTE:
monte(k0x,fl,&fl[d],d,k0,mg[0]);
break;
case ISPHERIC:
if (d==2) integ_disc(k0x,l1x,fl,k0,l0,mg);
if (d==3) integ_sphere(k0x,l1x,fl,k0,l0,mg);
break;
case ISIMPSON:
if (use_covar) simpson4(k0x,l1x,m0x,n0x,fl,&fl[d],d,k0,l0,m0,n0,mg,z);
else simpson4(k0x,l1x,m0x,n0x,fl,&fl[d],d,k0,l0,m0,n0,mg,z);
break;
case IDERFREE:
kodf(fl,&fl[d],mg,k0,l0);
break;
default:
Rprintf("Unknown integration type in tube_constants().\n");
}
if (deb>0) {
Rprintf("constants:\n");
Rprintf(" k0: %8.5f %8.5f %8.5f %8.5f\n",k0[0],k0[1],k0[2],k0[3]);
Rprintf(" l0: %8.5f %8.5f %8.5f\n",l0[0],l0[1],l0[2]);
Rprintf(" m0: %8.5f %8.5f\n",m0[0],m0[1]);
Rprintf(" n0: %8.5f\n",n0[0]);
if (d==2) Rprintf(" check: %8.5f\n",(k0[0]+k0[2]+l0[1]+m0[0])/(2*PI));
if (d==3) Rprintf(" check: %8.5f\n",(l0[0]+l0[2]+m0[1]+n0[0])/(4*PI));
}
if (aw) free(wk);
kap[0] = k0[0];
if (kap_terms==1) return(1);
kap[1] = l0[0]/2;
if ((kap_terms==2) | (d==1)) return(2);
kap[2] = (k0[2]+l0[1]+m0[0])/(2*PI);
if ((kap_terms==3) | (d==2)) return(3);
kap[3] = (l0[2]+m0[1]+n0[0])/(4*PI);
return(4);
}
locfit/src/S_enter.c 0000744 0001760 0000144 00000034074 14441366511 014132 0 ustar ripley users /*
* Copyright (c) 1996-2000 Lucent Technologies.
* See README file for details.
*/
/* All included by local.h
#include "S.h"
#undef WARN
#undef ERROR
#include
*/
#include "local.h"
extern int deitype(char *); /* in lfstr.c */
static design des;
static lfit lf;
int lf_error;
#ifdef RVERSION
typedef char * CALL_S_FUNC;
typedef void * CALL_S_ARGS;
#else
typedef void * CALL_S_FUNC;
typedef char * CALL_S_ARGS;
#endif
typedef long int CALL_S_LEN;
typedef long int CALL_S_NARG;
typedef char * CALL_S_MODE;
typedef long int CALL_S_NRES;
typedef char * CALL_S_VALS;
static CALL_S_FUNC bsfunc, bsf2;
#ifdef OLD
void basis(x,t,f,dim,p)
double *x, *t, *f;
Sint dim, p;
{
CALL_S_ARGS args[2];
CALL_S_LEN length[2];
CALL_S_NARG nargs;
CALL_S_MODE mode[2];
CALL_S_NRES nres;
CALL_S_VALS values[1];
/* double z0[1], z1[1], *vptr; */
double *vptr;
int i;
args[0] = (CALL_S_ARGS)x;
mode[0] = "double";
length[0] = dim;
args[1] = (CALL_S_ARGS)t;
mode[1] = "double";
length[1] = dim;
nargs = 2;
nres = 1;
call_S(bsfunc,nargs,args,mode,length,(char **)NULL,nres,values);
vptr = (double *)values[0];
for (i=0; ifl,ll,d*sizeof(double));
memmove(&evs->fl[d],ur,d*sizeof(double));
}
switch(ev(evs))
{ case ETREE:
case EKDTR:
case EKDCE:
case EPHULL:
cut(evs) = cut;
return;
case EGRID:
for (i=0; img[i] = mg[i];
return;
case ESPHR:
for (i=0; i<2; i++) evs->mg[i] = mg[i];
return;
case EDATA:
case ECROS:
case EPRES:
case EXBAR:
case ENONE:
return;
default:
printf("setevs: %2d not defined.\n",ev(evs));
}
}
static void setdata(lfd,x,y,c,w,b,n,d,sca,sty)
lfdata *lfd;
double *x, *y, *c, *w, *b, *sca;
Sint n, d, *sty;
{ int i;
for (i=0; isca[i] = sca[i];
lfd->sty[i] = sty[i];
}
lfd->y = y;
lfd->w = w;
lfd->b = b;
lfd->c = c;
lfd->n = n;
lfd->d = d;
lfd->ord = 0;
}
static void setsmpar(sp,dp,mi)
smpar *sp;
double *dp;
Sint *mi;
{ nn(sp) = dp[DALP];
fixh(sp)= dp[DFXH];
pen(sp) = dp[DADP];
ker(sp) = mi[MKER];
kt(sp) = mi[MKT];
acri(sp)= mi[MACRI];
deg(sp) = mi[MDEG];
deg0(sp) = mi[MDEG0];
fam(sp) = mi[MTG];
link(sp) = mi[MLINK];
ubas(sp) = mi[MUBAS];
npar(sp) = mi[MP];
lf.sp.vbasis = vbasis;
}
static void slocfit(x,y,c,w,b,lim,mi,dp,str,sca,xev,wdes,wtre,wpc,nvc,
iwk1, iwk2,lw,mg,L,kap,dv,nd,sty) /* ,bs) */
double *x, *y, *c, *w, *b, *lim, *dp, *sca, *xev, *L, *kap, *wdes, *wtre, *wpc;
Sint *mi, *nvc, *iwk1, *iwk2, *lw, *mg, *dv, *nd, *sty;
char **str;
/* CALL_S_FUNC *bs; */
{ Sint n, d, i;
mi[MKER] = lfkernel(str[0]);
mi[MTG] = lffamily(str[1]);
mi[MLINK]= lflink(str[2]);
mi[MIT] = deitype(str[3]);
mi[MACRI]= lfacri(str[4]);
mi[MKT] = lfketype(str[5]);
/* if (mi[MUBAS])
{ bsfunc = bs[0];
bsf2 = bs[1];
} */
lf_error = 0;
n = mi[MN]; d = mi[MDIM];
lfit_alloc(&lf);
setdata(&lf.lfd,x,y,c,w,b,n,d,sca,sty);
setsmpar(&lf.sp,dp,mi);
setevs(&lf.evs,mi,dp[DCUT],mg,&lim[2*d]);
lf_maxit = mi[MMXIT];
lf_debug = mi[MDEB];
de_mint = mi[MMINT];
de_itype = mi[MIT];
de_renorm= mi[MREN];
dc(&lf.fp) = mi[MDC];
geth(&lf.fp)=mi[MGETH];
des.wk = wdes; des.lwk = lw[0];
des.ind= iwk2; des.lind = lw[6];
des.des_init_id = DES_INIT_ID;
lf.fp.xev = xev; lf.fp.lev = d*nvc[0];
lf.fp.coef= wtre; lf.fp.lwk = lw[1];
lf.pc.wk = wpc; lf.pc.lwk = lw[3];
lf.evs.iwk = iwk1; lf.evs.liw = lw[2];
lf.fp.L = L; lf.fp.ll = lw[4];
lf.fp.nvm = nvc[0];
lf.dv.nd = *nd;
for (i=0; i= 70)
scb(&des,&lf);
else switch(mi[MGETH])
{ case GSTD: /* the standard fit */
case GAMF: /* for gam.lf, return residuals */
case GAMP: /* for gam.lf prediction */
if (mi[MDEG0]==mi[MDEG])
{ startlf(&des,&lf,procv,0);
if (!lf_error) ressumm(&lf,&des);
}
else startlf(&des,&lf,procvvord,0);
break;
case GSMP:
startlf(&des,&lf,procvraw,0);
break;
case GHAT:
startlf(&des,&lf,procvhatm,(int)mi[MKER]!=WPARM);
break;
case GKAP:
constants(&des,&lf);
for(i=0; i0) | dc(&lf.fp);
switch(mi[MEV])
{ case ETREE:
case EKDTR:
case EGRID:
case ESPHR: vc = 1<= 70)
{ lw[4] = k0_reqd(d,n,0);
if (lw[4]<2*nvm) lw[4] = 2*nvm;
lw[5] = d+1;
}
else switch(mi[MGETH])
{ case GSTD: lw[4] = 1; break; /* standard fit */
case GSMP: lw[4] = 1; break; /* simple fit */
case GHAT: lw[4] = nvm*n; break; /* hat matrix */
case GKAP: lw[4] = k0_reqd(d,n,0); /* kappa0 */
lw[5] = 1+d;
break;
case GRBD: lw[5] = 10; /* regband */
case GAMF: /* gam.lf fit */
case GAMP: lw[4] = 1; break; /* gam.lf pred */
case GLSC: lw[4] = 2; break; /* lscv */
default:
printf("sguessnv: invalid geth\n");
lw[4] = 0;
}
nvc[0] = nvm;
nvc[1] = ncm;
nvc[2] = vc;
nvc[3] = nvc[4] = 0;
}
/* Registration added Mar 2012 */
#include
/* From smisc.c */
void kdeb(double *x, int *mi, double*band, int *ind, double *h0, double *h1,
int *meth, int *nmeth, int *ker);
void scritval(double *k0, int *d, double *cov, int *m, double *rdf,
double *z, int *k);
void slscv(double *x, int *n, double *h, double *z);
static const R_CMethodDef CEntries[] = {
{"guessnv", (DL_FUNC) &guessnv, 6},
{"slocfit", (DL_FUNC) &slocfit, 24},
{"sfitted", (DL_FUNC) &sfitted, 23},
{"spreplot", (DL_FUNC) &spreplot, 20},
{"triterm", (DL_FUNC) &triterm, 12},
{"kdeb", (DL_FUNC) &kdeb, 9},
{"slscv", (DL_FUNC) &slscv, 4},
{"scritval", (DL_FUNC) &scritval, 7},
{NULL, NULL, 0}
};
void R_init_locfit(DllInfo *dll)
{
R_registerRoutines(dll, CEntries, NULL, NULL, NULL);
R_useDynamicSymbols(dll, FALSE);
}
locfit/src/density.c 0000744 0001760 0000144 00000030772 12134436032 014204 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
#include "local.h"
extern int lf_status;
static double u[MXDIM], ilim[2*MXDIM], *ff, hh, *cff;
static lfdata *den_lfd;
static design *den_des;
static smpar *den_sp;
int fact[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800};
int de_mint = 20;
int de_itype = IDEFA;
int de_renorm= 0;
int multint(), prodint(), gausint(), mlinint();
void prresp(coef,resp,p)
double *coef, *resp;
int p;
{ int i, j;
printf("Coefficients:\n");
for (i=0; ip;
wt = weight(den_lfd, den_sp, u, NULL, hh, 0, 0.0);
if (wt==0)
{ setzero(resp,p*p);
return(p*p);
}
fitfun(den_lfd, den_sp, u,NULL,ff,NULL);
if (link(den_sp)==LLOG)
wt *= lf_exp(innerprod(ff,cff,p));
for (i=0; isca));
d = den_lfd->d;
for (i=0; id; p = den_des->p; sca = den_lfd->sca;
hd = 1;
for (i=0; i1)
{ jj[1] = 2;
w0 = wint(d,jj,2,ker(den_sp)) * hd*h*h*h*h;
}
jj[0] = 4;
w1 = wint(d,jj,1,ker(den_sp)) * hd*h*h*h*h/4;
z = d+1;
for (i=0; i1.0e-8))
{ j++;
jj[0] = 2*j; w0 = wint(d,jj,1,ker(den_sp));
if (d==1) g[3] += wt * w0;
else
{ jj[0] = 2; jj[1] = 2*j-2; w1 = wint(d,jj,2,ker(den_sp));
g[3] += wt*w1;
g[2] += wu*(w0-w1);
}
wt /= (2*j-1.0); g[1] += wt*w0;
wt *= nb/(2*j); g[0] += wt*w0;
wu /= (2*j-1.0)*(2*j);
if (j>1) wu *= nb;
}
if (j==jmax) WARN(("mlinint: series not converged"));
}
g[0] *= hd; g[1] *= hd;
g[2] *= hd; g[3] *= hd;
resp1[0] = g[0];
for (i=1; i<=d; i++)
{ resp1[i] = resp1[(d+1)*i] = cf[i]*SQR(h*sca[i-1])*g[1];
for (j=1; j<=d; j++)
{ resp1[(d+1)*i+j] = (i==j) ? g[3]*SQR(h*sca[i-1]) : 0;
resp1[(d+1)*i+j] += g[2]*SQR(h*h*sca[i-1]*sca[j-1])*cf[i]*cf[j];
}
}
return(LF_OK);
}
ERROR(("mlinint: deg=0,1 only"));
return(LF_ERR);
}
void prodintresp(resp,prod_wk,dim,deg,p)
double *resp, prod_wk[MXDIM][2*MXDEG+1];
int dim, deg, p;
{ double prod;
int i, j, k, j1, k1;
prod = 1.0;
for (i=0; id;
p = den_des->p;
for (i=0; isca[i];
for (j=0; j=2 */
}
/* transfer to the resp array
*/
prodintresp(resp,prod_wk,dim,deg(den_sp),p);
/* Symmetrize.
*/
for (k=0; kd; p = den_des->p;
m1 = d+1; nb = 0;
P = &C[d*d];
resp[0] = 1;
for (i=0; ip;
if ((link(den_sp)==LIDENT) && (coef[0] != 0.0)) return(NR_BREAK);
lf_status = (den_des->itype)(den_des->xev,A,den_des->xtwx.Q,coef,den_des->h);
if (lf_error) lf_status = LF_ERR;
if (lf_status==LF_BADP)
{ *lk0 = -1.0e300;
return(NR_REDUCE);
}
if (lf_status!=LF_OK) return(NR_BREAK);
if (lf_debug>2) prresp(coef,A,p);
den_des->xtwx.p = p;
rstat = NR_OK;
switch(link(den_sp))
{ case LLOG:
r = den_des->ss[0]/A[0];
coef[0] += log(r);
multmatscal(A,r,p*p);
A[0] = den_des->ss[0];
lk = -A[0];
if (fabs(coef[0]) > 700)
{ lf_status = LF_OOB;
rstat = NR_REDUCE;
}
for (i=0; iss[i];
f1[i] = den_des->ss[i]-A[i];
}
break;
case LIDENT:
lk = 0.0;
for (i=0; iss[i];
for (j=0; jres[i] -= A[i*p+j]*coef[j];
}
break;
}
*lk0 = den_des->llk = lk;
return(rstat);
}
int inre(x,bound,d)
double *x, *bound;
int d;
{ int i, z;
z = 1;
for (i=0; i=bound[i]) & (x[i]<=bound[i+d]);
return(z);
}
int setintlimits(lfd, x, h, ang, lset)
lfdata *lfd;
int *ang, *lset;
double *x, h;
{ int d, i;
d = lfd->d;
*ang = *lset = 0;
for (i=0; isty[i]==STANGL)
{ ilim[i+d] = ((h<2) ? 2*asin(h/2) : PI)*lfd->sca[i];
ilim[i] = -ilim[i+d];
*ang = 1;
}
else
{ ilim[i+d] = h*lfd->sca[i];
ilim[i] = -ilim[i+d];
if (lfd->sty[i]==STLEFT) { ilim[i+d] = 0; *lset = 1; }
if (lfd->sty[i]==STRIGH) { ilim[i] = 0; *lset = 1; }
if (lfd->xl[i]xl[i+d]) /* user limits for this variable */
{ if (lfd->xl[i]-x[i]> ilim[i])
{ ilim[i] = lfd->xl[i]-x[i]; *lset=1; }
if (lfd->xl[i+d]-x[i]< ilim[i+d])
{ ilim[i+d] = lfd->xl[i+d]-x[i]; *lset=1; }
}
}
if (ilim[i]==ilim[i+d]) return(LF_DEMP); /* empty integration */
}
return(LF_OK);
}
int selectintmeth(itype,lset,ang)
int itype, lset, ang;
{
if (itype==IDEFA) /* select the default method */
{ if (fam(den_sp)==THAZ)
{ if (ang) return(IDEFA);
return( IHAZD );
}
if (ubas(den_sp)) return(IMULT);
if (ang) return(IMULT);
if (iscompact(ker(den_sp)))
{ if (kt(den_sp)==KPROD) return(IPROD);
if (lset)
return( (den_lfd->d==1) ? IPROD : IMULT );
if (deg(den_sp)<=1) return(IMLIN);
if (den_lfd->d==1) return(IPROD);
return(IMULT);
}
if (ker(den_sp)==WGAUS)
{ if (lset) WARN(("Integration for Gaussian weights ignores limits"));
if ((den_lfd->d==1)|(kt(den_sp)==KPROD)) return(IPROD);
if (deg(den_sp)<=1) return(IMLIN);
if (deg(den_sp)==2) return(IMULT);
}
return(IDEFA);
}
/* user provided an integration method, check it is valid */
if (fam(den_sp)==THAZ)
{ if (ang) return(INVLD);
if (!iscompact(ker(den_sp))) return(INVLD);
return( ((kt(den_sp)==KPROD) | (kt(den_sp)==KSPH)) ? IHAZD : INVLD );
}
if ((ang) && (itype != IMULT)) return(INVLD);
switch(itype)
{ case IMULT:
if (ker(den_sp)==WGAUS) return(deg(den_sp)==2);
return( iscompact(ker(den_sp)) ? IMULT : INVLD );
case IPROD: return( ((den_lfd->d==1) | (kt(den_sp)==KPROD)) ? IPROD : INVLD );
case IMLIN: return( ((kt(den_sp)==KSPH) && (!lset) &&
(deg(den_sp)<=1)) ? IMLIN : INVLD );
}
return(INVLD);
}
int densinit(lfd,des,sp,cf)
lfdata *lfd;
design *des;
smpar *sp;
double *cf;
{ int p, i, ii, j, nnz, rnz, ang, lset, status;
double w;
den_lfd = lfd;
den_des = des;
den_sp = sp;
p = des->p;
ff = des->xtwx.wk;
cf[0] = NOSLN;
for (i=1; ixev,lfd->xl,lfd->d)) return(LF_XOOR);
status = setintlimits(lfd,des->xev,des->h,&ang,&lset);
if (status != LF_OK) return(status);
switch(selectintmeth(de_itype,lset,ang))
{ case IMULT: des->itype = multint; break;
case IPROD: des->itype = prodint; break;
case IMLIN: des->itype = mlinint; break;
case IHAZD: des->itype = hazint; break;
case INVLD: ERROR(("Invalid integration method %d",de_itype));
break;
case IDEFA: ERROR(("No integration type available for this model"));
break;
default: ERROR(("densinit: unknown integral type"));
}
switch(deg(den_sp))
{ case 0: rnz = 1; break;
case 1: rnz = 1; break;
case 2: rnz = lfd->d+1; break;
case 3: rnz = lfd->d+2; break;
default: ERROR(("densinit: invalid degree %d",deg(den_sp)));
}
if (lf_error) return(LF_ERR);
setzero(des->ss,p);
nnz = 0;
for (i=0; in; i++)
{ ii = des->ind[i];
if (!cens(lfd,ii))
{ w = des->w[i]*prwt(lfd,ii);
for (j=0; jss[j] += d_xij(des,i,j)*w;
if (des->w[i]>0.00001) nnz++;
} }
if (fam(den_sp)==THAZ) haz_init(lfd,des,sp,ilim);
if (lf_debug>2)
{ printf(" LHS: ");
for (i=0; iss[i]);
printf("\n");
}
switch(link(den_sp))
{ case LIDENT:
cf[0] = 0.0;
return(LF_OK);
case LLOG:
if (nnzmode)
#define vlength(v) ((v)->n)
typedef struct {
char *arg, *val;
vari *result;
int used; } carg;
typedef struct {
void (*AddColor)(), (*SetColor)(), (*ClearScreen)(), (*TextDim)(), (*DoText)();
void (*DrawPoint)(), (*DrawLine)(), (*DrawPatch)(), (*wrapup)();
int (*makewin)(), ticklength, defth, deftw;
} device;
typedef struct {
vari *data[MXDIM], *fit, *se;
int d, wh, gr;
} pplot;
typedef struct {
char cmd;
double x, *v, (*f)();
int m, nx[3];
vari *vv; } arstruct;
typedef struct {
vari *x, *y, *z;
char type;
int id, t, n, nx, ny, pch; } plxyz;
typedef struct {
double theta, phi, xl[2], yl[2], zl[2], sl[10];
int id, ty, nsl;
char main[50], xlab[50], ylab[50], zlab[50];
vari *track, *xyzs; } plots;
#define PLNONE 0
#define PLDATA 1
#define PLFIT 2
#define PLTRK 4
struct lfcol {
char name[10];
int n, r, g, b;
};
/* FILES IN THE src-c DIRECTORY */
/* arith.c */
extern int arvect(), intitem();
extern double areval(), arith(), darith(), dareval();
extern vari *varith(), *saveresult(), *arbuild();
/* c_args.c */
#define argused(v,i) (((carg *)viptr(v,i))->used)
#define setused(v,i) { ((carg *)viptr(v,i))->used = 1; }
#define setunused(v,i) { ((carg *)viptr(v,i))->used = 0; }
#define argarg(v,i) (((carg *)viptr(v,i))->arg)
#define argvalis(v,i,z) (strcmp(argval(v,i),z)==0)
extern char *argval(), *getargval();
extern int getarg(), readilist(), getlogic();
/* cmd.c */
extern int dispatch();
extern void setuplf(), recondat(), cmdint();
extern double backtr(), docrit();
/* c_lf.c */
extern vari *vfitted();
extern void cfitted(), cwdiag();
/* c_plot.c */
extern void plotdata(), plotfit(), plottrack(), plotopt(), setplot();
/* help.c */
extern void example();
/* lfd.c */
extern void doreaddata(), dosavedata(), dosavefit();
extern int setfilename();
/* main.c */
extern void SetWinDev();
/* makecmd.c */
extern vari *getcmd();
extern void makecmd(), del_lines(), inc_forvar(), dec_forvar();
/* post.c */
extern void SetPSDev();
/* pout.c */
extern int pretty();
extern void displayplot();
extern void plotmaple(), plotmathe(), plotmatlb(), plotgnup(), plotxwin();
/* random.c */
extern double rnorm(), rexp(), runif(), rpois();
extern void rseed();
/* readfile.c */
extern void readfile();
/* scbmax.c */
extern void cscbmax();
/* vari.c */
extern int vbytes();
extern vari *createvar(), *findvar(), *growvar();
extern void initdb(), deletevar(), deletename(), deleteifhidden(), setvarname();
extern void *viptr(), vassn();
extern double *vdptr(), vitem();
locfit/src/band.c 0000744 0001760 0000144 00000020127 12134436032 013422 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
#include "local.h"
extern void fitoptions();
static double hmin, gmin, sig2, pen, vr, tb;
static lfit *blf;
static design *bdes;
int procvbind(des,lf,v)
design *des;
lfit *lf;
int v;
{ double s0, s1, bi;
int i, ii, k;
k = procvraw(des,lf,v);
wdiag(&lf->lfd, &lf->sp, des,des->wd,&lf->dv,0,1,0);
s0 = s1 = 0.0;
for (i=0; in; i++)
{ ii = des->ind[i];
s0+= prwt(&lf->lfd,ii)*des->wd[i]*des->wd[i];
bi = prwt(&lf->lfd,ii)*fabs(des->wd[i]*ipower(des->di[ii],deg(&lf->sp)+1));
s1+= bi*bi;
}
vr += s0;
tb += s1;
return(k);
}
double bcri(h,c,cri)
double h;
int c, cri;
{ double num, den;
int (*pv)();
if (c==DALP)
blf->sp.nn = h;
else
blf->sp.fixh = h;
if ((cri&63)==BIND)
{ pv = procvbind;
vr = tb = 0.0;
}
else pv = procv;
if (cri<64) startlf(bdes,blf,pv,0);
switch(cri&63)
{ case BGCV:
ressumm(blf,bdes);
num = -2*blf->lfd.n*llk(&blf->fp);
den = blf->lfd.n-df0(&blf->fp);
return(num/(den*den));
case BCP:
ressumm(blf,bdes);
return(-2*llk(&blf->fp)/sig2-blf->lfd.n+pen*df0(&blf->fp));
case BIND:
return(vr+pen*pen*tb);
}
ERROR(("bcri: unknown criterion"));
return(0.0);
}
void bsel2(h0,g0,ifact,c,cri)
double h0, g0, ifact;
int c, cri;
{ int done, inc;
double h1, g1;
h1 = h0; g1 = g0;
done = inc = 0;
while (!done)
{ h1 *= 1+ifact;
g0 = g1;
g1 = bcri(h1,c,cri);
if (g1g0) inc++; else inc = 0;
switch(cri)
{ case BIND:
done = (inc>=4) & (vrfp.nv);
break;
default:
done = (inc>=4);
}
}
}
void bsel3(h0,g0,ifact,c,cri)
double h0, g0, ifact;
int c, cri;
{ double h1, g1;
int i;
hmin = h0; gmin = g0;
for (i=-1; i<=1; i++) if (i!=0)
{ h1 = h0*(1+i*ifact);
g1 = bcri(h1,c,cri);
if (g1sp)+1);
hmin = h0 = (c==DFXH) ? fixh(&lf->sp) : nn(&lf->sp);
if (h0==0) ERROR(("bselect: initial bandwidth is 0"));
if (lf_error) return;
sig2 = 1.0;
gmin = g0 = bcri(h0,c,cri);
if (cri==BCP)
{ sig2 = rv(&lf->fp);
g0 = gmin = bcri(h0,c,cri+64);
}
ifact = 0.3;
bsel2(h0,g0,ifact,c,cri);
for (i=0; i<5; i++)
{ ifact = ifact/2;
bsel3(hmin,gmin,ifact,c,cri);
}
if (c==DFXH)
fixh(&lf->sp) = hmin;
else
nn(&lf->sp) = hmin;
startlf(des,lf,procv,0);
ressumm(lf,des);
}
double compsda(x,h,n)
double *x, h;
int n;
/* n/(n-1) * int( fhat''(x)^2 dx ); bandwidth h */
{ int i, j;
double ik, sd, z;
ik = wint(1,NULL,0,WGAUS);
sd = 0;
for (i=0; ifact*h[2])|(h[2]>fact*h[3]))
{ h[4] = h[3]-d[3]*(h[3]-h[2])/(d[3]-d[2]);
if ((h[4]h[1])) h[4] = (h[0]+h[1])/2;
kdecri(x,h[4],res,c,j,ker,n);
r[4] = res[0]; d[4] = res[1];
if (lf_error) return(0.0);
h[2] = h[3]; h[3] = h[4];
d[2] = d[3]; d[3] = d[4];
r[2] = r[3]; r[3] = r[4];
if (d[4]*d[0]>0) { h[0] = h[4]; d[0] = d[4]; r[0] = r[4]; }
else { h[1] = h[4]; d[1] = d[4]; r[1] = r[4]; }
}
if (j>=4) return(h[4]); /* first min for BCV etc */
if (r[4]<=min) { min = r[4]; minh = h[4]; }
nc++;
}
}
if (nc==0) minh = (r[5]f1; v2 = des->ss; wk = des->oc;
ispar = (ker(&lf->sp)==WPARM) && (haspc(&lf->pc));
p = npar(&lf->sp);
/* for parametric models, the covariance is
* A(x1)^T (X^T W V X)^{-1} A(x2)
* which we can find easily from the parametric component.
*/
if (ispar)
{ pc = &lf->pc;
fitfun(&lf->lfd, &lf->sp, &x1,pc->xbar,v1,NULL);
fitfun(&lf->lfd, &lf->sp, &x2,pc->xbar,v2,NULL);
jacob_hsolve(&lf->pc.xtwx,v1);
jacob_hsolve(&lf->pc.xtwx,v2);
}
/* for non-parametric models, we must use the cholseky decomposition
* of M2 = X^T W^2 V X. Courtesy of comp_vari, we already have
* des->P = M2^{1/2} M1^{-1}.
*/
if (!ispar)
{ fitfun(&lf->lfd, &lf->sp, &x1,des->xev,wk,NULL);
for (i=0; iP[i*p+j]*wk[j];
}
fitfun(&lf->lfd, &lf->sp, &x2,des->xev,wk,NULL);
for (i=0; iP[i*p+j]*wk[j];
}
}
return(innerprod(v1,v2,p));
}
void cumulant(lf,des,sd)
lfit *lf;
design *des;
double sd;
{ double b3i, b3j, b4i;
double ss, si, sj, uii, uij, ujj, k1;
int ii, i, j, jj;
for (i=1; i<10; i++) c[i] = 0.0;
k1 = 0;
/* ss = sd*sd; */
ss = covar_par(lf,des,des->xev[0],des->xev[0]);
/*
* this isn't valid for nonparametric models. At a minimum,
* the sums would have to include weights. Still have to work
* out the right way.
*/
for (i=0; ilfd.n; i++)
{ ii = des->ind[i];
//b2i = b2(des->th[i],fam(&lf->sp),prwt(&lf->lfd,ii));
b3i = b3(des->th[i],fam(&lf->sp),prwt(&lf->lfd,ii));
b4i = b4(des->th[i],fam(&lf->sp),prwt(&lf->lfd,ii));
si = covar_par(lf,des,des->xev[0],datum(&lf->lfd,0,ii));
uii= covar_par(lf,des,datum(&lf->lfd,0,ii),datum(&lf->lfd,0,ii));
if (lf_error) return;
c[2] += b4i*si*si*uii;
c[6] += b4i*si*si*si*si;
c[7] += b3i*si*uii;
c[8] += b3i*si*si*si;
/* c[9] += b2i*si*si*si*si;
c[9] += b2i*b2i*si*si*si*si; */
k1 += b3i*si*(si*si/ss-uii);
/* i=j components */
c[1] += b3i*b3i*si*si*uii*uii;
c[3] += b3i*b3i*si*si*si*si*uii;
c[4] += b3i*b3i*si*si*uii*uii;
for (j=i+1; jlfd.n; j++)
{ jj = des->ind[j];
b3j = b3(des->th[j],fam(&lf->sp),prwt(&lf->lfd,jj));
sj = covar_par(lf,des,des->xev[0],datum(&lf->lfd,0,jj));
uij= covar_par(lf,des,datum(&lf->lfd,0,ii),datum(&lf->lfd,0,jj));
ujj= covar_par(lf,des,datum(&lf->lfd,0,jj),datum(&lf->lfd,0,jj));
c[1] += 2*b3i*b3j*si*sj*uij*uij;
c[3] += 2*b3i*b3j*si*si*sj*sj*uij;
c[4] += b3i*b3j*uij*(si*si*ujj+sj*sj*uii);
if (lf_error) return;
}
}
c[5] = c[1];
c[7] = c[7]*c[8];
c[8] = c[8]*c[8];
c[1] /= ss; c[2] /= ss; c[3] /= ss*ss; c[4] /= ss;
c[5] /= ss; c[6] /= ss*ss; c[7] /= ss*ss;
c[8] /= ss*ss*ss; c[9] /= ss*ss;
/* constants used in p(x,z) computation */
kap[1] = k1/(2*sqrt(ss));
kap[2] = 1 + 0.5*(c[1]-c[2]+c[4]-c[7]) - 3*c[3] + c[6] + 1.75*c[8];
kap[4] = -9*c[3] + 3*c[6] + 6*c[8] + 3*c[9];
/* constants used in q(x,u) computation */
kaq[2] = c[3] - 1.5*c[8] - c[5] - c[4] + 0.5*c[7] + c[6] - c[2];
kaq[4] = -3*c[3] - 6*c[4] - 6*c[5] + 3*c[6] + 3*c[7] - 3*c[8] + 3*c[9];
}
/* q2(u) := u+q2(x,u) in paper */
double q2(u)
double u;
{ return(u-u*(36.0*kaq[2] + 3*kaq[4]*(u*u-3) + c[8]*((u*u-10)*u*u+15))/72.0);
}
/* p2(u) := p2(x,u) in paper */
double p2(u)
double u;
{ return( -u*( 36*(kap[2]-1+kap[1]*kap[1])
+ 3*(kap[4]+4*kap[1]*sqrt(kap[3]))*(u*u-3)
+ c[8]*((u*u-10)*u*u+15) ) / 72 );
}
extern int likereg();
double gldn_like(a)
double a;
{ int err;
scb_des->fix[0] = 1;
scb_des->cf[0] = a;
max_nr(likereg, scb_des->cf, scb_des->oc, scb_des->res, scb_des->f1,
&scb_des->xtwx, scb_des->p, lf_maxit, 1.0e-6, &err);
scb_des->fix[0] = 0;
return(scb_des->llk);
}
/* v1/v2 is correct for deg=0 only */
void get_gldn(fp,des,lo,hi,v)
fitpt *fp;
design *des;
double *lo, *hi;
int v;
{ double v1, v2, c, tlk;
int err;
v1 = fp->nlx[v];
v2 = fp->t0[v];
c = scb_crit * v1 / v2;
tlk = des->llk - c*c/2;
printf("v %8.5f %8.5f c %8.5f tlk %8.5f llk %8.5f\n",v1,v2,c,tlk,des->llk);
/* want: { a : l(a) >= l(a-hat) - c*c/2 } */
lo[v] = fp->coef[v] - scb_crit*v1;
hi[v] = fp->coef[v] + scb_crit*v1;
err = 0;
printf("lo %2d\n",v);
lo[v] = solve_secant(gldn_like,tlk,lo[v],fp->coef[v],1e-8,BDF_EXPLEFT,&err);
if (err>0) printf("solve_secant error\n");
printf("hi %2d\n",v);
hi[v] = solve_secant(gldn_like,tlk,fp->coef[v],hi[v],1e-8,BDF_EXPRIGHT,&err);
if (err>0) printf("solve_secant error\n");
}
int procvscb2(des,lf,v)
design *des;
lfit *lf;
int v;
{ double sd, *lo, *hi, u;
int err, st, tmp;
x = des->xev = evpt(&lf->fp,v);
tmp = haspc(&lf->pc);
/* if ((ker(&lf->sp)==WPARM) && (haspc(&lf->pc)))
{ lf->coef[v] = thhat = addparcomp(lf,des->xev,PCOEF);
lf->nlx[v] = lf->t0[v] = sd = addparcomp(lf,des->xev,PNLX);
}
else */
{ haspc(&lf->pc) = 0;
st = procv(des,lf,v);
//thhat = lf->fp.coef[v];
sd = lf->fp.nlx[v];
}
if ((type==GLM2) | (type==GLM3) | (type==GLM4))
{ if (ker(&lf->sp) != WPARM)
WARN(("nonparametric fit; correction is invalid"));
cumulant(lf,des,sd);
}
haspc(&lf->pc) = tmp;
lo = lf->fp.L;
hi = &lo[lf->fp.nvm];
switch(type)
{
case GLM1:
return(st);
case GLM2: /* centered scr */
lo[v] = kap[1];
hi[v] = sqrt(kap[2]);
return(st);
case GLM3: /* corrected 2 */
lo[v] = solve_secant(q2,scb_crit,0.0,2*scb_crit,0.000001,BDF_NONE,&err);
return(st);
case GLM4: /* corrected 2' */
u = fabs(p2(scb_crit));
max_p2 = MAX(max_p2,u);
return(st);
case GLDN:
get_gldn(&lf->fp,des,lo,hi,v);
return(st);
}
ERROR(("procvscb2: invalid type"));
return(st);
}
void scb(des,lf)
design *des;
lfit *lf;
{ double k1, k2; /* kap[10], */
double *lo, *hi, sig, thhat, nlx;
int i, nterms;
scb_des= des;
npar(&lf->sp) = calcp(&lf->sp,lf->lfd.d);
des_init(des,lf->lfd.n,npar(&lf->sp));
link(&lf->sp) = defaultlink(link(&lf->sp),fam(&lf->sp));
type = geth(&lf->fp);
if (type >= 80) /* simultaneous */
{
nterms = constants(des,lf);
scb_crit = critval(0.05,lf->fp.kap,nterms,lf->lfd.d,TWO_SIDED,0.0,GAUSS);
type -= 10;
}
else /* pointwise */
{ lf->fp.kap[0] = 1;
scb_crit = critval(0.05,lf->fp.kap,1,lf->lfd.d,TWO_SIDED,0.0,GAUSS);
}
max_p2 = 0.0;
startlf(des,lf,procvscb2,0);
if ((fam(&lf->sp)&64)==64)
{ i = haspc(&lf->pc); haspc(&lf->pc) = 0;
ressumm(lf,des);
haspc(&lf->pc) = i;
sig = sqrt(rv(&lf->fp));
}
else sig = 1.0;
lo = lf->fp.L;
hi = &lo[lf->fp.nvm];
for (i=0; ifp.nv; i++)
{ thhat = lf->fp.coef[i];
nlx = lf->fp.nlx[i];
switch(type)
{
case GLM1: /* basic scb */
lo[i] = thhat - scb_crit * sig * nlx;
hi[i] = thhat + scb_crit * sig * nlx;
break;
case GLM2:
k1 = lo[i];
k2 = hi[i];
lo[i] = thhat - k1*nlx - scb_crit*nlx*k2;
hi[i] = thhat - k1*nlx + scb_crit*nlx*k2;
break;
case GLM3:
k1 = lo[i];
lo[i] = thhat - k1*nlx;
hi[i] = thhat + k1*nlx;
case GLM4: /* corrected 2' */
lo[i] = thhat - (scb_crit-max_p2)*lf->fp.nlx[i];
hi[i] = thhat + (scb_crit-max_p2)*lf->fp.nlx[i];
break;
case GLDN:
break;
}
}
}
locfit/src/m_solve.c 0000744 0001760 0000144 00000006041 12134436032 014161 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
* solve f(x)=c by various methods, with varying stability etc...
* xlo and xhi should be initial bounds for the solution.
* convergence criterion is |f(x)-c| < tol.
*
* double solve_secant(f,c,xlo,xhi,tol,bd_flag,err)
* secant method solution of f(x)=c.
* xlo and xhi are starting values and bound for solution.
* tol = convergence criterion, |f(x)-c| < tol.
* bd_flag = if (xlo,xhi) doesn't bound a solution, what action to take?
* BDF_NONE returns error.
* BDF_EXPRIGHT increases xhi.
* BDF_EXPLEFT decreases xlo.
* err = error flag.
* The (xlo,xhi) bound is not formally necessary for the secant method.
* But having such a bound vastly improves stability; the code performs
* a bisection step whenever the iterations run outside the bounds.
*
* double solve_nr(f,f1,c,x0,tol,err)
* Newton-Raphson solution of f(x)=c.
* f1 = f'(x).
* x0 = starting value.
* tol = convergence criteria, |f(x)-c| < tol.
* err = error flag.
* No stability checks at present.
*
* double solve_fp(f,x0,tol)
* fixed-point iteration to solve f(x)=x.
* x0 = starting value.
* tol = convergence criteria, stops when |f(x)-x| < tol.
* Convergence requires |f'(x)|<1 in neighborhood of true solution;
* f'(x) \approx 0 gives the fastest convergence.
* No stability checks at present.
*
* TODO: additional error checking, non-convergence stop.
*/
#include
#include
#include
#include "mutil.h"
double solve_secant(f,c,xlo,xhi,tol,bd_flag,err)
double (*f)(), c, xhi, xlo, tol;
int bd_flag, *err;
{ double ylo, yhi, x1, x2, x, y1, y2, y;
*err = 0;
ylo = f(xlo)-c;
yhi = f(xhi)-c;
switch(bd_flag)
{ case BDF_EXPRIGHT:
while (yhi*ylo > 0)
{ x1 = xhi + (xhi-xlo);
y1 = f(x1) - c;
xlo = xhi; xhi = x1;
ylo = yhi; yhi = y1;
}
break;
case BDF_EXPLEFT:
while (yhi*ylo > 0)
{ x1 = xlo - (xhi-xlo);
y1 = f(x1) - c;
xhi = xlo; xlo = x1;
yhi = ylo; ylo = y1;
}
break;
case BDF_NONE:
default:
if (yhi*ylo > 0)
{ *err = 1;
return((xlo+xhi)/2);
}
break;
}
x1 = xlo; y1 = ylo;
x2 = xhi; y2 = yhi;
while (1)
{ x = x2 + (x1-x2)*y2/(y2-y1);
if ((x<=xlo) | (x>=xhi)) x = (xlo+xhi)/2;
y = f(x)-c;
if (fabs(y) < tol) return(x);
if (y*ylo>0) { xlo = x; ylo = y; }
else { xhi = x; yhi = y; }
if (y2==y)
{ Rprintf("secant: y2 %12.9f\n",y2);
return(x);
}
x1 = x2; y1 = y2;
x2 = x; y2 = y;
}
}
double solve_nr(f,f1,c,x0,tol,err)
double (*f)(), (*f1)(), c, x0, tol;
int *err;
{ double y;
do
{ y = f(x0)-c;
x0 -= y/f1(x0);
} while (fabs(y)>tol);
return(x0);
}
double solve_fp(f,x0,tol,maxit)
double (*f)(), x0, tol;
int maxit;
{ double x1=0.0;
int i;
for (i=0; id;
p = des->p; m = des->n;
if (lf_debug>1) printf(" Correcting derivatives\n");
fitfun(lfd, sp, des->xev,des->xev,des->f1,NULL);
jacob_solve(&des->xtwx,des->f1);
setzero(dc,d);
/* correction term is e1^T (XTWVX)^{-1} XTW' ldot. */
for (i=0; if1,&des->X[i*p],p);
ii = des->ind[i];
stdlinks(link,lfd,sp,ii,des->th[i],robscale);
for (j=0; jw[i]*weightd(datum(lfd,j,ii)-des->xev[j],lfd->sca[j],
d,ker(sp),kt(sp),des->h,lfd->sty[j],des->di[ii]);
dc[j] += s1*wd*link[ZDLL];
}
}
for (j=0; j6) ? ptail(-z) : exp(-z*z/2)/pz)/2.5066283;
res[ZLIK] = w*log(pz);
res[ZDLL] = w*dp;
res[ZDDLL]= w*dp*(dp-z);
return(LF_OK);
}
res[ZLIK] = -w*z*z/2;
switch(link)
{ case LIDENT:
res[ZDLL] = w*z;
res[ZDDLL]= w;
break;
case LLOG:
res[ZDLL] = w*z*mean;
res[ZDDLL]= w*mean*mean;
break;
case LLOGIT:
res[ZDLL] = w*z*mean*(1-mean);
res[ZDDLL]= w*mean*mean*(1-mean)*(1-mean);
break;
default:
ERROR(("Invalid link for Gaussian family"));
return(LF_LNK);
}
return(LF_OK);
}
int famrobu(y,mean,th,link,res,cens,w,rs)
double y, mean, th, *res, w, rs;
int link, cens;
{ double z, sw;
if (link==LINIT)
{ res[ZDLL] = w*y;
return(LF_OK);
}
sw = (w==1.0) ? 1.0 : sqrt(w); /* don't want unnecess. sqrt! */
z = sw*(y-mean)/rs;
res[ZLIK] = (fabs(z) HUBERC)
{ res[ZDLL] = sw*HUBERC/rs;
res[ZDDLL]= 0.0;
return(LF_OK);
}
res[ZDLL] = sw*z/rs;
res[ZDDLL] = w/(rs*rs);
return(LF_OK);
}
int famcauc(y,p,th,link,res,cens,w,rs)
double y, p, th, *res, w, rs;
int link, cens;
{ double z;
if (link!=LIDENT)
{ ERROR(("Invalid link in famcauc"));
return(LF_LNK);
}
z = w*(y-th)/rs;
res[ZLIK] = -log(1+z*z);
res[ZDLL] = 2*w*z/(rs*(1+z*z));
res[ZDDLL] = 2*w*w*(1-z*z)/(rs*rs*(1+z*z)*(1+z*z));
return(LF_OK);
}
int famrbin(y,p,th,link,res,cens,w)
double y, p, th, *res, w;
int link, cens;
{ double s2y;
if (link==LINIT)
{ res[ZDLL] = y;
return(LF_OK);
}
if ((y<0) | (y>w)) /* goon observation; delete it */
{ res[ZLIK] = res[ZDLL] = res[ZDDLL] = 0.0;
return(LF_OK);
}
res[ZLIK] = (th<0) ? th*y-w*log(1+exp(th)) : th*(y-w)-w*log(1+exp(-th));
if (y>0) res[ZLIK] -= y*log(y/w);
if (yHUBERC*HUBERC/2.0)
{ s2y = sqrt(-2*res[ZLIK]);
res[ZLIK] = HUBERC*(HUBERC/2.0-s2y);
res[ZDLL] *= HUBERC/s2y;
res[ZDDLL] = HUBERC/s2y*(res[ZDDLL]-1/(s2y*s2y)*w*p*(1-p));
}
return(LF_OK);
}
int fambino(y,p,th,link,res,cens,w)
double y, p, th, *res, w;
int link, cens;
{ double wp;
if (link==LINIT)
{ if (y<0) y = 0;
if (y>w) y = w;
res[ZDLL] = y;
return(LF_OK);
}
wp = w*p;
if (link==LIDENT)
{ if ((p<=0) && (y>0)) return(LF_BADP);
if ((p>=1) && (y0)
{ res[ZLIK] += y*log(wp/y);
res[ZDLL] += y/p;
res[ZDDLL]+= y/(p*p);
}
if (yw)) /* goon observation; delete it */
{ res[ZLIK] = res[ZDLL] = res[ZDDLL] = 0.0;
return(LF_OK);
}
res[ZLIK] = (th<0) ? th*y-w*log(1+exp(th)) : th*(y-w)-w*log(1+exp(-th));
if (y>0) res[ZLIK] -= y*log(y/w);
if (y0)) return(LF_BADP);
if ((p>=1) && (yPI/2)) return(LF_BADP);
res[ZDLL] = res[ZDDLL] = res[ZLIK] = 0;
if (y>0)
{ res[ZDLL] += 2*y*sqrt((1-p)/p);
res[ZLIK] += y*log(wp/y);
}
if (y0) res[ZLIK] += y*(th-log(y/w));
res[ZDDLL] = wmu;
return(LF_OK);
}
if (link==LIDENT)
{ if ((mean<=0) && (y>0)) return(LF_BADP);
res[ZLIK] = y-wmu;
res[ZDLL] = -w;
res[ZDDLL] = 0;
if (y>0)
{ res[ZLIK] += y*log(wmu/y);
res[ZDLL] += y/mean;
res[ZDDLL]= y/(mean*mean);
}
return(LF_OK);
}
if (link==LSQRT)
{ if ((mean<=0) && (y>0)) return(LF_BADP);
res[ZLIK] = y-wmu;
res[ZDLL] = -2*w*th;
res[ZDDLL]= 2*w;
if (y>0)
{ res[ZLIK] += y*log(wmu/y);
res[ZDLL] += 2*y/th;
res[ZDDLL]+= 2*y/mean;
}
return(LF_OK);
}
ERROR(("link %d invalid for Poisson family",link));
return(LF_LNK);
}
int famgamm(y,mean,th,link,res,cens,w)
double y, mean, th, *res, w;
int link, cens;
{ double pt, dg;
if (link==LINIT)
{ res[ZDLL] = MAX(y,0.0);
return(LF_OK);
}
if ((mean<=0) & (y>0)) return(LF_BADP);
if (cens)
{ if (y<=0)
{ res[ZLIK] = res[ZDLL] = res[ZDDLL] = 0.0;
return(LF_OK);
}
if (link==LLOG)
{ pt = 1-igamma(y/mean,w);
dg = exp((w-1)*log(y/mean)-y/mean-LGAMMA(w));
res[ZLIK] = log(pt);
res[ZDLL] = y*dg/(mean*pt);
res[ZDDLL]= dg*(w*y/mean-y*y/(mean*mean))/pt+SQR(res[ZDLL]);
return(LF_OK);
}
if (link==LINVER)
{ pt = 1-igamma(th*y,w);
dg = exp((w-1)*log(th*y)-th*y-LGAMMA(w));
res[ZLIK] = log(pt);
res[ZDLL] = -y*dg/pt;
res[ZDDLL]= dg*y*((w-1)*mean-y)/pt+SQR(res[ZDLL]);
return(LF_OK);
}
}
else
{ if (y<0) WARN(("Negative Gamma observation"));
if (link==LLOG)
{ res[ZLIK] = -y/mean+w*(1-th);
if (y>0) res[ZLIK] += w*log(y/w);
res[ZDLL] = y/mean-w;
res[ZDDLL]= y/mean;
return(LF_OK);
}
if (link==LINVER)
{ res[ZLIK] = -y/mean+w-w*log(mean);
if (y>0) res[ZLIK] += w*log(y/w);
res[ZDLL] = -y+w*mean;
res[ZDDLL]= w*mean*mean;
return(LF_OK);
}
if (link==LIDENT)
{ res[ZLIK] = -y/mean+w-w*log(mean);
if (y>0) res[ZLIK] += w*log(y/w);
res[ZDLL] = (y-mean)/(mean*mean);
res[ZDDLL]= w/(mean*mean);
return(LF_OK);
}
}
ERROR(("link %d invalid for Gamma family",link));
return(LF_LNK);
}
int famgeom(y,mean,th,link,res,cens,w)
double y, mean, th, *res, w;
int link, cens;
{ double p, pt, dp, dq;
if (link==LINIT)
{ res[ZDLL] = MAX(y,0.0);
return(LF_OK);
}
p = 1/(1+mean);
if (cens) /* censored observation */
{ if (y<=0)
{ res[ZLIK] = res[ZDLL] = res[ZDDLL] = 0;
return(LF_OK);
}
pt = 1-ibeta(p,w,y);
dp = -exp(LGAMMA(w+y)-LGAMMA(w)-LGAMMA(y)+(y-1)*th+(w+y-2)*log(p))/pt;
dq = ((w-1)/p-(y-1)/(1-p))*dp;
res[ZLIK] = log(pt);
res[ZDLL] = -dp*p*(1-p);
res[ZDDLL]= (dq-dp*dp)*p*p*(1-p)*(1-p)+dp*(1-2*p)*p*(1-p);
res[ZDDLL]= -res[ZDDLL];
return(LF_OK);
}
else
{ res[ZLIK] = (y+w)*log((y/w+1)/(mean+1));
if (y>0) res[ZLIK] += y*log(w*mean/y);
if (link==LLOG)
{ res[ZDLL] = (y-w*mean)*p;
res[ZDDLL]= (y+w)*p*(1-p);
return(LF_OK);
}
if (link==LIDENT)
{ res[ZDLL] = (y-w*mean)/(mean*(1+mean));
res[ZDDLL]= w/(mean*(1+mean));
return(LF_OK);
}
}
ERROR(("link %d invalid for geometric family",link));
return(LF_LNK);
}
int famweib(y,mean,th,link,res,cens,w)
double y, mean, th, *res, w;
int link, cens;
{ double yy;
yy = pow(y,w);
if (link==LINIT)
{ res[ZDLL] = MAX(yy,0.0);
return(LF_OK);
}
if (cens)
{ res[ZLIK] = -yy/mean;
res[ZDLL] = res[ZDDLL] = yy/mean;
return(LF_OK);
}
res[ZLIK] = 1-yy/mean-th;
if (yy>0) res[ZLIK] += log(w*yy);
res[ZDLL] = -1+yy/mean;
res[ZDDLL]= yy/mean;
return(LF_OK);
}
int famcirc(y,mean,th,link,res,cens,w)
double y, mean, th, *res, w;
int link, cens;
{ if (link==LINIT)
{ res[ZDLL] = w*sin(y);
res[ZLIK] = w*cos(y);
return(LF_OK);
}
res[ZDLL] = w*sin(y-mean);
res[ZDDLL]= w*cos(y-mean);
res[ZLIK] = res[ZDDLL]-w;
return(LF_OK);
}
/*
void robustify(res,rs)
double *res, rs;
{ double sc, z;
sc = rs*HUBERC;
if (res[ZLIK] > -sc*sc/2) return;
z = sqrt(-2*res[ZLIK]);
res[ZDDLL]= -sc*res[ZDLL]*res[ZDLL]/(z*z*z)+sc*res[ZDDLL]/z;
res[ZDLL]*= sc/z;
res[ZLIK] = sc*sc/2-sc*z;
}
*/
void robustify(res,rs)
double *res, rs;
{ double sc, z;
sc = rs*HUBERC;
if (res[ZLIK] > -sc*sc/2)
{ res[ZLIK] /= sc*sc;
res[ZDLL] /= sc*sc;
res[ZDDLL] /= sc*sc;
return;
}
z = sqrt(-2*res[ZLIK]);
res[ZDDLL]= (-sc*res[ZDLL]*res[ZDLL]/(z*z*z)+sc*res[ZDDLL]/z)/(sc*sc);
res[ZDLL]*= 1.0/(z*sc);
res[ZLIK] = 0.5-z/sc;
}
double lf_link(y,lin)
double y;
int lin;
{ switch(lin)
{ case LIDENT: return(y);
case LLOG: return(log(y));
case LLOGIT: return(logit(y));
case LINVER: return(1/y);
case LSQRT: return(sqrt(fabs(y)));
case LASIN: return(asin(sqrt(y)));
}
ERROR(("link: unknown link %d",lin));
return(0.0);
}
double invlink(th,lin)
double th;
int lin;
{ switch(lin)
{ case LIDENT: return(th);
case LLOG: return(lf_exp(th));
case LLOGIT: return(expit(th));
case LINVER: return(1/th);
case LSQRT: return(th*fabs(th));
case LASIN: return(sin(th)*sin(th));
case LINIT: return(0.0);
}
ERROR(("invlink: unknown link %d",lin));
return(0.0);
}
/* the link and various related functions */
int links(th,y,fam,link,res,c,w,rs)
double th, y, *res, w, rs;
int fam, link, c;
{ double mean;
int st;
mean = res[ZMEAN] = invlink(th,link);
if (lf_error) return(LF_LNK);
switch(fam&63)
{ case THAZ:
case TDEN:
case TRAT: return(famdens(mean,th,link,res,c,w));
case TGAUS: st = famgaus(y,mean,th,link,res,c,w);
break;
case TLOGT: st = fambino(y,mean,th,link,res,c,w);
break;
case TRBIN: return(famrbin(y,mean,th,link,res,c,w));
case TPROB:
case TPOIS: st = fampois(y,mean,th,link,res,c,w);
break;
case TGAMM: st = famgamm(y,mean,th,link,res,c,w);
break;
case TGEOM: st = famgeom(y,mean,th,link,res,c,w);
break;
case TWEIB: return(famweib(y,mean,th,link,res,c,w));
case TCIRC: st = famcirc(y,mean,th,link,res,c,w);
break;
case TROBT: return(famrobu(y,mean,th,link,res,c,w,rs));
case TCAUC: return(famcauc(y,mean,th,link,res,c,w,rs));
default:
ERROR(("links: invalid family %d",fam));
return(LF_FAM);
}
if (st!=LF_OK) return(st);
if (link==LINIT) return(st);
if ((fam&128)==128) robustify(res,rs);
return(st);
}
/*
stdlinks is a version of links when family, link, response e.t.c
all come from the standard places.
*/
int stdlinks(res,lfd,sp,i,th,rs)
lfdata *lfd;
smpar *sp;
double th, rs, *res;
int i;
{ return(links(th,resp(lfd,i),fam(sp),link(sp),res,cens(lfd,i),prwt(lfd,i),rs));
}
/*
* functions used in variance, skewness, kurtosis calculations
* in scb corrections.
*/
double b2(th,tg,w)
double th, w;
int tg;
{ double y;
switch(tg&63)
{ case TGAUS: return(w);
case TPOIS: return(w*lf_exp(th));
case TLOGT:
y = expit(th);
return(w*y*(1-y));
}
ERROR(("b2: invalid family %d",tg));
return(0.0);
}
double b3(th,tg,w)
double th, w;
int tg;
{ double y;
switch(tg&63)
{ case TGAUS: return(0.0);
case TPOIS: return(w*lf_exp(th));
case TLOGT:
y = expit(th);
return(w*y*(1-y)*(1-2*y));
}
ERROR(("b3: invalid family %d",tg));
return(0.0);
}
double b4(th,tg,w)
double th, w;
int tg;
{ double y;
switch(tg&63)
{ case TGAUS: return(0.0);
case TPOIS: return(w*lf_exp(th));
case TLOGT:
y = expit(th); y = y*(1-y);
return(w*y*(1-6*y));
}
ERROR(("b4: invalid family %d",tg));
return(0.0);
}
locfit/src/mutil.h 0000744 0001760 0000144 00000005200 12134436032 013650 0 ustar ripley users /*
* Copyright (c) 1998-2000 Lucent Technologies.
* See README file for details.
*
*
* Headers for math utility functions.
*/
#ifndef I_MUT_H
#define I_MUT_H
#include
typedef struct {
double *Z; /* jacobian matrix, length p*p */
double *Q; /* eigenvalue matrix, length p*p */
double *wk; /* work vector in eig_solve, length p */
double *dg; /* diag vector in eigd, length p */
int p; /* dimension */
int st; /* status */
int sm; /* requested decomposition */
} jacobian;
/* m_jacob.c */
extern int jac_reqd();
extern double *jac_alloc();
extern void jacob_dec(), chol_dec(), eig_dec();
extern int jacob_solve(), chol_solve(), eig_solve();
extern int jacob_hsolve(),chol_hsolve(),eig_hsolve();
extern double jacob_qf(), chol_qf(), eig_qf();
/* m_max.c */
extern double max_grid(), max_golden(), max_quad(), max_nr();
/* m_qr.c */
extern void qr(), qrinvx(), qrtinvx(), qrsolv();
/* m_svd.c */
extern void svd(), hsvdsolve();
extern int svdsolve();
/* m_solve.c */
extern double solve_secant(), solve_nr(), solve_fp();
/* m_vector.c */
extern void setzero(), unitvec(), addouter(), multmatscal(), transpose();
extern double innerprod(), m_trace();
#define BDF_NONE 0
#define BDF_EXPLEFT 1
#define BDF_EXPRIGHT 2
/* return codes for functions optimized by max_nr */
#define NR_OK 0
#define NR_INVALID 1
#define NR_BREAK 2
#define NR_REDUCE 3
#define NR_NCON 10
#define NR_NDIV 11
/* jacobian status definitions */
#define JAC_RAW 0
#define JAC_CHOL 1
#define JAC_EIG 2
#define JAC_EIGD 3
/* Numerical Integration Stuff
*/
#define MXRESULT 5
#define MXIDIM 10 /* max. dimension */
extern void simpsonm(), simpson4(), integ_disc(), integ_circ();
extern void integ_sphere(), monte(), rn3();
extern double simpson(), sptarea();
/* Density, distribution stuff
*/
#ifndef PI
#define PI 3.141592653589793238462643
#endif
#define PIx2 6.283185307179586476925286 /* 2*pi */
#define HF_LG_PIx2 0.918938533204672741780329736406 /* 0.5*log(2*pi) */
#define SQRT2 1.4142135623730950488
#define LOG_ZERO -1e100
#define D_0 ((give_log) ? LOG_ZERO : 0.0)
#define D_1 ((give_log) ? 0.0 : 1.0)
#define DEXP(x) ((give_log) ? (x) : exp(x))
#define FEXP(f,x) ((give_log) ? -0.5*log(f)+(x) : exp(x)/sqrt(f))
#define INVALID_PARAMS 0.0
extern double stirlerr(), bd0();
extern double dbinom_raw(), dpois_raw();
extern double dbinom(), dpois(), dnbinom(), dbeta(), dgamma(), dt(), df(), dhyper();
extern double dchisq();
extern double igamma(), ibeta();
extern double pf(), pchisq(), mut_pnorm();
#define pchisq(x,df) igamma((x)/2.0,(df)/2.0)
#endif /* define I_MUT_H */
locfit/src/ev_atree.c 0000744 0001760 0000144 00000011720 12134436032 014307 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
* This file contains functions for constructing and
* interpolating the adaptive tree structure. This is
* the default evaluation structure used by Locfit.
*/
#include "local.h"
/*
Guess the number of fitting points.
Needs improving!
*/
void atree_guessnv(evs,nvm,ncm,vc,d,alp)
evstruc *evs;
double alp;
int *nvm, *ncm, *vc, d;
{ double a0, cu, ifl;
int i, nv, nc;
*ncm = 1<<30; *nvm = 1<<30;
*vc = 1 << d;
if (alp>0)
{ a0 = (alp > 1) ? 1 : 1/alp;
if (cut(evs)<0.01)
{ WARN(("guessnv: cut too small."));
cut(evs) = 0.01;
}
cu = 1;
for (i=0; ifp.d; vc = 1<fp.h[ce[i]];
if ((h>0) && ((hmin==0)|(hlfd.sca[i];
if ((lf->lfd.sty[i]==STCPAR) || (hmin==0))
score[i] = 2*(ur[i]-ll[i])/(lf->evs.fl[i+d]-lf->evs.fl[i]);
else
score[i] = le[i]/hmin;
if (score[i]>score[is]) is = i;
}
if (cut(&lf->evs)fp.d; vc = 1<lfd.sty[i]!=STCPAR) &&
(le[ns] < (cut(&lf->evs)*MIN(lf->fp.h[i0],lf->fp.h[i1])));
nce[i] = newsplit(des,lf,i0,i1,pv);
if (lf_error) return;
}
}
z = ur[ns]; ur[ns] = (z+ll[ns])/2;
atree_grow(des,lf,nce,ct,term,ll,ur);
if (lf_error) return;
ur[ns] = z;
for (i=0; i1) printf(" In atree_start\n");
d = lf->fp.d;
atree_guessnv(&lf->evs,&nvm,&ncm,&vc,d,nn(&lf->sp));
if (lf_debug>2) printf(" atree_start: nvm %d ncm %d\n",nvm,ncm);
trchck(lf,nvm,ncm,vc);
/* Set the lower left, upper right limits. */
for (j=0; jevs.fl[j];
ur[j] = lf->evs.fl[j+d];
}
/* Set the initial cell; fit at the vertices. */
for (i=0; ifp,i,k) = (j%2) ? ur[k] : ll[k];
j >>= 1;
}
lf->evs.ce[i] = i;
des->vfun(des,lf,i);
if (lf_error) return;
lf->evs.s[i] = 0;
}
lf->fp.nv = vc;
/* build the tree */
atree_grow(des,lf,lf->evs.ce,NULL,NULL,ll,ur);
lf->evs.nce = 1;
}
double atree_int(lf,x,what)
lfit *lf;
double *x;
int what;
{ double vv[64][64], *ll, *ur, h, xx[MXDIM];
int lo, tk, ns, nv, nc=0, d, i, vc;
Sint ce[64];
fitpt *fp;
evstruc *evs;
fp = &lf->fp;
evs= &lf->evs;
d = fp->d;
vc = 1<ce[i];
}
ns = 0;
while(ns!=-1)
{ ll = evpt(fp,ce[0]); ur = evpt(fp,ce[vc-1]);
ns = atree_split(lf,ce,xx,ll,ur);
if (ns!=-1)
{ tk = 1<s[nv]) exvvalpv(vv[i+tk],vv[i],vv[i+tk],d,ns,h,nc);
else exvval(fp,vv[i+tk],nv,d,what,1);
}
else
{ ce[i] = nv;
if (evs->s[nv]) exvvalpv(vv[i],vv[i],vv[i+tk],d,ns,h,nc);
else exvval(fp,vv[i],nv,d,what,1);
} }
} }
ll = evpt(fp,ce[0]); ur = evpt(fp,ce[vc-1]);
return(rectcell_interp(x,vv,ll,ur,d,nc));
}
locfit/src/dens_haz.c 0000744 0001760 0000144 00000011655 12134436032 014317 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
*
* Integration for hazard rate estimation. The functions in this
* file are used to evaluate
* sum int_0^{Ti} W_i(t,x) A()A()' exp( P() ) dt
* for hazard rate models.
*
* These routines assume the weight function is supported on [-1,1].
* hasint_sph multiplies by exp(base(lf,i)), which allows estimating
* the baseline in a proportional hazards model, when the covariate
* effect base(lf,i) is known.
*
* TODO:
* hazint_sph, should be able to reduce mint in some cases with
* small integration range. onedint could be used for beta-family
* (RECT,EPAN,BISQ,TRWT) kernels.
* hazint_prod, restrict terms from the sum based on x values.
* I should count obs >= max, and only do that integration once.
*/
#include "local.h"
static double ilim[2*MXDIM], *ff, tmax;
static lfdata *haz_lfd;
static smpar *haz_sp;
/*
* hrao returns 0 if integration region is empty.
* 1 otherwise.
*/
int haz_sph_int(dfx,cf,h,r1)
double *dfx, *cf, h, *r1;
{ double s, t0, t1, wt, th;
int j, dim, p;
s = 0; p = npar(haz_sp);
dim = haz_lfd->d;
for (j=1; jsca[j]));
if (s>1) return(0);
setzero(r1,p*p);
t1 = sqrt(1-s)*h*haz_lfd->sca[0];
t0 = -t1;
if (t0ilim[dim]) t1 = ilim[dim];
if (t1>dfx[0]) t1 = dfx[0];
if (t1n;
for (i=0; i<=n; i++)
{
if (i==n)
{ dfx[0] = tmax-t[0];
for (j=1; jd; j++) dfx[j] = 0.0;
eb = exp(sb/n);
}
else
{ eb = exp(base(haz_lfd,i)); sb += base(haz_lfd,i);
for (j=0; jd; j++) dfx[j] = datum(haz_lfd,j,i)-t[j];
}
st = haz_sph_int(dfx,cf,h,r1);
if (st)
for (j=0; jd;
setzero(resp,p*p);
hj = hs = h*haz_lfd->sca[0];
ncf[0] = cf[0];
for (i=1; i<=deg(haz_sp); i++)
{ ncf[i] = hj*cf[(i-1)*d+1]; hj *= hs;
}
/* for i=0..n....
* First we compute prod_wk[j], j=0..d.
* For j=0, this is int_0^T_i (u-t)^k W((u-t)/h) exp(b0*(u-t)) du
* For remaining j, (x(i,j)-x(j))^k Wj exp(bj*(x..-x.))
*
* Second, we add to the integration (exp(a) incl. in integral)
* with the right factorial denominators.
*/
t_prev = ilim[0]; sb = 0.0;
for (i=0; i<=haz_lfd->n; i++)
{ if (i==haz_lfd->n)
{ dfx[0] = tmax-t[0];
for (j=1; jn);
}
else
{ eb = exp(base(haz_lfd,i)); sb += base(haz_lfd,i);
for (j=0; jilim[0]) /* else it doesn't contribute */
{
/* time integral */
il1 = (dfx[0]>ilim[d]) ? ilim[d] : dfx[0];
if (il1 != t_prev) /* don't repeat! */
{ st = onedint(haz_sp,ncf,ilim[0]/hs,il1/hs,prod_wk[0]);
if (st>0) return(st);
hj = eb;
for (j=0; j<=2*deg(haz_sp); j++)
{ hj *= hs;
prod_wk[0][j] *= hj;
}
t_prev = il1;
}
/* covariate terms */
for (j=1; j0; k--) ef = (ef+dfx[j])*cf[1+(k-1)*d+j];
ef = exp(ef);
prod_wk[j][0] = ef * W(dfx[j]/(h*haz_lfd->sca[j]),ker(haz_sp));
for (k=1; k<=2*deg(haz_sp); k++)
prod_wk[j][k] = prod_wk[j][k-1] * dfx[j];
}
/* add to the integration. */
prodintresp(resp,prod_wk,d,deg(haz_sp),p);
} /* if dfx0 > ilim0 */
} /* n loop */
/* symmetrize */
for (k=0; kd==1) return(hazint_prod(t,resp,resp1,cf,h));
if (kt(haz_sp)==KPROD) return(hazint_prod(t,resp,resp1,cf,h));
return(hazint_sph(t,resp,resp1,cf,h));
}
void haz_init(lfd,des,sp,il)
lfdata *lfd;
design *des;
smpar *sp;
double *il;
{ int i;
haz_lfd = lfd;
haz_sp = sp;
tmax = datum(lfd,0,0);
for (i=1; in; i++) tmax = MAX(tmax,datum(lfd,0,i));
ff = des->xtwx.wk;
for (i=0; i<2*lfd->d; i++) ilim[i] = il[i];
}
locfit/src/lf_wdiag.c 0000744 0001760 0000144 00000013667 12134436032 014305 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
* Routines for computing weight diagrams.
* wdiag(lf,des,lx,deg,ty,exp)
* Must locfit() first, unless ker==WPARM and has par. comp.
*
*/
#include "local.h"
static double *wd;
extern double robscale;
void nnresproj(lfd,sp,des,u,m,p)
lfdata *lfd;
smpar *sp;
design *des;
double *u;
int m, p;
{ int i, j;
double link[LLEN];
setzero(des->f1,p);
for (j=0; jind[j],des->th[j],robscale);
for (i=0; if1[i] += link[ZDDLL]*d_xij(des,j,i)*u[j];
}
jacob_solve(&des->xtwx,des->f1);
for (i=0; if1,d_xi(des,i),p)*des->w[i];
}
void wdexpand(l,n,ind,m)
double *l;
Sint *ind;
int n, m;
{ int i, j, t;
double z;
for (j=m; j=0)
{ if (ind[j]==j) j--;
else
{ i = ind[j];
z = l[j]; l[j] = l[i]; l[i] = z;
t = ind[j]; ind[j] = ind[i]; ind[i] = t;
if (ind[j]==-1) j--;
}
}
/* for (i=n-1; i>=0; i--)
{ l[i] = ((j>=0) && (ind[j]==i)) ? l[j--] : 0.0; } */
}
int wdiagp(lfd,sp,des,lx,pc,dv,deg,ty,exp)
lfdata *lfd;
smpar *sp;
design *des;
paramcomp *pc;
deriv *dv;
double *lx;
int deg, ty, exp;
{ int i, j, p, nd;
double *l1;
p = des->p;
fitfun(lfd,sp,des->xev,pc->xbar,des->f1,dv);
if (exp)
{ jacob_solve(&pc->xtwx,des->f1);
for (i=0; in; i++)
lx[i] = innerprod(des->f1,d_xi(des,i),p);
return(lfd->n);
}
jacob_hsolve(&pc->xtwx,des->f1);
for (i=0; if1[i];
nd = dv->nd;
dv->nd = nd+1;
if (deg>=1)
for (i=0; id; i++)
{ dv->deriv[nd] = i;
l1 = &lx[(i+1)*p];
fitfun(lfd,sp,des->xev,pc->xbar,l1,dv);
jacob_hsolve(&pc->xtwx,l1);
}
dv->nd = nd+2;
if (deg>=2)
for (i=0; id; i++)
{ dv->deriv[nd] = i;
for (j=0; jd; j++)
{ dv->deriv[nd+1] = j;
l1 = &lx[(i*lfd->d+j+lfd->d+1)*p];
fitfun(lfd,sp,des->xev,pc->xbar,l1,dv);
jacob_hsolve(&pc->xtwx,l1);
} }
dv->nd = nd;
return(p);
}
int wdiag(lfd,sp,des,lx,dv,deg,ty,exp)
lfdata *lfd;
smpar *sp;
design *des;
deriv *dv;
double *lx;
int deg, ty, exp;
/* deg=0: l(x) only.
deg=1: l(x), l'(x)
deg=2: l(x), l'(x), l''(x)
ty = 1: e1 (X^T WVX)^{-1} X^T W -- hat matrix
ty = 2: e1 (X^T WVX)^{-1} X^T WV^{1/2} -- scb's
*/
{ double w, *X, *lxd=NULL, *lxdd=NULL, wdd, wdw, *ulx, link[LLEN], h;
double dfx[MXDIM], hs[MXDIM];
int i, ii, j, k, l, m, d, p, nd;
h = des->h;
nd = dv->nd;
wd = des->wd;
d = lfd->d; p = des->p; X = d_x(des);
ulx = des->res;
m = des->n;
for (i=0; isca[i];
if (deg>0)
{ lxd = &lx[m];
setzero(lxd,m*d);
if (deg>1)
{ lxdd = &lxd[d*m];
setzero(lxdd,m*d*d);
} }
if (nd>0) fitfun(lfd,sp,des->xev,des->xev,des->f1,dv); /* c(0) */
else unitvec(des->f1,0,p);
jacob_solve(&des->xtwx,des->f1); /* c(0) (X^TWX)^{-1} */
for (i=0; iind[i];
lx[i] = innerprod(des->f1,&X[i*p],p); /* c(0)(XTWX)^{-1}X^T */
if (deg>0)
{ wd[i] = Wd(des->di[ii]/h,ker(sp));
for (j=0; jxev[j];
lxd[j*m+i] = lx[i]*des->w[i]*weightd(dfx[j],lfd->sca[j],
d,ker(sp),kt(sp),h,lfd->sty[j],des->di[ii]);
/* c(0) (XTWX)^{-1}XTW' */
}
if (deg>1)
{ wdd = Wdd(des->di[ii]/h,ker(sp));
for (j=0; jdi[ii]==0) ? 0 : h/des->di[ii];
w = wdd * (des->xev[k]-datum(lfd,k,ii)) * (des->xev[j]-datum(lfd,j,ii))
* w*w / (hs[k]*hs[k]*hs[j]*hs[j]);
if (j==k) w += wd[i]/(hs[j]*hs[j]);
lxdd[(j*d+k)*m+i] = lx[i]*w;
/* c(0)(XTWX)^{-1}XTW'' */
}
}
}
lx[i] *= des->w[i];
}
dv->nd = nd+1;
if (deg==2)
{ for (i=0; ideriv[nd] = i;
fitfun(lfd,sp,des->xev,des->xev,des->f1,dv);
for (k=0; kind[k],des->th[k],robscale);
for (j=0; jf1[j] -= link[ZDDLL]*lxd[i*m+k]*X[k*p+j];
/* c'(x)-c(x)(XTWX)^{-1}XTW'X */
}
jacob_solve(&des->xtwx,des->f1); /* (...)(XTWX)^{-1} */
for (j=0; jf1,&X[j*p],p); /* (...)XT */
for (j=0; jind[k];
dfx[j] = datum(lfd,j,ii)-des->xev[j];
wdw = des->w[k]*weightd(dfx[j],lfd->sca[j],d,ker(sp),
kt(sp),h,lfd->sty[j],des->di[ii]);
lxdd[(i*d+j)*m+k] += ulx[k]*wdw;
lxdd[(j*d+i)*m+k] += ulx[k]*wdw;
}
/* + 2(c'-c(XTWX)^{-1}XTW'X)(XTWX)^{-1}XTW' */
}
for (j=0; j0)
{ for (j=0; jderiv[nd]=i;
fitfun(lfd,sp,des->xev,des->xev,des->f1,dv);
jacob_solve(&des->xtwx,des->f1);
for (k=0; kf1[l]*X[k*p+l]*des->w[k];
/* add c'(0)(XTWX)^{-1}XTW */
}
}
dv->nd = nd+2;
if (deg==2)
{ for (i=0; ideriv[nd]=i;
for (j=0; jderiv[nd+1]=j;
fitfun(lfd,sp,des->xev,des->xev,des->f1,dv);
jacob_solve(&des->xtwx,des->f1);
for (k=0; kf1[l]*X[k*p+l]*des->w[k];
/* + c''(x)(XTWX)^{-1}XTW */
}
}
}
dv->nd = nd;
k = 1+d*(deg>0)+d*d*(deg==2);
if (exp) wdexpand(lx,lfd->n,des->ind,m);
if (ty==1) return(m);
for (i=0; iind[i],des->th[i],robscale);
link[ZDDLL] = sqrt(fabs(link[ZDDLL]));
for (j=0; j
#include "local.h"
#include "mutil.h"
void svd(x,p,q,d,mxit) /* svd of square matrix */
double *x, *p, *q;
int d, mxit;
{ int i, j, k, iter, ms, zer;
double r, u, v, cp, cm, sp, sm, c1, c2, s1, s2, mx;
for (i=0; is2) ? s1 : s2;
zer = 1;
if (mx*mx>1.0e-15*fabs(x[i*d+i]*x[j*d+j]))
{ if (fabs(x[i*(d+1)])0) { cp /= r; sp /= r; }
else { cp = 1.0; zer = 0;}
cm = x[i*(d+1)]-x[j*(d+1)];
sm = x[i*d+j]+x[j*d+i];
r = sqrt(cm*cm+sm*sm);
if (r>0) { cm /= r; sm /= r; }
else { cm = 1.0; zer = 0;}
c1 = cm+cp;
s1 = sm+sp;
r = sqrt(c1*c1+s1*s1);
if (r>0) { c1 /= r; s1 /= r; }
else { c1 = 1.0; zer = 0;}
if (fabs(s1)>ms) ms = (int)fabs(s1);
c2 = cm+cp;
s2 = sp-sm;
r = sqrt(c2*c2+s2*s2);
if (r>0) { c2 /= r; s2 /= r; }
else { c2 = 1.0; zer = 0;}
for (k=0; k0)
{ mx = D[0];
for (i=1; imx) mx = D[i*(d+1)];
tol *= mx;
}
rank = 0;
for (i=0; itol)
{ w[i] /= D[i*(d+1)];
rank++;
}
for (i=0; i0)
{ mx = D[0];
for (i=1; imx) mx = D[i*(d+1)];
tol *= mx;
}
for (i=0; itol) w[i] /= sqrt(D[i*(d+1)]);
for (i=0; i
/*
* DIRSEP: '/' for unix; '\\' for DOS
*/
#ifdef DOS
#define DIRSEP '\\'
#else
#define DIRSEP '/'
#endif
/*
Some older math libraries have no lgamma() function, and gamma(arg)
actually returns log(gamma(arg)). If so, you need to change
LGAMMA macro below.
If all else fails, you can also use lflgamma().
Use the definitions for erf, erfc and daws only if your
math libraries don't include these functions.
*/
#ifdef DOS
#define LGAMMA(arg) lflgamma(arg)
#define erf(x) lferf(x)
#define erfc(x) lferfc(x)
#else
#define LGAMMA(arg) lgamma(arg)
#endif
#define daws(x) lfdaws(x)
/******** NOTHING BELOW HERE NEEDS CHANGING **********/
#include
#include
#include
#include
#define RVERSION
#ifdef SWINVERSION
#define SVERSION
#include "newredef.h"
#endif
#ifdef RVERSION
/* #typedef int used to be defined in R.h */
typedef int Sint;
#include
#include
#include
#define list_elt(ev,i) VECTOR_PTR(ev)[i]
#define dval2(ev,i,j) NUMERIC_POINTER(list_elt(ev,i))[j]
#define dvec2(ev,i) NUMERIC_POINTER(list_elt(ev,i))
#define ivec2(ev,i) INTEGER_POINTER(list_elt(ev,i))
#undef pmatch
#define printf Rprintf
#define printe REprintf
#else
#ifdef SVERSION
#include
typedef long int Sint;
typedef s_object * SEXP;
#define list_elt(ev,i) LIST_POINTER(ev)[i]
#define dval2(ev,i,j) NUMERIC_POINTER(list_elt(ev,i))[j]
#define dvec2(ev,i) NUMERIC_POINTER(list_elt(ev,i))
#define ivec2(ev,i) INTEGER_POINTER(list_elt(ev,i))
#else
typedef int Sint;
#endif
#endif
#ifdef RVERSION
#undef LGAMMA
#define LGAMMA(arg) Rf_lgammafn(arg)
extern double Rf_lgammafn();
#define SVERSION
#endif
#include "mutil.h"
#include "tube.h"
#include "lfcons.h"
typedef char varname[15];
#ifdef CVERSION
#include "cversion.h"
#endif
#include "lfstruc.h"
#include "design.h"
#include "lffuns.h"
#ifdef CVERSION
#undef printf
#define printf lfprintf
extern int lfprintf(const char *format, ...);
extern int printe(const char *format, ...);
/* #else
#define printe printf */
#endif
#ifdef ERROR
#undef ERROR
#endif
#ifdef WARN
#undef WARN
#endif
/* #define ERROR(args) {printe("Error: "); printe args; printe("\n"); lf_error=
1;} */
#define ERROR(args) {error args; lf_error=1;}
/* #define WARN(args) {printe("Warning: "); printe args; printe("\n"); } */
#define WARN(args) warning args;
#define MAX(a,b) (((a)>(b)) ? (a) : (b))
#define MIN(a,b) (((a)<(b)) ? (a) : (b))
#define SGN(x) (((x)>0) ? 1 : -1)
#define SQR(x) ((x)*(x))
#define NOSLN 0.1278433
#define GFACT 2.5
#define EFACT 3.0
#define MAXCOLOR 20
#define MAXWIN 5
#define ISWAP(a,b) { int zz; zz = a; a = b; b = zz; }
extern int lf_error;
#endif /* I_LF_H */
locfit/src/scb_iface.c 0000744 0001760 0000144 00000003057 12134436032 014417 0 ustar ripley users #include "local.h"
static lfit *lf_scb;
static lfdata *lfd_scb;
static smpar *scb_sp;
static design *des_scb;
int scbfitter(x,l,reqd)
double *x, *l;
int reqd;
{
int m;
des_scb->xev = x;
if ((ker(scb_sp)!=WPARM) | (!haspc(&lf_scb->pc)))
{ locfit(lfd_scb,des_scb,&lf_scb->sp,1,1);
m = wdiag(lfd_scb, scb_sp, des_scb,l,&lf_scb->dv,reqd,2,0);
}
else
m = wdiagp(lfd_scb, scb_sp, des_scb,l,&lf_scb->pc,&lf_scb->dv,reqd,2,0);
return(m);
}
/* function to test tube_constants with covariance.
double ll[5000];
int scbfitter2(x,l,reqd)
double *x, *l;
int reqd;
{ double h;
int d, m, n, i, j;
m = scbfitter(x,ll,reqd);
d = lfd_scb->d;
n = d*d+d+1;
for (i=0; ilfd;
scb_sp = &lf->sp;
evs = &lf->evs;
d = lfd_scb->d;
m = lfd_scb->n;
if (lf_error) return(0);
if ((ker(scb_sp) != WPARM) && (lf->sp.nn>0))
WARN(("constants are approximate for varying h"));
npar(scb_sp) = calcp(scb_sp,lf->lfd.d);
des_init(des,m,npar(scb_sp));
set_scales(&lf->lfd);
set_flim(&lf->lfd,&lf->evs);
compparcomp(des,&lf->lfd,&lf->sp,&lf->pc,geth(&lf->fp),ker(scb_sp)!=WPARM);
rw = k0_reqd(d,m,0);
if (lf->fp.llfp.L = (double *)calloc(rw,sizeof(double));
lf->fp.ll= rw;
}
nt = tube_constants(scbfitter,d,m,ev(evs),mg(evs),evs->fl,
lf->fp.kap,lf->fp.L,(d>3) ? 4 : d+1,0);
return(nt);
}
locfit/src/preplot.c 0000744 0001760 0000144 00000005651 12134436032 014210 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
#include "local.h"
/*
preplot(): interpolates the fit to a new set of points.
lf -- the fit structure.
x -- the points to predict at.
f -- vector to return the predictions.
se -- vector to return std errors (NULL if not req'd)
band-- char for conf band type. ('n'=none, 'g'=global etc.)
n -- no of predictions (or vector of margin lengths for grid)
where -- where to predict:
1 = points in the array x.
2 = grid defined by margins in x.
3 = data points from lf (ignore x).
4 = fit points from lf (ignore x).
what -- what to predict.
(PCOEF etc; see lfcons.h file)
*/
static char cb;
double *sef, *fit, sigmahat;
void predptall(lf,x,what,ev,i)
lfit *lf;
double *x;
int what, ev, i;
{ double lik, rdf;
fit[i] = dointpoint(lf,x,what,ev,i);
if (cb=='n') return;
sef[i] = dointpoint(lf,x,PNLX,ev,i);
if (cb=='g')
{ sef[i] *= sigmahat;
return;
}
if (cb=='l')
{ lik = dointpoint(lf,x,PLIK,ev,i);
rdf = dointpoint(lf,x,PRDF,ev,i);
sef[i] *= sqrt(-2*lik/rdf);
return;
}
if (cb=='p')
{ sef[i] = sigmahat*sqrt(1+sef[i]*sef[i]);
return;
}
}
void prepvector(lf,x,n,what) /* interpolate a vector */
lfit *lf;
double **x;
int n, what;
{ int i, j;
double xx[MXDIM];
for (i=0; ifp.d; j++) xx[j] = x[j][i];
predptall(lf,xx,what,ev(&lf->evs),i);
if (lf_error) return;
}
}
void prepfitp(lf,what)
lfit *lf;
int what;
{ int i;
for (i=0; ifp.nv; i++)
{ predptall(lf,evpt(&lf->fp,i),what,EFITP,i);
if (lf_error) return;
}
}
void prepgrid(lf,x,mg,n,what) /* interpolate a grid given margins */
lfit *lf;
double **x;
Sint *mg;
int n, what;
{ int i, ii, j, d;
double xv[MXDIM];
d = lf->fp.d;
for (i=0; ievs),i);
if (lf_error) return;
}
}
void preplot(lf,x,f,se,band,mg,where,what)
lfit *lf;
double **x, *f, *se;
Sint *mg;
int where, what;
char band;
{ int d, i, n=0;
double *xx[MXDIM];
d = lf->fp.d;
fit = f;
sef = se;
cb = band;
if (cb!='n') sigmahat = sqrt(rv(&lf->fp));
switch(where)
{ case 1: /* vector */
n = mg[0];
prepvector(lf,x,n,what);
break;
case 2: /* grid */
n = 1;
for (i=0; ilfd.n;
if ((ev(&lf->evs)==EDATA) | (ev(&lf->evs)==ECROS))
prepfitp(lf,what);
else
{ for (i=0; ilfd,i);
prepvector(lf,xx,n,what);
}
break;
case 4: /* fit points */
n = lf->fp.nv;
prepfitp(lf,what);
break;
default:
ERROR(("unknown where in preplot"));
}
if ((what==PT0)|(what==PVARI))
for (i=0; isp.
* evs is a pointer to the evaluation structure, &lf->evs.
* int ppwhat(str) interprets the preplot what argument.
* int restyp(str) interprets the residual type argument.
*
* return values of -1 indicate failure/unknown string.
*/
#include "local.h"
int ct_match(z1, z2)
char *z1, *z2;
{ int ct = 0;
while (z1[ct]==z2[ct])
{ if (z1[ct]=='\0') return(ct+1);
ct++;
}
return(ct);
}
int pmatch(z, strings, vals, n, def)
char *z, **strings;
int *vals, n, def;
{ int i, ct, best, best_ct;
best = -1;
best_ct = 0;
for (i=0; ibest_ct) { best = i; best_ct = ct; }
}
if (best==-1) return(def);
return(vals[best]);
}
static char *famil[17] =
{ "density", "ate", "hazard", "gaussian", "binomial",
"poisson", "gamma", "geometric", "circular", "obust", "huber",
"weibull", "cauchy","probab", "logistic", "nbinomial", "vonmises" };
static int fvals[17] =
{ TDEN, TRAT, THAZ, TGAUS, TLOGT,
TPOIS, TGAMM, TGEOM, TCIRC, TROBT, TROBT,
TWEIB, TCAUC, TPROB, TLOGT, TGEOM, TCIRC };
int lffamily(z)
char *z;
{ int quasi, robu, f;
quasi = robu = 0;
while ((z[0]=='q') | (z[0]=='r'))
{ quasi |= (z[0]=='q');
robu |= (z[0]=='r');
z++;
}
f = pmatch(z,famil,fvals,16,-1);
if ((z[0]=='o') | (z[0]=='a')) robu = 0;
if (f==-1)
{ WARN(("unknown family %s",z));
f = TGAUS;
}
if (quasi) f += 64;
if (robu) f += 128;
return(f);
}
static char *wfuns[13] = {
"rectangular", "epanechnikov", "bisquare", "tricube",
"triweight", "gaussian", "triangular", "ququ",
"6cub", "minimax", "exponential", "maclean", "parametric" };
static int wvals[13] = { WRECT, WEPAN, WBISQ, WTCUB,
WTRWT, WGAUS, WTRIA, WQUQU, W6CUB, WMINM, WEXPL, WMACL, WPARM };
int lfkernel(char *z)
{ return(pmatch(z, wfuns, wvals, 13, WTCUB));
}
static char *ktype[5] = { "spherical", "product", "center", "lm", "zeon" };
static int kvals[5] = { KSPH, KPROD, KCE, KLM, KZEON };
int lfketype(char *z)
{ return(pmatch(z, ktype, kvals, 5, KSPH));
}
static char *ltype[8] = { "default", "canonical", "identity", "log",
"logi", "inverse", "sqrt", "arcsin" };
static int lvals[8] = { LDEFAU, LCANON, LIDENT, LLOG,
LLOGIT, LINVER, LSQRT, LASIN };
int lflink(char *z)
{ return(pmatch(z, ltype, lvals, 8, LDEFAU));
}
static char *etype[11]= { "tree", "phull", "data", "grid", "kdtree",
"kdcenter", "cross", "preset", "xbar", "none",
"sphere" };
static int evals[11]= { ETREE, EPHULL, EDATA, EGRID, EKDTR,
EKDCE, ECROS, EPRES, EXBAR, ENONE, ESPHR };
int lfevstr(char *z)
{ return(pmatch(z, etype, evals, 11, ETREE));
}
static char *itype[7] = { "default", "multi", "product", "mlinear",
"hazard", "sphere", "monte" };
static int ivals[7] = { IDEFA, IMULT, IPROD, IMLIN, IHAZD, ISPHR, IMONT };
int deitype(char *z)
{ return(pmatch(z, itype, ivals, 6, IDEFA));
}
static char *atype[5] = { "none", "cp", "ici", "mindex", "ok" };
static int avals[5] = { ANONE, ACP, AKAT, AMDI, AOK };
int lfacri(char *z)
{ return(pmatch(z, atype, avals, 5, ANONE));
}
static char *rtype[8] = { "deviance", "d2", "pearson", "raw",
"ldot", "lddot", "fit", "mean" };
static int rvals[8] = { RDEV, RDEV2, RPEAR, RRAW, RLDOT, RLDDT, RFIT, RMEAN};
static char *whtyp[8] = { "coef", "nlx", "infl", "band",
"degr", "like", "rdf", "vari" };
static int whval[8] = { PCOEF, PNLX, PT0, PBAND, PDEGR, PLIK, PRDF, PVARI };
int restyp(z)
char *z;
{ int val;
val = pmatch(z, rtype, rvals, 8, -1);
if (val==-1) ERROR(("Unknown type = %s",z));
return(val);
}
int ppwhat(z)
char *z;
{ int val;
val = pmatch(z, whtyp, whval, 8, -1);
if (val==-1) ERROR(("Unknown what = %s",z));
return(val);
}
locfit/src/m_imont.c 0000744 0001760 0000144 00000001617 12134436032 014163 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
* Multivariate integration of a vector-valued function
* using Monte-Carlo method.
*
* uses drand48() random number generator. Does not seed.
*/
#include
#include "R.h"
#include "mutil.h"
extern void setzero();
/* static int lfindex[MXIDIM];
static double M[(1+MXIDIM)*MXIDIM*MXIDIM]; */
void monte(f,ll,ur,d,res,n)
int (*f)(), d, n;
double *ll, *ur, *res;
{ int i, j, nr=0;
double z, x[MXIDIM], tres[MXRESULT];
/* srand48(234L); */
GetRNGstate(); /* Use R's RNG */
for (i=0; i=2 dimensions?
* fix df computation (in lscv) for link=IDENT.
*/
#include "local.h"
/*
* Finds the order of observations in the array x, and
* stores in integer array ind.
* At input, lset l=0 and r=length(x)-1.
* At output, x[ind[0]] <= x[ind[1]] <= ...
*/
void lforder(ind,x,l,r)
Sint *ind;
int l, r;
double *x;
{ double piv;
int i, i0, i1;
piv = (x[ind[l]]+x[ind[r]])/2;
i0 = l; i1 = r;
while (i0<=i1)
{ while ((i0<=i1) && (x[ind[i0]]<=piv)) i0++;
while ((i0<=i1) && (x[ind[i1]]>piv)) i1--;
if (i0=l) && (x[ind[i1]]==piv)) i1--;
for (i=l; i<=i1; i++)
if (x[ind[i]]==piv)
{ ISWAP(ind[i],ind[i1]);
while (x[ind[i1]]==piv) i1--;
}
if (lfp;
if (fp->d >= 2)
{ WARN(("dens_integrate requires d=1"));
return(0.0);
}
has_deriv = (deg(&lf->sp) > 0); /* not right? */
fit = fp->coef;
if (has_deriv)
deriv = &fit[fp->nvm];
xev = evp(fp);
/*
* order the vertices
*/
nv = fp->nv;
if (lf->lfd.nind;
for (i=0; isp)==LLOG)
{ f1 *= 2; d1 *= 2; }
else
{ d1 = 2*d1*f1; f1 = f1*f1; }
}
term = (link(&lf->sp)==LIDENT) ? f1*f1/(2*d1) : exp(f1)/d1;
sum += term;
i0 = ind[nv-2]; i1 = ind[nv-1];
f0 = fit[i1];
d0 = (has_deriv) ? deriv[i1] :
(fit[i1]-fit[i0])/(xev[i1]-xev[i0]);
if (d0 >= 0) WARN(("dens_integrate - ouch!"));
if (z==2)
{ if (link(&lf->sp)==LLOG)
{ f0 *= 2; d0 *= 2; }
else
{ d0 = 2*d0*f0; f0 = f0*f0; }
}
term = (link(&lf->sp)==LIDENT) ? -f0*f0/(2*d0) : exp(f0)/d0;
sum += term;
for (i=1; isp)==LLOG)
{ f0 *= 2; f1 *= 2; d0 *= 2; d1 *= 2; }
else
{ d0 *= 2*f0; d1 *= 2*f1; f0 = f0*f0; f1 = f1*f1; }
}
term = estdiv(xev[i0],xev[i1],f0,f1,d0,d1,link(&lf->sp));
sum += term;
}
return(sum);
}
void dens_renorm(lf,des)
lfit *lf;
design *des;
{ int i;
double sum;
sum = dens_integrate(lf,des,1);
if (sum==0.0) return;
sum = log(sum);
for (i=0; ifp.nv; i++) lf->fp.coef[i] -= sum;
}
void dens_lscv(des,lf)
lfit *lf;
design *des;
{ double df, fh, fh_cv, infl, z0, z1, x[MXDIM];
int i, n, j, evo;
z1 = df = 0.0;
evo = ev(&lf->evs);
n = lf->lfd.n;
if ((evo==EDATA) | (evo==ECROS)) evo = EFITP;
z0 = dens_integrate(lf,des,2);
for (i=0; ilfd.d; j++) x[j] = datum(&lf->lfd,j,i);
fh = base(&lf->lfd,i)+dointpoint(lf,x,PCOEF,evo,i);
if (link(&lf->sp)==LLOG) fh = exp(fh);
infl = dointpoint(lf,x,PT0,evo,i);
infl = infl * infl;
if (infl>1) infl = 1;
fh_cv = (link(&lf->sp) == LIDENT) ?
(n*fh - infl) / (n-1.0) : fh*(1-infl)*n/(n-1.0);
z1 += fh_cv;
df += infl;
}
lf->fp.L[0] = z0-2*z1/n;
lf->fp.L[1] = df;
}
locfit/src/startlf.c 0000744 0001760 0000144 00000007753 12134436032 014207 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*
*
*
startlf(des,lf,vfun,nopc) -- starting point for locfit.
des and lf are pointers to the design and fit structures.
vfun is the vertex processing function.
nopc=1 inhibits computation of parametric component.
lfit_init(lf) -- initialize the lfit structure.
lf is pointer to fit.
preproc() -- fit preprocessing (limits, scales, paramcomp etc.)
set_scales()
set_flim() -- compute bounding box.
fitoptions()
clocfit() -- start point for CLocfit - interpret cmd line etc.
*/
#include "local.h"
void evstruc_init(evs)
evstruc *evs;
{ int i;
ev(evs) = ETREE;
mk(evs) = 100;
cut(evs) = 0.8;
for (i=0; ifl[i] = evs->fl[i+MXDIM] = 0.0;
evs->mg[i] = 10;
}
evs->nce = evs->ncm = 0;
}
void fitpt_init(fp)
fitpt *fp;
{
dc(fp) = 0;
geth(fp) = GSTD;
fp->nv = fp->nvm = 0;
}
void lfit_init(lf)
lfit *lf;
{
lfdata_init(&lf->lfd);
evstruc_init(&lf->evs);
smpar_init(&lf->sp,&lf->lfd);
deriv_init(&lf->dv);
fitpt_init(&lf->fp);
}
void fitdefault(lf)
lfit *lf;
{ WARN(("fitdefault deprecated -- use lfit_init()"));
lfit_init(lf);
}
void set_flim(lfd,evs)
lfdata *lfd;
evstruc *evs;
{ int i, j, d, n;
double z, mx, mn, *bx;
if (ev(evs)==ESPHR) return;
d = lfd->d; n = lfd->n;
bx = evs->fl;
for (i=0; isty[i]==STANGL)
{ bx[i] = 0.0; bx[i+d] = 2*PI*lfd->sca[i];
}
else
{ mx = mn = datum(lfd,i,0);
for (j=1; jxl[i]xl[i+d]) /* user set xlim; maybe use them. */
{ z = mx-mn;
if (mn-0.2*z < lfd->xl[i]) mn = lfd->xl[i];
if (mx+0.2*z > lfd->xl[i+d]) mx = lfd->xl[i+d];
}
bx[i] = mn;
bx[i+d] = mx;
}
}
}
double vecsum(v,n)
double *v;
int n;
{ int i;
double sum;
sum = 0.0;
for (i=0; id; i++)
if (lfd->sca[i]<=0) /* set automatic scales */
{ if (lfd->sty[i]==STANGL)
lfd->sca[i] = 1.0;
else lfd->sca[i] = sqrt(vvari(lfd->x[i],lfd->n));
}
}
void startlf(des,lf,vfun,nopc)
design *des;
lfit *lf;
int (*vfun)(), nopc;
{ int i, d, n;
if (lf_debug>0) printf("startlf\n");
n = lf->lfd.n;
d = lf->lfd.d;
des->vfun = vfun;
npar(&lf->sp) = calcp(&lf->sp,lf->lfd.d);
des_init(des,n,npar(&lf->sp));
des->smwt = (lf->lfd.w==NULL) ? n : vecsum(lf->lfd.w,n);
set_scales(&lf->lfd);
set_flim(&lf->lfd,&lf->evs);
compparcomp(des,&lf->lfd,&lf->sp,&lf->pc,geth(&lf->fp),nopc);
makecfn(&lf->sp,des,&lf->dv,lf->lfd.d);
lf->lfd.ord = 0;
if ((d==1) && (lf->lfd.sty[0]!=STANGL))
{ i = 1;
while ((ilfd,0,i)>=datum(&lf->lfd,0,i-1))) i++;
lf->lfd.ord = (i==n);
}
for (i=0; isp); i++) des->fix[i] = 0;
lf->fp.d = lf->lfd.d;
lf->fp.hasd = (des->ncoef==(1+lf->fp.d));
if (lf_debug>1) printf("call eval structure\n");
switch(ev(&lf->evs))
{ case EPHULL: triang_start(des,lf); break;
case EDATA: dataf(des,lf); break;
case ECROS: crossf(des,lf); break;
case EGRID: gridf(des,lf); break;
case ETREE: atree_start(des,lf); break;
case EKDCE: kt(&lf->sp) = KCE;
case EKDTR: kdtre_start(des,lf); break;
case EPRES: preset(des,lf); break;
case EXBAR: xbarf(des,lf); break;
case ENONE: lf->fp.nv = lf->evs.nce = 0;
return;
case ESPHR: sphere_start(des,lf); break;
case ESPEC: lf->evs.espec(des,lf); break;
default: ERROR(("startlf: Invalid evaluation structure %d",ev(&lf->evs)));
}
/* renormalize for family=density */
if ((de_renorm) && (fam(&lf->sp)==TDEN)) dens_renorm(lf,des);
}
locfit/src/imatlb.h 0000744 0001760 0000144 00000001566 12134436032 014001 0 ustar ripley users typedef struct {
int n;
double *dpr;
} vari;
typedef struct {
double *Z, *Q, *dg, *f2;
int p, sm; } xtwxstruc;
typedef struct {
vari *wk;
double *coef, *xbar, *f;
xtwxstruc xtwx; } paramcomp;
typedef struct {
vari *dw, *index;
double *xev, *X, *w, *di, *res, *th, *wd, h, xb[15];
double *V, *P, *f1, *ss, *oc, *cf, llk;
xtwxstruc xtwx;
int *ind, n, p, pref, (*itype)();
int (*vfun)(); } design;
typedef struct {
vari *tw, *L, *iw, *xxev;
double *x[15], *y, *w, *base, *c, *xl;
double *coef, *nlx, *t0, *lik, *h, *deg;
double *sv, *fl, *sca, *dp, kap[3];
int *ce, *s, *lo, *hi, sty[15];
int *mg, nvm, ncm, vc;
int nl, nv, nnl, nce, nk, nn, *mi, ord, deriv[9], nd;
paramcomp pc;
varname yname, xname[15], wname, bname, cname; } lfit;
extern void mlbcall(
double *x, double *y,
double *xx, double *ff, int n);
locfit/src/lf_adap.c 0000744 0001760 0000144 00000012540 14441366737 014125 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
/*
Functions implementing the adaptive bandwidth selection.
Will make the final call to nbhd() to set smoothing weights
for selected bandwidth, But will **not** make the
final call to locfit().
*/
#include "local.h"
static double hmin;
double adcri(lk,t0,t2,pen)
double lk, t0, t2, pen;
{ double y;
/* return(-2*lk/(t0*exp(pen*log(1-t2/t0)))); */
/* return((-2*lk+pen*t2)/t0); */
y = (MAX(-2*lk,t0-t2)+pen*t2)/t0;
return(y);
}
double mmse(lfd,sp,dv,des)
lfdata *lfd;
smpar *sp;
deriv *dv;
design *des;
{ int i, ii, j, p1;
double sv, sb, *l, dp;
l = des->wd;
wdiag(lfd, sp, des,l,dv,0,1,0);
sv = sb = 0;
// p = npar(sp);
for (i=0; in; i++)
{ sv += l[i]*l[i];
ii = des->ind[i];
dp = des->di[ii];
for (j=0; jdi[ii];
sb += fabs(l[i])*dp;
}
p1 = factorial(deg(sp)+1);
return(sv+sb*sb*pen(sp)*pen(sp)/(p1*p1));
}
static double mcp, clo, cup;
/*
Initial bandwidth will be (by default)
k-nearest neighbors for k small, just large enough to
get defined estimate (unless user provided nonzero nn or fix-h components)
*/
int ainitband(lfd,sp,dv,des)
lfdata *lfd;
smpar *sp;
deriv *dv;
design *des;
{ int lf_status=0, p, z, cri, noit, redo;
double ho, t[6];
if (lf_debug >= 2) printf("ainitband:\n");
p = des->p;
cri = acri(sp);
noit = (cri!=AOK);
z = (int)(lfd->n*nn(sp));
if ((noit) && (zn) z = des->n;
if (des->h>ho) lf_status = locfit(lfd,des,sp,noit,0,0);
z++;
redo = 1;
} while ((z<=lfd->n) && ((des->h==0)||(lf_status!=LF_OK)));
hmin = des->h;
switch(cri)
{ case ACP:
local_df(lfd,sp,des,t);
mcp = adcri(des->llk,t[0],t[2],pen(sp));
return(lf_status);
case AKAT:
local_df(lfd,sp,des,t);
clo = des->cf[0]-pen(sp)*t[5];
cup = des->cf[0]+pen(sp)*t[5];
return(lf_status);
case AMDI:
mcp = mmse(lfd,sp,dv,des);
return(lf_status);
case AOK: return(lf_status);
}
ERROR(("aband1: unknown criterion"));
return(LF_ERR);
}
/*
aband2 increases the initial bandwidth until lack of fit results,
or the fit is close to a global fit. Increase h by 1+0.3/d at
each iteration.
*/
double aband2(lfd,sp,dv,des,h0)
lfdata *lfd;
smpar *sp;
deriv *dv;
design *des;
double h0;
{ double t[6], h1, nu1, cp, ncp, tlo, tup;
int d, inc, n, p, done;
if (lf_debug >= 2) printf("aband2:\n");
d = lfd->d; n = lfd->n; p = npar(sp);
h1 = des->h = h0;
done = 0; nu1 = 0.0;
inc = 0; ncp = 0.0;
while ((!done) & (nu1<(n-p)*0.95))
{ fixh(sp) = (1+0.3/d)*des->h;
nbhd(lfd,des,0,1,sp);
if (locfit(lfd,des,sp,1,0,0) > 0) WARN(("aband2: failed fit"));
local_df(lfd,sp,des,t);
nu1 = t[0]-t[2]; /* tr(A) */
switch(acri(sp))
{ case AKAT:
tlo = des->cf[0]-pen(sp)*t[5];
tup = des->cf[0]+pen(sp)*t[5];
/* printf("h %8.5f tlo %8.5f tup %8.5f\n",des->h,tlo,tup); */
done = ((tlo>cup) | (tuph;
}
break;
case ACP:
cp = adcri(des->llk,t[0],t[2],pen(sp));
/* printf("h %8.5f lk %8.5f t0 %8.5f t2 %8.5f cp %8.5f\n",des->h,des->llk,t[0],t[2],cp); */
if (cph; }
if (cp>=ncp) inc++; else inc = 0;
ncp = cp;
done = (inc>=10) | ((inc>=3) & ((t[0]-t[2])>=10) & (cp>1.5*mcp));
break;
case AMDI:
cp = mmse(lfd,sp,dv,des);
if (cph; }
if (cp>ncp) inc++; else inc = 0;
ncp = cp;
done = (inc>=3);
break;
}
}
return(h1);
}
/*
aband3 does a finer search around best h so far. Try
h*(1-0.2/d), h/(1-0.1/d), h*(1+0.1/d), h*(1+0.2/d)
*/
double aband3(lfd,sp,dv,des,h0)
lfdata *lfd;
smpar *sp;
deriv *dv;
design *des;
double h0;
{ double t[6], h1, cp, tlo, tup;
int i, i0, d;
if (lf_debug >= 2) printf("aband3:\n");
d = lfd->d; // n = lfd->n;
h1 = h0;
i0 = (acri(sp)==AKAT) ? 1 : -2;
if (h0==hmin) i0 = 1;
for (i=i0; i<=2; i++)
{ if (i==0) i++;
fixh(sp) = h0*(1+0.1*i/d);
nbhd(lfd,des,0,1,sp);
if (locfit(lfd,des,sp,1,0,0) > 0) WARN(("aband3: failed fit"));
local_df(lfd,sp,des,t);
switch (acri(sp))
{ case AKAT:
tlo = des->cf[0]-pen(sp)*t[5];
tup = des->cf[0]+pen(sp)*t[5];
if ((tlo>cup) | (tuph;
clo = MAX(clo,tlo);
cup = MIN(cup,tup);
}
break;
case ACP:
cp = adcri(des->llk,t[0],t[2],pen(sp));
if (cph; }
else
{ if (i>0) i = 2; }
break;
case AMDI:
cp = mmse(lfd,sp,dv,des);
if (cph; }
else
{ if (i>0) i = 2; }
}
}
return(h1);
}
int alocfit(lfd,sp,dv,des)
lfdata *lfd;
smpar *sp;
deriv *dv;
design *des;
{ int lf_status;
double h0;
lf_status = ainitband(lfd,sp,dv,des);
if (lf_error) return(lf_status);
if (acri(sp) == AOK) return(lf_status);
h0 = fixh(sp);
fixh(sp) = aband2(lfd,sp,dv,des,des->h);
fixh(sp) = aband3(lfd,sp,dv,des,fixh(sp));
nbhd(lfd,des,0,1,sp);
lf_status = locfit(lfd,des,sp,0,0,0);
fixh(sp) = h0;
return(lf_status);
}
locfit/src/tube.h 0000744 0001760 0000144 00000001610 12134436032 013456 0 ustar ripley users /*
* Copyright (c) 1998-2001 Catherine Loader, Jiayang Sun
* See README file for details.
*
*
* Headers for the tube library.
*/
#ifndef I_TUBE_H
#define I_TUBE_H
/*
* public functions needed by routines calling the tube library.
*/
extern double critval();
extern double tailp(), taild();
extern int tube_constants();
extern int k0_reqd();
/*
* stuff used internally.
*/
#include "mutil.h"
#define TUBE_MXDIM 10
/*
* definitions for integration methods.
* these match locfit evaluation structures where applicable.
*/
#define ISIMPSON 4 /* grid */
#define ISPHERIC 11 /* circle or sphere */
#define IDERFREE 25 /* derivative free */
#define IMONTE 30 /* monte carlo */
#ifndef PI
#define PI 3.141592653589793238462643
#endif
#define ONE_SIDED 1
#define TWO_SIDED 2
#define UNIF 400
#define GAUSS 401
#define TPROC 402
#endif /* define I_TUBE_H */
locfit/src/m_qr.c 0000744 0001760 0000144 00000003637 12134436032 013463 0 ustar ripley users /*
* Copyright (c) 1996-2001 Lucent Technologies.
* See README file for details.
*/
#include
#include
#include "mutil.h"
/* qr decomposition of X (n*p organized by column).
* Take w for the ride, if not NULL.
*/
void qr(X,n,p,w)
double *X, *w;
int n, p;
{ int i, j, k, mi;
double c, s, mx, nx, t;
for (j=0; jmx)
{ mi = i;
mx = fabs(X[j*n+i]);
}
}
for (i=j; i0)
{ for (i=j; i=0; i--)
{ for (j=i+1; jfp.d; vc = d+1;
for (i=0; ifp,ce[i],k)-evptx(&lf->fp,ce[j],k);
di = rho(dfx,lf->lfd.sca,d,KSPH,NULL);
le[i*vc+j] = le[j*vc+i] = di/MIN(lf->fp.h[ce[i]],lf->fp.h[ce[j]]);
nts = nts || le[i*vc+j]>cut(&lf->evs);
}
return(nts);
}
void resort(pv,xev,dig)
double *xev;
int *pv, *dig;
{ double d0, d1, d2;
int i;
d0 = d1 = d2 = 0;
for (i=0; i<3; i++)
{ d0 += (xev[3*pv[11]+i]-xev[3*pv[1]+i])*(xev[3*pv[11]+i]-xev[3*pv[1]+i]);
d1 += (xev[3*pv[ 7]+i]-xev[3*pv[2]+i])*(xev[3*pv[ 7]+i]-xev[3*pv[2]+i]);
d2 += (xev[3*pv[ 6]+i]-xev[3*pv[3]+i])*(xev[3*pv[ 6]+i]-xev[3*pv[3]+i]);
}
if ((d0<=d1) & (d0<=d2))
{ dig[0] = pv[1]; dig[1] = pv[11];
dig[2] = pv[2]; dig[3] = pv[7];
dig[4] = pv[3]; dig[5] = pv[6];
}
else if (d1<=d2)
{ dig[0] = pv[2]; dig[1] = pv[7];
dig[2] = pv[1]; dig[3] = pv[11];
dig[4] = pv[3]; dig[5] = pv[6];
}
else
{ dig[0] = pv[3]; dig[1] = pv[6];
dig[2] = pv[2]; dig[3] = pv[7];
dig[4] = pv[1]; dig[5] = pv[11];
}
}
void triang_grow(des,lf,ce,ct,term)
design *des;
lfit *lf;
Sint *ce, *ct, *term;
{ double le[(1+MXDIM)*(1+MXDIM)], ml;
int d, i, j, im=0, jm=0, vc, pv[(1+MXDIM)*(1+MXDIM)], dig[6];
Sint nce[1+MXDIM];
if (lf_error) return;
d = lf->fp.d; vc = d+1;
if (!triang_split(lf,ce,le))
{ if (ct != NULL)
{ for (i=0; i3)
{ ml = 0;
for (i=0; iml) { ml = le[i*vc+j]; im = i; jm = j; }
pv[0] = newsplit(des,lf,(int)ce[im],(int)ce[jm],0);
for (i=0; ievs));
for (i=0; i<=d; i++) /* corners */
{ for (j=0; j<=d; j++) nce[j] = (j==i) ? ce[i] : pv[i*vc+j];
triang_grow(des,lf,nce,ct,term);
}
if (d==2) /* center for d=2 */
{ nce[0] = pv[5]; nce[1] = pv[2]; nce[2] = pv[1];
triang_grow(des,lf,nce,ct,term);
}
if (d==3) /* center for d=3 */
{ resort(pv,evp(&lf->fp),dig);
nce[0] = dig[0]; nce[1] = dig[1];
nce[2] = dig[2]; nce[3] = dig[4]; triang_grow(des,lf,nce,ct,term);
nce[2] = dig[5]; nce[3] = dig[3]; triang_grow(des,lf,nce,ct,term);
nce[2] = dig[2]; nce[3] = dig[5]; triang_grow(des,lf,nce,ct,term);
nce[2] = dig[4]; nce[3] = dig[3]; triang_grow(des,lf,nce,ct,term);
}
}
void triang_descend(tr,xa,ce)
lfit *tr;
double *xa;
Sint *ce;
{ double le[(1+MXDIM)*(1+MXDIM)], ml;
int d, vc, i, j, im=0, jm=0, pv[(1+MXDIM)*(1+MXDIM)];
design *des;
des = NULL;
if (!triang_split(tr,ce,le)) return;
d = tr->fp.d; vc = d+1;
if (d>3) /* split longest edge */
{ ml = 0;
for (i=0; i