5jP7yB:_ezC˫Cf4+
:}kik_H>v6 oUfY_Iߦ3G[mRjX]0cu oO*VLWJ8>hآ쿀NZ8+}ruY7
/?a=eFMaymy W?N8&{OG}3IųBlendstream
endobj
174 0 obj
<< /Filter /FlateDecode /Length 4791 >>
stream
x\[o q~W91l/ `ae$1pDRlG`.=szxHraOwuu]5/ƓzR~=3
< ~UFIq֟}Ƅ1h5: lHZ;ZlJ%̀t8pM
M9h[zjO).ly '$^ ۲sJ?9똆0êlH!; s>&A9Ұy pF9g \r
L֣K 8uvb?:O֏)|A а2s+ڈR:aw=3yE?o649 ;|\@{jm`
?㹒qr^~ RZmL q4؉Bx؊+w{+
b{+#BilA~P}/:=tf4,âa&$rM{y_&hS a҂2+16HBX*1ĆYN Ǟ.YY mÂTPؕrj}]c%4م =
Ȱ {AXrFsc
iVAN ڐGo@q SD\\02]4MNs ?GP[T(OE'NH-ڋI͆?aEQZ'ɮw0Y4 ;Iޝ{$IՆ%[>d?2A&"!P@9UN:'m
.gN
BrNl)el5eȿ& ɺ4<+;
ޠo[VoY F 81Zcu {Bq܋r
2[-8}ވ97WJ 0D3btL>PWr&E
y+Ok:( Ħ~zEOc"n.|X%ځ'_ %a /7`8p h 06K0[F 5J(We5+&=i FM:}
IHS /JE,VoGMRFZ윆d'curϫ]ϑu q g ' $H
,R:|[ux]MORBB.'(|r)^>@mv2 ̷ 9jPlNwzCk1h-mˀq&2 R3|wu V;9OU(DE 4J-Ծ
`!uّ9`8Y{cVrAo&ɥ:|[ux]:qMWr Pi{*>Qix[D IQ UPD iB 6 -Bzݚn:P ˚Gp@шpKڜU9++*M*wQ&!6ÐQŒ 9>A8FWXFF0ջr68S^!vYkU(|5"%qmޡ]!W!詃00/K vEn`3
uB)iD~%%pu P^
Ag 8s Lpe-o y%MQ&s..o% |Nu qՏ5oSu%'uKZࡌM&?u( } ^SɕPY2~k \C!\7>i/v۪ά ha lL^&`M4SSRoyCI6o;4:*7\׃v0*矨_s7p;hdQg̺Pb]OuFeDz '|
xAS7 羅b3RaD^^
A:w%R5˜j V;016KLLn W0e p]Ǥ06N: B 3du~i6i#Dyڭ/*ө{iqy/moz*Qn$K*z$cp˂ˤ&o|\*a 6ac jMυnY3Cx1MV͜r
{X
mPWLrζIIɽ`U;tIRC5;~
wn.;D7w;f)dQ
\vi=Ws m4R:48ùA NT+|u v_Eeq9ae`n[9'HBEEKaDJM>R JDlWSo :LIE ǴyGpOmU.@$ $aVw 2>2Ш:ҪiKG8) ?qOf!ߢd`;I1T} Ю+LM}: O5RZ3mҖ?Ty /uhݧuTO>xu
}t?1Wܦ+x'+M 3Om K9 :~[۵^1 끈uxU*Aj :c闓,`}==^`^
bgv!BMK51ʊoPO?r>펖D/e l2ͱ؍\JFP%-yjjٜxjWVl⁒rP˰%2!%E
ˎB i^Hq-|Qa^4P dɂ1V/-R(|kҦ6H>_ DBM[ʃɖE*E$7͙A/(eW0' Rm+V,|e-O ?A6 Kdusv좯wz ϛHE(
9*2( ;*:fD~`2(q*yhIDyb-TsOT1kMxK`z! tSy51^ VEud_+Xi"-r ˴ ;*,$ IHXi_tAU% (WW
(60JbE,@
BtsK9vYB,JW>}_!*
? xf;(
X= 5!wLZDb4t+'ZrLv.LV4P
.jl^ UMQb g:AZqU% cquE`XsBNd !2}8YN \9k4mXrK 6bmmE[nQ[2캊5Q{/xNa*jx N}fZVv>E4aVH?j<[
v& _3s{:ޱ
gx!'CZk%A_w@ʫC帷\K"x$J Ōec[?U?ա@Mo^֡!݊QZo{H Іx jEK?=UkO d]Mu-v V_wʇ> 7g/
)sendstream
endobj
175 0 obj
<< /Filter /FlateDecode /Length 3266 >>
stream
x[Ko fcA1@9DfdCrAr).ſ=U3S .)Q:جGw}5w3ʙG{߾~jݞL | FHE1D\è,1z dcQdX u0Zk *\/o5줖16gya T*xʵ.Sg.4%hؙl0-La Z`W2- UZg m\֊7
TBW"|!A5 s&Fr2Q܆ԭ5/:٬lM6j _p¨%ػc Sc.v&GW z]%řO|B5K"s"["ψ<
cc05H|an>U X35 ^u
aP=k"WDN'"5dP>E>) ފB/K3_kA*?,DJ1'ɘ0̥~Kw`Aͩu5we팸Wȁt@}%Q*O㪺MuC몡6U 9_kx^j<\yu0hkK"/ <.n7ω =sZedvr0 ,o&$1P+K!H MږZ;=xtXG j'Ҧ/ƽacIB es`(w8q>7=swq!@٤U:2])abxAPE0bf᧔E.bB$ӏXfp=X_ rO ?5okT
ǜ*a!7]814d <\ɃՊH)YfVWP 0σabg%@j {97+ 6~E@$jߦۡOw
x
GC[4vMp!TE*ǃh QC6Ao%'XgT@_pL68%rC4z T>S;s~'hREݺl dNQ8 ?D$ Ɵ IwS!d-:
bScu42u*br_(J Q)T5H^ (@sZ+' ?H 8&&dcԊ` B0*P
eHih'Wi?j
%
ce/[{(aIW&8/ F,TJg$s6q& Ef B`oƎ"q>݀@V2`=^t3&*~G @- %}ǖ+5j7C}Ͻe Qŋy6
:P8PCBG[U1y
>6ғ6Rp 5Vkp*ڴ73GIZ
Z?M AW Ι!hܒq`);GEx4 pϮH c;fdpI`{H hk Je)C".A 9q-PxVZX ܐr"`n 9$]Ѿq8~vi0C0la4 gZ%4tOnU8ڨNy5C\VӢ%X]5ǘ0^}e>`/DEln 6=8Eka:VvPFöuR`amZQC8|%o;B@V(b]"rw:cޘL1` mW
Kat696`sXn\R2 f/D9=*\oPZ p Scd\K nѯk{laW$SIֽm~AwAXuQ0f:˦/>b~YbPF6i/W}t@`v|fT>S=#gH䬳 -iT#>kr&D;yxFtֺ,+Ή >P +.SjՎ^ڿ:vN_ށ@&F4ʦ1_"P}[] `e%ka0R5 jzH$cXraك<}VDڪ hj2.|K${r092r%Vދ z¥ f*-.Mǥ_=RS|W~?N{K/\QSo۪FhS(Q &H#/xLԎ#_%o$rq -wۇ?H屪J*
mYkGR Wb;UwBz 7/_ TU 'wxPp Ua202 Ȼ=Xl oXբr~ 2lPc K )&2ׂ:w):|lK }C 0Iy֤b7f *~{pU*LDve{ϴa B Ԡ(yF /&ַGǔaReؿ|=+}#=
j2>ʿu rAW,y+ {[w ߮oe!WbZخ?DaX[dղN5y# ɨO+D0Az -8"ٛVU NܗhgXd^m{
M[d7yo =^uxL?mɁy N4י#B!p Cxm7
]5UY f!N>|"%}<0f"N8 Ǹc~(u);;Y
,MX"9m'5Q+fĄ{"eF#9Q|)_N=?;7~/endstream
endobj
176 0 obj
<< /Filter /FlateDecode /Length 3561 >>
stream
x[[o ~#ã˃g+Ơm ^t0>@lHjm v?Vk`Dp
3+q2 ǜ .; >pCV4<
o 0n)
s1
aU)4lOCv8s>&A9Ұa<8# |/ %Hd=ARG'C^ SJr9}~L!g÷,\ ~Z{cG GRy2y)LL6L2s&1|`K&-Ov ZΧێnn~%Oxɤe }ͣkxժܖoo t6T.+LQ[Ok;zD5_ޠc22] ѯZ}mw_!t'2MݮKK uKw쪻Xr
wB,YPLl}Z>| *<|2
Z .;/|(3X)NgQG(֧`S M3|L'Z4EqRϽFyX %?,B8Ŕ iԡg ,~w n+e5~D_r Nk9L!97<;&JwGtn ݝŅ }9T= ife ]vpz&^QpEJJX
HN&G"Ai8[}t' j $X
݉rQ78sl 8# * o0 MlNv\'C#~ /
.h|),@'QJ9^9Oޯ#rh9*nfVqK:j-(e;D,FAzc\hv~q6) &tAJ6cqځ'g d`u8D$rf;P %CfQހZzO!nw >iY ~`*PkW(o٠7NJ'yJJ?yVR/]k`1L
{|*.&@ U oTipUlѐQJ.̓Y
t`g0a-)O w,+d[ !XSWw nMeoWH".;BpVd8pOgT0A!I'f &*2G4tASjI$pR8_InDvvIe׆ $q
uNć C TVƚ=f
zIXMt@B %\` V&ӇN?fi&~3Kׄ~, }k~&+ Гr7irJH+sޔkv*sgZ҂n!KѠ\0'|etѱ<&R,a3K&Lvl+m1+)](8tX-XׂİՔlmZGS,J,x̽Zz#Z^)@'Ll QI
O: ͂)-WSdpf VS.-XcC97AOzs}3 ڶ}g? f^ĎU|+m]-IՀafKnLߖ }Z!bܖ&O}
L:2yI}2Y+?^u
' ;'^H*2!ϙ|d,61 ݯ.UrjYjb;\Z C
`]^ͻ];%Fen_bj YՅ &G&
걨3ɪDmŷU2)qztbw*n!G+W¼G{WĨyd] 7EV=r
˕ZM|ZŪetF$Ӯ_sߕɧk.)f`b>}Mw_7H /ධ Y 1ΫԜNprS B
@("s +mUí(3 p_ZVfeaz4%;M!)y8wJ.]-/2I
x]
.YhT\ڻmr~XBZjˆf(lљ,j--
ᝬ:"6! dg,Kz~r)
9 "W۸*rfy m l`{Ģ *rΦVUzv)i(p-BSFX?ZX1aG6ofR ǫ\# V. ](8)(JG¢չff\u0 ܠ;cL"*s9cܓ^+zŌTփv?k6^2d˔k. crln]9NztFjeרwǩmAQj
;mMtm mN=%֎F?3inRIŧ#4;j.,_S%/[*# ,0Vb?0%}Id,7s t4b^Ȳ.LgWѲdo''b6 oDH5c'ߨ'}YCWLE (_}3TTtεspd&=VsH : K)aMS&ᕶWShY7LY|Mb g.E!x7_b~B|rSKg^n:{U2q `J! ~d5OzhvDM&ދ%@OGJ(p~TXs-]kޛ<:μWf}r@@gXr-^FC 7Pe7dH'wLA^Kk|XeQ66 '}'hj$&QsT_J_Sou`):23loxg
Q"?)ݭOj(K$ܻ e fx%^kQ?h{Q$KZ] F
Ӌ. 8Sć;|rRy/!_x6"`횷:gF5-"(-Dr<;<^ϴ-my#X'a g@m"M%#\Y0) X 7 V{ T++<`"YGtoe,=n
)tlm {/1F7Ulkz-py(rc 7(9俻k&EOs'&G&dپ{_ģ3& N(^ ɯ?o,
wEendstream
endobj
177 0 obj
<< /Filter /FlateDecode /Length 4417 >>
stream
x ]o ]#@ߖKmHCNZSt#m~{g\rIyȘ7 =C?<_o@ | ? Q0A*< m.:)GP#[{;ݗ ib)!`B w AukDH =",:]j u,j腄5N 줖!t8Oju50/.[ڮSRh67Bvo0wGANFeN| {2Km{8 03&tX,=pv
pUeW
( |\u}?+G'}t}AxXDJVG_ I$1cSSo
yY*]F* _.ޕê2gƍl,?8].].6 "*!Thf!iB23o*զ, S狦sΜq!C02h SqD@ /*a;hpm r Z^j< rR>x۽|T {> "M xY^pdnHX8-l'h
ݸ4_5Nz`6i
۲K/+߽j \ꂐ݄& -骐u]m{SD.@=ՙQeBJuEv0 4]ٝaVQ/0کjrg8! c}gKDw#QRT3T^6GFp /ԃEq:mYR^ȇ <\hJaP(@q]࿆n/uԻ\v$HYFX
$5׃EGe 8#)9PJjZR-_Dt\CHt=do&xV> Cw. _[ ߔVq#2s
YrUt=*P, Abjtt8 ɯȧ `Tn_yQTBhP r~P87k$mzgs6MBM$(,@+A1M^{& FTot #,CF &=ʆ=ƻrF:M+xWxDɂe*'$PÉQ$F8dt_Q*e'y| uK ꊆ"9y X_,KʲP2Bt$;HrAq[ M)Ӿ "#F1^߲mɕ9ȩ`a~:6q tipI,a lIݖ-FZA0"V[XSi
H`pP,&^ xW٨0Hi 1bX+ <
BdD Ι &^a9 Zb )BXn#q)tK*͍! r?j"lIKgôx,o VdžHЋ(`
c_rbwy4enT)UUU26]Mk Qvvb.2OM QDsnt.Ae 9UY8xcTt$Zn(
<7DIPa
)wv9J rb`|KN+Mi~PZ ٻ 7+ ̅?M赒y͙ꔱmywn;\ 馁0]̋0BE\wZo%fׅXո o>eN[]K.G1s!5o=`Gvg$ _ 2%?cYw;Z/kyO~(QpV""s=&){#%((&3bXqWI Wtm|vE$atc ճwTSxkW4<dsQT uDv#@`<5z AK7W!Ac$
Tgmu{_g#Fzr͚5pBU iPpO'vBUc톈}9fٛuGL ]ZhlpD~%˪CWuEUjk Jm/S'jUb:1(E /z6
A+gd@j^lWLٚ$=SiWhs| %joߕee]B\7x@zg75' 'M}Ӷ^p"n7G4n%(]* UrrĨmR
VRU~d^&^]bϕ..`D`. 0&&,jJq)@ۙ,_~[/wHNC?q{m£mYS5Eײp{/U
`I,dygޗd::~|6r=
vTך X ث t =پy ìyM~=|ҺvHf3Sd̐N$Uu̖K0&c ?ew{ic+OڧdG{\EJ,cthMȏgbG-ghhAq cw2#a s@J3`mVlD dΚi3҉V38>H'{uO j'/q
!?ޗDIWlx6{I
M Ӡ
D9Oc%z p G9?K 'aP֏0[%
%OLsl u|{3'IA_3m:T ߃.v/rޜ7?T7g NfHǟoe uyՃoY endstream
endobj
178 0 obj
<< /Filter /FlateDecode /Subtype /Type1C /Length 360 >>
stream
xcd`ab`ddt
v04 qT~H3a!Sk7s7˚ׅ' ~O +XX_PYQ`hii`d``ZXX('gT*hdX뗗%i(gd(((%*\c8)槤1000103012ԽK 2>}wy ߯jcws~7yŞ>~nSg>;3wߛgO^-ym̾^];ǂXπ| wt\eXp~ |endstream
endobj
179 0 obj
<< /Filter /FlateDecode /Subtype /Type1C /Length 321 >>
stream
xcd`ab`dddu
1T~H3a!#.k7s7鉶 ~ (Ș[_PYQ`hii`d``ZXX('gT*hdX뗗%i(gd(((%*\"s JKR|SR
YtX53~OAe=rIa: Y˺v ]g*{ZG\Fۖ;Q>
stream
xcd`ab`dddu
21T~H3a!.k7s7鉶 ~ (Ș[_PYQ`hii`d``ZXX('gT*hdX뗗%i(gd(((%*\"s JKR|SR
YtM3~_+ۻsO/{Vw\B
ۡ݇f<ʛUg+[yNƾ | Փxxe` Kq'endstream
endobj
181 0 obj
<< /Filter /FlateDecode /Subtype /Type1C /Length 4055 >>
stream
xX TS>1sD" NS p*Xւ @2 0%&1 W)*֡rmtpz}}(1@ pman 0Վ,gs'+n(?E X<&IA/)89D ,jeg?o8zLMޤ(Ej EmUʇIvQQk:j=KmDm6QT ,AT4JM8QpO $\"a%ǹi z`ΏN㖌s~9 H]vMqxjSO}6ͭ '
XyGkir@OMo]~| NU'
5Sp
u}St (@ge>&yQZ5rF'r U2⬝b\ WA/Q5MM!"X4i}gxLA Nb;u}
moh=]y#6A = 0.VA]>"FZ oKpއEh Zv=Ɩ@qjduL셝WNf1^߇?bC> *(40gi4lYښ8 9}7ZbmvsBLaڗIͭqZ0@
k 0h &;vں#~T~2gځZW0=~@OC7͝`Dc;{+vߎȟSЁ$=+D[Ȯ3 3_y% E$tVqLL]rC]CesKTsF%g'}Op #IWiJ.ËNZQM +$`*'w+ZZ+y =(DiOGiݒi5 DcO}WZ߹˷+eaaj5.åKVd {oi_F6C `i!<G5У?9y7#+Z7T.{g'Re*S*![/"{E;6,:áhrlזZG a[X3w1qbH,ҲA"w) {vYh܇'I7hοTdF]@\- E;/{Ok_ h:(j)DTYRCa7G?47ؑP#&xLCta䪪. -aR-TnmAe~˃ZylU{7ţyv#D}' ^;e_v{:3&@JB!:Gy8O*̞Q-8&vǷq(R ݠ6 !~p4x9D&B ?}q&⸖hB"1I 1o\~k}hET\\T1ytdr|&h[* ^1%xRȻ &%\} 1pp
" Ccv8:rz
TvfGlXi[I놓pX Q)5ɽgdZBV[|O hv\>S"ߖv%2~ qD7fVA}߇^c"mZ洔lR& ^#Mw'#c2ѯ.X+hzYt;-=mZ3}]xީr2Nd@ M2! -?g߉프'Ĵr^ Qvh )**șC# ۾Ŀ@\m!u{X{Gb|!Cp1'IQB,yXgTo̪Srv""
ETDmT15q#8"!p>GVp~%VC/:!6).X;o0K:[k,;d+ ~;f@]Y4mF/g
E9Y }`+kN4bЪ2`
ĿDF$t/gohv$܌\}H& m&Ǡ)ߎ wY&7d^c,)u
p3L\;2*h!>E7BOm!es?bo*f y2>Sock."#I<ӎi,u
RR ^Q="xBFA! vgM:۸a>;wp<$ӗ&} iӯ< i$=OSfW; |%G<3Nu+lo*ÂLŴ?vnM̩5qvy
tPC:i;Va]ZX/h8aIXS@x Hendstream
endobj
182 0 obj
<< /Filter /FlateDecode /Subtype /Type1C /Length 1528 >>
stream
xyPgwIYkݍ 1ЂJV(`!
})
*GD
Z[j^:: -u:Vˡ>{% A$dIP8;{]ɦ@wHxJSzp|h0f("$$3FLfZP('(SL
R eN(UiXhyF%d*|fA MoTEZe)qjUF3 b"'\C""@b(1L /d9$ISQL)'FFkk Iu*ĭAZyM ˰l^]I #/+q sK\5uJLx8'J9$ -`E[lfjE q \1Tb)e!5 cfR %+ם)qG1`K
oaUU h a 㛌;C7wVV֜3՛yA0sr *+J;6=:֪7Vr}*Qz"tDMnM*s}i?QU`Mn g!% l\W_{p:l6oMݚ4iG+uWw$,T}!5!pEo&<ܴ v[Z5ު>S2}BV-X1 fj3vbE{Ζh܊G, t蕨;;8h{ 46!ے%k+ 4Z Mjlj}ry 5Q6V:dsxeы#>n_duW+ń4QHAxLIeEzuqiY k=}_r"'yȅ
{_~Ji%qĞ#G8-d g4 y3q+gύ}g?c{[1`-T!qLu-|0'zDo|PWc)5S.g\l0㐹.Tݾx;
+Jf/9"Oe x-Z d55@WhO'sK};S9:qh{7o h]_C#7c@hFi2tYrmަKgجw}˞y}֓"4D hu^djmzmjrᨭ .bsk;P{pzz<_?vendstream
endobj
183 0 obj
<< /Filter /FlateDecode /Subtype /Type1C /Length 1188 >>
stream
xS}Lg ~S *%d')
E"2+Zm{PUp XC]u nZF-j%KJdn% -Z&<TQ u>7wa
i6!EI Yg
hHШMqx&" wKvsI s 'pIIi{V\hqz`2Z
RX|(e&A(Yt:uk3?sc,3ˍ[L&pk V# 2xkC09=h!2a0Yeh EG}#=Z4JH>DDO*5F 1Wj="U$
FlaG2QRSg/RHS,ܦ n6-EA&Sk>:۶] 0xN< \ٰ"nTrG2cq@s : m[&D[$.KaIǘ9ن7!_wBU t y]K3oǪbXNpil綡@aRg]Cv0oqvlj7O~d GOʝdz #c¹LW S+o͓c?9]TȺ
{9p'4t Ơ+eo <%%+Co
dPu
ٚn_wPts2!>֘<0)M HU
Cy 6&]yZ%L/N3#s0=H)_`ULE%q<
b6Xnan# 0 -^ dwZNSyTQ i8endstream
endobj
184 0 obj
<< /Type /XRef /Length 154 /Filter /FlateDecode /DecodeParms << /Columns 5 /Predictor 12 >> /W [ 1 3 1 ] /Info 3 0 R /Root 2 0 R /Size 185 /ID [<9a578ca26c647d60dfc05b5c1b8062cd>] >>
stream
xcb &F~0 $8Ja?V {Ft(ٲx"3Ak) "9nH&y "HqV*$y (H17ɶD
\`q5`A$/3B RlZ0d p
endstream
endobj
startxref
118169
%%EOF
Formula/inst/doc/Formula.Rnw 0000644 0001754 0000144 00000061365 12510770244 015706 0 ustar zeileis users \documentclass[nojss]{jss}
\usepackage{thumbpdf}
%% need no \usepackage{Sweave}
%% additional commands
\newcommand{\squote}[1]{`{#1}'}
\newcommand{\dquote}[1]{``{#1}''}
\newcommand{\fct}[1]{{\texttt{#1()}}}
\newcommand{\class}[1]{\dquote{\texttt{#1}}}
%% for internal use
\newcommand{\fixme}[1]{\emph{\marginpar{FIXME} (#1)}}
\newcommand{\readme}[1]{\emph{\marginpar{README} (#1)}}
\author{Achim Zeileis\\Universit\"at Innsbruck
\And Yves Croissant\\Universit{\'e} de la R{\'e}union}
\Plainauthor{Achim Zeileis, Yves Croissant}
\title{Extended Model Formulas in \proglang{R}: Multiple Parts and Multiple Responses}
\Plaintitle{Extended Model Formulas in R: Multiple Parts and Multiple Responses}
\Shorttitle{Extended Model Formulas in \proglang{R}}
\Keywords{formula processing, model frame, model matrix, \proglang{R}}
\Plainkeywords{formula processing, model frame, model matrix, R}
\Abstract{
This introduction to the \proglang{R} package \pkg{Formula} is a (slightly)
modified version of \cite{Formula:Zeileis+Croissant:2010}, published in the
\emph{Journal of Statistical Software}.
Model formulas are the standard approach for specifying the variables
in statistical models in the \proglang{S} language. Although being eminently
useful in an extremely wide class of applications, they have certain limitations
including being confined to single responses and not providing convenient support for
processing formulas with multiple parts. The latter is relevant for models
with two or more sets of variables, e.g., different equations for different model
parameters (such as mean and dispersion), regressors and instruments in instrumental
variable regressions, two-part models such as hurdle models, or alternative-specific
and individual-specific variables in choice models among many others.
The \proglang{R}~package \pkg{Formula} addresses these two problems
by providing a new class \class{Formula} (inheriting from \class{formula})
that accepts an additional formula operator \code{|} separating multiple parts
and by allowing all formula operators (including the new \code{|})
on the left-hand side to support multiple responses.
}
\Address{
Achim Zeileis\\
Department of Statistics\\
Universit\"at Innsbruck\\
Universit\"atsstr. 15\\
6020 Innsbruck, Austria\\
E-mail: \email{Achim.Zeileis@R-project.org}\\
URL: \url{http://statmath.wu.ac.at/~zeileis/}\\
Yves Croissant\\
Universit{\'e} de la R{\'e}union\\
Facult{\'e} de Droit et d'Economie\\
15, avenue Ren{\'e} Cassin\\
BP7151\\
97715 Saint-Denis Messag Cedex 9, France\\
E-mail: \email{Yves.Croissant@univ-reunion.fr}\\
}
\begin{document}
\SweaveOpts{engine = R, eps = FALSE, keep.source = TRUE}
%\VignetteIndexEntry{Extended Model Formulas in R: Multiple Parts and Multiple Responses}
%\VignetteDepends{stats}
%\VignetteKeywords{formula processing, model frame, model matrix, R}
%\VignettePackage{Formula}
<>=
options(width = 70, prompt = "R> ", continue = "+ ")
library("Formula")
@
\section{Introduction} \label{sec:intro}
Since publication of the seminal ``white book'' \citep{Formula:Chambers+Hastie:1992}
the standard approach for fitting statistical models in the \proglang{S}
language is to apply some model-fitting function (such as \fct{lm} or \fct{glm})
to a \class{formula} description of the variables involved in the model and typically
stored in a \class{data.frame}. The semantics of formula processing
are based on the ideas of the \cite{Formula:Wilkinson+Rogers:1973} notation which in turn
was targeted at specification of analysis of variance models. Despite this emphasis on
specification of terms in models with linear predictors, formula notation
has always been used much more generally in \proglang{S}, e.g., for specifying variables in classification
and regression trees, margins in contingency tables, or variables in graphical displays.
In such applications, the precise meaning of a particular formula depends on the function
that processes it. Typically, the standard formula processing approach would
encompass extraction of the specified terms using \fct{terms}, preparation of a preprocessed
data frame using \fct{model.frame}, and computation of a ``design'' or ``regressor''
matrix using \fct{model.matrix}.
However, there are certain limitations to these standard formula processing tools in \proglang{S} that
can be rather inconvenient in certain applications:
\begin{enumerate}
\item The formula notation can just be used on the right-hand side (RHS) of a formula
(to the right of the \code{~}) while it has its original arithmetic meaning on
the left-hand side (LHS). This makes it difficult to specify multiple responses,
especially if these are not numeric (e.g., factors). This feature would be
useful for specifying multivariate outcomes of mixed types in independence tests
\citep[e.g., in the \pkg{coin} package,][]{Formula:Hothorn+Hornik+VanDeWiel:2006,Formula:Hothorn+Hornik+VanDeWiel:2008}
or in models with multivariate responses
\citep[e.g., supported in the \pkg{party} package][]{Formula:Zeileis+Hothorn+Hornik:2008}.
\item There is no simple construct in standard formula notation that allows one to
separate several groups of variables from which separate model matrices can be
derived. This task occurs in many types of models, e.g., when processing
separate sets of variables for mean and dispersion
\citep[e.g., in the \pkg{betareg} package,][]{Formula:Cribari-Neto+Zeileis:2010},
separate equations for location, scatter, and shape
\citep[e.g., in the \pkg{gamlss} package,][]{Formula:Stasinopoulos+Rigby:2007},
regressors and instruments in instrumental variable regressions
(e.g., in the \pkg{plm} package, \citealp{Formula:Croissant+Millo:2008},
or the \pkg{AER} package, \citealp{Formula:Kleiber+Zeileis:2008}),
variables in two-part models such as hurdle models or zero-inflated regressions
\citep[e.g., in the \pkg{pscl} package,][]{Formula:Zeileis+Kleiber+Jackman:2008},
alternative-specific and individual-specific variables in choice models
\citep[e.g., in the \pkg{mlogit} package,][]{Formula:Croissant:2010},
efficiency level variables in stochastic frontier analysis
\citep[e.g., in the \pkg{frontier} package,][]{Formula:Coelli+Henningsen:2010}, or
modeling variables and partitioning variables in model-based recursive partitioning techniques
\citep[e.g., in the \pkg{party} package,][]{Formula:Zeileis+Hothorn+Hornik:2008}.
\end{enumerate}
In many of the aformentioned packages, standard \class{formula} objects are employed
but their processing is generalized, e.g., by using multiple formulas, multiple terms,
by adding new formula operators or even more elaborate solutions. However, in many situations
it is not easy to reuse these generalizations outside the package/function they were designed for.
Therefore, as we repeatedly needed such generalizations in our own packages
and addressed this in the past by various different solutions, it seemed natural
to provide a more general unified approach by means of our new \pkg{Formula} package.
This has already been reused in some of our own packages (including \pkg{AER}, \pkg{betareg},
\pkg{mlogit}, and \pkg{plm}) but can also be easily employed by other package developers
(e.g., as in the \pkg{frontier} package). More applications in our own and other packages
will hopefully follow.
In the remainder of this paper we discuss
how multiple responses and multiple parts (both on the LHS and RHS) are enabled
in the \pkg{Formula} package written in the \proglang{R} system for statistical
computing \citep{Formula:R:2009} and available from the Comprehensive \proglang{R}
Archive Network (CRAN) at \url{http://CRAN.R-project.org/package=Formula}. Built on top of
basic \class{formula} objects, the \class{Formula} class just adds a thin additional layer
which is based on a single additional operator, namely \code{|}, that can be used to separate different
parts (or groups) of variables. \pkg{Formula} essentially just handles the different
formula parts and leverages the existing methods for \class{formula} objects for all
remaining operations.\footnote{Throughout the paper, no terminological distinction is made between
classic \class{formula} objects as such and the way they are interpreted by
standard processing tools (e.g., \fct{terms}, \fct{model.frame}, \fct{model.matrix}).
The reasons for this are twofold: First, it reflects their use as described in
\cite{Formula:Chambers+Hastie:1992} and, second, generalizations generally require
extra effort from the user.}
In Section~\ref{sec:motivation} we show two small motivating
examples that convey the main ideas implemented in the package and how easily they
can be employed. The details of the \class{Formula} class and its associated methods
are discussed in Section~\ref{sec:implementation} and Section~\ref{sec:usage} illustrates
the usage of \pkg{Formula} in developing new model-fitting functions.
A short summary in Section~\ref{sec:summary} concludes the paper.
\section{Motivating examples} \label{sec:motivation}
To illustrate the basic ideas of the \pkg{Formula} package, we first generate a small
artificial data set (with both numeric and categorical variables) and subsequently
illustrate its usage with a multi-part and a multi-response \class{Formula}, respectively.
<>=
set.seed(1090)
dat <- as.data.frame(matrix(round(runif(21), digits = 2), ncol = 7))
colnames(dat) <- c("y1", "y2", "y3", "x1", "x2", "x3", "x4")
for(i in c(2, 6:7)) dat[[i]] <- factor(dat[[i]] < 0.5,
labels = c("a", "b"))
dat$y2[1] <- NA
dat
@
\subsection{Multiple parts}
We start out with a simple formula \verb/log(y1) ~ x1 + x2 | I(x1^2)/ which
has a single response \code{log(y1)} on the LHS and two parts on the RHS, separated
by \code{|}. The first part contains \code{x1} and \code{x2}, the second contains
\verb/I(x1^2)/, i.e., the squared values of \code{x1}. The initial \class{formula}
can be transformed to a \class{Formula} using the constructor function \fct{Formula}:
%
<>=
F1 <- Formula(log(y1) ~ x1 + x2 | I(x1^2))
length(F1)
@
%
The \fct{length} method indicates that there is one part on the LHS and two parts
on the RHS. The first step of processing data using a formula is typically the
construction of a so-called model frame containing only the variables required
by the formula. As usual, this can be obtained with the \fct{model.frame} method.
%
<>=
mf1 <- model.frame(F1, data = dat)
mf1
@
%
As this model just has a single response (as in base \class{formula} objects),
the extractor function \fct{model.response} can be employed:
%
<>=
model.response(mf1)
@
%
For constructing separate model matrices for the two parts on the RHS, the
\fct{model.matrix} can be employed and additionally specifying the argument
\code{rhs}:
%
<>=
model.matrix(F1, data = mf1, rhs = 1)
model.matrix(F1, data = mf1, rhs = 2)
@
\subsection{Multiple responses}
To accommodate multiple responses, all formula operators can be employed
on the LHS in \class{Formula} objects (whereas they would have their original
arithmetic meaning in \class{formula} objects). This also includes the
new \code{|} operator for separating different parts. Thus, one could
specify a two-part response via \code{y1 | y2 ~ x3} or a single part
with two variables via \code{y1 + y2 ~ x3}. We do the latter in the
following illustration.
%
<>=
F2 <- Formula(y1 + y2 ~ x3)
length(F2)
@
%
As usual, the model frame can be derived by
%
<>=
mf2 <- model.frame(F2, data = dat)
mf2
@
%
However, there is an important difference to the model frame \code{mf1}
derived in the previous example. As the (non-generic) \fct{model.response}
function would only be able to extract a single response column from a model frame,
multi-response model frames in \pkg{Formula} are implemented to have no response
at all in the \fct{model.response} sense:
%
<>=
model.response(mf2)
@
%
As \fct{model.response} cannot be extended (without overloading the base \proglang{R}
function), \pkg{Formula} provides a new generic function \fct{model.part} which can
be used to extract all variables from a model frame pertaining to specific parts.
This can also be used to extract multiple responses. Its syntax is modeled
after \fct{model.matrix} taking a \class{Formula} as the first argument. For further
details see Section~\ref{sec:implementation}. Its application is straightforward
and all LHS variables (in the first and only part of the LHS) can be extracted via
%
<>=
model.part(F2, data = mf2, lhs = 1)
@
%
The same method also works for single response models as in the previous example:
%
<>=
model.part(F1, data = mf1, lhs = 1, drop = TRUE)
@
\section{Implementation} \label{sec:implementation}
Below we discuss the ideas for the design of the \class{Formula} class
and methods. As all tools are built on top of the
\class{formula} class and its associated methods whose most important feature are briefly outlined
as well.
\subsection[Working with classic ``formula'' objects]{Working with classic \class{formula} objects}
Classic \class{formula} objects \citep{Formula:Chambers+Hastie:1992}
are constructed by using \code{~} to separate LHS and RHS, typically
(but not necessarily) interpreted as ``dependent'' and ``explanatory''
variables. For describing relationships between variables on
the RHS, several operators can be used: \code{+}, \code{-}, \code{*},
\code{/}, \code{:}, \verb+%in%+, \verb+^+. Thus, these do not have
their original meaning in the top-level RHS while they keep their original
arithmetic meaning on higher levels of the RHS (thus, within function
calls such as \verb+I(x1^2)+) and on the LHS in general. A first step
in using \class{formula} objects is often to compute the associated
\class{terms} using the function \fct{terms}. Based on the formula or
the associated terms and a suitable set of variables (typically either
in a data frame or in the global environment) \fct{model.frame} can
build a so-called model frame that contains all variables in the formula/terms.
This might include processing of missing values (\code{NA}s),
carrying out variable transformations (such as logs, squares,
or other functions of one or more variables) and providing further variables
like weights, offset, etc. A model frame is simply a \class{data.frame} with
additional attributes (including \class{terms}) but without a specific class.
From this preprocessed model frame several components can
be extracted using \fct{model.extract} or \fct{model.response},
\fct{model.weights}, and \fct{model.offset}, all of which are non-generic.
Last not least, \fct{model.matrix} (which is generic) can compute ``design'' or ``regressor''
matrices based on the formula/terms and the associated model frame.
\subsection[Constructing ``Formula'' objects]{Constructing \class{Formula} objects}
To accomplish the main objectives of the \class{Formula} class,
the following design
principles have been used: reuse of \class{formula} objects,
introduction of a single new operator \code{|}, and support of all
formula operators on the LHS. Thus, \code{|} loses its original
meaning (logical ``or'') on the first level of formulas but can
still be used with its original meaning on higher levels, e.g.,
\code{factor(x1 > 0.5 | x3 == "a")} still works as before.
For assigning a new class to formulas containing \code{|},
the constructor function \fct{Formula} is used:
%
<>=
F3 <- Formula(y1 + y2 | log(y3) ~ x1 + I(x2^2) | 0 + log(x1) | x3 / x4)
F3
length(F3)
@
%
In this example, \code{F3} is an artificially complex formula with two
parts on the LHS and three parts on the RHS, both containing multiple
terms, transformations or other formula operators. Apart from assigning
the new class \class{Formula} (in addition to the old \class{formula} class),
\fct{Formula} also splits up the formula into LHS and RHS parts which
are stored as list attributes \code{"lhs"} and \code{"rhs"}, respectively,
e.g.,
%
<>=
attr(F3, "lhs")
@
and analogously \code{attr(F3, "rhs")}. The user never has to compute
on these attributes directly, but many methods for \class{Formula}
objects take \code{lhs} and/or \code{rhs} arguments. These always refer
to index vectors for the two respective lists.
It would have been conceivable to generalize not only the notion of
formulas but also of terms or model frames. However, there are few
generics with methods for \class{terms} objects and there is
no particular class for model frames at all. Hence, computing with
generalized versions of these concepts would have required much more
overhead for users of \pkg{Formula}. Hence, it was decided
not to do so and keep the package interface as simple as possible.
\subsection[Extracting ``formula'' and ``terms'' objects]{Extracting \class{formula} and \class{terms} objects}
As subsequent computations typically require a \class{formula} or
a \class{terms} object, \pkg{Formula} provides suitable \fct{formula}
and \fct{terms} extractors for \class{Formula} objects. For the former,
the idea is to be able to switch back and forth between the \class{Formula}
and \class{formula} representation, e.g., \code{formula(Formula(...))}
should recover the original input formula. For the latter, the objective
is somewhat different: \fct{terms} should always return a \class{terms}
object that can be processed by \fct{model.frame} and similar functions.
Thus, the terms must not contain multiple responses and/or the new
\code{|} operator.
The \fct{formula} method is straightforward. When no additional arguments
are supplied it recovers the original \class{formula}. Furthermore, there
are two optional additional arguments \code{lhs} and \code{rhs}. With
these arguments subsets of formulas
can be chosen, indexing the LHS and RHS parts. The default value for
both is \code{NULL}, meaning that all parts are employed.
%
<>=
formula(F3)
formula(F3, lhs = 2, rhs = -2)
formula(F3, lhs = c(TRUE, FALSE), rhs = 0)
@
Similarly, \fct{terms} computes a \class{terms} object, by default using
all parts in the formula, but \code{lhs} and \code{rhs} can be used as
above. To remove the \code{|} operator, all parts are collapsed using the
\code{+} operator. Furthermore, the LHS variables can only be kept on the
LHS if they contain a single term. Otherwise, to stop subsequent computations
from interpreting the formula operators as arithmetic operators, all LHS
components are added on the RHS as well. Thus, for \code{F3} we obtain
%
<>=
terms(F3)
@
%
Instead of using all parts, subsets can again be selected. We illustrate this
below but only show the associated \class{formula} to save output space:
<>=
formula(terms(F3))
formula(terms(F3, lhs = 2, rhs = -2))
formula(terms(F3, lhs = c(TRUE, FALSE), rhs = 0))
@
\subsection{Computing model frames, matrices, and responses}
Given that suitable \class{terms} can be extracted from \class{Formula}
objects, it is straightforward to set up the corresponding model frame.
The \fct{model.frame} method simply first calls the \fct{terms} method
and then applies the default \fct{model.frame}. Hence, all further
arguments are processed as usual, e.g.,
%
<>=
mf3 <- model.frame(F3, data = dat, subset = y1 < 0.75, weights = x1)
mf3
@
%
All subsequent computations are then based on this preprocessed model
frame (and possibly the original \class{Formula}). Thus, the model matrices
for each RHS part can be easily computed, again setting the \code{rhs} argument:
%
<>=
model.matrix(F3, data = mf3, rhs = 2)
@
%
Typically, just a single RHS will be selected and hence \code{rhs = 1}
and not \code{rhs = NULL} is the default in this method. However, multiple RHS parts
are also supported. Also, there is a \code{lhs} argument available (defaulting to \code{NULL})
which might seem unnecessary at first sight but it is important
in case the selected RHS part(s) contain(s) a ``\code{.}'' that needs to
be resolved (see \code{?model.matrix.Formula} for an example).
The LHS parts can be extracted using the method
for the new \fct{model.part} generic, employing a syntax similar to \fct{model.matrix}:
%
<>=
model.part(F3, data = mf3, lhs = 1)
model.part(F3, data = mf3, lhs = 2)
@
%
As argued above, introduction of a new generic is necessary for supporting multi-response
formulas because \fct{model.response} is non-generic. For model frames derived
from single-response formulas, \fct{model.response} can be used as usual.
The remaining extractors work as usual:
%
<>=
model.weights(mf3)
@
\subsection{Further methods}
To conclude the suite of methods available for the new \class{Formula} class,
\pkg{Formula} provides an \fct{update} method and a new \fct{as.Formula}
generic with suitable methods. The former updates the formula part by part,
adding new parts if necessary:
%
<>=
update(F1, . ~ . - x1 | . + x1)
update(F1, . + y2 | y3 ~ .)
@
%
The \fct{as.Formula} method coerces to \class{Formula}, possibly also processing
multiple arguments:
%
<>=
as.Formula(y1 ~ x1, y2 ~ x2, ~ x3)
@
\section{Usage in model fitting functions} \label{sec:usage}
A typical application of \pkg{Formula} is to provide the workhorse for formula
processing in model-fitting functions that require specification of multiple
parts or multiple responses. To provide a very brief and simple example, we
show how such a function can be set up. For illustration, we compute the
coefficients in an instrumental variables regression using two-stage least
squares.
The \fct{ivcoef} function below takes the usual arguments \code{formula},
\code{data}, \code{subset}, and\linebreak \code{na.action} (and further arguments
\code{weights} and \code{offset} could be included in the same way).
The \code{formula} should be a two-part formula like \code{y ~ x1 + x2 | z1 + z2 + z3}.
There is a single response on the LHS, one RHS part with the regressors and
a second RHS part with the instruments. The function \fct{ivcoef} uses the
typical workflow of model-fitting functions and processes
its arguments in the following four steps:
(1)~process the call,
(2)~set up the model frame (using the \class{Formula} method),
(3)~extract response and regressors from the model frame,
(4)~estimate the model (by calling \fct{lm.fit} twice to compute the
two-stage least squares coefficients).
%
<>=
ivcoef <- function(formula, data, subset, na.action, ...)
{
mf <- match.call(expand.dots = FALSE)
m <- match(c("formula", "data", "subset", "na.action"), names(mf), 0)
mf <- mf[c(1, m)]
f <- Formula(formula)
mf[[1]] <- as.name("model.frame")
mf$formula <- f
mf <- eval(mf, parent.frame())
y <- model.response(mf)
x <- model.matrix(f, data = mf, rhs = 1)
z <- model.matrix(f, data = mf, rhs = 2)
xz <- as.matrix(lm.fit(z, x)$fitted.values)
lm.fit(xz, y)$coefficients
}
@
%
The resulting function can then be applied easily (albeit not very meaningfully)
to the \code{dat} data frame:
%
<>=
ivcoef(log(y1) ~ x1 | x2, data = dat)
@
%
The same coefficients can be derived along with all the usual inference
using the \fct{ivreg} function from the \pkg{AER} package \citep{Formula:Kleiber+Zeileis:2008},
which also uses the \pkg{Formula} tools in its latest release. Apart from
providing inference and many other details, \fct{ivreg} also supports \code{weights},
\code{offsets} etc. Finally, for backward compatibility, the function
also allows separate formulas for regressors and instruments (i.e.,
\code{formula = y ~ x1 + x2} and \code{instruments = ~ z1 + z2 + z3})
which can be easily incorporated using the \pkg{Formula} tools, e.g.,
replacing \code{f <- Formula(formula)} by
%
\begin{Sinput}
+ f <- if(!is.null(instruments)) as.Formula(formula, instruments)
+ else as.Formula(formula)
+ stopifnot(isTRUE(all.equal(length(f), c(1, 2))))
\end{Sinput}
%
In summary, the usage of \pkg{Formula} should reduce the overhead for the
developers of model-fitting functions in \proglang{R} with multiple responses and/or multiple
parts and make the resulting programs more intelligible. Further \proglang{R}
packages employing the \class{Formula} approach can be obtained from CRAN,
including \pkg{betareg}, \pkg{frontier}, \pkg{mlogit}, and \pkg{plm}.
\section{Summary} \label{sec:summary}
The \pkg{Formula} package provides tools for processing multi-response and
multi-part formulas in the \proglang{R} system for statistical computing.
The new class \class{Formula} inherits from the existing \class{formula}
class, only adds a single new formula operator \code{|}, and enables
the usage of formula operators on the left-hand side of formulas. The methods provided
for \class{Formula} objects are as similar as possible to the classic
methods, facilitating their usage in model-fitting functions that require
support for multiple responses and/or multiple parts of variables.
\bibliography{Formula}
\end{document}
Formula/inst/doc/Formula.R 0000644 0001754 0000144 00000012412 12510770244 015326 0 ustar zeileis users ### R code from vignette source 'Formula.Rnw'
###################################################
### code chunk number 1: preliminaries
###################################################
options(width = 70, prompt = "R> ", continue = "+ ")
library("Formula")
###################################################
### code chunk number 2: example-data
###################################################
set.seed(1090)
dat <- as.data.frame(matrix(round(runif(21), digits = 2), ncol = 7))
colnames(dat) <- c("y1", "y2", "y3", "x1", "x2", "x3", "x4")
for(i in c(2, 6:7)) dat[[i]] <- factor(dat[[i]] < 0.5,
labels = c("a", "b"))
dat$y2[1] <- NA
dat
###################################################
### code chunk number 3: multi-part1
###################################################
F1 <- Formula(log(y1) ~ x1 + x2 | I(x1^2))
length(F1)
###################################################
### code chunk number 4: multi-part2
###################################################
mf1 <- model.frame(F1, data = dat)
mf1
###################################################
### code chunk number 5: multi-part3
###################################################
model.response(mf1)
###################################################
### code chunk number 6: multi-part4
###################################################
model.matrix(F1, data = mf1, rhs = 1)
model.matrix(F1, data = mf1, rhs = 2)
###################################################
### code chunk number 7: multi-response1
###################################################
F2 <- Formula(y1 + y2 ~ x3)
length(F2)
###################################################
### code chunk number 8: multi-response2
###################################################
mf2 <- model.frame(F2, data = dat)
mf2
###################################################
### code chunk number 9: multi-response3
###################################################
model.response(mf2)
###################################################
### code chunk number 10: multi-response4
###################################################
model.part(F2, data = mf2, lhs = 1)
###################################################
### code chunk number 11: single-response
###################################################
model.part(F1, data = mf1, lhs = 1, drop = TRUE)
###################################################
### code chunk number 12: details1
###################################################
F3 <- Formula(y1 + y2 | log(y3) ~ x1 + I(x2^2) | 0 + log(x1) | x3 / x4)
F3
length(F3)
###################################################
### code chunk number 13: details2
###################################################
attr(F3, "lhs")
###################################################
### code chunk number 14: formula-method
###################################################
formula(F3)
formula(F3, lhs = 2, rhs = -2)
formula(F3, lhs = c(TRUE, FALSE), rhs = 0)
###################################################
### code chunk number 15: terms-method1
###################################################
terms(F3)
###################################################
### code chunk number 16: terms-method
###################################################
formula(terms(F3))
formula(terms(F3, lhs = 2, rhs = -2))
formula(terms(F3, lhs = c(TRUE, FALSE), rhs = 0))
###################################################
### code chunk number 17: model.frame-method
###################################################
mf3 <- model.frame(F3, data = dat, subset = y1 < 0.75, weights = x1)
mf3
###################################################
### code chunk number 18: model.matrix-method
###################################################
model.matrix(F3, data = mf3, rhs = 2)
###################################################
### code chunk number 19: model.response-substitute
###################################################
model.part(F3, data = mf3, lhs = 1)
model.part(F3, data = mf3, lhs = 2)
###################################################
### code chunk number 20: model.foo-methods
###################################################
model.weights(mf3)
###################################################
### code chunk number 21: update-method
###################################################
update(F1, . ~ . - x1 | . + x1)
update(F1, . + y2 | y3 ~ .)
###################################################
### code chunk number 22: as.Formula-method
###################################################
as.Formula(y1 ~ x1, y2 ~ x2, ~ x3)
###################################################
### code chunk number 23: ivcoef
###################################################
ivcoef <- function(formula, data, subset, na.action, ...)
{
mf <- match.call(expand.dots = FALSE)
m <- match(c("formula", "data", "subset", "na.action"), names(mf), 0)
mf <- mf[c(1, m)]
f <- Formula(formula)
mf[[1]] <- as.name("model.frame")
mf$formula <- f
mf <- eval(mf, parent.frame())
y <- model.response(mf)
x <- model.matrix(f, data = mf, rhs = 1)
z <- model.matrix(f, data = mf, rhs = 2)
xz <- as.matrix(lm.fit(z, x)$fitted.values)
lm.fit(xz, y)$coefficients
}
###################################################
### code chunk number 24: ivcoef-example
###################################################
ivcoef(log(y1) ~ x1 | x2, data = dat)
Formula/tests/ 0000755 0001754 0000144 00000000000 12213624611 013212 5 ustar zeileis users Formula/tests/Examples/ 0000755 0001754 0000144 00000000000 12213624611 014770 5 ustar zeileis users Formula/tests/Examples/Formula-Ex.Rout.save 0000644 0001754 0000144 00000021051 12510735736 020571 0 ustar zeileis users
R version 3.1.2 (2014-10-31) -- "Pumpkin Helmet"
Copyright (C) 2014 The R Foundation for Statistical Computing
Platform: x86_64-pc-linux-gnu (64-bit)
R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.
R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.
Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
> pkgname <- "Formula"
> source(file.path(R.home("share"), "R", "examples-header.R"))
> options(warn = 1)
> library('Formula')
>
> base::assign(".oldSearch", base::search(), pos = 'CheckExEnv')
> cleanEx()
> nameEx("Formula")
> ### * Formula
>
> flush(stderr()); flush(stdout())
>
> ### Name: Formula
> ### Title: Extended Formulas: Multiple Responses and Multiple Regressor
> ### Parts
> ### Aliases: Formula formula.Formula as.Formula as.Formula.default
> ### as.Formula.formula as.Formula.Formula is.Formula print.Formula
> ### update.Formula length.Formula all.equal.Formula str.Formula
> ### Keywords: classes
>
> ### ** Examples
>
> ## create a simple Formula with one response and two regressor parts
> f1 <- y ~ x1 + x2 | z1 + z2 + z3
> F1 <- Formula(f1)
> class(F1)
[1] "Formula" "formula"
> length(F1)
[1] 1 2
>
> ## switch back to original formula
> formula(F1)
y ~ x1 + x2 | z1 + z2 + z3
>
> ## create formula with various transformations
> formula(F1, rhs = 1)
y ~ x1 + x2
> formula(F1, collapse = TRUE)
y ~ x1 + x2 + (z1 + z2 + z3)
> formula(F1, lhs = 0, rhs = 2)
~z1 + z2 + z3
>
> ## put it together from its parts
> as.Formula(y ~ x1 + x2, ~ z1 + z2 + z3)
y ~ x1 + x2 | z1 + z2 + z3
>
> ## update the formula
> update(F1, . ~ . + I(x1^2) | . - z2 - z3)
y ~ x1 + x2 + I(x1^2) | z1
> update(F1, . | y2 + y3 ~ .)
y | y2 + y3 ~ x1 + x2 | z1 + z2 + z3
>
> # create a multi-response multi-part formula
> f2 <- y1 | y2 + y3 ~ x1 + I(x2^2) | 0 + log(x1) | x3 / x4
> F2 <- Formula(f2)
> length(F2)
[1] 2 3
>
> ## obtain various subsets using standard indexing
> ## no lhs, first/seconde rhs
> formula(F2, lhs = 0, rhs = 1:2)
~x1 + I(x2^2) | 0 + log(x1)
> formula(F2, lhs = 0, rhs = -3)
~x1 + I(x2^2) | 0 + log(x1)
> formula(F2, lhs = 0, rhs = c(TRUE, TRUE, FALSE))
~x1 + I(x2^2) | 0 + log(x1)
> ## first lhs, third rhs
> formula(F2, lhs = c(TRUE, FALSE), rhs = 3)
y1 ~ x3/x4
>
>
>
> cleanEx()
> nameEx("model.frame.Formula")
> ### * model.frame.Formula
>
> flush(stderr()); flush(stdout())
>
> ### Name: model.frame.Formula
> ### Title: Model Frame/Matrix/Response Construction for Extended Formulas
> ### Aliases: terms.Formula model.matrix.Formula model.frame.Formula
> ### model.part model.part.formula model.part.Formula
> ### Keywords: models
>
> ### ** Examples
>
> ## artificial example data
> set.seed(1090)
> dat <- as.data.frame(matrix(round(runif(21), digits = 2), ncol = 7))
> colnames(dat) <- c("y1", "y2", "y3", "x1", "x2", "x3", "x4")
> for(i in c(2, 6:7)) dat[[i]] <- factor(dat[[i]] > 0.5, labels = c("a", "b"))
> dat$y2[1] <- NA
> dat
y1 y2 y3 x1 x2 x3 x4
1 0.82 0.27 0.09 0.22 b a
2 0.70 b 0.17 0.26 0.46 a a
3 0.65 a 0.28 0.03 0.37 b b
>
> ######################################
> ## single response and two-part RHS ##
> ######################################
>
> ## single response with two-part RHS
> F1 <- Formula(log(y1) ~ x1 + x2 | I(x1^2))
> length(F1)
[1] 1 2
>
> ## set up model frame
> mf1 <- model.frame(F1, data = dat)
> mf1
log(y1) x1 x2 I(x1^2)
1 -0.1984509 0.09 0.22 0.0081
2 -0.3566749 0.26 0.46 0.0676
3 -0.4307829 0.03 0.37 9e-04
>
> ## extract single response
> model.part(F1, data = mf1, lhs = 1, drop = TRUE)
1 2 3
-0.1984509 -0.3566749 -0.4307829
> model.response(mf1)
1 2 3
-0.1984509 -0.3566749 -0.4307829
> ## model.response() works as usual
>
> ## extract model matrices
> model.matrix(F1, data = mf1, rhs = 1)
(Intercept) x1 x2
1 1 0.09 0.22
2 1 0.26 0.46
3 1 0.03 0.37
attr(,"assign")
[1] 0 1 2
> model.matrix(F1, data = mf1, rhs = 2)
(Intercept) I(x1^2)
1 1 0.0081
2 1 0.0676
3 1 0.0009
attr(,"assign")
[1] 0 1
>
> #########################################
> ## multiple responses and multiple RHS ##
> #########################################
>
> ## set up Formula
> F2 <- Formula(y1 + y2 | log(y3) ~ x1 + I(x2^2) | 0 + log(x1) | x3 / x4)
> length(F2)
[1] 2 3
>
> ## set up full model frame
> mf2 <- model.frame(F2, data = dat)
> mf2
y1 y2 log(y3) x1 I(x2^2) log(x1) x3 x4
2 0.70 b -1.771957 0.26 0.2116 -1.347074 a a
3 0.65 a -1.272966 0.03 0.1369 -3.506558 b b
>
> ## extract responses
> model.part(F2, data = mf2, lhs = 1)
y1 y2
2 0.70 b
3 0.65 a
> model.part(F2, data = mf2, lhs = 2)
log(y3)
2 -1.771957
3 -1.272966
> ## model.response(mf2) does not give correct results!
>
> ## extract model matrices
> model.matrix(F2, data = mf2, rhs = 1)
(Intercept) x1 I(x2^2)
2 1 0.26 0.2116
3 1 0.03 0.1369
attr(,"assign")
[1] 0 1 2
> model.matrix(F2, data = mf2, rhs = 2)
log(x1)
2 -1.347074
3 -3.506558
attr(,"assign")
[1] 1
> model.matrix(F2, data = mf2, rhs = 3)
(Intercept) x3b x3a:x4b x3b:x4b
2 1 0 0 0
3 1 1 0 1
attr(,"assign")
[1] 0 1 2 2
attr(,"contrasts")
attr(,"contrasts")$x3
[1] "contr.treatment"
attr(,"contrasts")$x4
[1] "contr.treatment"
>
> #######################
> ## Formulas with '.' ##
> #######################
>
> ## set up Formula with a single '.'
> F3 <- Formula(y1 | y2 ~ .)
> mf3 <- model.frame(F3, data = dat)
> ## without y1 or y2
> model.matrix(F3, data = mf3)
(Intercept) y3 x1 x2 x3b x4b
2 1 0.17 0.26 0.46 0 0
3 1 0.28 0.03 0.37 1 1
attr(,"assign")
[1] 0 1 2 3 4 5
attr(,"contrasts")
attr(,"contrasts")$x3
[1] "contr.treatment"
attr(,"contrasts")$x4
[1] "contr.treatment"
> ## without y1 but with y2
> model.matrix(F3, data = mf3, lhs = 1)
(Intercept) y2b y3 x1 x2 x3b x4b
2 1 1 0.17 0.26 0.46 0 0
3 1 0 0.28 0.03 0.37 1 1
attr(,"assign")
[1] 0 1 2 3 4 5 6
attr(,"contrasts")
attr(,"contrasts")$y2
[1] "contr.treatment"
attr(,"contrasts")$x3
[1] "contr.treatment"
attr(,"contrasts")$x4
[1] "contr.treatment"
> ## without y2 but with y1
> model.matrix(F3, data = mf3, lhs = 2)
(Intercept) y1 y3 x1 x2 x3b x4b
2 1 0.70 0.17 0.26 0.46 0 0
3 1 0.65 0.28 0.03 0.37 1 1
attr(,"assign")
[1] 0 1 2 3 4 5 6
attr(,"contrasts")
attr(,"contrasts")$x3
[1] "contr.treatment"
attr(,"contrasts")$x4
[1] "contr.treatment"
>
> ## set up Formula with multiple '.'
> F3 <- Formula(y1 | y2 | log(y3) ~ . - x3 - x4 | .)
> ## process both '.' separately (default)
> mf3 <- model.frame(F3, data = dat, dot = "separate")
> ## only x1-x2
> model.part(F3, data = mf3, rhs = 1)
x1 x2
2 0.26 0.46
3 0.03 0.37
> ## all x1-x4
> model.part(F3, data = mf3, rhs = 2)
x1 x2 x3 x4
2 0.26 0.46 a a
3 0.03 0.37 b b
> ## process the '.' sequentially, i.e., the second RHS conditional on the first
> mf3 <- model.frame(F3, data = dat, dot = "sequential")
> ## only x1-x2
> model.part(F3, data = mf3, rhs = 1)
x1 x2
2 0.26 0.46
3 0.03 0.37
> ## only x3-x4
> model.part(F3, data = mf3, rhs = 2)
x3 x4
2 a a
3 b b
>
> ##############################
> ## Process multiple offsets ##
> ##############################
>
> ## set up Formula
> F4 <- Formula(y1 ~ x3 + offset(x1) | x4 + offset(log(x2)))
> mf4 <- model.frame(F4, data = dat)
> ## model.part can be applied as above and includes offset!
> model.part(F4, data = mf4, rhs = 1)
x3 offset(x1)
1 b 0.09
2 a 0.26
3 b 0.03
> ## additionally, the corresponding corresponding terms can be included
> model.part(F4, data = mf4, rhs = 1, terms = TRUE)
x3 offset(x1)
1 b 0.09
2 a 0.26
3 b 0.03
> ## hence model.offset() can be applied to extract offsets
> model.offset(model.part(F4, data = mf4, rhs = 1, terms = TRUE))
[1] 0.09 0.26 0.03
> model.offset(model.part(F4, data = mf4, rhs = 2, terms = TRUE))
[1] -1.5141277 -0.7765288 -0.9942523
>
>
>
> ### *