# Numbers

## Standard Numeric Types

A type tree for all subtypes of `Number` in `Base` is shown below. Abstract types have been marked, the rest are concrete types.

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

### Abstract number types

`Core.Number` — Type

    Number

Abstract supertype for all number types.

source
`Core.Real` — Type

    Real <: Number

Abstract supertype for all real numbers.

source
`Core.AbstractFloat` — Type

    AbstractFloat <: Real

Abstract supertype for all floating point numbers.

source
`Core.Integer` — Type

    Integer <: Real

Abstract supertype for all integers (e.g. `Signed`, `Unsigned`, and `Bool`).

See also `isinteger`, `trunc`, `div`.

Examples

    julia> 42 isa Integer
    true

    julia> 1.0 isa Integer
    false

    julia> isinteger(1.0)
    true

source
`Core.Signed` — Type

    Signed <: Integer

Abstract supertype for all signed integers.

source
`Core.Unsigned` — Type

    Unsigned <: Integer

Abstract supertype for all unsigned integers.

Built-in unsigned integers are printed in hexadecimal, with prefix `0x`, and can be entered in the same way.

Examples

    julia> typemax(UInt8)
    0xff

    julia> Int(0x00d)
    13

    julia> unsigned(true)
    0x0000000000000001

source
`Base.AbstractIrrational` — Type

    AbstractIrrational <: Real

Number type representing an exact irrational value, which is automatically rounded to the correct precision in arithmetic operations with other numeric quantities.

Subtypes `MyIrrational <: AbstractIrrational` should implement at least `==(::MyIrrational, ::MyIrrational)`, `hash(x::MyIrrational, h::UInt)`, and `convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}`.

If a subtype is used to represent values that may occasionally be rational (e.g. a square-root type that represents `√n` for integers `n` will give a rational result when `n` is a perfect square), then it should also implement `isinteger`, `iszero`, `isone`, and `==` with `Real` values (since all of these default to `false` for `AbstractIrrational` types), as well as defining `hash` to equal that of the corresponding `Rational`.

source

### Concrete number types

`Core.Float16` — Type

    Float16 <: AbstractFloat <: Real

16-bit floating point number type (IEEE 754 standard). Binary format is 1 sign, 5 exponent, 10 fraction bits.

source
`Core.Float32` — Type

    Float32 <: AbstractFloat <: Real

32-bit floating point number type (IEEE 754 standard). Binary format is 1 sign, 8 exponent, 23 fraction bits.

The exponent for scientific notation should be entered as lower-case `f`, thus `2f3 === 2.0f0 * 10^3 === Float32(2_000)`. For array literals and comprehensions, the element type can be specified before the square brackets: `Float32[1,4,9] == Float32[i^2 for i in 1:3]`.

See also `Inf32`, `NaN32`, `Float16`, `exponent`, `frexp`.

source
`Core.Float64` — Type

    Float64 <: AbstractFloat <: Real

64-bit floating point number type (IEEE 754 standard). Binary format is 1 sign, 11 exponent, 52 fraction bits. See `bitstring`, `signbit`, `exponent`, `frexp`, and `significand` to access various bits.

This is the default for floating point literals, `1.0 isa Float64`, and for many operations such as `1/2, 2pi, log(2), range(0,90,length=4)`. Unlike integers, this default does not change with `Sys.WORD_SIZE`.

The exponent for scientific notation can be entered as `e` or `E`, thus `2e3 === 2.0E3 === 2.0 * 10^3`. Doing so is strongly preferred over `10^n` because integers overflow, thus `2.0 * 10^19 < 0` but `2e19 > 0`.

See also `Inf`, `NaN`, `floatmax`, `Float32`, `Complex`.

source
`Base.MPFR.BigFloat` — Type

    BigFloat <: AbstractFloat

Arbitrary precision floating point number type.

source
`Core.Bool` — Type

    Bool <: Integer

Boolean type, containing the values `true` and `false`.

`Bool` is a kind of number: `false` is numerically equal to `0` and `true` is numerically equal to `1`. Moreover, `false` acts as a multiplicative "strong zero" against `NaN` and `Inf`:

    julia> [true, false] == [1, 0]
    true

    julia> 42.0 + true
    43.0

    julia> 0 .* (NaN, Inf, -Inf)
    (NaN, NaN, NaN)

    julia> false .* (NaN, Inf, -Inf)
    (0.0, 0.0, -0.0)

Branches via `if` and other conditionals only accept `Bool`. There are no "truthy" values in Julia.

Comparisons typically return `Bool`, and broadcasted comparisons may return `BitArray` instead of an `Array{Bool}`.

    julia> [1 2 3 4 5] .< pi
    1×5 BitMatrix:
     1  1  1  0  0

    julia> map(>(pi), [1 2 3 4 5])
    1×5 Matrix{Bool}:
     0  0  0  1  1

