Atomic data types are the object types that you can use to create atomic vectors. To check if any data object is atomic in R, use the is.atomic() function.

**Atomic Vector in R**

Atomic vector is a fundamental data structure in the R programming language. An atomic vector is different from a one-dimensional array because it has a **dim** **attribute** of length while a vector has no such attribute. Atomic vector is also different from the list since the vector items have the same types, while a list can contain various arbitrary data types.

**Types of Atomic Vector in R**

There are five types of atomic vectors.

- Numeric: integer and double (real)
- Character
- Logical
- Complex
- Raw

**Integer vectors**

The integer data type is a type of numeric data type. To create an integer vector in R, use the integer() function.

`integer(length = 7)`

**Output**

`[1] 0 0 0 0 0 0 0`

**as.integer()**

The as.integer() is a built-in R function that attempts to coerce its argument to be of integer type.

```
rv <- "10"
ind <- as.integer(rv)
ind
typeof(ind)
```

**Output**

```
[1] 10
[1] "integer"
```

**is.integer()**

To check if the argument is an integer or not, use the is.integer() function. The is.integer() method returns **TRUE** or **FALSE** depending on if the input is an integer or not.

```
rv <- "10"
ind <- as.integer(rv)
ind
is.integer(ind)
```

**Output**

```
[1] 10
[1] TRUE
```

**Character Vectors**

Character vectors consist of characters. To create a character vector in R, use the character() method. Text in R is represented by character vectors. You can also assign a character value to a Vector sing the assignment operator (<- ), and it becomes the character vector.

To create an empty character vector, use the character() function and pass the length of that empty vector.

```
rc <- character(5)
rc
```

**Output**

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

**as.character()**

The as.character() is a built-in R method that tries to coerce its argument to character type; like as.vector() method, it strips attributes including names.

```
rc <- 10
rnd <- as.character(rc)
rnd
typeof(rnd)
```

**Output**

```
[1] "10"
[1] "character"
```

As you can see that we defined an integer vector, and then using **as.vector() **function, we converted integer vector to character vector. To check the data type of a variable in R, use the **typeof() **function.

**is.character()**

To check if the argument is a character or not, use the is.character() function. The **is.character()** method returns **TRUE** or **FALSE** depending on if the input is a character vector or not.

```
rc <- 10
rnd <- as.character(rc)
rnd
is.character(rnd)
```

**Output**

```
[1] "10"
[1] TRUE
```

**Logical Vectors**

Logical vectors are the vectors that only contain logical values like **TRUE** or **FALSE**. To create a logical vector in R, use the **logical() **function.

```
rl <- logical(length = 4)
rl
```

**Output**

`[1] FALSE FALSE FALSE FALSE`

**as.logical()**

The **as.logical()** is a built-in R method that tries to coerce its argument to logical type.

```
rl <- 1
lnd <- as.logical(rl)
lnd
typeof(lnd)
```

**Output**

```
[1] TRUE
[1] "logical"
```

As you can see that we defined an integer vector, and then using **as.logical() **function, we converted integer vector to logical vector.

**is.logical()**

To check if the argument is a logical vector or not, use the is.logical() function. The **is.logical()** method returns **TRUE** or **FALSE** depending on if the input is a logical vector or not.

```
rl <- 1
lnd <- as.logical(rl)
lnd
is.logical(lnd)
```

**Output**

```
[1] TRUE
[1] TRUE
```

**Complex vectors**

The complex vectors can be created with complex() function. Pass the length you want to create, and it will create a complex vector for you.

```
rcom <- complex(length = 4)
rcom
```

**Output**

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

**as.complex()**

The as.complex() is a built-in function that tries to coerce its argument to be of complex type: like as.vector(), it strips attributes including names.

```
rcom <- 1
cnd <- as.complex(rcom)
cnd
typeof(cnd)
```

**Output**

```
[1] 1+0i
[1] "complex"
```

As you can see that we defined an integer vector, and then using the **as.complex() **function, we converted integer vector to complex vector.

**is.complex()**

To check if the argument is a complex vector or not, use the is.complex() function.

```
rcom <- 1
cnd <- as.complex(rcom)
cnd
is.complex(cnd)
```

**Output**

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

**Raw Vectors**

Raw vectors are used to store fixed-length sequences of bytes. You can create a raw vector of the specified length. Each element of the vector is equal to 0. To create a raw vector in R, use the raw() function.

```
rawv <- raw(length = 4)
rawv
```

**Output**

`[1] 00 00 00 00`

**as.raw()**

The as.raw() is a built-in function that tries to coerce its argument to be raw.

```
rw <- 1
rawd <- as.raw(rw)
rawd
typeof(rawd)
```

**Output**

```
[1] 01
[1] "raw"
```

**is.raw()**

To check if the argument is a raw vector or not, use the is.raw() function.

```
rw <- 1
rawd <- as.raw(rw)
rawd
is.raw(rawd)
```

**Output**

```
[1] 01
[1] TRUE
```

As you can see that the is.raw() method returns **TRUE** since we have passed a raw vector to the is.raw() function.

That is it for atomic vectors in R.

Krunal Lathiya is an Information Technology Engineer by education and web developer by profession. He has worked with many back-end platforms, including Node.js, PHP, and Python. In addition, Krunal has excellent knowledge of Data Science and Machine Learning, and he is an expert in R Language. Krunal has written many programming blogs, which showcases his vast expertise in this field.