In this tutorial you will learn about vectors, type of vectors, vector operations, accessing elements of vectors and coercion of vectors in R.

## Vectors in R

A basic data structure in R is vector. It is a **atomic (homogeneous)** data structure, where all the stored objects are of same type. Vector can be defined as a set of constants or scalars of **same type** arranged in a one-dimensional array.

In R there are four type of vectors, namely,

- numeric vector (integer or double)
- character vector
- logical vector
- complex vector

R provides a set of explicit function to initialize a vector, to check the class of a vector and to coerce a vector. The list of vector class functions are as follows:

Initialize | Check the class | Coerce function |
---|---|---|

`integer()` |
`is.integer()` |
`as.integer()` |

`numeric()` |
`is.numeric()` |
`as.numeric()` |

`character()` |
`is.character()` |
`as.character()` |

`logical()` |
`is.logical()` |
`as.logical()` |

`complex()` |
`is.complex()` |
`as.complex()` |

Some important properties of vectors can be checked using the following functions. Knowledge about these properties are very important while manipulating vectors.

Property | Command | Meaning |
---|---|---|

Type | `typeof()` |
Type of Storage mode of object |

Length | `length()` |
Number of elements in object |

Class | `class()` |
Class of object |

Mode | `mode()` |
Storage mode of object |

Structure | `str()` |
Compactly display the structure of object |

The `str()`

function check the internal structure of the R object and print a preview of its content.

Vectors are usually created with `c()`

function. The `c()`

function is known as **concatenation** or **combine** which combines its arguments.

### Initialize a vector in R

Below R code initialize `vec.int`

as a integer vector of length 5.

```
vec.int <- integer(5)
vec.int
```

`[1] 0 0 0 0 0`

`class(vec.int)`

`[1] "integer"`

Below R code initialize `vec.num`

as a numeric vector of length 4.

```
vec.num <- numeric(4)
vec.num
```

`[1] 0 0 0 0`

`class(vec.num)`

`[1] "numeric"`

Below R code initialize a logical vector of length 4.

```
vec.log <- logical(4)
vec.log
```

`[1] FALSE FALSE FALSE FALSE`

`class(vec.log)`

`[1] "logical"`

Below R code initialize a character vector of length 5.

```
vec.char <- character(5)
vec.char
```

`[1] "" "" "" "" ""`

`class(vec.char)`

`[1] "character"`

Below R code initialize a complex vector of length 4.

```
vec.comp <- complex(4)
vec.comp
```

`[1] 0+0i 0+0i 0+0i 0+0i`

`class(vec.comp)`

`[1] "complex"`

### Creating an empty vector

An empty vector can be created with the `vector()`

function. The function `vector(mode,length)`

produces a vector of the given mode and length.

Below R code create an empty numeric vector of length 3.

```
vec1 <- vector(mode = "numeric", length = 3)
vec1
```

`[1] 0 0 0`

Below R code create an empty logical vector of length 4.

```
vec2 <- vector(mode = "logical", length = 4)
vec2
```

`[1] FALSE FALSE FALSE FALSE`

Below R code create an empty complex vector of length 3.

```
vec3 <- vector(mode = "complex", length = 3)
vec3
```

`[1] 0+0i 0+0i 0+0i`

Below R code create an empty character vector of length 5.

```
vec4 <- vector(mode = "character", length = 5)
vec4
```

`[1] "" "" "" "" ""`

### Numeric Vector

Numeric vectors have elements which are numeric (integer or double) values. If the numbers are follows by letter `L`

then R define the vector as an integer vector otherwise as a double vector.

Suppose we have age of 5 individuals as `20,31,45,37 and 24`

. Below R code store the age of 5 individuals as integer to a integer vector `age.1`

.

```
# store the values as integer to age.1
age.1 <- c(20L, 31L, 45L, 37L, 24L)
age.1
```

`[1] 20 31 45 37 24`

In the above code first line create an object `age.1`

, as a integer vector, containing the entries 20, 31, 45, 37, 24. The second line display the output of `age.1`

.

Below R code display the structure of `age.1`

