The is.infinite() function checks each element of a vector or an R object contains infinity. If an element is infinite, the corresponding element in the output vector is TRUE. Otherwise, FALSE.
By default, it handles atomic vectors, but it can also handle other data types.
In R, there are two types of infinity:
- Inf (positive infinity)
- -Inf (negative infinity)
The output object of is.infinite() function has the same length as an input object with the difference that it will be filled with logical values (TRUE or FALSE).
In mathematical calculations, infinite values can disrupt our calculations if they are not appropriately handled. Instances like division by 0, numerical overflow, or log(0) can produce infinite results.
Syntax
is.infinite(obj)
Parameters
Name | Value |
obj | It is an input R object. It can be anything like a vector, list, factor, data frame, etc. |
Numeric vector
# Basic usage
vec <- c(11, Inf, -Inf, 21, 19)
is.infinite(vec) # Output: FALSE TRUE TRUE FALSE FALSE
# Division by zero
y <- 21 / 0
is.infinite(y) # Output: TRUE
z <- -19 / 0
is.infinite(z) # Output: TRUE
# Large numbers
a <- 1e308 # It is a large number, but still finite
is.infinite(a) # Output: FALSE
Here, you can see in the above program that we covered most of the basic scenarios where infinity can be generated in the output, and we handled it.
We can use the if statement further to handle it properly.
# Division by zero
y <- 21 / 0
is.infinite(y) # Output: TRUE
# Adding if statement to avoid division by zero
if (y == Inf) {
y <- 0
}
print(y) # Output: 0
Complex vector
If your input object is a complex vector, the is.infinite() function checks whether the real or imaginary part is infinite.
# Define complex vector with inf and -inf
complex_vec <- c(1 + 2i, Inf + 0i, 3 - Inf * i, 0 + 0i)
# Checking for infinite values
is.infinite(complex_vec) # Output: FALSE TRUE TRUE FALSE
For 1+2i, both real and imaginary parts are finite, so it returns FALSE.
For Inf+oi, the real part is infinite, and the imaginary part is finite, so it returns TRUE since one of them is infinite.
For 3-inf*i, the real part is finite, but the imaginary part is infinite, so it returns TRUE.
For 0+0i, both real and imaginary parts are finite, so it returns FALSE.
Handling NA and NaN values
The is.infinite() function is specifically designed to handle Inf or -Inf values. It does not handle NA and NaN values properly.
exceptional_vec <- c(Inf, -Inf, NA, NA, 0 / 0)
is.infinite(exceptional_vec) # Output: TRUE TRUE FALSE FALSE FALSE
You can see in the above program that it returns FALSE for NA, NaN, and 0 / 0.
To detect NA values, use is.na() function.
To detect NaN values, use is.nan() function.
Factor
The Factor is a tricky data type because factors are stored as integers with associated levels and integers will never be Inf or -Inf. So, you cannot apply is.infinite() function to a factor directly because it always returns FALSE.
my_fact <- factor(c("a", "b", "c", "d", "e"))
is.infinite(my_fact) # FALSE FALSE FALSE FALSE FALSE
To check for infinite values, you must convert the factor to a numeric type if the levels themselves represent numeric values. For that, you need conversion functions like as.character() and as.numeric().
numeric_factor <- factor(c("21", "Inf", "-19", "-Inf"))
is.infinite(as.numeric(as.character(numeric_factor))) # Output: FALSE TRUE FALSE TRUE
List
The list is a collection of different types of data, and here also, we cannot directly apply this function. What we can do here is apply is.infinite() function to individual elements of the list using lapply() or sapply() functions.
# Define a list with Inf and -Inf values
main_list <- list(c(11, Inf, 21), c(-Inf, 19, 21), "KB")
is_infinite_list <- lapply(main_list, is.infinite)
print(is_infinite_list)
Output
Data Frame
Data Frame is also a complex type in which what you can do is to apply is.infinite() function to individual columns or use lapply() or apply() to apply it to all numeric columns.
# Define a data frame where Inf and -Inf values are present
df <- data.frame(
col1 = c(21, Inf, 3),
col2 = c(-Inf, 15, 19),
col3 = c("KB", "KL", "KE")
)
# Applying to a specific column
is.infinite(df$col1) # Output: FALSE TRUE FALSE
# Applying to only numeric columns
numeric_cols <- sapply(df, is.numeric)
lapply(df[, numeric_cols], is.infinite)
# Output:
# $col1
# [1] FALSE TRUE FALSE
# $col2
# [1] TRUE FALSE FALSE
That’s all!
Krunal Lathiya is a seasoned Computer Science expert with over eight years in the tech industry. He boasts deep knowledge in Data Science and Machine Learning. Versed in Python, JavaScript, PHP, R, and Golang. Skilled in frameworks like Angular and React and platforms such as Node.js. His expertise spans both front-end and back-end development. His proficiency in the Python language stands as a testament to his versatility and commitment to the craft.