Module 10: Building your own R package

This week we begin to dive into the procedures needed to create an official R package. Our assignment this week was to create a package in R and create a DESCRIPTION File. 

Let us begin!: 

First thing first, we will be heavily reliant on two main packages:
1. devtools
2. roxygen2

devtools will provide us with most of the functions needed in order to create a package and roxygen2 is a great package that streamlines many of the documentations needed in packages for R. 

We simply have to install the packages:
>install.packages("devtools")
>library("devtools")
>install.packages("roxygen2")
>library*"roxygen2")

Unfortunately for me there was an error in my "backports", that prevented me from installing and using devtools correctly. Upon searching online I found a way to reinstall the backports package and install devtools again. This fixed my issue:
>install.packages("backports"); install.packages("devtools")



Once we have these installed there are a few ways we can create a new package.
The easiest way was by using Rstudios clicking on the project button in the top right hand corner and creating a new project with the project type being a package.
What is great is this automatically creates a directory for you with the files and folders that are standard in most packages
The project button

Automatically generated files and folders for the project

While everything is automatically generated, some things to keep in mind is that many unnecessary and placeholder items are generated as well. For instance, a built in place holder function is generated called "hello.R" that just demonstrates the universally recognized "hello world" example. This is obviously unnecessary and if left in the package may look funny to other that use the package. This can easily be fixed by simply removing the files from the package (note that a hello.rd will also be in the man file as well). 

The auto generated DESCRIPTION file will also have to be edit as well. By default the description file looks like this:

As you can see there are many default values that simply explain what should be entered and not actually useful. Also certain descriptions are missing, for instance there is no Depends section which is fairly standard in most packages today. This is not too difficult, all one has to do is add it to their file, which can easily be done in Rstudios. 
I simply followed the instructions from Friedrich Leisch and Hadley Wickham to fill out a mock DESCRIPTION file. I also found it useful to open up a package I have installed and look at their DESCRIPTION file as refence. One that I found was the file for pkgbuild. 

DESCRIPTION file for pkgbuild


Here I get a concrete example of how the authors section should be formatted (persons format). Which helped with some of the ambiguities when simply reading instructions. 

Alternative ways to start a package:

While the method above is a quick and simple way to create a package, it relies on being in Rstudios. We may not always have that luxury and so I decided to explore other methods.
One method that comes to mind is using devtools' create() function.
This is best highlighted in Hilary Parker's blog: https://hilaryparker.com/2014/04/29/writing-an-r-package-from-scratch/
With the create function we simply need to just load up devtools and assign the name of our package within the create() argument.
For instance if we want to name our package "ThePackage" we would simply use the following lines:
>library(devtools)
>library(roxygen2)
>create("ThePackage")
devtools will automatically create a DESCRIPTION file and an R folder for your R code. We will need to create a man file manually.
The result of using create() to make a package.

Overall I feel that with Devtools and RStudios, creating a package is very streamlined and user friendly. I'm looking forward to creating our package for our class!

-Anthony 


Comments

Post a Comment

Popular posts from this blog

R Final project package: Introducing muMotif

Image
Welcome! Greetings and welcome to the write up of muMotif package. Github link to muMotif:  https://github.com/Ant-nguyen/RmuMotif This was a final project for our R programming course, the goal of this package is to provide some tools that can help one look up motifs in DNA sequences. Motifs can be thought as patterns or hidden messages that standout in DNA. Motifs can be useful for narrowing down on regions of interest in large DNA sequences.  Much of the logic and principles of motif search were inspired by:  https://www.bioinformaticsalgorithms.org/ Throughout this blog I hope to explain the concepts and though processes behind the package, if you find some of these concepts interesting or if my explanation is lacking I highly recommend the link above. Let us begin! Quick Tour: MuMotif is a package of functions that help allow one to find motifs in strings of DNA. The package is also set up to allow for quick visualization of some of the results. There are two broad s...
Read more

Module 8 : I/O, string manipulation and plyr package

Image
This week we will be exploring the Input and Out capabilities of R, as well as the usefulness of the tools of the plyr package. For this assignment we are given three different tasks: 1. We must import a text file with that contain a data set of Name, Age, Sex and Grade of 20 students and then using plyr package organize the data based on sex, and include a new column with the grade average of their sex.  2. We need to take our data and output our data into a CSV(Comma Separated Value) format. 3. We will take the original data set and extract the data for only students that have the character "i" in their name. And then output a the results to a file in the CSV format. Github link:  https://github.com/Ant-nguyen/Intro_r_2021/blob/main/Module%208.R Let us begin! First we need to input the text file into R. To do this I used the read.table() function. This is a specific function for files that are already in a table like format. I used the arguments header = TRUE and sep =...
Read more

Module 9 : Visualization

Image
This week we will be exploring some of the different visualization options available in R. We will mainly be comparing the built in R plot, lattice package and ggplot2 package. We will discuss the difference syntax and abilities of each method.  Our assignment was to find a dataset from the following link :  https://vincentarelbundock.github.io/Rdatasets/datasets.html   and using the three different visualization methods listed above create some visualization with the data.  GitHub link:  https://github.com/Ant-nguyen/Intro_r_2021/blob/main/Module%209.R Let us begin! The dataset I decided to use was the  Wong   dataset.  https://vincentarelbundock.github.io/Rdatasets/doc/carData/Wong.html This dataset looks at IQ of patients after being in a coma.  I downloaded the csv file into the directory that is the same as where R is installed and ran the following line of code to input the data into R: > wong<- read.table("Wong.CSV",header =...
Read more