Overview of R Data Types

Introduction

R comes with several built-in data types, which include numeric, integer, complex, character, logical, and raw. In this article, we’ll briefly discuss each data type and provide some code examples to illustrate their usage.

Data Types

Numeric

The numeric data type are commonly used for scientific or statistical computations where decimal values and high precision are often required. You can perform arithmetic operations on numeric variables in R, such as addition, subtraction, multiplication, and division.

The numeric data type in R is used to represent both integer and floating-point numbers. You can create a numeric variable in R by simply assigning a value to it using the assignment operator, ‘<-’. For example:

x <- 100 # integer

y <- 3.1415926 # floating-point number

R will automatically choose the appropriate data type (integer or floating-point) depending on the operands and the result of the operation.

You can use the typeof() function to check the data type of a variable in R, as shown below:

x <- 100
typeof(x) # returns "double"

## [1] "double"

y <- 3.1415926
typeof(y) # returns "double"

## [1] "double"

R uses the “double” precision data type to represent numeric values, which provides high precision and can represent a wide range of values. However, it is important to consider memory usage and performance when working with large data sets or computationally intensive operations. The numeric data types can use more memory than the integer data type we will talk about next, so it may be preferable to use the integer data type when possible to optimize memory usage.

Integer

In R, the integer are a specific type of numeric data type used to represent whole numbers without a fractional component. The integer data type uses less memory than the numeric data type, which can make it more efficient for certain operations.

You can create an integer variable in R by simply assigning a value that is a whole number, without a decimal component. For example:

x <- 100
typeof(x) # returns "double" (implicitly converted to numeric data type)

## [1] "double"

However, it’s important to note that the above assignment implicitly converts the value to a numeric data type, which uses more memory. To explicitly create an integer variable, you have to use the ‘as.integer()’ function. For example:

y <- as.integer(100)
typeof(y) # returns "integer"

## [1] "integer"

You can also explicitly declare an integer variable by using the ‘L’ suffix when assigning a value. For example:

z <- 5L
typeof(z) # returns "integer"

## [1] "integer"

You can perform arithmetic operations on integer variables in R, including addition, subtraction, multiplication, and division. R will automatically choose the appropriate data type (integer or floating-point) depending on the operands and the result of the operation. So when working with integer variables in R, it’s important to ensure that you’re not inadvertently converting them to numeric data types, which can result in precision loss and increased memory usage. To ensure that an integer variable remains an integer, you can use the ‘as.integer()’ function or the ‘L’ suffix when assigning a value.

Complex

The complex data type represents complex numbers in R, which have both real and imaginary components. You can create a complex variable in R using the ‘complex()’ function, which takes two arguments: the real component and the imaginary component. For example:

z <- complex(real = 2, imaginary = 3)

You can access the real and imaginary components of a complex variable using the Re() and Im() functions, respectively. For example:

z <- complex(real = 2, imaginary = 3)
z

## [1] 2+3i

Re(z) # returns 2

## [1] 2

Im(z) # returns 3

## [1] 3

You can perform arithmetic operations on complex variables in R, including addition, subtraction, multiplication, and division. R will automatically apply the appropriate rules for complex arithmetic, which take into account both the real and imaginary components of the numbers.

To calculate the magnitude (or absolute value) of a complex number, you can use the ‘abs()’ function. To calculate the angle (or argument) of a complex number, you can use the ‘Arg()’ function, which returns the result in radians. For example:

z <- complex(real = 2, imaginary = 3)
z

## [1] 2+3i

abs(z) # returns 3.605551

## [1] 3.605551

Arg(z) # returns 0.9827937 (in radians)

## [1] 0.9827937

Character

The character data type is used to represent text or strings of characters in R. Text data can include letters, numbers, and special characters, and can be of variable length. A character data type is created by enclosing the text in single or double quotation marks. For example:

name <- 'Alex Lee'
typeof(name) # returns "charater"

## [1] "character"

name <- "Alex Lee"
typeof(name) # returns "character"

## [1] "character"

You can concatenate two or more character variables using the ‘paste()’ or ‘paste0()’ functions. The ‘paste()’ function separates the concatenated variables with a space, while the ‘paste0()’ function concatenates them without a separator. For example:

first_name <- "Alex"
last_name <- "Lee"
full_name <- paste(first_name, last_name, sep = " ")
full_name # returns "Alex Lee"

## [1] "Alex Lee"

full_name_no_sep <- paste0(first_name, last_name)
full_name_no_sep # returns "AlexLee"

## [1] "AlexLee"

Logical

The logical data type represents true/false values in R. It is created using the TRUE and FALSE keywords. For example:

is_raining <- TRUE
typeof(is_raining) # returns "logical"

## [1] "logical"

You can perform logical operations on logical variables in R, including negation (!), conjunction (& or &&), and disjunction (| or ||). R applies the appropriate rules for logical operations based on the truth values of the operands.

To perform conditional operations on logical variables, you can use the ‘ifelse()’ function, which takes three arguments: a logical expression, a value to return if the expression is true, and a value to return if the expression is false. For example:

x <- 10
y <- ifelse(x > 5, "greater than 5", "less than or equal to 5")
y # returns "greater than 5"

## [1] "greater than 5"

When working with logical variables in R, it is important to be aware of issues related to truth values and logical operators. For example, the && and || operators only evaluate the first operand if the result can be determined from that operand alone, which can lead to unexpected results if the second operand has side effects.

Raw

The raw data type in R is used to represent binary data in its original form, such as the contents of a file or a network packet. Each element of a raw vector represents a single byte of data, with values ranging from 0x00 to 0xFF (hexadecimal) or 0 to 255 (decimal).

To create a raw vector in R, you can use the ‘as.raw()’ function, which takes a numeric vector as input and returns a raw vector. For example, the following code creates a raw vector with the hexadecimal values for the ASCII characters “Hello”:

x <- as.raw(c(0x48, 0x65, 0x6c, 0x6c, 0x6f))
cat(rawToChar(x)) # output: "Hello"

## Hello

You can also create a raw vector with the decimal values for the same ASCII characters:

x <- as.raw(c(72, 101, 108, 108, 111))
cat(rawToChar(x)) # output: "Hello"

## Hello

Once you have a raw vector, you can manipulate its values using various functions and operators in R. For example, you can extract a single byte from a raw vector using the [ ] operator, like this:

x <- as.raw(c(0x48, 0x65, 0x6c, 0x6c, 0x6f))
byte <- x[1] # extract the first byte (0x48)
byte

## [1] 48

You can also combine raw vectors using the ‘c()’ function, like this:

x1 <- as.raw(c(0x48, 0x65, 0x6c))
x2 <- as.raw(c(0x6c, 0x6f))
x3 <- c(x1, x2) # combine the two raw vectors into one
x3

## [1] 48 65 6c 6c 6f

Finally, you can convert a raw vector to a character string using the ‘rawToChar()’ function, like this:

x <- as.raw(c(0x48, 0x65, 0x6c, 0x6c, 0x6f))
str <- rawToChar(x) # convert the raw vector to a character string ("Hello")
str

## [1] "Hello"

Summary

In summary, R has several built-in data types that you can use to store and manipulate data. These data types include numeric, integer, complex, character, logical and raw. Understanding the different data types in R is essential for working with data effectively.