# R Vector

A **vector** is a basic data structure which plays an important role in R programming.

In R, a sequence of elements which share the same data type is known as vector. A vector supports logical, integer, double, character, complex, or raw data type. The elements which are contained in vector known as **components** of the vector. We can check the type of vector with the help of the **typeof()** function.

The length is an important property of a vector. A vector length is basically the number of elements in the vector, and it is calculated with the help of the length() function.

Vector is classified into two parts, i.e., **Atomic vectors** and **Lists** . They have three common properties, i.e., **function type, function length** , and **attribute function** .

There is only one difference between atomic vectors and lists. In an atomic vector, all the elements are of the same type, but in the list, the elements are of different data types. In this section, we will discuss only the atomic vectors. We will discuss lists briefly in the next topic.

## How to create a vector in R?

In R, we use c() function to create a vector. This function returns a one-dimensional array or simply vector. The c() function is a generic function which combines its argument. All arguments are restricted with a common data type which is the type of the returned value. There are various other ways to create a vector in R, which are as follows:

### 1) Using the colon`(:)`

operator

We can create a vector with the help of the colon operator. There is the following syntax to use colon operator:

z<-x:y

This operator creates a vector with elements from x to y and assigns it to z.

Example:

a<-4:-10

a

**Output**

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

`

**2) Using the seq() function**

In R, we can create a vector with the help of the seq() function. A sequence function creates a sequence of elements as a vector. The seq() function is used in two ways, i.e., by setting step size with ?by’ parameter or specifying the length of the vector with the ‘length.out’ feature.

**Example:**

seq_vec<-seq(1,4,by=0.5)

seq_vec

class(seq_vec)

**Output**

[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0

**Example:**

seq_vec<-seq(1,4,length.out=6)

seq_vec

class(seq_vec)

**Output**

[1] 1.0 1.6 2.2 2.8 3.4 4.0

[1] “numeric”

## Atomic vectors in R

In R, there are four types of atomic vectors. Atomic vectors play an important role in Data Science. Atomic vectors are created with the help of **c()** function. These atomic vectors are as follows:

### Numeric vector

The decimal values are known as numeric data types in R. If we assign a decimal value to any variable d, then this d variable will become a numeric type. A vector which contains numeric elements is known as a numeric vector.

**Example:**

d<-45.5

num_vec<-c(10.1, 10.2, 33.2)

d

num_vec

class(d)

class(num_vec)

**Output**

```
[1] 45.5
[1] 10.1 10.2 33.2
[1] "numeric"
[1] "numeric"
```

### Integer vector

A non-fraction numeric value is known as integer data. This integer data is represented by “Int.” The Int size is 2 bytes and long Int size of 4 bytes. There is two way to assign an integer value to a variable, i.e., by using as.integer() function and appending of L to the value.

A vector which contains integer elements is known as an integer vector.

**Example:**

d<-as.integer(5)

e<-5L

int_vec<-c(1,2,3,4,5)

int_vec<-as.integer(int_vec)

int_vec1<-c(1L,2L,3L,4L,5L)

class(d)

class(e)

class(int_vec)

class(int_vec1)

**Output**

[1] “integer”

[1] “integer”

[1] “integer”

[1] “integer”

### Character vector

A character is held as a one-byte integer in memory. In R, there are two different ways to create a character data type value, i.e., using as.character() function and by typing string between double quotes("") or single quotes(’’).

A vector which contains character elements is known as an integer vector.

**Example:**

`d<-'shubham' e<-"Arpita" f<-65 f<-as.character(f) d e f char_vec<-c(1,2,3,4,5) char_vec<-as.character(char_vec) char_vec1<-c("shubham","arpita","nishka","vaishali") char_vec class(d) class(e) class(f) class(char_vec) class(char_vec1)`

**Output**

[1] “shubham”

[1] “Arpita”

[1] “65”

[1] “1” “2” “3” “4” “5”

[1] “shubham” “arpita” “nishka” “vaishali”

[1] “character”

[1] “character”

[1] “character”

[1] “character”

[1] “character”

### Logical vector

The logical data types have only two values i.e., True or False. These values are based on which condition is satisfied. A vector which contains Boolean values is known as the logical vector.

**Example:**

d<-as.integer(5)

e<-as.integer(6)

f<-as.integer(7)

g<-d>e

h<-e<f

g

h

log_vec<-c(d<e, d<f, e<d,e<f,f<d,f<e)

log_vec

class(g)

class(h)

class(log_vec)

**Output**

[1] FALSE

[1] TRUE

[1] TRUE TRUE FALSE TRUE FALSE FALSE

[1] “logical”

[1] “logical”

[1] “logical”

## Accessing elements of vectors

We can access the elements of a vector with the help of vector indexing. Indexing denotes the position where the value in a vector is stored. Indexing will be performed with the help of integer, character, or logic.

### 1) Indexing with integer vector

On integer vector, indexing is performed in the same way as we have applied in C, C++, and java. There is only one difference, i.e., in C, C++, and java the indexing starts from 0, but in R, the indexing starts from 1. Like other programming languages, we perform indexing by specifying an integer value in square braces [] next to our vector.

**Example:**

seq_vec<-seq(1,4,length.out=6)

seq_vec

seq_vec[2]

**Output**

[1] 1.0 1.6 2.2 2.8 3.4 4.0

[1] 1.6

### 2) Indexing with a character vector

In character vector indexing, we assign a unique key to each element of the vector. These keys are uniquely defined as each element and can be accessed very easily. Let’s see an example to understand how it is performed.

**Example:**

char_vec<-c(“shubham”=22,“arpita”=23,“vaishali”=25)

char_vec

char_vec[“arpita”]

**Output**

shubham arpita vaishali

22 23 25

arpita

23

### 3) Indexing with a logical vector

In logical indexing, it returns the values of those positions whose corresponding position has a logical vector TRUE. Let see an example to understand how it is performed on vectors.

**Example:**

`a<-c(1,2,3,4,5,6) a[c(TRUE,FALSE,TRUE,TRUE,FALSE,TRUE)]`

**Output**

[1] 1 3 4 6