Vectors

Vectors are a collection of a single kind of data

Creating Vectors

It is rather rare that we work with a single entity for any data type. The main syntax in R used to make a collection of objects is to enclose them into the c() function (c for combine and since we use it so often, making it as short as possible—anything we can do to type less is good for reducing the number of errors in our code).

Here is how we can get a vector of numeric values.

x <- c(1,2,3,4,5,6,7)
x

[1] 1 2 3 4 5 6 7

The variable x contains a number of numeric types and is a single object.

length( x )

[1] 7

Vectors from Sequences

It would really suck if we had to type in all the elements into every array we want. Say we want a vector of 100 numbers, it would be really likely if we had to type all the numbers 1, 2, 3, ... , 99, 100 (and quite boring 💤). The main way we will get data into R is by loading it from files or databases, which we will get to later, but for now let’s look at how we can specifically create sequences of values with a little bit of code.

The first is the colon operator. The syntax is X:Y which will produce the values from X to Y (inclusive on both ends). In R we use it like this:

y <- 3:8 
y

[1] 3 4 5 6 7 8

This is just a shortcut for the more general seq() function (seq is short for sequence). This function takes a value to start at and one to end with (inclusive just like above).

y <- seq(3,8)
y

[1] 3 4 5 6 7 8

These are the required arguments. By default, the seq() function counts by \(1.0\) (either up or down, depending upon the magnitude of the first and second argument).

seq(8,3)

[1] 8 7 6 5 4 3

If we want it to count by some other interval, we can tell it by passing the optional argument by=.

y <- seq(3,8,by=0.25)
y

 [1] 3.00 3.25 3.50 3.75 4.00 4.25 4.50 4.75 5.00 5.25 5.50 5.75 6.00 6.25 6.50
[16] 6.75 7.00 7.25 7.50 7.75 8.00

Another way we can use the seq() function is to create a vector of values that are equally spaced. For example, consider the sampling locations below where I collected Sonoran desert bark beetles (Araptus attenuatus).

If I wanted an elevation profile along the Baja Califorinia Peninsula (the red line), I could ask for a sequence in latitude (the north-south dimension) with exactly 50 equally spaced entities starting at the southern site near Cabo San Lucas and finishing up just north of Nva. Chapala (n.b., the data are in longitude and latitude).

coords <- cbind(  seq(-109.6487 , -114.2935 , length.out = 50), 
                  seq( 23.07, 29.32, length.out = 50) )

coords[1:5,]

          [,1]     [,2]
[1,] -109.6487 23.07000
[2,] -109.7435 23.19755
[3,] -109.8383 23.32510
[4,] -109.9331 23.45265
[5,] -110.0279 23.58020

From these locals we, we can then quickly query an elevation raster to extract the values at those sites

Indexing

Since vector objects contains collections of variables, we often need to get or set the value at a particular location or within a slice of the vector. For example, the object y above has 21 entities in it. To get to these individual entities within the y we use a square bracket notation to indicate that we want to get an item within the variable and must indicate which element (or elements) we are interested in getting. The numeric indices within the brackets are 1-based (e.g., the first element is 1, the second is 2, etc.). So the code

y[4]

[1] 3.75

returns the 4\(^{th}\) element in the vector. This notation can be used to get as well as set values within the vector.

y[2] <- 42
y

 [1]  3.00 42.00  3.50  3.75  4.00  4.25  4.50  4.75  5.00  5.25  5.50  5.75
[13]  6.00  6.25  6.50  6.75  7.00  7.25  7.50  7.75  8.00

In addition to numbers, you can also do logical values.

x <- 1:5
x[ c(TRUE, FALSE, TRUE, FALSE, FALSE) ]

[1] 1 3

Slices

In addition to getting a single entity from a vector, we can also grab a sequence of values by using a sequence of indices within the square brackets. For example, if I wanted the first five entries of y I could ask for it as:

y[1:5]

[1]  3.00 42.00  3.50  3.75  4.00

You can also grab the end parts of a vector using the head() and tail() functions. By default, they return 6 entries each, though you can customize it.

y

 [1]  3.00 42.00  3.50  3.75  4.00  4.25  4.50  4.75  5.00  5.25  5.50  5.75
[13]  6.00  6.25  6.50  6.75  7.00  7.25  7.50  7.75  8.00

head(y, n=2)

[1]  3 42

tail(y, n=3)

[1] 7.50 7.75 8.00

The tail() function is really convienent because you do not have to know how many elements are in the vector to grab the last few. If you were going to use indices, you’d have to figure out how many elements are in the vector.

to <- length(y)
from <- to - 6
y[from:to]

[1] 6.50 6.75 7.00 7.25 7.50 7.75 8.00

Dropping Values

While less often used, it is sometimes convienent to remove some values from a vector. We can do this by passing a negative index.

x <- 1:5
x[-3]

[1] 1 2 4 5

It works with slices as well:

x[-(2:4)]

[1] 1 5

However, unless you assign this back to x, the values in x are not changed in any way.

x

[1] 1 2 3 4 5

If you want to change the values in x then you would have to reassign the values back to x

x <- x[-(2:4)]
x

[1] 1 5

Concatenating Vectors

WE can concatenate vectors together (as well as vectors and individual elements)

x <- 1:5
y <- 6:10
z <- c(x,y, 12)
z

 [1]  1  2  3  4  5  6  7  8  9 10 12

If you attempt to concatenate things with different data types, it will coerce them all (if possible) into the least common denominator. For example, if we look at the first five counting integers and the first five letters of the English alphabet, when they are concatenated, R will coerce the letters into character data types to enforce the requirement that all entities in a vector are the same data type.

a <- 1:5
b <- LETTERS[1:5]
c(a,b)

 [1] "1" "2" "3" "4" "5" "A" "B" "C" "D" "E"

1

2

3

4

5

A

B

C

D

E

Vector Arithmatic

Just like we can use opertors to work on single entites (numeric, character, logical, etc.), you can apply the same operations on vectors of data types.

x <- 1:5
x * 12   

[1] 12 24 36 48 60

b <- 6:10
x + b 

[1]  7  9 11 13 15

Named Vectors

Thus far, we’ve seen individual elements in a vector represented by only the numerical index.

x 

[1] 1 2 3 4 5

There are several occasions where being more verbose in our data may increase interpretation and readability. One way to to this is to assign an actual name to one or more (or all) of the elements in a vector rather than just having them sitting in a row right next to each other (like above). By default, the names() of elements in a vector are blank (which the total absence of anything in R is NULL.

names(x)

NULL

However, we can assign values to those name like this:

names(x) <- c("James", "Patuxent", "Potomac", "Rappahannock", "York")
x

       James     Patuxent      Potomac Rappahannock         York 
           1            2            3            4            5 

Once you name these elements, you can similarily use the names as indice.

x[ c("James","Potomac")]

  James Potomac 
      1       3 

The Recycling Rule

Operations on vectors that expect a particular length are handled (somewhat gracefully) using the

Recycling Rule: The shorter of the two vectors will be stretched by reusing values from the start to equal the length of the larger vector.

x <- c(10,20,30)
y <- c(1,2,3,4,5,6,7,8,9) 
x + y

[1] 11 22 33 14 25 36 17 28 39

If the shorter vector length is not a clean multiple of the larger one, it will issue a warning to let you know in case these dangling parts could cause problems.

y <- 1:10
x + y

Warning in x + y: longer object length is not a multiple of shorter object
length

 [1] 11 22 33 14 25 36 17 28 39 20

---