## Numerical Type Hierarchy

One characteristic feature of Julia is the existence of a **type hierarchy**. Instead of discussing the full theory behind this (which you can check here in the Julia official documenation) let’s go over an example, the Hierarchy of Numerical Types:

```
Number
│
├── Complex
│
├── Real
│
├── AbstractFloat
│ │
│ ├── BigFloat
│ │
│ ├── Float16
│ │
│ ├── Float32
│ │
│ └── Float64
│
├── AbstractIrrational
│ │
│ └── Irrational
│
├── Integer
│ │
│ ├── Bool
│ │
│ ├── Signed
│ │ │
│ │ ├── BigInt
│ │ │
│ │ ├── Int128
│ │ │
│ │ ├── Int16
│ │ │
│ │ ├── Int32
│ │ │
│ │ ├── Int64
│ │ │
│ │ └── Int8
│ │
│ └── Unsigned
│ │
│ ├── UInt128
│ │
│ ├── UInt16
│ │
│ ├── UInt32
│ │
│ ├── UInt64
│ │
│ └── UInt8
│
└── Rational
```

## Conversion of Integer to Float

Conversion of integer variables to floating-point numbers is straightforward. We can convert an integers to floats with different kinds of precisions, using functions like `Float64`

, `Float32`

and `Float16`

which correspond to double, single, and half precision numbers.

```
Float64(2) # 2.0 (double-precision)
Float32(2) # 2.0f0 (single-precision)
Float16(2) # Float16(2.0) (half-precision)
```

## Conversion of Float to Integer

Some care must be taken when converting float to integer variables in Julia, as the conversion is not always valid (as the float must coincide with an integer exaclty). It is preferable to use functions like `floor`

,`ceil`

and `round`

, as opposed to the direct use of functions like `Int64`

,`Int32`

.

For example:

```
Int64(2.0) # 2
Int64(2.4) # Error!
floor(Int64,2.4) # 2
ceil(Int64,2.4) # 3
round(Int64,2.4) # 2
```

## Integer Division

By default, dividing two integers could return a float. If we are interested in the integer (or Euclidean) division, the `div`

function (or `÷`

, whose Unicode symbol can be obtained with `\div`

) returns the quotient, while for the remainder we have the `rem`

function, or `%`

.

For example:

`a = 1/2 # 0.5 (Float64)`

`div(x,y)`

computes `x/y`

, truncated to an integer.

```
div(10,3) # 3
÷(10,3) # 3
```

`rem(x,y)`

computes the remainder of `x/y`

```
rem(10,3) # 1
10%3 # 1
```

## Gotcha! Integer vs Float

In Julia, if you input a number like

`a = 2`

you’ll be getting an `Int64`

by default. This can lead to errors if we are not careful. For example, consider the following operation

`a = 1/2^64`

`Inf`

Now, that’s unexpected. Two things just happened. In the first place, an `Int64`

will overflow past `2^{64}`

, and the default overflow value is 0.

`2^64 # returns 0`

In the second place, in Julia 1 divided by 0 returns `Inf`

. We just computed 1/0.

We have some alternatives:

```
1/2.0^64 # 5.421010862427522e-20
(1/2)^64 # 5.421010862427522e-20
1.0/2^64 # Inf
```