# Infinity in Ruby

Have you ever wondered how Ruby handles infinity? We’ve all run into the divide-by-zero error when diving an integer by zero, but things are different in case of floating point numbers.

As you can see above, Ruby gives you a value that represents infinity when a floating point operation returns an infinite value.

There isn’t a constant
with the name `Infinity`

,
as shown by the NameError
that we encountered
when trying to access it directly.
But it is available as the constant `Float::INFINITY`

.
Let’s take a closer look at it.

Ok, now that we know that it’s a value of type Float, let’s try some arithmetic operations on it.

`NaN`

- not a number

Subtraction and division
of two infinite values
yield undefined results.
Now we have another kind of value, `NaN`

,
to represent such values.
Let’s dig into `NaN`

for a minute.

# Infinite ranges

One interesting use of `Infinity`

is to get infinite ranges.

You need to be careful
when using methods like `#select`

because you might end up with
an infinite loop
while `#select`

keeps checking every number
because it never reaches `Infinity`

.

In such cases,
you can use the
`Enumerable#lazy`

method
to create a lazy enumerator
and then use the `#first`

method
to take a certain number of items
from that list.

# An example

Let’s look at an situation
where we might find
infinite ranges useful.
You have an `Article`

class,
and need to implement
a `within_word_limit?`

method
that checks if the word count is
between `@min_word_count`

and `@max_word_count`

.

If either of those variables is nil,
that limit does not exist,
ie. the range would be `0..Infinity`

.
Here’s one way of doing it
by setting the upper limit
of the range as infinity.

We could do this by using the comparison operators and if statements, but using a range makes it much more readable.