# Math, Numbers & Tez

LIGO offers three built-in numerical types: `int`

, `nat`

and
`tez`

. Values of type `int`

are integers; values of type `nat`

are
natural numbers (integral numbers greater than or equal to zero);
values of type `tez`

are units of measure of Tezos tokens.

Integer literals are the same found in mainstream programming languages, for example,

`10`

,`-6`

and`0`

, but there is only one canonical zero:`0`

(so, for instance,`-0`

and`00`

are invalid).Natural numbers are written as digits follwed by the suffix

`n`

, like so:`12n`

,`0n`

, and the same restriction on zero as integers applies:`0n`

is the only way to specify the natural zero.Tezos tokens can be specified using literals of three kinds:

- units of millionth of
`tez`

, using the suffix`mutez`

after a natural literal, like`10000mutez`

or`0mutez`

; - units of
`tez`

, using the suffix`tz`

or`tez`

, like`3tz`

or`3tez`

; - decimal amounts of
`tz`

or`tez`

, like`12.3tz`

or`12.4tez`

.

- units of millionth of

Note that large integral values can be expressed using underscores to
separate groups of digits, like `1_000mutez`

or `0.000_004tez`

.

## #

AdditionAddition in LIGO is accomplished by means of the `+`

infix
operator. Some type constraints apply, for example you cannot add a
value of type `tez`

to a value of type `nat`

.

In the following example you can find a series of arithmetic
operations, including various numerical types. However, some bits
remain in comments as they would otherwise not compile, for example,
adding a value of type `int`

to a value of type `tez`

is invalid. Note
that adding an integer to a natural number produces an integer.

Pro tip: you can use underscores for readability when defining large numbers:

const sum : tez = 100_000mutez

## #

SubtractionSubtraction looks as follows.

⚠️ Even when subtracting two

`nats`

, the result is an`int`

## #

MultiplicationYou can multiply values of the same type, such as:

## #

Euclidean DivisionIn LIGO you can divide `int`

, `nat`

, and `tez`

. Here is how:

⚠️ Division of two

`tez`

values results into a`nat`

LIGO also allows you to compute the remainder of the Euclidean division. In LIGO, it is a natural number.

For cases when you need both the quotient and the remainder, LIGO provides the
`ediv`

operation. `ediv x y`

returns `Some (quotient, remainder)`

, unless `y`

is zero, in which case it returns `None`

`int`

to `nat`

and back#

From You can *cast* an `int`

to a `nat`

and vice versa. Here is how:

`nat`

#

Checking a You can check if a value is a `nat`

by using a predefined cast
function which accepts an `int`

and returns an optional `nat`

: if the
result is not `None`

, then the provided integer was indeed a natural
number, and not otherwise.