# Integers and Floating-Point Numbers

In any programming language, there are two basic building blocks of arithmetic and computation. They are integers and floating-point values. Built-in representation of the values of integers and floating-point are called numeric primitives. On the other hand, their representation as immediate values in code are called numeric literals.

Following are the example of integer and floating-point literals −

• 100 is an integer literal

• 100.50 is a floating-point literal

• Their built-in memory representations as objects is numeric primitives.

## Integers

Integer is one of the primitive numeric types in Julia. It is represented as follows −

julia> 100
100

julia> 123456789
123456789


We can check the default type of an integer literal, which depends on whether our system is 32-bit or 64-bit architecture.

julia> Sys.WORD_SIZE
64

julia> typeof(100)
Int64


### Integer types

The table given below shows the integer types in Julia −

Type Signed? Number of bits Smallest value Largest value
Int8 8 -2^7 2^7 – 1
UInt8 8 0 2^8 – 1
Int16 16 -2^15 2^15 – 1
UInt16 16 0 2^16 – 1
Int32 32 -2^31 2^31 – 1
UInt32 32 0 2^32 – 1
Int64 64 -2^63 2^63 – 1
UInt64 64 0 2^64 – 1
Int128 128 -2^127 2^127 – 1
UInt128 128 0 2^128 – 1
Bool N/A 8 false (0) true (1)

### Overflow behavior

In Julia, if the maximum representable value of a given type exceeds, then it results in a wraparound behavior. For example −

julia> A = typemax(Int64)
9223372036854775807

julia> A + 1
-9223372036854775808

julia> A + 1 == typemin(Int64)
true


It is recommended to explicitly check for wraparound produced by overflow especially where overflow is possible. Otherwise use BigInt type in Arbitrary Precision Arithmetic.

Below is an example of overflow behavior and how we can resolve it −

julia> 10^19
-8446744073709551616

julia> big(10)^19
10000000000000000000


### Division errors

Integer division throws a DivideError in the following two exceptional cases −

• Dividing by zero

• Dividing the lowest negative number

The rem (remainder) and mod (modulus) functions will throw a DivideError whenever their second argument is zero. The example are given below −

julia> mod(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
[1] div at .\int.jl:260 [inlined]
[2] div at .\div.jl:217 [inlined]
[3] div at .\div.jl:262 [inlined]
[4] fld at .\div.jl:228 [inlined]
[5] mod(::Int64, ::Int64) at .\int.jl:252
[6] top-level scope at REPL[52]:1

julia> rem(1, 0)
ERROR: DivideError: integer division error
Stacktrace:
[1] rem(::Int64, ::Int64) at .\int.jl:261
[2] top-level scope at REPL[54]:1


## Floating-point numbers

Another primitive numeric types in Julia is floating-point numbers. It is represented (using E-notation when needed) as follows −

julia> 1.0
1.0

julia> 0.5
0.5

julia> -1.256
-1.256

julia> 2e11
2.0e11

julia> 3.6e-5
3.6e-5


All the above results are Float64. If we would like to enter Float32 literal, they can be written by writing f in the place of e as follows −

julia> 0.5f-5
5.0f-6

julia> typeof(ans)
Float32

julia> 1.5f0
1.5f0

julia> typeof(ans)
Float32


### Floating-point types

The table given below shows the floating-point types in Julia −

Type Precision Number of bits
Float16 half 16
Float32 single 32
Float64 double 64

### Floating-point zeros

There are two kind of floating-point zeros, one is positive zero and other is negative zero. They are same but their binary representation is different. It can be seen in the example below −

julia> 0.0 == -0.0
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"


## Special floating-point values

The table below represents three specified standard floating-point values. These floating-point values do not correspond to any point on the real number line.

Float16 Float32 Float64 Name Description
Inf16 Inf32 Inf positive infinity It is the value greater than all finite floating-point values
-Inf16 -Inf32 -Inf negative infinity It is the value less than all finite floating-point values
NaN16 NaN32 NaN not a number It is a value not == to any floating-point value (including itself)

We can also apply typemin and typemax functions as follows −

julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)

julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)

julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)


### Machine epsilon

Machine epsilon is the distance between two adjacent representable floating-point numbers. It is important to know machine epsilon because most of the real numbers cannot be represented exactly with floating-point numbers.

In Julia, we have eps() function that gives us the distance between 1.0 and the next larger representable floating-point value. The example is given below −

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16


### Rounding modes

As we know that the number should be rounded to an appropriate representable value if it does not have an exact floating-point representation. Julia uses the default mode called RoundNearest. It rounds to the nearest integer, with ties being rounded to the nearest even integer. For example,

julia> BigFloat("1.510564889",2,RoundNearest)
1.5