# Floating point in Julia¶

In Julia, `1`

and `1.0`

are different values, because they have different types:

```
@show typeof(1);
@show typeof(1.0);
```

```
typeof(1) = Int64
typeof(1.0) = Float64
```

The standard choice for floating-point values is `Float64`

, which is double precision using 64 binary bits.

```
bitstring(1.0)
```

```
"0011111111110000000000000000000000000000000000000000000000000000"
```

The first bit determines the sign of the number:

```
[bitstring(1.0); bitstring(-1.0)]
```

```
2-element Array{String,1}:
"0011111111110000000000000000000000000000000000000000000000000000"
"1011111111110000000000000000000000000000000000000000000000000000"
```

The next 11 bits determine the exponent (scaling) of the number, and so on.

```
[bitstring(1.0); bitstring(2.0)]
```

```
2-element Array{String,1}:
"0011111111110000000000000000000000000000000000000000000000000000"
"0100000000000000000000000000000000000000000000000000000000000000"
```

Floating-point values have three parts: the sign bit, the exponent, and the mantissa or **significand**. These are all directly accessible.

```
x = 1.0; @show x,sign(x),exponent(x),significand(x);
```

```
(x, sign(x), exponent(x), significand(x)) = (1.0, 1.0, 0, 1.0)
```

```
x = 0.125; @show x,sign(x),exponent(x),significand(x);
```

```
(x, sign(x), exponent(x), significand(x)) = (0.125, 1.0, -3, 1.0)
```

The spacing between floating-point values in \([2^e,2^{e+1})\) is \(2^e \epsilon_\text{mach}\), where \(\epsilon_\text{mach}\) is known as **machine epsilon**. You can get it from the `eps`

function in Julia.

```
eps()
```

```
2.220446049250313e-16
```

Because double precision allocates 52 bits to the mantissa, the default value of machine epsilon is \(2^{-52}\).

```
log2(eps())
```

```
-52.0
```

The spacing between adjacent floating-point values is proportional to the magnitude of the value itself. This is how relative precision is kept roughly constant throughout the range of values. You can get the adjusted spacing by calling `eps`

with a value.

```
eps(2.0^20)
```

```
2.3283064365386963e-10
```

```
log2(ans)
```

```
-32.0
```

```
bitstring(47.0)
```

```
"0100000001000111100000000000000000000000000000000000000000000000"
```

```
bitstring(47.0+eps(47.0))
```

```
"0100000001000111100000000000000000000000000000000000000000000001"
```

A common mistake is to think that \(\epsilon_\text{mach}\) is the “smallest floating-point number.” In fact, the *scaling* of values is limited by the exponent, not the mantissa. The actual range of positive values in double precision is

```
@show [floatmin(),floatmax()];
```

```
[floatmin(), floatmax()] = [2.2250738585072014e-308, 1.7976931348623157e308]
```

For the most part you can mix integers and floating-point values and get what you expect.

```
1/7
```

```
0.14285714285714285
```

```
37.3 + 1
```

```
38.3
```

```
2^(-4)
```

```
0.0625
```

There are some exceptions. A floating-point value can’t be used as an index into an array, for example, even if it is numerically equal to an integer. In such cases you use `Int`

to convert it.

```
@show 5.0,Int(5.0);
```

```
(5.0, Int(5.0)) = (5.0, 5)
```

If you try to convert a noninteger floating-point value into an integer you get an `InexactValue`

error. This occurs whenever you try to force a type conversion that doesn’t make clear sense.