R Programming Notes

落日映苍穹つ 2022-08-20 08:27 3阅读 0赞

I’ve been on a note taking binge recently. This post covers a variety of topics related to programming in R. The contents were gathered from many sources and structured in such a way that it provided the author with a useful reference guide for understanding a number of useful R functions.

**DO.CALL**

The do.call function executes a function call on a list of arguments.

do.call("R_Function", "List_of_Arguments")

This is equivilant to telling R which arguments the function should operate on.

R_Function( "List_of_Arguments" ){
      ...
    }

Consider the following list with four elements. We can use this function to find the total sum across all list elements or bind the rows into a data frame.

x1 <- c(1,2,5)
    x2 <- c(1,3,6)
    x3 <- c(1,4,7)
    x4 <- c(1,5,8)
     
    do.call(sum, list(x1,x2,x3,x4))  # sum all list elements
    do.call(rbind, list(x1,x2,x3,x4))  # rbind the list elements

Let’s consider a scenario where we have a small data frame and want to run a general linear model on different combintions of attributes. One solution to this problem is to create the formula object as a list within a function, and then utilize do.call to run a linear model on the desired attribute.

dat <- data.frame(x1 = rnorm(100, m=50), x2 = rnorm(100, m=50), x3 = rnorm(100, m=50), y = rnorm(100))
     
    new_mod <- function(form){
      lstt = list(formula=as.formula(paste("y ~ ", form, sep="")), data=as.name("dat"))
      summary(do.call("lm", lstt))
    }
     
    new_mod("x1")
    new_mod("x2")
    new_mod("x3")

**EVAL**

The eval function evaluates an expression, an object that represents an action that can be performed in R. An expression is different from an operation, which refers to the execution of an operation. In the following example, we assigned a value to a variable and performed an operation using that variable.

x <- 4
    y <- x * 10
    y

The expression and quote functions are used to takes an expression as an argument and returns an expression without evaluation.

ee = expression(y~x1)
    ee
     
    z <- quote(y <- x * 10)
    z
     
    is.expression(ee)
    is.call(z)

In the above example, z is referred to as a call object. They are usually created with the call function. For example, the following code pieces together commands into a call object and evaluates them.

mycall <- call("lm", quote(y ~ x1), data=quote(dat))
    mod <- eval(mycall)
    summary(mod)

**SUBSTITUTE**

Another common procedure is to replace certain variables within a user defined function. This can be achieved with the substitute function. The below code replaces x1 and x2 in the expression with the values from the list.

replace <- list(x1 = as.name("alphabet"), x2 = as.name("zoology"))
    substitute(expression(x1 + x2 + log(x1) + x3), replace)

**SETNAMES**

There are a number of commands for working within column and row names in R. It’s generally suggested that the setNames function be used when modifying data structure names within a function.

names_new <- c("one","two","three","four")
    new_dat <- expression(data.frame(x1 = rnorm(100, m=50), x2 = rnorm(100, m=50), x3 = rnorm(100, m=50), y = rnorm(100)))
    head(setNames(eval(new_dat), names_new))
     
    my_lst <- list(lname = as.name("xls"))
    setNames(my_lst, "x1")

When working with data within a function, it will often be useful to write code that creates the names and data structure, and then evaluates the pieces together.

**MISSING**

Use the missing function to check whether an argument was supplied by the user.

func <- function(x){
        if(missing(x)){
            x = 5
        }
        y = x*x; y
    }
     
    func(2)
    func()

**STOP**

The stop function is used to halt a function, and is usually used when a particular condition is met.

guess <- function(n){
      if( n >= 6 ){
          stop("WRONG!")
    }}
     
    guess(5)
    guess(10)

**WARNING**

Use the warning function to throw a comment when a condition is met. It does not halt the function.

guess <- function(n){
      if( n >= 6 ){
          warning("BE CAREFUL!")
    }}
     
    guess(5)
    guess(10)

**ELIPSES (…)**

When functions are evaluated, R scans each function argument it can understand. When ellipsis are added as a function argument, it allows for other arguments to be passed into the function. This technique is frequently used when plotting and should be used when the function is designed to take any number of named or unnamed arguments.

plotter <- function(x, y, ...){
      plot(x, y, ...)
    }

To make use of ellipsis, it’s suggested that the user scan through the … and turn them into a list. This is because some of the arguments in dots may be intended for several different functions.