. It is clear from the output that the vector `age.1`

is an integer vector with 5 elements.

```
# display structure
str(age.1)
```

` int [1:5] 20 31 45 37 24`

```
# display length
length(age.1)
```

`[1] 5`

```
# display mode
mode(age.1)
```

`[1] "numeric"`

```
# display storage mode
typeof(age.1)
```

`[1] "integer"`

`is.vector(age.1)`

`[1] TRUE`

`is.vector(age.1, mode = "logical")`

`[1] FALSE`

Below R code create an object `age.2`

as a vector of continuous values (double).

```
# Store the values as double to age.2
age.2 <- c(20, 31, 45, 37, 24)
age.2
```

`[1] 20 31 45 37 24`

Remember that, while defining `age.1`

we have used integer numbers follows by `L`

. Hence, R create `age.1`

as a integer vector while `age.2`

as a double vector.

Below R code display the structure of vector `age.2`

. It is clear from the output that the `age.2`

vector is a numeric vector with 5 elements.

```
# display structure
str(age.2)
```

` num [1:5] 20 31 45 37 24`

```
# display mode
mode(age.2)
```

`[1] "numeric"`

```
# display storage mode
typeof(age.2)
```

`[1] "double"`

We can see the difference between the results of `typeof()`

command for `age.1`

and `age.2`

. The `typeof(age.1)`

display the output integer while `typeof(age.2)`

display the output double.

### Character Vectors

Character vectors have elements which are character strings, where strings are sequence of characters enclosed in double quotes, `"First"`

, or single quotes, `'First'`

. The function `nchar()`

returns the length of the character strings in a character vector.

```
result<-c("First","Second","Third",
"Pass","Fail","Second","Pass")
result
```

`[1] "First" "Second" "Third" "Pass" "Fail" "Second" "Pass" `

Below R code display the structure of `result`

. It is clear from the output that the `result`

vector is character vector with 7 elements.

```
# display structure
str(result)
```

` chr [1:7] "First" "Second" "Third" "Pass" "Fail" "Second" "Pass"`

```
# Display the length of the each character string
nchar(result)
```

`[1] 5 6 5 4 4 6 4`

```
# Display the number of element in result
length(result)
```

`[1] 7`

```
# Display the mode of data stored in result
mode(result)
```

`[1] "character"`

`typeof(result) `

`[1] "character"`

### Logical Vectors

Logical vectors have elements which are logical character strings `T`

or `TRUE`

and `F`

or `FALSE`

.

```
x <- c(T, F, T, F, T, F)
x
```

`[1] TRUE FALSE TRUE FALSE TRUE FALSE`

`str(x)`

` logi [1:6] TRUE FALSE TRUE FALSE TRUE FALSE`

`mode(x)`

`[1] "logical"`

`typeof(x)`

`[1] "logical"`

```
y <- c(TRUE, FALSE, TRUE, TRUE)
length(y)
```

`[1] 4`

`mode(y)`

`[1] "logical"`

`typeof(y)`

`[1] "logical"`

Logical vectors can also be created using a logical expression on numeric vector.

```
a <- c(1, 2, 3, 5)
mode(a)
```

`[1] "numeric"`

```
z <- a < 2.5 # logical expression
z
```

`[1] TRUE TRUE FALSE FALSE`

`mode(z)`

`[1] "logical"`

### Complex Vectors

Complex vectors have elements which are complex constants.

```
z1 <- c(1i, 0i, 2 + 3i, 3 - 4i)
z1
```

`[1] 0+1i 0+0i 2+3i 3-4i`

`str(z1)`

` cplx [1:4] 0+1i 0+0i 2+3i ...`

```
z2 <- c(0, 0, 1 + 3i, -4i)
z2
```

`[1] 0+0i 0+0i 1+3i 0-4i`

`str(z2)`

` cplx [1:4] 0+0i 0+0i 1+3i ...`

`length(z2)`

`[1] 4`

`mode(z2)`

`[1] "complex"`

`typeof(z2)`

`[1] "complex"`

Some functions associated with complex vectors are as follows:

`Re(z2) # gives real part of z2`