See also `trues`, `falses`, `ifelse`.

source
`Core.Int8` — Type

    Int8 <: Signed <: Integer

8-bit signed integer type.

Represents numbers `n ∈ -128:127`. Note that such integers overflow without warning, thus `typemax(Int8) + Int8(1) < 0`.

See also `Int`, `widen`, `BigInt`.

source
`Core.UInt8` — Type

    UInt8 <: Unsigned <: Integer

8-bit unsigned integer type.

Printed in hexadecimal, thus 0x07 == 7.

source
`Core.Int16` — Type

    Int16 <: Signed <: Integer

16-bit signed integer type.

Represents numbers `n ∈ -32768:32767`. Note that such integers overflow without warning, thus `typemax(Int16) + Int16(1) < 0`.

See also `Int`, `widen`, `BigInt`.

source
`Core.UInt16` — Type

    UInt16 <: Unsigned <: Integer

16-bit unsigned integer type.

Printed in hexadecimal, thus 0x000f == 15.

source
`Core.Int32` — Type

    Int32 <: Signed <: Integer

32-bit signed integer type.

Note that such integers overflow without warning, thus `typemax(Int32) + Int32(1) < 0`.

See also `Int`, `widen`, `BigInt`.

source
`Core.UInt32` — Type

    UInt32 <: Unsigned <: Integer

32-bit unsigned integer type.

Printed in hexadecimal, thus 0x0000001f == 31.

source
`Core.Int64` — Type

    Int64 <: Signed <: Integer

64-bit signed integer type.

Note that such integers overflow without warning, thus `typemax(Int64) + Int64(1) < 0`.

See also `Int`, `widen`, `BigInt`.

source
`Core.UInt64` — Type

    UInt64 <: Unsigned <: Integer

64-bit unsigned integer type.

Printed in hexadecimal, thus 0x000000000000003f == 63.

source
`Core.Int128` — Type

    Int128 <: Signed <: Integer

128-bit signed integer type.

Note that such integers overflow without warning, thus `typemax(Int128) + Int128(1) < 0`.

See also `Int`, `widen`, `BigInt`.

source
`Core.UInt128` — Type

    UInt128 <: Unsigned <: Integer

128-bit unsigned integer type.

Printed in hexadecimal, thus 0x0000000000000000000000000000007f == 127.

source
`Core.Int` — Type

    Int

Sys.WORD_SIZE-bit signed integer type, `Int <: Signed <: Integer <: Real`.

This is the default type of most integer literals and is an alias for either `Int32` or `Int64`, depending on `Sys.WORD_SIZE`. It is the type returned by functions such as `length`, and the standard type for indexing arrays.

Note that integers overflow without warning, thus `typemax(Int) + 1 < 0` and `10^19 < 0`. Overflow can be avoided by using `BigInt`. Very large integer literals will use a wider type, for instance `10_000_000_000_000_000_000 isa Int128`.

Integer division is `div` alias `÷`, whereas `/` acting on integers returns `Float64`.

See also `Int64`, `widen`, `typemax`, `bitstring`.

source
`Core.UInt` — Type

    UInt

Sys.WORD_SIZE-bit unsigned integer type, `UInt <: Unsigned <: Integer`.

Like `Int`, the alias `UInt` may point to either `UInt32` or `UInt64`, according to the value of `Sys.WORD_SIZE` on a given computer.

Printed and parsed in hexadecimal: `UInt(15) === 0x000000000000000f`.

source
`Base.GMP.BigInt` — Type

    BigInt <: Signed

Arbitrary precision integer type.

source
`Base.Complex` — Type

    Complex{T<:Real} <: Number

Complex number type with real and imaginary part of type `T`.

`ComplexF16`, `ComplexF32` and `ComplexF64` are aliases for `Complex{Float16}`, `Complex{Float32}` and `Complex{Float64}` respectively.

See also: `Real`, `complex`, `real`.

source
`Base.Rational` — Type

    Rational{T<:Integer} <: Real

Rational number type, with numerator and denominator of type `T`. Rationals are checked for overflow.

source
`Base.Irrational` — Type

    Irrational{sym} <: AbstractIrrational

Number type representing an exact irrational value denoted by the symbol `sym`, such as `π`, `ℯ` and `γ`.

See also `AbstractIrrational`.

source

## Data Formats

`Base.digits` — Function

    digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

Return an array with element type `T` (default `Int`) of the digits of `n` in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indices, such that `n == sum(digits[k]*base^(k-1) for k in 1:length(digits))`.

See also `ndigits`, `digits!`, and for base 2 also `bitstring`, `count_ones`.

