# Is there special significance to 16331239353195370.0?

Using `import numpy as np`

I've noticed that

```
np.tan(np.pi/2)
```

gives the number in the title and not `np.inf`

```
16331239353195370.0
```

I'm curious about this number. Is it related to some system machine precision parameter? Could I have calculated it from something? (I'm thinking along the lines of something similar to `sys.float_info`

)

**EDIT:** The same result is indeed reproducible in other environments such as Java, octace, matlab... The suggested dupe does not explain why, though.

`pi`

isn't exactly representable as Python float (same as the platform C's `double`

type). The closest representable approximation is used.

Here's the exact approximation in use on my box (probably the same as on your box):

```
>>> import math
>>> (math.pi / 2).as_integer_ratio()
(884279719003555, 562949953421312)
```

To find the tangent of that ratio, I'm going to switch to wxMaxima now:

```
(%i1) fpprec: 32;
(%o1) 32
(%i2) tan(bfloat(884279719003555) / 562949953421312);
(%o2) 1.6331239353195369755967737041529b16
```

So essentially identical to what you got. The binary approximation to `pi/2`

used is a little bit less than the mathematical ("infinite precision") value of `pi/2`

. So you get a very large tangent instead of `infinity`

. The computed `tan()`

is appropriate for the actual input!

For exactly the same kinds of reasons, e.g.,

```
>>> math.sin(math.pi)
1.2246467991473532e-16
```

doesn't return 0. The approximation `math.pi`

is a little bit less than `pi`

, and the displayed result is correct *given* that truth.

## OTHER WAYS OF SEEING math.pi

There are several ways to see the exact approximation in use:

```
>>> import math
>>> math.pi.as_integer_ratio()
(884279719003555, 281474976710656)
```

`math.pi`

is exactly equal to the mathematical ("infinite precision") value of that ratio.

Or as an exact float in hex notation:

```
>>> math.pi.hex()
'0x1.921fb54442d18p+1'
```

Or in a way most easily understood by just about everyone:

```
>>> import decimal
>>> decimal.Decimal(math.pi)
Decimal('3.141592653589793115997963468544185161590576171875')
```

While it may not be immediately obvious, every finite binary float is exactly representable as a finite decimal float (the reverse is *not* true; e.g. the decimal `0.1`

is not exactly representable as a finite binary float), and the `Decimal(some_float)`

constructor produces the exact equivalent.

Here's the true value of `pi`

followed by the exact decimal value of `math.pi`

, and a caret on the third line points to the first digit where they differ:

```
true 3.14159265358979323846264338327950288419716939937510...
math.pi 3.141592653589793115997963468544185161590576171875
^
```

`math.pi`

is the same across "almost all" boxes now, because almost all boxes now use the same binary floating-point format (IEEE 754 double precision). You can use any of the ways above to confirm that on *your* box, or to find the precise approximation in use if your box is an exception.

From: stackoverflow.com/q/38295501

**★ Back to homepage or read more recommendations:**