What name can I assign to a variable?

You are free to assign most any letter or name to a variable as long as it follows these rules:

• does not contain spaces,
• starts with a letter (and not a number),
• contains only alphanumeric characters, underscores _, and dots .,
• is not a reserved word.

You can see a list of reserved words by typing the following at the command line:

?reserved

if, else, repeat, while, function, for, in, next, break,
TRUE, FALSE, NULL, Inf, NaN, NA, NA_integer_, NA_real_, NA_complex, NA_character_

The following are examples of valid variable names:

x
dat1
reg_class_1
dat.l

The following are examples of invalid variable names:

2x
dat ver2
reg%class
abc-d 

Another rule of thumb is to try and avoid creating variable names that match the built-in R function names. For example, we encountered the function c() in the last code chunk. We could create a variable named c if we really wanted to (R will differentiate a variable from a function) as highlighted in the following example:

c <- c(100,200,300,400)
a + b + c

[1] 111 222 333 444

However, such practice is discouraged since it can make code a bit more difficult to read when functions and variable names are intertwined.

Numeric

The numeric data type is probably the simplest. It consists of numbers such as integers (e.g. whole numbers such as 1 ,-3 ,33 ,0) or doubles (e.g. numbers with a decimal point such as 0.3, 12.4, -0.04, 1.0).

x <- c(1.0, -3.4, 2, 140.1)
typeof(x)

[1] "double"

Note that removing the fractional part of a number when creating a numeric object does not necessarily create an integer. For example, creating what seems to be an integer object returns double when queried by typeof():

x <- 4
typeof(x)

[1] "double"

To force R to recognize a value as an integer, add an upper case L to the number.

x <- 4L
typeof(x)

[1] "integer"

You can also force a double to an integer using the as.integer() function.

x <- 4
x <- as.integer(x)
typeof(x)

[1] "integer"

Characters

The character data type consists of letters or words such as "a", "f", "project" and "house value".

x <- "a"
y <- c("a", "ab", "abc")

Characters are always referenced as such using double quotes. Not wrapping character data in double quotes can have unintended consequences:

w <- c(a, b)
w

[1] 10 20 30 40  1  2  3  4

Here, a and b are treated as variable names (they were created earlier in this exercise), so the concatenate function is simply combining the elements in a with those in b.

Numbers can be treated as characters in R.

z <- c("10", "20", "30", "40")

But note that once in character form, numbers cannot be operated on mathematically. For example, the following chunk of code will return an error.

z + z

Error in z + z: non-numeric argument to binary operator

Logical

Logical values can take on one of two values: TRUE or FALSE. These can also be represented as 1 or 0. For example, to create a logical vector of 4 elements, you can type:

x <- c(TRUE, FALSE, FALSE, TRUE)

or

x <- as.logical(c(1,0,0,1))

Note that in both cases, typeof(x) returns logical. Also note that the 1’s and 0’s in the last example are converted to TRUE’s and FALSE’s internally.

Coercing from one data type to another

Data can be coerced from one type to another. For example, to coerce the following vector object from character to numeric, use the as.double() function.

y   <- c("23.8", "6", "100.01", "6")
as.double(y)

[1]  23.80   6.00 100.01   6.00

The as.double function forces the vector y to a double (numeric). If you convert y to an integer, R will remove all fractional parts of the number.

as.integer(y)

[1]  23   6 100   6

If the vector contains a non-numeric element, that element is converted to NA. NA is a placeholder for missing values.

y   <- c("23.8", "6", "abc","6")
as.double(y)

[1] 23.8  6.0   NA  6.0

There are many other coercion functions in R, a summary of some the most common ones follows:

(Atomic) vector

The atomic vector (or vector for short) is the simplest data structure in R which consists of an ordered set of values of the same type and or class (e.g. numeric, character, etc…). This is the data structure we have worked with thus far. You can think of a vector as a single column of values in a spreadsheet. As such, one important property of a vector is that it cannot mix data types. For example, let’s mix double, integer and character in the vector variable x.

x <- c( 1.2, 5L, "Rt", "2000")

R does not stop us from doing this (if it did, it would have returned an error message). However, if we pass x to the typeof function, we get:

typeof(x)

[1] "character"

