A system for doing object oriented programming

R was originally quite interesting because it is both interactive and has a system for object
orientation.
In R much of the code for supporting classes/methods is written by J ohn Chambers himself (the
creator of the original S language) and documented in the book Programming with Data: A Guide
to the S Language
A natural extension of Chambers idea of allowing someone to cross the user programmer
spectrum
Object oriented programming is a bit different in R than it is in most languages even if you are
familiar with the idea, you may want to pay attention to the details

Other languages which support OOP (C++, J ava, Lisp, Python, Perl) generally speaking are
not interactive languages
-

S3 classes/methods
S4 classes/methods
Included with version 3 of the S language.
Informal, a little kludgey
Sometimes called old-style classes/methods

more formal and rigorous

Included with S-PLUS 6 and R 1.4.0 (December 2001)
Also called new-style classes/methods

For now (and the forseeable future), S3 classes/methods and S4 classes/methods are separate
systems (but they can be mixed to some degree).
Each system can be used fairly independently of the other.
Developers of new projects (you!) are encouraged to use the S4 style classes/methods.
But many developers still use S3 classes/methods because they are quick and dirty (and
easier).
In this lecture we will focus primarily on S4 classes/methods
The code for implementing S4 classes/methods in R is in the methods package, which is usually
loaded by default (but you can load it with l i br ar y( met hods) if for some reason it is not
loaded)

Used extensively in the Bioconductor project -

A class is a description of an thing. A class can be defined using set Cl ass( ) in the methods
package.
An object is an instance of a class. Objects can be created using new( ) .
A method is a function that only operates on a certain class of objects.
A generic function is an R function which dispatches methods. A generic function typically
encapsulates a generic concept (e.g. pl ot , mean, pr edi ct , ...)
A method is the implementation of a generic function for an object of a particular class.

The generic function does not actually do any computation. -

The help files for the methods package are extensive do read them as they are the primary
documentation
You may want to start with ?Cl asses and ?Met hods
Check out ?set Cl ass, ?set Met hod, and ?set Gener i c
Some of it gets technical, but try your best for nowit will make sense in the future as you keep
using it.
Most of the documentation in the methods package is oriented towards developers/programmers
as these are the primary people using classes/methods

All objects in R have a class which can be determined by the class function
cl ass( 1)
## [ 1] "numer i c"
cl ass( TRUE)
## [ 1] "l ogi cal "
cl ass( r nor m( 100) )
## [ 1] "numer i c"
cl ass( NA)
## [ 1] "l ogi cal "
cl ass( "f oo")
## [ 1] "char act er "
Data classes go beyond the atomic classes
x <- r nor m( 100)
y <- x + r nor m( 100)
f i t <- l m( y ~ x) ## l i near r egr essi on model
cl ass( f i t )
## [ 1] "l m"
S4 and S3 style generic functions look different but conceptually, they are the same (they play the
same role).
When you program you can write new methods for an existing generic OR create your own
generics and associated methods.
Of course, if a data type does not exist in R that matches your needs, you can always define a
new class along with generics/methods that go with it

The mean and pr i nt functions are generic