`[1] 0 0 1 0`

`Im(z2) # gives imaginary part of z2`

`[1] 0 0 3 -4`

`Mod(z2) # gives modulus of z2`

`[1] 0.000000 0.000000 3.162278 4.000000`

`Conj(z2) # gives conjugate of z2`

`[1] 0+0i 0+0i 1-3i 0+4i`

### Creating Vector with named elements

Suppose you want to create a named vector with weight of students along with their names. One way is to create a `Weight`

vector as follows:

```
Weight <- c(58, 46, 75, 49, 67)
Weight
```

`[1] 58 46 75 49 67`

Then use `names()`

function to assign name of students.

```
names(Weight) <- c("Jatin", "Shruti", "David", "Parag", "Daniel")
Weight
```

```
Jatin Shruti David Parag Daniel
58 46 75 49 67
```

Another way to create a named vector using a single command is as follows:

```
Weight <- c(
"Jatin" = 58,
"Shruti" = 46,
"David" = 75,
"Parag" = 49,
"Daniel" = 67
)
Weight
```

```
Jatin Shruti David Parag Daniel
58 46 75 49 67
```

## Vectors using functions

### Generating vectors using `:`

operator

R provides a very useful way of generating a regular sequence of increasing or decreasing values using sequence operator `:`

.

The general expression is `n1:n2`

, which generates sequence of integers ranging from `n1`

to `n2`

.

It generates a sequence of values `n1`

, `n1 + 1`

, … , up to the sequence value less than or equal to `n2`

.

#### Examples of `:`

operator

```
# generate sequence of numbers from 2 to 6
x <- 2:6
x
```

`[1] 2 3 4 5 6`

```
y <- 2.5:6
y
```

`[1] 2.5 3.5 4.5 5.5`

In the first case, since the starting value is integer, the sequence operator `:`

generate a sequence of integers from 2 to 6, whereas in the second case the starting value is float, the sequence operator `:`

generate a sequence of floats ranging from 2.5 to 6.

```
z <- 2.5:6.9
z
```

`[1] 2.5 3.5 4.5 5.5 6.5`

It will generate a sequence of real numbers starting with 2.5 to 6.5.

```
# generate a sequence of integers in increasing order
x <- -3:5
x
```

`[1] -3 -2 -1 0 1 2 3 4 5`

```
# generates a sequence of integers in decreasing order
x <- 5:-3
x
```

`[1] 5 4 3 2 1 0 -1 -2 -3`

(as precedence of `-`

(unary minus) is higher than that of `:`

).

### Generating Vectors using `seq()`

function

The operator `:`

generate regular sequence of numbers in increasing or decreasing orders. The sequence of numbers with specific pattern can be generated using `seq()`

function.

The general syntax of `seq()`

function is

`seq(from, to)`

or`seq(from, to, by=)`

or`seq(from, to, length=)`

.

#### Examples of `seq()`

function

Below R code generate a sequence of numbers from 1 to 8.

`seq(1, 8) `

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

To generate a sequence from 1 to 8 with increment 2, use the below R code.

`seq(1, 8, by = 2) `

`[1] 1 3 5 7`

Below R code generate a sequence of numbers from 8 to 1 with decrements 2

`seq(8, 1, by = -2) `

`[1] 8 6 4 2`

Below R code generate a sequence of 3 numbers (because `length`

argument is specified) from 1 to 8 with equal spacing.

`seq(1, 8, length = 3) `

`[1] 1.0 4.5 8.0`

Below R code generate a sequence of numbers from 0 to 2 with length 5.

`seq(0, 2, length = 5)`

`[1] 0.0 0.5 1.0 1.5 2.0`

Below R code generate a sequence of numbers from 0 to 2 with length 10. The `by`

value is calculated using the formula $\frac{\text{to}-\text{from}}{\text{length}-1}=0.2222222$.

`seq(from = 0, to = 2, length = 10)`

```
[1] 0.0000000 0.2222222 0.4444444 0.6666667 0.8888889 1.1111111 1.3333333
[8] 1.5555556 1.7777778 2.0000000
```