Examples

    julia> digits(10)
    2-element Vector{Int64}:
     0
     1

    julia> digits(10, base = 2)
    4-element Vector{Int64}:
     0
     1
     0
     1

    julia> digits(-256, base = 10, pad = 5)
    5-element Vector{Int64}:
     -6
     -5
     -2
      0
      0

    julia> n = rand(-999:999);

    julia> n == evalpoly(13, digits(n, base = 13))
    true

source
`Base.digits!` — Function

    digits!(array, n::Integer; base::Integer = 10)

Fills an array of the digits of `n` in the given base. More significant digits are at higher indices. If the array length is insufficient, the least significant digits are filled up to the array length. If the array length is excessive, the excess portion is filled with zeros.

Examples

    julia> digits!([2, 2, 2, 2], 10, base = 2)
    4-element Vector{Int64}:
     0
     1
     0
     1

    julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
    6-element Vector{Int64}:
     0
     1
     0
     1
     0
     0

source
`Base.bitstring` — Function

    bitstring(n)

A string giving the literal bit representation of a primitive type (in bigendian order, i.e. most-significant bit first).

See also `count_ones`, `count_zeros`, `digits`.

Examples

    julia> bitstring(Int32(4))
    "00000000000000000000000000000100"

    julia> bitstring(2.2)
    "0100000000000001100110011001100110011001100110011001100110011010"

source
`Base.parse` — Function

    parse(::Type{SimpleColor}, rgb::String)

An analogue of `tryparse(SimpleColor, rgb::String)` (which see), that raises an error instead of returning `nothing`.

source

    parse(::Type{Platform}, triplet::AbstractString)

Parses a string platform triplet back into a `Platform` object.

source

    parse(type, str; base)

Parse a string as a number. For `Integer` types, a base can be specified (the default is 10). For floating-point types, the string is parsed as a decimal floating-point number. `Complex` types are parsed from decimal strings of the form `"R±Iim"` as a `Complex(R,I)` of the requested type; `"i"` or `"j"` can also be used instead of `"im"`, and `"R"` or `"Iim"` are also permitted. If the string does not contain a valid number, an error is raised.

Julia 1.1

`parse(Bool, str)` requires at least Julia 1.1.

Examples

    julia> parse(Int, "1234")
    1234

    julia> parse(Int, "1234", base = 5)
    194

    julia> parse(Int, "afc", base = 16)
    2812

    julia> parse(Float64, "1.2e-3")
    0.0012

    julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
    0.32 + 4.5im

source
`Base.tryparse` — Function

    tryparse(::Type{SimpleColor}, rgb::String)

Attempt to parse `rgb` as a `SimpleColor`. If `rgb` starts with `#` and has a length of 7, it is converted into a `RGBTuple`-backed `SimpleColor`. If `rgb` starts with `a`-`z`, `rgb` is interpreted as a color name and converted to a `Symbol`-backed `SimpleColor`.

Otherwise, `nothing` is returned.