mean
## f unct i on ( x, . . . )
## UseMet hod( "mean")
## <byt ecode: 0x7f acdb660ad0>
## <envi r onment : namespace: base>
pr i nt
## f unct i on ( x, . . . )
## UseMet hod( "pr i nt ")
## <byt ecode: 0x7f acd9ccf d58>
## <envi r onment : namespace: base>
The mean generic function has a number of methods associated with it.
met hods( "mean")
## [ 1] mean. Dat e mean. def aul t mean. di f f t i me mean. POSI Xct mean. POSI Xl t
The show function is from the methods package and is the S4 equivalent of pr i nt
The show function is usually not called directly (much like pr i nt ) because objects are auto-printed.
show
## st andar dGener i c f or "show" def i ned f r ompackage "met hods"
##
## f unct i on ( obj ect )
## st andar dGener i c( "show")
## <byt ecode: 0x7f acdb8034d8>
## <envi r onment : 0x7f acdb779868>
## Met hods may be def i ned f or ar gument s: obj ect
## Use showMet hods( "show") f or cur r ent l y avai l abl e ones.
## ( Thi s gener i c f unct i on excl udes non- si mpl e i nher i t ance; see ?set I s)
showMet hods( "show")
## Funct i on: show ( package met hods)
## obj ect ="ANY"
## obj ect ="cl assGener at or Funct i on"
## obj ect ="cl assRepr esent at i on"
## obj ect ="envRef Cl ass"
## obj ect ="f unct i on"
## ( i nher i t ed f r om: obj ect ="ANY")
## obj ect ="gener i cFunct i on"
## obj ect ="gener i cFunct i onWi t hTr ace"
## obj ect ="Met hodDef i ni t i on"
## obj ect ="Met hodDef i ni t i onWi t hTr ace"
## obj ect ="Met hodSel ect i onRepor t "
## obj ect ="Met hodWi t hNext "
## obj ect ="Met hodWi t hNext Wi t hTr ace"
## obj ect ="namedLi st "
## obj ect ="Obj ect sWi t hPackage"
## obj ect ="ol dCl ass"
## obj ect ="r ef Cl assRepr esent at i on"
## obj ect ="r ef Met hodDef "
## obj ect ="r ef Obj ect Gener at or"
The first argument of a generic function is an object of a particular class (there may be other
arguments)
The generic function checks the class of the object. 1.
A search is done to see if there is an appropriate method for that class. 2.
If there exists a method for that class, then that method is called on the object and were done. 3.
If a method for that class does not exist, a search is done to see if there is a default method for
the generic. If a default exists, then the default method is called.
4.
If a default method doesnt exist, then an error is thrown. 5.
You cannot just print the code for a method like other functions because the code for the method
is usually hidden.
If you want to see the code for an S3 method, you can use the function get S3met hod.
The call is get S3met hod( <gener i c>, <cl ass>)
For S4 methods you can use the function get Met hod
The call is get Met hod( <gener i c>, <si gnat ur e>) (more details later)

Whats happening here?

set . seed( 2)
x <- r nor m( 100)
mean( x)
## [ 1] - 0. 0307
The class of x is numeric 1.
But there is no mean method for numeric objects! 2.
So we call the default function for mean. 3.
head( get S3met hod( "mean", "def aul t ") , 10)
##
## 1 f unct i on ( x, t r i m= 0, na. r m= FALSE, . . . )
## 2 {
## 3 i f ( ! i s. numer i c( x) && ! i s. compl ex( x) && ! i s. l ogi cal ( x) ) {
## 4 war ni ng( "ar gument i s not numer i c or l ogi cal : r et ur ni ng NA")
## 5 r et ur n( NA_r eal _)
## 6 }
## 7 i f ( na. r m)
## 8 x <- x[ ! i s. na( x) ]
## 9 i f ( ! i s. numer i c( t r i m) | | l engt h( t r i m) ! = 1L)
## 10 st op( "' t r i m' must be numer i c of l engt h one")
t ai l ( get S3met hod( "mean", "def aul t ") , 10)
##
## 15 i f ( any( i s. na( x) ) )
## 16 r et ur n( NA_r eal _)
## 17 i f ( t r i m>= 0. 5)
## 18 r et ur n( st at s: : medi an( x, na. r m= FALSE) )
## 19 l o <- f l oor ( n * t r i m) + 1
## 20 hi <- n + 1 - l o
## 21 x <- sor t . i nt ( x, par t i al = uni que( c( l o, hi ) ) ) [ l o: hi ]
## 22 }
## 23 . I nt er nal ( mean( x) )
## 24 }
What happens here?
set . seed( 3)
df <- dat a. f r ame( x = r nor m( 100) , y = 1: 100)
sappl y( df , mean)
## x y
## 0. 01104 50. 50000
The class of df is "data.frame"; each column can be an object of a different class 1.
We sappl y over the columns and call the mean function 2.
In each column, mean checks the class of the object and dispatches the appropriate method. 3.
We have a numer i c column and an i nt eger column; mean calls the default method for both 4.
Some S3 methods are visible to the user (i.e. mean. def aul t ),
Never call methods directly
Use the generic function and let the method be dispatched automatically.
With S4 methods you cannot call them directly at all