When data types are mixed in a vector, R will convert the element types to the highest common type following the order logical < integer < double < character. In our last example, character is the highest data type in this hierarchy thus forcing all elements in that vector to character.

x

[1] "1.2"  "5"    "Rt"   "2000"

You can tell that all data elements have been converted to character by the double quotes.

A vector object is an indexable collection of values which allows one to access a specific index number. For example, to access the third element of x, type:

x[3]

[1] "Rt"

You can also select a subset of elements by index values using the combine function c().

x[c(1,2,4)]

[1] "1.2"  "5"    "2000"

Or, if you are interested in a range of indexed values such as index 2 through 4, use the sequence, :, operator.

x[2:4]

[1] "5"    "Rt"   "2000"

Dataframe

A dataframe is what comes closest to our perception of a data table. You can think of a dataframe as a collection of vector elements where each vector represents a column. As such, it’s important that the vectors have the same number of elements.

name <- c("a1", "a2", "b3")
col1 <- c(23, 4, 12)
col2 <- c(1, 45, 5)
dat  <- data.frame(name, col1, col2)
dat

  name col1 col2
1   a1   23    1
2   a2    4   45
3   b3   12    5

To view each column’s data type we’ll make use of a new function: the structure, str, function.

str(dat)

'data.frame':   3 obs. of  3 variables:
 $ name: Factor w/ 3 levels "a1","a2","b3": 1 2 3
 $ col1: num  23 4 12
 $ col2: num  1 45 5

You’ll notice that the col1 and col2 columns are stored as numeric (i.e. as doubles) and not as integer. There is some inconsistency in R’s characterization of data type. Here, numeric represents double whereas an integer datatype would display integer. For example:

col2 <- c(1L, 45L, 5L)
dat  <- data.frame(name, col1, col2)
str(dat)

'data.frame':   3 obs. of  3 variables:
 $ name: Factor w/ 3 levels "a1","a2","b3": 1 2 3
 $ col1: num  23 4 12
 $ col2: int  1 45 5

Data frames can also be constructed without needing to create separate vector objects.

dat  <- data.frame(name = c("a1", "a2", "b3"),
                   col1 = c(23, 4, 12),
                   col2 = c(1, 45, 5))
dat

  name col1 col2
1   a1   23    1
2   a2    4   45
3   b3   12    5

Like a vector, elements of a data frame can be accessed by their index (aka subscripts). The first index represents the row number and the second index represents the column number. For example, to list the second row of the third column, type:

dat[2, 3]

[1] 45

If you wish to list all rows for columns one through two, leave the first index blank:

dat[ , 1:2]

  name col1
1   a1   23
2   a2    4
3   b3   12

Or, if you wish to list the third row for all columns, leave the second index blank:

dat[ 3 , ]

  name col1 col2
3   b3   12    5

You can also reference columns by their names if you append the $ character to the dataframe object name. For example, to list the values in the column named col2, type:

dat$col2

[1]  1 45  5

To get the column names of a table, use the names() function.

names(dat)

[1] "name" "col1" "col2"

Spacing

Spaces help improve readability. Add spaces around operators (this includes the assignment operator) and after commas.

Place a space before an open parenthesis/curly brace except when an open parenthesis is preceded with a function name. Place a space after a closed parenthesis/curly brace.

Parentheses

Use parentheses to isolate conditional statements. Do not wrap overall statements with parentheses.

Comments

Comments allow the user to document parts of the code without the comments being interpreted by R as code. All comments are preceded by the # character.

# Assign three values to p
p <- c(23, 1.2, 5)

Comments should be used to isolate key steps in a workflow. But they should not be used to document each and every line of code (except when used in an instructional setting).

An empty line should be placed before the comment but not after. A space should separate the first letter of a comment and the # symbol.

# Load file
dat <- read.csv("file.csv")

# Process file
dat$date <- ymd(YY,MM,DD)
dat1 <- dat[ , -c(2,3)]

#Load file
dat <- read.csv("file.csv")
#Process file`
#Create date column
dat$date <- ymd(YY,MM,DD)
#Subset columns
dat1 <- dat[ , -c(2,3)]

Line length

Try to limit the line length to 80 characters. You can add an 80 character vertical line to your code editor via Tools >> Global Options >> Code and the Display tab.