A introduction to working with simple data in R, including how to use variables, different types of values and the basics of vectors.

The command line is the primary mechanism that you’ll use to interact with R. When you enter instructions the R interpreter will perform computations for you.

While this may seem like an arcane method for interacting with software, it has one *huge* advantage over point-and-click environments: it is incredibly easy to repeat or abstract computations that you need to do often or on very large data sets. Any instruction that you type at the R command line can also be saved to a “R script” file or an “R Markdown” document. These files are just plain text files (by convention, R scripts have a “.r” or “.R” at the end of the file name and markdown files end in “.rmd”). Running an R script or documents is identical to hand typing all of the commands in that script at the command line.

Let’s try entering some simple math expressions to see how this interaction with the command line works. In the code examples you see on this site the commands you type are followed by the text or visual output that R produces.

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

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

No surprises; R can be used as a calculator. R recognizes the standard syntax for numbers and mathematical operators. When you’ve enter a complete expression at the command line and hit “enter”, R evaluates the result of that expression. If you don’t tell R what to do with the result, it will just print out a representation of the value on the next line.

Usually you will want to perform a calculation and save the result for later use. If you’ve used Excel, you’ve probably used cells on a worksheet to hold the results of calculations based on the data in other cells. In R we can save the results of computations in variables. To do this we’ll use the assignment operator, which is a little arrow `<-`

.

If you’re coming from another programming language and the arrow syntax bugs you, you *can* use `=`

operator for general assignment – see the R help pages for a few important edge cases.

```
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.

Finally, let’s see what happens if we try hitting `enter`

before we’ve finished entering a complete expression. Type `2 +`

and then hit `enter`

. You’ll see a little `+`

shows up as your prompt on the next line. This is R’s way of telling you the text you’ve entered so far isn’t a complete thought. Finish this expression by entering another number and hitting `enter`

again.

In the above expressions we appeared to be doing computations on single numbers. In fact, something more complicated was going on under the hood. In R all data are actually vectors of values.

Unlike other programming languages, there are no scalar values in R; the most basic data structure is a vector. Single values are just vectors with one element. This may seem odd at first, until you consider the key implication: all operators and functions in R are built to handle vectors of data, not just single values. This means anything that can be done with a single number can also be done with a vector of numbers. This is a language that was clearly designed by statisticians!

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`

Above `length`

is the first example we’ve seen of an R function. In programming, functions are analogous to their mathematical counter parts: they take in one or more values and evaluate to a new value. The R syntax for running, or “calling”, a function is in the form of `functionName(value1, value2, ...)`

. We’ll explore functions in more depth on Monday.

The `length`

function has reported that we’ve been working with vectors of 1 element so far. To **c**ompose a vector with more than one element, we’ll use the `c()`

function:

`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`

As you can see, mathematical operators in R are built to handle vectorized operations: we could add a 4 element vector `d`

to a one element vector `10`

and get a sensible result.

**Side note for programmers**: if you’re coming to R with a background in other programming languages, you might have caught something in the last code block that freaked you out. We had previously assigned the variable `c`

to hold a number; yet we were still able to call the built-in `c`

function from this scope. In almost any other common scripting language this would not have worked. Although base scoping rules in R are strictly lexical, there are a number of aggressive additional checks that are performed on look-up failures. For example, when an attempt is made to apply a non-function in an inner scope, the interpreter will ascend the scope chain looking for up-values that *are* functions. This is why we were able to bind `c`

to a vector of numbers in our current scope and still use the base R `c()`

function. Another example of this design philosophy at play in R is aggressive partial matching for named arguments in function calls. Core R is designed with fallbacks galore to give it a good shot at being able to execute whatever mess you hand it.

So far we’ve just been working with numbers (`numeric`

values in R lingo), but R also supports text (`string`

values) and True/False (`boolean`

values) data.

To create strings, surround your text with either double `" ... "`

or single `' ... '`

quotes:

`"a"`

`## [1] "a"`

`"a" == 'a'`

`## [1] TRUE`

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

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

You can create strings containing single quotes using double quotes and visa versa, but if you need to make a string that contains both single and double quotes you need to use the `\`

“escape” character:

```
s <- "My data are \"awesome\"!"
cat(s)
```

`## My data are "awesome"!`

Two other special string characters are tab `\t`

and newline `\n`

:

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

`## a b c`

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

```
## a
## b
## c
```

To create Boolean values use `TRUE`

or `FALSE`

:

`TRUE`

`## [1] TRUE`

`FALSE`

`## [1] FALSE`

`TRUE == FALSE`