The pl ot function is generic and its behavior depends on the object being plotted.
set . seed( 10)
x <- r nor m( 100)
pl ot ( x)
For time series objects, pl ot connects the dots
set . seed( 10)
x <- r nor m( 100)
x <- as. t s( x) ## Conver t t o a t i me ser i es obj ect
pl ot ( x)
If you write new methods for new classes, youll probably end up writing methods for the following
generics:
There are two ways that you can extend the R system via classes/methods
print/show
summary
plot

Write a method for a new class but for an existing generic function (i.e. like pr i nt )
Write new generic functions and new methods for those generics

Why would you want to create a new class?

To represent new types of data (e.g. gene expression, space-time, hierarchical, sparse matrices)
New concepts/ideas that havent been thought of yet (e.g. a fitted point process model, mixed-
effects model, a sparse matrix)
To abstract/hide implementation details from the user I say things are new meaning that R does
not know about them (not that they are new to the statistical community).

A new class can be defined using the set Cl ass function

At a minimum you need to specify the name of the class
You can also specify data elements that are called slots
You can then define methods for the class with the set Met hod function Information about a class
definition can be obtained with the showCl ass function

Creating new classes/methods is usually not something done at the console; you likely want to save
the code in a separate file
l i br ar y( met hods)
set Cl ass( "pol ygon",
r epr esent at i on( x = "numer i c",
y = "numer i c") )
The slots for this class are xand y
The slots for an S4 object can be accessed with the @operator.

A plot method can be created with the set Met hod function.
For set Met hod you need to specify a generic function (pl ot ), and a signature.
A signature is a character vector indicating the classes of objects that are accepted by the
method.
In this case, the pl ot method will take one type of object, a pol ygon object.

Creating a pl ot method with set Met hod.

set Met hod( "pl ot ", "pol ygon",
f unct i on( x, y, . . . ) {
pl ot ( x@x, x@y, t ype ="n", . . . )
xp <- c( x@x, x@x[ 1] )
yp <- c( x@y, x@y[ 1] )
l i nes( xp, yp)
})
## Cr eat i ng a gener i c f unct i on f or ' pl ot ' f r ompackage ' gr aphi cs' i n t he gl obal envi r onment
## [ 1] "pl ot "
Notice that the slots of the polygon (the x- and y-coordinates) are accessed with the @operator.
After calling set Met hod the new pl ot method will be added to the list of methods for pl ot .
Notice that the signature for class pol ygon is listed. The method for ANY is the default method and it
is what is called when now other signature matches
l i br ar y( met hods)
showMet hods( "pl ot ")
## Funct i on: pl ot ( package gr aphi cs)
## x="ANY"
## x="pol ygon"
p <- new( "pol ygon", x = c( 1, 2, 3, 4) , y = c( 1, 2, 3, 1) )
pl ot ( p)
Developing classes and associated methods is a powerful way to extend the functionality of R
Classes define new data types
Methods extend generi c functions to specificy the behavior of generic functions on new classes
As new data types and concepts are created, classes/methods provide a way for you to develop
an intuitive interface to those data/concepts for users

The best way to learn this stuff is to look at examples

There are quite a few examples on CRAN which use S4 classes/methods. You can usually tell if
they use S4 classes/methods if the methods package is listed in the Depends: field
Bioconductor (http://www.bioconductor.org) a rich resource, even if you know nothing about
bioinformatics
Some packages on CRAN (as far as I know) SparseM, gpclib, flexmix, its, lme4, orientlib,
filehash
The st at s4 package (comes with R) has a bunch of classes/methods for doing maximum
likelihood analysis.