### Repeating vectors using `rep()`

function

A very useful function to create a vector by repeating a given number/vector with specified number of times is the `rep()`

function.

The general structure of `rep()`

function is

`rep(v1,n1)`

.

Here vector `v1`

is repeated `n1`

times.

The forms of `rep()`

function are

`rep(v1, times=)`

,`rep(v1, each=)`

,`rep(v1, length=)`

.

#### Examples of `rep()`

function

Below R code replicate `0`

five times.

```
# replicates 0 five times
rep(0, 5)
```

`[1] 0 0 0 0 0`

Below R code replicate `1, 2, 3`

numbers 3 times.

```
# replicates 1 to 3 numbers 3 times
rep(1:3, times = 3)
```

`[1] 1 2 3 1 2 3 1 2 3`

Below R code replicate each element from the sequence 1,2 3 three times .

```
# each number 1 to 3 is replicated three times
rep(1:3,each=3)
```

`[1] 1 1 1 2 2 2 3 3 3`

Below R code generate a vector 1:3 and store it in `x`

. The next R code replicate the elements of `x`

until you get the length 5. Here R recycle the elements of `x`

till the length becomes 5.

```
# generate a vector 1,2,3
x <- 1:3
# vector x is replicated to get length five.
rep(x, length = 5)
```

`[1] 1 2 3 1 2`

Below R code replicate each element of `x`

twice until you get length 4. As the length is given as 4, R take each element twice and replicate the elements till the length becomes 4.

```
# replicate each element of x twice
# until you get length of 4
rep(x, each = 2, length = 4)
```

`[1] 1 1 2 2`

The R code below replicate each element of `x`

twice until you get length of 8. As there are only 3 elements 1,2 and 3 in `x`

, R use recycling to get the length of 8.

`rep(x, each = 2, length = 8) `

`[1] 1 1 2 2 3 3 1 1`

Below R code replicate each element of `x`

twice and repeat the process six times.

`rep(x, each = 2, times = 6)`

` [1] 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3 1 1 2 2 3 3`

Below R code replicate each element of `x`

one by one six times until the length becomes 10.

`rep(x, each = 6, length = 10)`

` [1] 1 1 1 1 1 1 2 2 2 2`

Below R code replicate element of `x`

such that first element replicated 2 times, second element replicated 1 time and third element replicated 3 times.

```
# 1 is replicated 2 times, and so on
rep(x, c(2, 1, 3))
```

`[1] 1 1 2 3 3 3`

## Accessing Elements of Vectors

Any particular element or elements of vectors in R can be accessed using a square brackets `[]`

.

### Accessing elements by Positive Indexing

The element of vector can be accessed by using positive index of the position of that element, or using sequence of positive index (for adjacent elements) of elements or using `c()`

function with position of elements of vector.

Recall the `age.1`

vector defined earlier.

```
age.1 <- c(20L, 31L, 45L, 37L, 24L)
age.1
```

`[1] 20 31 45 37 24`

Below R code return the $3^{rd}$ element from `age.1`

.

`age.1[3]`

`[1] 45`

Consecutive elements of vector can be accessed using `:`

operator. Below R code returns first and second element from `age.1`

.

`age.1[1:2]`

`[1] 20 31`

Non-consecutive elements of vector can be accessed using `c()`

function. Below R code returns first and third element from `age.1`

.

`age.1[c(1, 3)]`

`[1] 20 45`

### Accessing elements by Negative Indexing

Below R code is used to access all the elements except the third element of `age.1`

vector.

`age.1[-3]`

`[1] 20 31 37 24`

Below R code returns all the elements except the elements from the 1 through 3 index.

`age.1[-(1:3)]`

`[1] 37 24`

Below R code returns all the elements except the first and fourth elements from `age.1`

vector.

`age.1[-c(1, 4)]`

`[1] 31 45 24`

### Accessing elements by Logical Vector

In accessing elements of vector using logical vector, R will return only those elements from vector where the logical values of logical vector are TRUE.

For example, in the below R code, R returns the value of first and third element of `age`

vector because the first and third value of the logical vector is `TRUE`

