# How can I represent an infinite number in Python?

## Question:

How can I represent an infinite number in python? No matter which number you enter in the program, no number should be greater than this representation of infinity.

## Answers:

I don’t know exactly what you are doing, but `float("inf")`

gives you a float Infinity, which is greater than any other number.

In Python, you can do:

```
test = float("inf")
```

In Python 3.5, you can do:

```
import math
test = math.inf
```

And then:

```
test > 1
test > 10000
test > x
```

Will always be true. Unless of course, as pointed out, x is also infinity or “nan” (“not a number”).

Additionally (Python 2.x ONLY), in a comparison to `Ellipsis`

, `float(inf)`

is lesser, e.g:

```
float('inf') < Ellipsis
```

would return true.

Another, less convenient, way to do it is to use `Decimal`

class:

```
from decimal import Decimal
pos_inf = Decimal('Infinity')
neg_inf = Decimal('-Infinity')
```

In python2.x there was a dirty hack that served this purpose (NEVER use it unless absolutely necessary):

```
None < any integer < any string
```

Thus the check `i < ''`

holds `True`

for any integer `i`

.

It has been reasonably deprecated in python3. Now such comparisons end up with

```
TypeError: unorderable types: str() < int()
```

Since Python 3.5 you can use `math.inf`

:

```
>>> import math
>>> math.inf
inf
```

There is an infinity in the NumPy library: `from numpy import inf`

. To get negative infinity one can simply write `-inf`

.

No one seems to have mentioned about the negative infinity explicitly, so I think I should add it.

For negative infinity:

```
-math.inf
```

For positive infinity (just for the sake of completeness):

```
math.inf
```

Also if you use SymPy you can use `sympy.oo`

```
>>> from sympy import oo
>>> oo + 1
oo
>>> oo - oo
nan
```

etc.

For Positive Infinity

```
pos_inf_val = float("infinity")
```

For Negative Infinity

```
neg_inf_val = float("-infinity")
```

Representing **∞** in `python`

`float("inf")`

or `float("INF")`

or `float("Inf")`

or `float("inF")`

or `float("infinity")`

or `float("Infinity")`

creates a `float`

object holding **∞**

You can also represent **-∞** in `python`

`float("-inf")`

or `float("-INF")`

or `float("-Inf")`

or `float("-infinity")`

creates a float object holding **-∞**

You can perform **arithmetic operations**:

```
infinity = float("inf")
ninfinity = float("-inf")
nan = float("nan")
print(infinity*infinity)#inf
print(ninfinity+infinity)#not a number
print(1/-infinity)#is -0.0
print(nan*nan)# is not a number
print(1/infinity) # is 0.0 since 1/∞ is 0
```

## Output:

```
$ python3 floating.py
inf
nan
-0.0
nan
0.0
```

In Summary, there is two kinds definition for Infinity.

For Positive Infinity

```
posVal1 = math.inf
posVal2 = float("inf")
```

For Negative Infinity

```
negVal1 = -math.inf
negVal2 = float("-inf")
```

## Infinity

### 1. Using `float('inf')`

and `float('-inf)`

```
positive_infinity = float('inf')
negative_infinity = float('-inf')
```

### 2. Using Python’s math module

```
import math
positive_infinity = math.inf
negative_infinity = -math.inf
```

### 3. Integer `maxsize`

```
import sys
maxSize = sys.maxsize
minSize = -sys.maxsize
```

### 4. Using Python’s decimal module

```
from decimal import Decimal
positive_infinity = Decimal('Infinity')
negative_infinity = Decimal('-Infinity')
```

## 5. Using Numpy Library

```
from numpy import inf
positive_infinity = inf # Inf
negative_infinity = -inf # -Inf
```

Use:

```
float('inf')
```

Or the math module:

```
import math
math.inf
```

But if you print it, they will both return `inf`

, which proves that `math`

uses `float('inf')`

as well.