R 101

The basics

What will happen when you enter these commands? Try it out.

1 + 2
2 * 3
4 ^ 5
6.7 / 8.9

a <- 10
a

[1] 10

b <- a + 11
b

[1] 21

c <- a / b
c

[1] 0.4761905

If you’re working with very large numbers you can use scientific notation:

2e10

[1] 2e+10

2 * 10^10

[1] 2e+10

2e10 == 2 * 10^10

[1] TRUE

In that last line we used the comparison operator ==; it tests whether or not two values are equivalent.

You can see how many elements a vector holds using the length function:

length(10)

[1] 1

length(c)

[1] 1

length(1:10)

[1] 10

c(1, 2, 3, 4)

[1] 1 2 3 4

d <- c(5, 6, 7, 8)
d + 10

[1] 15 16 17 18

d + d

[1] 10 12 14 16

d + c(1, 2)

[1]  6  8  8 10

d + c(1, 2, 3)

Warning in d + c(1, 2, 3): longer object length is not a multiple of
shorter object length

[1]  6  8 10  9

So, for example, we could flip the sign of every other number in a vector with:

d * c(1, -1)

[1]  5 -6  7 -8

"a"

[1] "a"

"a" == 'a'

[1] TRUE

c( "a", "b", "c", "d" )

[1] "a" "b" "c" "d"

s <- "a\tb\tc"
cat(s)

a   b   c

s <- "a\nb\nc"
cat(s)

a
b
c

Boolean can either be “True” or “False”, and represent a variable with binary values. To create Boolean use TRUE or FALSE:

TRUE

[1] TRUE

FALSE

[1] FALSE

c(TRUE, TRUE, FALSE)

[1]  TRUE  TRUE FALSE

TRUE == FALSE

[1] FALSE

c(1, 2, NA, 4)

[1]  1  2 NA  4

c( "a", NA, "c", NA )

[1] "a" NA  "c" NA

c(TRUE, FALSE, NA, FALSE)

[1]  TRUE FALSE    NA FALSE

is.na( c(1, NA) )

[1] FALSE  TRUE

NULL is used to signify unassigned variables:

NULL

NULL

is.null(NULL)

[1] TRUE

Let’s say we have a vector of numbers:

myNumbers <- c( 10, 20, 30, 40, 50 )

We can extract elements from 1D vectors using the index syntax [] and integers:

myNumbers

[1] 10 20 30 40 50

myNumbers[1]

[1] 10

myNumbers[3]

[1] 30

We can use integer vectors with more than one element inside of our index [...]’s::

myNumbers[ c(1, 3) ]

[1] 10 30

You can use the : operator to easily create a sequence of numbers:

2:4

[1] 2 3 4

myNumbers[2:4]

[1] 20 30 40

myNumbers

[1] 10 20 30 40 50

myNumbers[ c(FALSE, TRUE,  TRUE,  TRUE,  TRUE ) ]

[1] 20 30 40 50

myNumbers[ c(TRUE,  FALSE, FALSE, FALSE, FALSE) ]

[1] 10

Logical operators always return a logical vector:

myNumbers > 25

[1] FALSE FALSE  TRUE  TRUE  TRUE

myNumbers < 25

[1]  TRUE  TRUE FALSE FALSE FALSE

myNumbers == 30

[1] FALSE FALSE  TRUE FALSE FALSE

myNumbers != 30

[1]  TRUE  TRUE FALSE  TRUE  TRUE

The %in% operator asks if the first set of numbers can be found in the second:

30 %in% myNumbers

[1] TRUE

c(10, 100) %in% myNumbers

[1]  TRUE FALSE

The ! operator negates (flips) each value of a logical vector:

!TRUE

[1] FALSE

!(myNumbers > 25)

[1]  TRUE  TRUE FALSE FALSE FALSE

So how can we combine logical comparisons with indexing?

myNumbers[myNumbers > 25]

[1] 30 40 50

myNumbers[myNumbers < 25]

[1] 10 20

You can get fancy…

myNumbers[ (myNumbers %% 2) == 0 ]

[1] 10 20 30 40 50

What happened there? If you need help figuring it out, look up the %% (modulo) operator on the help panel.

myNumbers

[1] 10 20 30 40 50

myNumbers[3]    <- 100
myNumbers

[1]  10  20 100  40  50

myNumbers[2:3]  <- c(1, 2)
myNumbers

[1] 10  1  2 40 50

So how can you shift your thinking to get moving again when you’re stuck and frustrated?

Footnote: about the most destructive thing you can do is erase all of your files. Please don’t do that.

?mean