`## [1] FALSE`

R has built-in support for flagging values as missing data. The special `NA`

value can be mixed with any other kind of data in a vector. For example:

`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`

Most R functions will either understand how to deal with missing data, or issue an error if they involve a type of statistical analysis that can’t be used with missing data.

R also has a special “no-value” type called `NULL`

. If you are coming to R from another programming language it is easy confuse `NA`

and `NULL`

(for example, in Python data analysis modules the `None`

type is often used to do double duty, signifying `NULL`

or `NA`

depending on the context). By convention, you should use `NA`

in data structures to represent missing data points.

`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`

Here, we’ve extracted elements at the position given by the integer we put inside of the `[...]`

. Remember that the numbers `1`

and `3`

in the code above are actually *vectors* of integers.

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`

In addition to putting integer vectors inside of the index `[...]`

we can also use logical vectors. If we do, `TRUE`

at a position causes a value to be extracted, while a `FALSE`

indicates that it should be skipped. Let’s look at an example:

`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`

So why would you ever want to do this? The answer lies in the combination of indexing and the logical operators (`>`

, `<`

, `==`

, `!=`

, and `%in%`

).

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`

**A note about = vs ==:** Many beginners are confused by the difference between

`=`

and `==`

. The `=`

operator is used for value assignment, traditionally for arguments inside of function calls such as `plot(x = 10, y = 1)`

, or in newer versions of R in place of the `<-`

operator as in `a = 10`

. If you want to compare `==`

operator. These operations will evaluate to a logical vector (`TRUE`

or `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.

Finally, the indexing `[...]`

syntax isn’t just used to extract values from data structures. It can also be used to assign values *into* existing structures. For example:

`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`

As we saw in the previous section, vectors are the basic building blocks of all data in R and can hold numeric, string or Boolean values. Vectors can in turn be composed into more complicated data structures including matrices, arrays, data frames and lists.

A matrix is a vector of vectors, each the same length and with the same type of data:

```
m <- matrix(1:8, nrow = 2, ncol = 4)
m
```

```
## [,1] [,2] [,3] [,4]
## [1,] 1 3 5 7
## [2,] 2 4 6 8
```

You access values on a matrix by using a one element index, referring to a n’th position:

`m[2]`

`## [1] 2`

Alternatively you can specify a `[row, col]`

:

`m[1, 2]`

`## [1] 3`

Or just a row:

`m[1, ]`

`## [1] 1 3 5 7`

Or just a column:

`m[, 2]`

`## [1] 3 4`

If you forget this syntax, just pay attention to how R prints out matrices!

An array is a matrix of more than two dimensions. It’s unlikely that you’ll need to work with arrays this term, but it’s good to know what you’re looking at if you see one in the wild:

`array(1:8, dim = c(2, 2, 2))`

```
## , , 1
##
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4
##
## , , 2
##
## [,1] [,2]
## [1,] 5 7
## [2,] 6 8
```

Unlike arrays and matrices, lists are collections of vectors where the individual vectors can hold different types of data and be of different lengths:

```
l <- list( a = c(1, 2, 3, 4), b = c("a", "b", "c") )
l
```

```
## $a
## [1] 1 2 3 4
##
## $b
## [1] "a" "b" "c"
```

You can access individual vectors on lists using indexing with numbers or names:

`l[1]`

```
## $a
## [1] 1 2 3 4
```

`l["a"]`

```
## $a
## [1] 1 2 3 4
```

Did you notice what type of thing was returned there?

To simplify the result of indexing down to a vector (rather than a one element list):

`l[[1]]`

`## [1] 1 2 3 4`

`l[["a"]]`

`## [1] 1 2 3 4`

The second example above is a common task in R: referring to a named elements on a list to get the value (instead of a list with that value as the only element). Because of this there’s a short hand, the `$`

:

`l$a`

`## [1] 1 2 3 4`

`l$a == l[["a"]]`

`## [1] TRUE TRUE TRUE TRUE`

Make sure you understand why this fails:

`l$a == l["a"]`

Finish up the parts of this document we didn’t get to in class today. If you are a beginner and aren’t feeling confident with the basics I’d recommend doing the first 3 excercises on the tryR site. Don’t worry if you’re still feeling a bit confused; come to class on Monday ready to ask questions.

If you’re a computer science guru and were bored to tears with this introduction, I’d recommend reading Evaluating the Design of the R Language. It’s an excellent overview of R language semantics and the standard library which will provides some insights into differences you’re likely to run into between evaluation semantics and idiomatic constructs in R and other languages you’ve seen.