and a class is assigned to x and y c. Next, mymethod() is applied to each object, and the appropriate function is called d. The default method is used for object z because the object has class integer and no mymethod.integer() function has been defined.

An object can be assigned to more than one class (for example, building, residential, and commercial). How does R determine which generic function to call in such a case? When z is assigned two classes e, the first class is used to determine which generic function to call. In the final example f, there is no mymethod.c() function, so the next class in line (a) is used. R searches the class list from left to right, looking for the first available generic function.

20.3.2Limitations of the S3 model

The primarily limitation of the S3 object model is the fact that any class can be assigned to any object. There are no integrity checks. In this example,

>class(women) <- "lm"

>summary(women)

Error in if (p == 0) { : argument is of length zero

the data frame women is assigned class lm, which is nonsensical and leads to errors. The S4 OOP model is more formal and rigorous and designed to avoid the difficul-

ties raised by the S3 method’s less structured approach. In the S4 approach, classes are defined as abstract objects that have slots containing specific types of information (that is, typed variables). Object and method construction are formally defined, with rules that are enforced. But programming using the S4 model is more complex and less interactive. To learn more about the S4 OOP model, see “A (Not So) Short Introduction to S4” by Chistophe Genolini (http://mng.bz/1VkD).

20.4 Writing efficient code

There is a saying among programmers: “A power user is someone who spends an hour tweaking their code so that it runs a second faster.” R is a spritely language, and most R users don’t have to worry about writing efficient code. The easiest way to make your code run faster is to beef up your hardware (RAM, processor speed, and so on). As a general rule, it’s more important to write code that is understandable and easy to maintain than it is to optimize its speed. But when you’re working with large datasets or highly repetitive tasks, speed can become an issue.

Several coding techniques can help to make your programs more efficient:

■Read in only the data you need.

■Use vectorization rather than loops whenever possible.

■Create objects of the correct size, rather than resizing repeatedly.

■Use parallelization for repetitive, independent tasks.

Let’s look at each one in turn.

EFFICIENT DATA INPUT

When you’re reading data from a delimited text file via the read.table() function, you can achieve significant speed gains by specifying which variables are needed and their

(iterating over the elements in a collection) and facilitates executing loops in parallel. The doParallel package provides a parallel back end for the foreach package.

In principal components and factor analysis, a critical step is identifying the appropriate number of components or factors to extract from the data (see section 14.2.1). One approach involves repeatedly performing an eigenanalysis of correlation matrices derived from random data that have the same number of rows and columns as the original data. The analysis is demonstrated in listing 20.3. Parallel and non-parallel versions of this analysis are compared in the listing. To execute this code, you’ll need to install both packages and know how many cores your computer has.

Listing 20.3 Parallelization with foreach and doParallel

First the packages are loaded and the number of cores (four on my machine) is registered b. Next, the function for the eigenanalysis is defined c. Here 100,000 × 100 random data matrices are analyzed c. The eig() function is executed 500 times using foreach and %do%. d. The %do% operator runs the function sequentially, and the .combine=rbind option appends the results to object x as rows. Finally, the function is run in parallel using the %dopar% operator e. In this case, parallel execution was about 2.5 times faster than sequential execution.

In this example, each iteration of the eig() function was numerically intensive, didn’t require access to other iterations, and didn’t involve disk I/0. This is the type of situation that benefits the most from parallelization. The downside of parallelization is that it can make the code less portable—there is no guarantee that others will have the same hardware configuration that you do.