.

`age.1[c(TRUE, FALSE, TRUE, FALSE)]`

`[1] 20 45 24`

We can also use logical expression to access the elements of a vector. First, R evaluate the logical expression and create a logical vector. Then R returns Based on the value of the For example,

`age.1[age.1 < 25]`

`[1] 20 24`

In the above R code, the logical expression `age.1<25`

returns a logical vector (TRUE, FALSE, FALSE, FALSE, TRUE). Based on the result of logical vector, R returns those elements of `age.1`

for which the logical value is `TRUE`

.

### Accessing elements by Character Vector

The elements of named vector can be assessed by the name of the elements. Earlier we have seen how to give names to the elements of a vector.

```
Weight <- c(46, 58, 75, 49, 67)
Weight
```

`[1] 46 58 75 49 67`

Using `names()`

function, we can assign names to the elements of vector.

```
names(Weight) <- c("Jatin", "Shruti", "David", "Parag", "Daniel")
Weight
```

```
Jatin Shruti David Parag Daniel
46 58 75 49 67
```

Below R code, return the weights of `David`

and `Daniel`

from the `weight`

vector.

`Weight[c("David", "Daniel")]`

```
David Daniel
75 67
```

## Coercion in vectors

When you mix different data values (like numeric, character, logical or complex) in a vector, R will coerce them so that they are all of the same type.

R follows two basic rules of coercion:

- If a character is present in a vector, R will coerce everything else to characters.
- If a vector contains logical values and numbers, R will convert the logical values to numbers (Like TRUE to 1 and FALSE to 0).

When different objects are mixed in a vector, coercion occurs so that every element in the vector is of the same type.

### Vector with character and numeric values

Suppose the vector contains some character and some numeric values. In such a case R coerce all the numeric values to character and consider that vector as a character vector.

```
## xx is a character vector
xx <- c(1.8, "Male", 20)
xx
```

`[1] "1.8" "Male" "20" `

Since in the above R code two elements are numeric and one is character string, R will coerce all the elements to character and consider that vector as a `character`

vector.

`class(xx)`

`[1] "character"`

`as.numeric(xx)`

`Warning: NAs introduced by coercion`

`[1] 1.8 NA 20.0`

The above R code convert vector `xx`

to numeric. Since one of the element is character, R introduce `NA`

by coercion in place of character and consider the vector `xx`

as numeric vector.

### Vector with numeric and logical values

Suppose the vector contains some numeric and some logical values. In such a case R coerce all the logical values to their numerical equivalent and consider that vector as a numeric vector. The numerical equivalent for `TRUE`

or `T`

is 1 and for `FALSE`

or `F`

is 0.

```
## yy is a numeric vector
yy <- c(TRUE, 1.8, -1.2, FALSE, T)
yy
```

`[1] 1.0 1.8 -1.2 0.0 1.0`

`class(yy)`

`[1] "numeric"`

If we convert `yy`

numeric vector using `as.logical()`

function, R will convert `0`

to `FALSE`

and all other values to `TRUE`

.

`as.logical(yy)`

`[1] TRUE TRUE TRUE FALSE TRUE`

### Vector with character and logical values

Suppose the vector contains some character and some logical values. In such a case R coerce all the logical values to character and consider that vector as a character vector.

```
## zz is a character vector
zz <- c("Male", TRUE)
zz
```

`[1] "Male" "TRUE"`

If we convert `zz`

character vector using `as.logical()`

function, R will convert character values to `NA`

and the logical values to their logical equivalent.

`as.logical(zz)`

`[1] NA TRUE`

## Endnote

In this tutorial you learned about what is `vector`

data structure in R, how to create vectors in R, how to initialize vectors in R and how to create vectors using various functions in R with some illustrations.

To learn more about other data structures in R, please refer to the following tutorials:

- Data Types in R
- Data Structures in R
- Variables and Constants in R
- Matrix in R
- Array in R
- List in R
- Factors in R
- Data Frames in R

Hopefully you enjoyed learning this tutorial on `vector`

type data structure in R. Hope the content is more than sufficient to understand `vector`

in R.