”;
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 −
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
”;