R Package with S4 Objects

When performing R packages, Linux may be the best choice because R packaging in Windows implies to install a lot of base Linux applications and tools on Windows. For those that wish to go that road, here’s what one has to do: read Making tutorial about R Packages Under Windows: A Tutorial by Peter Rossi.
For everyone else, just boot your Linux.

Before starting, one should take a look at Writting R Extensions. This is the first step for all that wish to build R extensions. A fast and easy way to know how to pack, is to read An Introduction to the R package mechanism.

When developing using S4 objects, packaging may become a big headache.
I’ve suffered this headache. I had all kinds of warnings and errors during the package tests and installation.

I’ve started by posting to the R-Help list asking for help. Here’s the post transcript:

Here's what I do:

1. in R console, I do and get:
> package.skeleton(name='remora')remora-package
Creating directories ...
Creating DESCRIPTION ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Further steps are described in './remora/Read-and-delete-me'.
Warning messages:
1: In dump(internalObjs, file = file.path(code_dir,
sprintf("%s-internal.R",  :
deparse of an S4 object will not be
2: In dump(internalObjs, file = file.path(code_dir,
sprintf("%s-internal.R",  :
deparse of an S4 object will not be
3: In dump(internalObjs, file = file.path(code_dir,
sprintf("%s-internal.R",  :
deparse of an S4 object will not be
4: In dump(internalObjs, file = file.path(code_dir,
sprintf("%s-internal.R",  :
deparse of an S4 object will not be source()able

I don't know why I get these warnings. 
I've followed R implementation rules and the S4 objects work fine.
2. Performing the 'R CMD build remora' command I get:

* checking for file 'remora/DESCRIPTION' ... OK
* preparing 'remora':
* checking DESCRIPTION meta-information ... OK
* removing junk files
* checking for LF line-endings in source and make files
* checking for empty or unneeded directories
* building 'remora_1.0.tar.gz'

And the remora_1.0.tar.gz file seems ok.
3. Performing the 'R CMD check remora' command I get:

* checking for working pdflatex ...sh: pdflatex: not found
* checking for working latex ...sh: latex: not found
* using log directory '/home/fmm/thesis/R/src/remora.Rcheck'
* using R version 2.8.1 (2008-12-22)
* using session charset: UTF-8
* checking for file 'remora/DESCRIPTION' ... OK
* checking extension type ... Package
* this is package 'remora' version '1.0'
* checking package dependencies ... OK
* checking if this is a source package ... OK
* checking for executable files ... OK
* checking whether package 'remora' can be installed ...
Installation failed.
See '/home/fmm/thesis/R/src/remora.Rcheck/00install.out'
for details.
4. the log file contains:

* Installing *source* package 'remora'


** preparing package for lazy
Error in parse(n = -1, file = file) : unexpected '-> code2LazyLoadDB
-> sys.source -> parse Execution halted
ERROR: lazy loading failed for package
** Removing
fmm@Darkmaster:~/thesis/R/src$ grep -i __C__remoraConfiguration *
fmm@Darkmaster:~/thesis/R/src$ grep -i __C__remoraConfiguration */*
remora.Rcheck/00install.out:745: `.__C__remoraConfiguration`

But, unfortunately, no help came from there…

In the quest for the solution I’ve found out that many others were having similar problems with S4 object packaging, but no solutions were provided.
After a lot investigation, I’ve finally found it and the solution is actually quite easy.
Instead of packing it from the current environment, I’ve just passed to the package.skeleton the list of source files to build the package. As an example, here’s the small R script I’ve done to automate the packaging procedure for my “Remora” package:

cat('\nPacking Remora...\n')

file_lst <- character(5)
file_lst[1] <- '/home/m6/thesis/R/src/1_classes.r'
file_lst[2] <- '/home/m6/thesis/R/src/2_common.r'
file_lst[3] <- '/home/m6/thesis/R/src/3_model.r'
file_lst[4] <- '/home/m6/thesis/R/src/4_predict.r'
file_lst[5] <- '/home/m6/thesis/R/src/5_main.r'   

package.skeleton(name = "remora", force = TRUE, namespace = TRUE,
code_files = file_lst)


Now it's time to go to the directory created, with the name of the package,from now on {package}, and edit the following files:

  • {package}/DESCRIPTION, the description of the package;
  • {package}/NAMESPACE, the list of functions and classes to export to the user;
  • {package}/man/{package}-package.Rd, the package help file, the \examples section must provide executable code, since R check command will execute this code;
  • {package}/man/{class_name}-class.Rd, the classes help files;
  • {package}/man/{function_name}.Rd, the functions help files;

All files under /man/ are tex files and will be compiled to provide the functions help when invoked by the user.
It's only necessary to document the classes and functions that will be exported, i. e. exported in the NAMESPACE file, since all the others will not be visible to the user. All the other .Rd files may be deleted.

After the package has been created, I've tested with the "R CMD check {package}" command. My package name is "remora", so my command was "sudo R CMD check remora".
I had to run this command with the administration role, so I prefixed it with the"sudo" command. This is a characteristic my Kubuntu installation and one may not require to perform this with administrator privilegies.

Finally I've build the package with the "R CMD build {package}" command that created the tar.gz file for distribution.

To install it, just use the "R CMD INSTALL {package}" command. I've entered R and it worked fine.
To uninstall just execute "R CMD REMOVE {package}".

Debug in R

Development in R usually is performed using JGR, or Tinn-R, editors and the R console.
Since these are no “state of the art” IDEs for R development, this is usually the best one can have.

So, how does one debug a program in R?
The usual answer is classical: with print.
But the correct answer is: using the browser() function.

The browser() function works as a break point marker.
Just write browser() where a break point is needed and run the program.
When browser() is interpreted, the program hang its execution and a new command line prompt will be provided, Browse[1]>.
This command line allows one to interact with the variables available in the scope where the program is temporary hanged.
This debug command line accepts the following debug commands:

  • n: next, advances to the next line, allows step-by-step.
  • c: continue, continues the execution, until the program ends or a new browser() function is found.
  • traceback(), shows the stack trace function call.
  • Q: quit, stop the program execution.

It does not look as cool as using the mouse to insert a break point on a line, but it works.

Reorder Columns in R

There is a very easy way to reorder the column order or a data frame, but it seems to be unknown from many R users.

Having a data frame named test like

     a  b  c  d  e
[1,] 1 11 21 31 41
[2,] 2 12 22 32 42
[3,] 3 13 23 33 43
[4,] 4 14 24 34 44
[5,] 5 15 25 35 45

all that is required is to reassign the data frame using a new column order, like

new_column_order <- c("b", "c", "a", "e", "d")

test <- test[,new_column_order] 

And that solves the problem.

This works both with a data frame and a matrix.

Install R on Kubuntu

Installing R on Kubuntu, or Ubuntu, with an editor is quite easy. The following steps will possibly work on the most common Linux distributions. Check the official information for more information.

To get R, start by updating the repositories and the get r-base:

$ sudo apt-get update
$ sudo apt-get install r-base

When one needs to develop a R package, the development stuff should also be installed:

$ sudo apt-get install r-base-dev r-recommended

As for an editor, one can use JGR. In order to use it, just follow the official installation under Linux.
JGR is Java based, so when there’s no Java installed, get it using:

$ sudo apt-get install sun-java6-jdk

To install JGR, it’s necessary to enable Java support in R:

$ sudo R CMD javareconf

And then install the JGR library:

$ sudo R
&gt; install.packages('JGR')

After installed, run:

&gt; library(JGR)
&gt; JGR()

JGR has a small problem though, it has been installed as root and it seems unusable with any other user. One can set the correct user permissions for that.

Automating the startup of R with JGR is simple when using a shell script. Name it runr.sh and include:

R -f /home/myUser/bin/jgr.r

While the jgr.r file contains the JGR start commands


Now, running ./runr.sh starts R and JGR all in one.

There are alternatives to JGR. Check Tinn-R and R Commander.