# On Numeric Types¶

## Interpreting JSON Numbers¶

JSON has a single numeric type: number. JSON numbers are in the decimal system, they can be positive and negative, they can have a fractional part, and they can have an exponent. Numbers are unlimited in size. They are a formalization of scientific notation.

A JSON number can be one of three things:

- An integer
- An arbitary-precision approximation of a real number
- An exact decimal fraction

The first two cases represent general purpose numbers, the third is a specialized numeric type, useful for accounting and scientific software – software that requires exact numbers and is tied to the decimal system.

Note

The latest version of the JSON spec, RFC 7159
does not require implementations to support arbitrary-precision decimals,
allowing them to sacrifice exactness and precision as they see fit. In fact,
according that spec, the only *truly* interoperable numbers are integers
ranging from -(2^53)+1 to (2^53)-1. This makes the author a very sad panda.

Teleport’s design is guided by JSON in its full, correct form, despite
the fact that some JSON implementations could not support it. This is done
partly because it is *The Right Thing* to do, and partly because
implementing JSON correctly is not that difficult. For example, extra work
must be performed to map JSON numbers to floats, whereas reading them
correctly as decimals is trivial.

## Floats vs. Decimals¶

Floats are fixed-precision approximations of a real numbers, stored in a non-trivial binary format allowing for very fast and reasonably correct hardware calculations. Floats have been designed so well that for most inexact arithmetic, a programmer will never run into their limitations. It is easy to forget that floats are a carefully crafted standard, not a fundamental number representation.

By default, the `json`

module from the Python standard library maps
non-integer JSON numbers to floats. This is a practical design decision made by
most JSON software and Teleport supports it completely. Nevertheless, Teleport
does not define a Float type, opting instead for Decimal. Why is that?

There are two reasons: one philosophical and the other practical. The
philosophical reason is that JSON numbers simply *are* decimals, for better or
for worse. The practical reason is that mapping floats to decimals is not
trivial.

Consider the float value represented by `1.1`

in Python. Because floats are
not stored in base 10, the actual value in memory looks more like this:

```
>>> (1.1).as_integer_ratio()
(2476979795053773, 2251799813685248)
```

If you perform long division on these numbers, you will get a repeating decimal. Needless to say, JSON numbers are not capable of representing this number exactly, the best we can do is represent it with slightly more precision than the underlying float, so it could be unambiguously parsed back into its original binary form.

If you need exact float representations, then this hex string is by far the simplest, most robust option:

```
>>> (1.1).hex()
'0x1.199999999999ap+0'
```

However, floats were designed for *inexact* arithmetic, for which purpose
the Decimal type with its arbitrary precision is perfectly adequate. An exact
float representation is conceivably useful, but only for low-level hacks, which
are outside of the scope of this project.

## Accounting Software¶

Floats are not acceptable for representing currency values in accounting software. It is possible to implement correct accounting algorithms using floats, but if you wish to do it, be prepared to write mathematical proofs.

Currency values are fixed-precision decimals, so they can be represented
trivially and safely using Teleport’s Decimal type. It should be noted that by
making this choice, you are limiting yourself to those implementations of JSON
which support arbitrary-precision decimals, like Python’s `json`

module.