# Numbers

## Integer types

Kotlin provides a set of built-in types that represent numbers.

For integer numbers, there are four types with different sizes and, hence, value ranges:

Type | Size (bits) | Min value | Max value |
---|---|---|---|

| 8 | -128 | 127 |

| 16 | -32768 | 32767 |

| 32 | -2,147,483,648 (-2 | 2,147,483,647 (2 |

| 64 | -9,223,372,036,854,775,808 (-2 | 9,223,372,036,854,775,807 (2 |

When you initialize a variable with no explicit type specification, the compiler automatically infers the type with the smallest range enough to represent the value. If it is not exceeding the range of `Int`

, the type is `Int`

. If it exceeds, the type is `Long`

. To specify the `Long`

value explicitly, append the suffix `L`

to the value. Explicit type specification triggers the compiler to check the value not to exceed the range of the specified type.

## Floating-point types

For real numbers, Kotlin provides floating-point types `Float`

and `Double`

that adhere to the IEEE 754 standard. `Float`

reflects the IEEE 754 *single precision*, while `Double`

reflects *double precision*.

These types differ in their size and provide storage for floating-point numbers with different precision:

Type | Size (bits) | Significant bits | Exponent bits | Decimal digits |
---|---|---|---|---|

| 32 | 24 | 8 | 6-7 |

| 64 | 53 | 11 | 15-16 |

You can initialize `Double`

and `Float`

variables with numbers having a fractional part. It's separated from the integer part by a period (`.`

) For variables initialized with fractional numbers, the compiler infers the `Double`

type:

To explicitly specify the `Float`

type for a value, add the suffix `f`

or `F`

. If such a value contains more than 6-7 decimal digits, it will be rounded:

Unlike some other languages, there are no implicit widening conversions for numbers in Kotlin. For example, a function with a `Double`

parameter can be called only on `Double`

values, but not `Float`

, `Int`

, or other numeric values:

To convert numeric values to different types, use explicit conversions.

## Literal constants for numbers

There are the following kinds of literal constants for integral values:

Decimals:

`123`

Longs are tagged by a capital

`L`

:`123L`

Hexadecimals:

`0x0F`

Binaries:

`0b00001011`

Kotlin also supports a conventional notation for floating-point numbers:

Doubles by default:

`123.5`

,`123.5e10`

Floats are tagged by

`f`

or`F`

:`123.5f`

You can use underscores to make number constants more readable:

## Numbers representation on the JVM

On the JVM platform, numbers are stored as primitive types: `int`

, `double`

, and so on. Exceptions are cases when you create a nullable number reference such as `Int?`

or use generics. In these cases numbers are boxed in Java classes `Integer`

, `Double`

, and so on.

Nullable references to the same number can refer to different objects:

All nullable references to `a`

are actually the same object because of the memory optimization that JVM applies to `Integer`

s between `-128`

and `127`

. It doesn't apply to the `b`

references, so they are different objects.

On the other hand, they are still equal:

## Explicit number conversions

Due to different representations, smaller types *are not subtypes* of bigger ones. If they were, we would have troubles of the following sort:

So equality would have been lost silently, not to mention identity.

As a consequence, smaller types *are NOT implicitly converted* to bigger types. This means that assigning a value of type `Byte`

to an `Int`

variable requires an explicit conversion:

All number types support conversions to other types:

`toByte(): Byte`

`toShort(): Short`

`toInt(): Int`

`toLong(): Long`

`toFloat(): Float`

`toDouble(): Double`

In many cases, there is no need for explicit conversions because the type is inferred from the context, and arithmetical operations are overloaded for appropriate conversions, for example:

## Operations on numbers

Kotlin supports the standard set of arithmetical operations over numbers: `+`

, `-`

, `*`

, `/`

, `%`

. They are declared as members of appropriate classes:

You can also override these operators for custom classes. See Operator overloading for details.

### Division of integers

Division between integers numbers always returns an integer number. Any fractional part is discarded.

This is true for a division between any two integer types:

To return a floating-point type, explicitly convert one of the arguments to a floating-point type:

### Bitwise operations

Kotlin provides a set of *bitwise operations* on integer numbers. They operate on the binary level directly with bits of the numbers' representation. Bitwise operations are represented by functions that can be called in infix form. They can be applied only to `Int`

and `Long`

:

Here is the complete list of bitwise operations:

`shl(bits)`

– signed shift left`shr(bits)`

– signed shift right`ushr(bits)`

– unsigned shift right`and(bits)`

– bitwise**AND**`or(bits)`

– bitwise**OR**`xor(bits)`

– bitwise**XOR**`inv()`

– bitwise inversion

### Floating-point numbers comparison

The operations on floating-point numbers discussed in this section are:

Equality checks:

`a == b`

and`a != b`

Comparison operators:

`a < b`

,`a > b`

,`a <= b`

,`a >= b`

Range instantiation and range checks:

`a..b`

,`x in a..b`

,`x !in a..b`

When the operands `a`

and `b`

are statically known to be `Float`

or `Double`

or their nullable counterparts (the type is declared or inferred or is a result of a smart cast), the operations on the numbers and the range that they form follow the IEEE 754 Standard for Floating-Point Arithmetic.

However, to support generic use cases and provide total ordering, the behavior is different for operands that are **not** statically typed as floating-point numbers. For example, `Any`

, `Comparable<...>`

, or `Collection<T>`

types. In this case, the operations use the `equals`

and `compareTo`

implementations for `Float`

and `Double`

. As a result:

`NaN`

is considered equal to itself`NaN`

is considered greater than any other element including`POSITIVE_INFINITY`

`-0.0`

is considered less than`0.0`

Here is an example that shows the difference in behavior between operands statically typed as floating-point numbers (`Double.NaN`

) and operands **not** statically typed as floating-point numbers (`listOf(T)`

).