# Ruby Infinity: How It Works & Why It Matters

What is infinity in Ruby?

It’s something that has a starting point but no ending.

In Ruby, we can express this concept of infinity with the `Float::INFINITY` constant.

You may be wondering how this is useful.

Let me explain with examples!

## Infinity As A Result Of Arithmetic Operations

Ruby returns an `Infinity` object, as the result of certain math operations.

For example:

You may be familiar with the “division by zero” error.

Here it is:

```1/0
# ZeroDivisionError: divided by 0
```

But…

If you use a float, you get something else:

```1/0.0
# Infinity
```

`Infinity`!

But that’s not all.

If you try a division of `0` by `0.0`, then you get another special value.

Take a look:

```0/0.0
# NaN
```

What is this NaN?

It means “Not a Number”, and as far as I know, this is the only place in Ruby where you’ll find this value.

Why is this a thing?

It’s part of the IEEE 754 Specification, which explains how floating-point operations should behave.

Btw, there are some related methods:

• `nan?`
• `finite?`
• `infinite?`

You can use these methods to check for special values.

These methods are available on Floats.

Since Ruby 2.4 you can also use `finite?` & `infinite?` with Integers.

## How to Create Infinite Ranges

Ok.

That was interesting… let’s see more examples.

Now with Ranges!

Here’s an infinite range:

```(1..Float::INFINITY).take(10)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

This can be helpful when you don’t know the end of the range in advance.

One problem…

It only works with numbers as the starting value.

Example:

```("a"..Float::INFINITY)
# ArgumentError: bad value for range
```

What’s the solution?

With Ruby 2.6, you can do this:

```("a"..).take(5)
# ["a", "b", "c", "d", "e"]
```

Yes, that’s not a mistake! This range has no ending value, only a starting value of `"a"`, then two dots `..` to make it a never-ending range.

This is new syntax.

Use Ruby 2.6+ if you want this to work.

## Infinity As Maximum & Minimum Value

Another practical use for `Infinity`?

Well…

It’s the biggest (`Infinity`) & smallest (`-Infinity`) number in Ruby.

You can use this as a starting value.

Here’s an example:

```def smallest_percent_size(style, ary_size)
@smallest_percent ||= Float::INFINITY

if style == :percent && ary_size < @smallest_percent
@smallest_percent = ary_size
end

@smallest_percent
end
```

This code is from Rubocop, an open-source project.

Here's how it works:

We are trying to find the smallest array size, but we need a starting value for that because using `nil` would give you an error.

You could type a big number & hope that's enough.

Or you can use `Float::INFINITY`, knowing that's that biggest number possible.

## Summary

You have learned about infinity in Ruby, what it is, where it may show up & how to use it.