Examples

    julia> tryparse(SimpleColor, "blue")
    SimpleColor(blue)

    julia> tryparse(SimpleColor, "#9558b2")
    SimpleColor(#9558b2)

    julia> tryparse(SimpleColor, "#nocolor")

source

    tryparse(type, str; base)

Like `parse`, but returns either a value of the requested type, or `nothing` if the string does not contain a valid number.

source
`Base.big` — Function

    big(x)

Convert a number to a maximum precision representation (typically `BigInt` or `BigFloat`). See `BigFloat` for information about some pitfalls with floating-point numbers.

source
`Base.signed` — Function

    signed(x)

Convert a number to a signed integer. If the argument is unsigned, it is reinterpreted as signed without checking for overflow.

See also: `unsigned`, `sign`, `signbit`.

source

    signed(T::Integer)

Convert an integer bitstype to the signed type of the same size.

Examples

    julia> signed(UInt16)
    Int16
    julia> signed(UInt64)
    Int64

source
`Base.unsigned` — Function

    unsigned(T::Integer)

Convert an integer bitstype to the unsigned type of the same size.

Examples

    julia> unsigned(Int16)
    UInt16
    julia> unsigned(UInt64)
    UInt64

source
`Base.float` — Method

    float(x)

Convert a number or array to a floating point data type.

See also: `complex`, `oftype`, `convert`.

Examples

    julia> float(1:1000)
    1.0:1.0:1000.0

    julia> float(typemax(Int32))
    2.147483647e9

source
`Base.Math.significand` — Function

    significand(x)

Extract the significand (a.k.a. mantissa) of a floating-point number. If `x` is a non-zero finite number, then the result will be a number of the same type and sign as `x`, and whose absolute value is on the interval $[1,2)$. Otherwise `x` is returned.

See also `frexp`, `exponent`.

Examples

    julia> significand(15.2)
    1.9

    julia> significand(-15.2)
    -1.9

    julia> significand(-15.2) * 2^3
    -15.2

    julia> significand(-Inf), significand(Inf), significand(NaN)
    (-Inf, Inf, NaN)

source
`Base.Math.exponent` — Function

    exponent(x::Real) -> Int

Return the largest integer `y` such that `2^y ≤ abs(x)`. For a normalized floating-point number `x`, this corresponds to the exponent of `x`.

Throws a `DomainError` when `x` is zero, infinite, or `NaN`. For any other non-subnormal floating-point number `x`, this corresponds to the exponent bits of `x`.

See also `signbit`, `significand`, `frexp`, `issubnormal`, `log2`, `ldexp`.

Examples

    julia> exponent(8)
    3

    julia> exponent(6.5)
    2

    julia> exponent(-1//4)
    -2

    julia> exponent(3.142e-4)
    -12

    julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
    (-126, -149)

    julia> exponent(0.0)
    ERROR: DomainError with 0.0:
    Cannot be ±0.0.
    [...]

source
`Base.complex` — Method

    complex(r, [i])

Convert real numbers or arrays to complex. `i` defaults to zero.

Examples

    julia> complex(7)
    7 + 0im

    julia> complex([1, 2, 3])
    3-element Vector{Complex{Int64}}:
     1 + 0im
     2 + 0im
     3 + 0im

source
`Base.bswap` — Function

    bswap(n)

Reverse the byte order of `n`.

(See also `ntoh` and `hton` to convert between the current native byte order and big-endian order.)

Examples

    julia> a = bswap(0x10203040)
    0x40302010

    julia> bswap(a)
    0x10203040

    julia> string(1, base = 2)
    "1"

    julia> string(bswap(1), base = 2)
    "100000000000000000000000000000000000000000000000000000000"

source
`Base.hex2bytes` — Function

    hex2bytes(itr)

Given an iterable `itr` of ASCII codes for a sequence of hexadecimal digits, returns a `Vector{UInt8}` of bytes corresponding to the binary representation: each successive pair of hexadecimal digits in `itr` gives the value of one byte in the return vector.

The length of `itr` must be even, and the returned array has half of the length of `itr`. See also `hex2bytes!` for an in-place version, and `bytes2hex` for the inverse.

Julia 1.7

Calling `hex2bytes` with iterators producing `UInt8` values requires Julia 1.7 or later. In earlier versions, you can `collect` the iterator before calling `hex2bytes`.

Examples

    julia> s = string(12345, base = 16)
    "3039"

    julia> hex2bytes(s)
    2-element Vector{UInt8}:
     0x30
     0x39

    julia> a = b"01abEF"
    6-element Base.CodeUnits{UInt8, String}:
     0x30
     0x31
     0x61
     0x62
     0x45
     0x46

    julia> hex2bytes(a)
    3-element Vector{UInt8}:
     0x01
     0xab
     0xef

source
`Base.hex2bytes!` — Function

    hex2bytes!(dest::AbstractVector{UInt8}, itr)

Convert an iterable `itr` of bytes representing a hexadecimal string to its binary representation, similar to `hex2bytes` except that the output is written in-place to `dest`. The length of `dest` must be half the length of `itr`.

Julia 1.7

Calling hex2bytes! with iterators producing UInt8 requires version 1.7. In earlier versions, you can collect the iterable before calling instead.

source
`Base.bytes2hex` — Function

    bytes2hex(itr) -> String
    bytes2hex(io::IO, itr)

Convert an iterator `itr` of bytes to its hexadecimal string representation, either returning a `String` via `bytes2hex(itr)` or writing the string to an `io` stream via `bytes2hex(io, itr)`. The hexadecimal characters are all lowercase.

Julia 1.7

Calling `bytes2hex` with arbitrary iterators producing `UInt8` values requires Julia 1.7 or later. In earlier versions, you can `collect` the iterator before calling `bytes2hex`.

Examples

    julia> a = string(12345, base = 16)
    "3039"

    julia> b = hex2bytes(a)
    2-element Vector{UInt8}:
     0x30
     0x39

    julia> bytes2hex(b)
    "3039"

source

## General Number Functions and Constants

`Base.one` — Function

    one(x)
    one(T::Type)

Return a multiplicative identity for `x`: a value such that `one(x)*x == x*one(x) == x`. If the multiplicative identity can be deduced from the type alone, then a type may be given as an argument to `one` (e.g. `one(Int)` will work because the multiplicative identity is the same for all instances of `Int`, but `one(Matrix{Int})` is not defined because matrices of different shapes have different multiplicative identities.)

If possible, `one(x)` returns a value of the same type as `x`, and `one(T)` returns a value of type `T`. However, this may not be the case for types representing dimensionful quantities (e.g. time in days), since the multiplicative identity must be dimensionless. In that case, `one(x)` should return an identity value of the same precision (and shape, for matrices) as `x`.

If you want a quantity that is of the same type as `x`, or of type `T`, even if `x` is dimensionful, use `oneunit` instead.

See also the `identity` function, and `I` in `LinearAlgebra` for the identity matrix.

Examples

    julia> one(3.7)
    1.0

    julia> one(Int)
    1

    julia> import Dates; one(Dates.Day(1))
    1

source
`Base.oneunit` — Function

    oneunit(x::T)
    oneunit(T::Type)

Return `T(one(x))`, where `T` is either the type of the argument, or the argument itself in cases where the `oneunit` can be deduced from the type alone. This differs from `one` for dimensionful quantities: `one` is dimensionless (a multiplicative identity) while `oneunit` is dimensionful (of the same type as `x`, or of type `T`).

Examples

    julia> oneunit(3.7)
    1.0

    julia> import Dates; oneunit(Dates.Day)
    1 day

source
`Base.zero` — Function

    zero(x)
    zero(::Type)

Get the additive identity element for `x`. If the additive identity can be deduced from the type alone, then a type may be given as an argument to `zero`.

For example, `zero(Int)` will work because the additive identity is the same for all instances of `Int`, but `zero(Vector{Int})` is not defined because vectors of different lengths have different additive identities.

See also `iszero`, `one`, `oneunit`, `oftype`.

Examples

    julia> zero(1)
    0

    julia> zero(big"2.0")
    0.0

    julia> zero(rand(2,2))
    2×2 Matrix{Float64}:
     0.0  0.0
     0.0  0.0

source
`Base.im` — Constant

    im

The imaginary unit.

See also: `imag`, `angle`, `complex`.

Examples

    julia> im * im
    -1 + 0im

    julia> (2.0 + 3im)^2
    -5.0 + 12.0im

source
`Base.MathConstants.pi` — Constant

    π
    pi

The constant pi.

Unicode `π` can be typed by writing `\pi` then pressing tab in the Julia REPL, and in many editors.

See also: `sinpi`, `sincospi`, `deg2rad`.

Examples

    julia> pi
    π = 3.1415926535897...

    julia> 1/2pi
    0.15915494309189535

source
`Base.MathConstants.ℯ` — Constant

    ℯ
    e

The constant ℯ.

Unicode `ℯ` can be typed by writing `\euler` and pressing tab in the Julia REPL, and in many editors.

See also: `exp`, `cis`, `cispi`.

Examples

    julia> ℯ
    ℯ = 2.7182818284590...

    julia> log(ℯ)
    1

    julia> ℯ^(im)π ≈ -1
    true

source
`Base.MathConstants.catalan` — Constant

    catalan

Catalan's constant.

Examples

    julia> Base.MathConstants.catalan
    catalan = 0.9159655941772...

    julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01
    0.9159466120554123

source
`Base.MathConstants.eulergamma` — Constant

    γ
    eulergamma

Euler's constant.

Examples

    julia> Base.MathConstants.eulergamma
    γ = 0.5772156649015...

    julia> dx = 10^-6;

    julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
    0.5772078382499133

source
`Base.MathConstants.golden` — Constant

    φ
    golden

The golden ratio.

Examples

    julia> Base.MathConstants.golden
    φ = 1.6180339887498...

    julia> (2ans - 1)^2 ≈ 5
    true

source
`Base.Inf` — Constant

    Inf, Inf64

Positive infinity of type `Float64`.

See also: `isfinite`, `typemax`, `NaN`, `Inf32`.

Examples

    julia> π/0
    Inf

    julia> +1.0 / -0.0
    -Inf

    julia> ℯ^-Inf
    0.0

source
`Base.Inf64` — Constant

    Inf, Inf64

Positive infinity of type `Float64`.

See also: `isfinite`, `typemax`, `NaN`, `Inf32`.

Examples

    julia> π/0
    Inf

    julia> +1.0 / -0.0
    -Inf

    julia> ℯ^-Inf
    0.0

source
`Base.Inf32` — Constant

    Inf32

Positive infinity of type `Float32`.

source
`Base.Inf16` — Constant

    Inf16

Positive infinity of type `Float16`.

source
`Base.NaN` — Constant

    NaN, NaN64

A not-a-number value of type `Float64`.

See also: `isnan`, `missing`, `NaN32`, `Inf`.

Examples

    julia> 0/0
    NaN

    julia> Inf - Inf
    NaN

    julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
    (false, true, true)

Note

Always use `isnan` or `isequal` for checking for `NaN`. Using `x === NaN` may give unexpected results:

    julia> reinterpret(UInt32, NaN32)
    0x7fc00000

    julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
    NaN32

    julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
    (false, true, true)

source
`Base.NaN64` — Constant

    NaN, NaN64

A not-a-number value of type `Float64`.

See also: `isnan`, `missing`, `NaN32`, `Inf`.

Examples

    julia> 0/0
    NaN

    julia> Inf - Inf
    NaN

    julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
    (false, true, true)

Note

Always use `isnan` or `isequal` for checking for `NaN`. Using `x === NaN` may give unexpected results:

    julia> reinterpret(UInt32, NaN32)
    0x7fc00000

    julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
    NaN32

    julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
    (false, true, true)

source
`Base.NaN32` — Constant

    NaN32

A not-a-number value of type `Float32`.

See also: `NaN`.

source
`Base.NaN16` — Constant

    NaN16

A not-a-number value of type `Float16`.

See also: `NaN`.

source
`Base.issubnormal` — Function

    issubnormal(f) -> Bool

Test whether a floating point number is subnormal.

An IEEE floating point number is subnormal when its exponent bits are zero and its significand is not zero.

Examples

    julia> floatmin(Float32)
    1.1754944f-38

    julia> issubnormal(1.0f-37)
    false

    julia> issubnormal(1.0f-38)
    true

source
`Base.isfinite` — Function

    isfinite(f) -> Bool

Test whether a number is finite.

Examples

    julia> isfinite(5)
    true

    julia> isfinite(NaN32)
    false

source
`Base.isinf` — Function

    isinf(f) -> Bool

Test whether a number is infinite.

See also: `Inf`, `iszero`, `isfinite`, `isnan`.

source
`Base.isnan` — Function

    isnan(f) -> Bool

Test whether a number value is a NaN, an indeterminate value which is neither an infinity nor a finite number ("not a number").

See also: `iszero`, `isone`, `isinf`, `ismissing`.

source
`Base.iszero` — Function

    iszero(x)

Return `true` if `x == zero(x)`; if `x` is an array, this checks whether all of the elements of `x` are zero.

See also: `isone`, `isinteger`, `isfinite`, `isnan`.

Examples

    julia> iszero(0.0)
    true

    julia> iszero([1, 9, 0])
    false

    julia> iszero([false, 0, 0])
    true

source
`Base.isone` — Function

    isone(x)

Return `true` if `x == one(x)`; if `x` is an array, this checks whether `x` is an identity matrix.

Examples

    julia> isone(1.0)
    true

    julia> isone([1 0; 0 2])
    false

    julia> isone([1 0; 0 true])
    true

source
`Base.nextfloat` — Function

    nextfloat(x::AbstractFloat)

Return the smallest floating point number `y` of the same type as `x` such that `x < y`. If no such `y` exists (e.g. if `x` is `Inf` or `NaN`), then return `x`.

See also: `prevfloat`, `eps`, `issubnormal`.

source

    nextfloat(x::AbstractFloat, n::Integer)

The result of `n` iterative applications of `nextfloat` to `x` if `n >= 0`, or `-n` applications of `prevfloat` if `n < 0`.

source
`Base.prevfloat` — Function

    prevfloat(x::AbstractFloat)

Return the largest floating point number `y` of the same type as `x` such that `y < x`. If no such `y` exists (e.g. if `x` is `-Inf` or `NaN`), then return `x`.

source

    prevfloat(x::AbstractFloat, n::Integer)

The result of `n` iterative applications of `prevfloat` to `x` if `n >= 0`, or `-n` applications of `nextfloat` if `n < 0`.

source
`Base.isinteger` — Function

    isinteger(x) -> Bool

Test whether `x` is numerically equal to some integer.

Examples

    julia> isinteger(4.0)
    true

source
`Base.isreal` — Function

    isreal(x) -> Bool

Test whether `x` or all its elements are numerically equal to some real number including infinities and NaNs. `isreal(x)` is true if `isequal(x, real(x))` is true.

Examples

    julia> isreal(5.)
    true

    julia> isreal(1 - 3im)
    false

    julia> isreal(Inf + 0im)
    true

    julia> isreal([4.; complex(0,1)])
    false

source
`Core.Float32` — Method

    Float32(x [, mode::RoundingMode])

Create a `Float32` from `x`. If `x` is not exactly representable then `mode` determines how `x` is rounded.

Examples

    julia> Float32(1/3, RoundDown)
    0.3333333f0

    julia> Float32(1/3, RoundUp)
    0.33333334f0

See `RoundingMode` for available rounding modes.

source
`Core.Float64` — Method

    Float64(x [, mode::RoundingMode])

Create a `Float64` from `x`. If `x` is not exactly representable then `mode` determines how `x` is rounded.

Examples

    julia> Float64(pi, RoundDown)
    3.141592653589793

    julia> Float64(pi, RoundUp)
    3.1415926535897936

See `RoundingMode` for available rounding modes.

source
`Base.Rounding.rounding` — Function

    rounding(T)

Get the current floating point rounding mode for type `T`, controlling the rounding of basic arithmetic functions (`+`, `-`, `*`, `/` and `sqrt`) and type conversion.

See `RoundingMode` for available modes.

source
`Base.Rounding.setrounding` — Method

    setrounding(T, mode)

Set the rounding mode of floating point type `T`, controlling the rounding of basic arithmetic functions (`+`, `-`, `*`, `/` and `sqrt`) and type conversion. Other numerical functions may give incorrect or invalid values when using rounding modes other than the default `RoundNearest`.

Note that this is currently only supported for `T == BigFloat`.

Warning

This function is not thread-safe. It will affect code running on all threads, but its behavior is undefined if called concurrently with computations that use the setting.

source
`Base.Rounding.setrounding` — Method

    setrounding(f::Function, T, mode)

Change the rounding mode of floating point type `T` for the duration of `f`. It is logically equivalent to:

    old = rounding(T)
    setrounding(T, mode)
    f()
    setrounding(T, old)

See `RoundingMode` for available rounding modes.

source
`Base.Rounding.get_zero_subnormals` — Function

    get_zero_subnormals() -> Bool

Return `false` if operations on subnormal floating-point values ("denormals") obey rules for IEEE arithmetic, and `true` if they might be converted to zeros.

Warning

This function only affects the current thread.

source
`Base.Rounding.set_zero_subnormals` — Function

    set_zero_subnormals(yes::Bool) -> Bool

If `yes` is `false`, subsequent floating-point operations follow rules for IEEE arithmetic on subnormal values ("denormals"). Otherwise, floating-point operations are permitted (but not required) to convert subnormal inputs or outputs to zero. Returns `true` unless `yes==true` but the hardware does not support zeroing of subnormal numbers.

`set_zero_subnormals(true)` can speed up some computations on some hardware. However, it can break identities such as `(x-y==0) == (x==y)`.

Warning

This function only affects the current thread.

source

### Integers

`Base.count_ones` — Function

    count_ones(x::Integer) -> Integer

Number of ones in the binary representation of `x`.

Examples

    julia> count_ones(7)
    3

    julia> count_ones(Int32(-1))
    32

source
`Base.count_zeros` — Function

    count_zeros(x::Integer) -> Integer

Number of zeros in the binary representation of `x`.

Examples

    julia> count_zeros(Int32(2 ^ 16 - 1))
    16

    julia> count_zeros(-1)
    0

source
`Base.leading_zeros` — Function

    leading_zeros(x::Integer) -> Integer

Number of zeros leading the binary representation of `x`.

Examples

    julia> leading_zeros(Int32(1))
    31

source
`Base.leading_ones` — Function

    leading_ones(x::Integer) -> Integer

Number of ones leading the binary representation of `x`.

Examples

    julia> leading_ones(UInt32(2 ^ 32 - 2))
    31

source
`Base.trailing_zeros` — Function

    trailing_zeros(x::Integer) -> Integer

Number of zeros trailing the binary representation of `x`.

Examples

    julia> trailing_zeros(2)
    1

source
`Base.trailing_ones` — Function

    trailing_ones(x::Integer) -> Integer

Number of ones trailing the binary representation of `x`.

Examples

    julia> trailing_ones(3)
    2

source
`Base.isodd` — Function

    isodd(x::Number) -> Bool

Return `true` if `x` is an odd integer (that is, an integer not divisible by 2), and `false` otherwise.

Julia 1.7

Non-`Integer` arguments require Julia 1.7 or later.

Examples

    julia> isodd(9)
    true

    julia> isodd(10)
    false

source
`Base.iseven` — Function

    iseven(x::Number) -> Bool

Return `true` if `x` is an even integer (that is, an integer divisible by 2), and `false` otherwise.

Julia 1.7

Non-`Integer` arguments require Julia 1.7 or later.

Examples

    julia> iseven(9)
    false

    julia> iseven(10)
    true

source
`Core.@int128_str` — Macro

    @int128_str str

Parse `str` as an `Int128`. Throw an `ArgumentError` if the string is not a valid integer.

Examples

    julia> int128"123456789123"
    123456789123

    julia> int128"123456789123.4"
    ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
    [...]

source
`Core.@uint128_str` — Macro

    @uint128_str str

Parse `str` as an `UInt128`. Throw an `ArgumentError` if the string is not a valid integer.

Examples

    julia> uint128"123456789123"
    0x00000000000000000000001cbe991a83

    julia> uint128"-123456789123"
    ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
    [...]

source

## BigFloats and BigInts

The `BigFloat` and `BigInt` types implements arbitrary-precision floating point and integer arithmetic, respectively. For `BigFloat` the GNU MPFR library is used, and for `BigInt` the [GNU Multiple Precision Arithmetic Library (GMP)] (https://gmplib.org) is used.

`Base.MPFR.BigFloat` — Method

    BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

Create an arbitrary precision floating point number from `x`, with precision `precision`. The `rounding` argument specifies the direction in which the result should be rounded if the conversion cannot be done exactly. If not provided, these are set by the current global values.

`BigFloat(x::Real)` is the same as `convert(BigFloat,x)`, except if `x` itself is already `BigFloat`, in which case it will return a value with the precision set to the current global precision; `convert` will always return `x`.

`BigFloat(x::AbstractString)` is identical to `parse`. This is provided for convenience since decimal literals are converted to `Float64` when parsed, so `BigFloat(2.1)` may not yield what you expect.

See also:

- `@big_str`
- `rounding` and `setrounding`
- `precision` and `setprecision`

Julia 1.1

`precision` as a keyword argument requires at least Julia 1.1. In Julia 1.0 `precision` is the second positional argument (`BigFloat(x, precision)`).

Examples

    julia> BigFloat(2.1) # 2.1 here is a Float64
    2.100000000000000088817841970012523233890533447265625

    julia> BigFloat("2.1") # the closest BigFloat to 2.1
    2.099999999999999999999999999999999999999999999999999999999999999999999999999986

    julia> BigFloat("2.1", RoundUp)
    2.100000000000000000000000000000000000000000000000000000000000000000000000000021

    julia> BigFloat("2.1", RoundUp, precision=128)
    2.100000000000000000000000000000000000007

source
`Base.precision` — Function

    precision(num::AbstractFloat; base::Integer=2)
    precision(T::Type; base::Integer=2)

Get the precision of a floating point number, as defined by the effective number of bits in the significand, or the precision of a floating-point type `T` (its current default, if `T` is a variable-precision type like `BigFloat`).

If `base` is specified, then it returns the maximum corresponding number of significand digits in that base.

Julia 1.8

The `base` keyword requires at least Julia 1.8.

source
`Base.MPFR.setprecision` — Function

    setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

Change the `T` arithmetic precision (in the given `base`) for the duration of `f`. It is logically equivalent to:

    old = precision(BigFloat)
    setprecision(BigFloat, precision)
    f()
    setprecision(BigFloat, old)

Often used as `setprecision(T, precision) do ... end`

Note: `nextfloat()`, `prevfloat()` do not use the precision mentioned by `setprecision`.

Warning

There is a fallback implementation of this method that calls `precision` and `setprecision`, but it should no longer be relied on. Instead, you should define the 3-argument form directly in a way that uses `ScopedValue`, or recommend that callers use `ScopedValue` and `@with` themselves.

Julia 1.8

The `base` keyword requires at least Julia 1.8.

source

    setprecision([T=BigFloat,] precision::Int; base=2)

Set the precision (in bits, by default) to be used for `T` arithmetic. If `base` is specified, then the precision is the minimum required to give at least `precision` digits in the given `base`.

Warning

This function is not thread-safe. It will affect code running on all threads, but its behavior is undefined if called concurrently with computations that use the setting.

Julia 1.8

The `base` keyword requires at least Julia 1.8.

source
`Base.GMP.BigInt` — Method

    BigInt(x)

Create an arbitrary precision integer. `x` may be an `Int` (or anything that can be converted to an `Int`). The usual mathematical operators are defined for this type, and results are promoted to a `BigInt`.

Instances can be constructed from strings via `parse`, or using the `big` string literal.

Examples

    julia> parse(BigInt, "42")
    42

    julia> big"313"
    313

    julia> BigInt(10)^19
    10000000000000000000

source
`Core.@big_str` — Macro

    @big_str str

Parse a string into a `BigInt` or `BigFloat`, and throw an `ArgumentError` if the string is not a valid number. For integers `_` is allowed in the string as a separator.

Examples

    julia> big"123_456"
    123456

    julia> big"7891.5"
    7891.5

    julia> big"_"
    ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
    [...]

Warning

Using `@big_str` for constructing `BigFloat` values may not result in the behavior that might be naively expected: as a macro, `@big_str` obeys the global precision (`setprecision`) and rounding mode (`setrounding`) settings as they are at load time. Thus, a function like `() -> precision(big"0.3")` returns a constant whose value depends on the value of the precision at the point when the function is defined, not at the precision at the time when the function is called.

source

Theme

This document was generated with Documenter.jl version 1.16.0 on Thursday 20 November 2025. Using Julia version 1.12.2.