Numbers

Numbers

Standard Numeric Types

Abstract number types

Core.NumberType.
Number

Abstract supertype for all number types.

source
Core.RealType.
Real <: Number

Abstract supertype for all real numbers.

source
AbstractFloat <: Real

Abstract supertype for all floating point numbers.

source
Core.IntegerType.
Integer <: Real

Abstract supertype for all integers.

source
Core.SignedType.
Signed <: Integer

Abstract supertype for all signed integers.

source
Core.UnsignedType.
Unsigned <: Integer

Abstract supertype for all unsigned integers.

source
AbstractIrrational <: Real

Number type representing an exact irrational value.

source

Concrete number types

Core.Float16Type.
Float16 <: AbstractFloat

16-bit floating point number type.

source
Core.Float32Type.
Float32 <: AbstractFloat

32-bit floating point number type.

source
Core.Float64Type.
Float64 <: AbstractFloat

64-bit floating point number type.

source
BigFloat <: AbstractFloat

Arbitrary precision floating point number type.

source
Core.BoolType.
Bool <: Integer

Boolean type.

source
Core.Int8Type.
Int8 <: Signed

8-bit signed integer type.

source
Core.UInt8Type.
UInt8 <: Unsigned

8-bit unsigned integer type.

source
Core.Int16Type.
Int16 <: Signed

16-bit signed integer type.

source
Core.UInt16Type.
UInt16 <: Unsigned

16-bit unsigned integer type.

source
Core.Int32Type.
Int32 <: Signed

32-bit signed integer type.

source
Core.UInt32Type.
UInt32 <: Unsigned

32-bit unsigned integer type.

source
Core.Int64Type.
Int64 <: Signed

64-bit signed integer type.

source
Core.UInt64Type.
UInt64 <: Unsigned

64-bit unsigned integer type.

source
Core.Int128Type.
Int128 <: Signed

128-bit signed integer type.

source
Core.UInt128Type.
UInt128 <: Unsigned

128-bit unsigned integer type.

source
Base.GMP.BigIntType.
BigInt <: Signed

Arbitrary precision integer type.

source
Base.ComplexType.
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.

source
Base.RationalType.
Rational{T<:Integer} <: Real

Rational number type, with numerator and denominator of type T.

source
Base.IrrationalType.
Irrational{sym} <: AbstractIrrational

Number type representing an exact irrational value denoted by the symbol sym.

source

Data Formats

Base.binFunction.
bin(n, pad::Int=1)

Convert an integer to a binary string, optionally specifying a number of digits to pad to.

julia> bin(10,2)
"1010"

julia> bin(10,8)
"00001010"
source
Base.hexFunction.
hex(n, pad::Int=1)

Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to.

julia> hex(20)
"14"

julia> hex(20, 3)
"014"
source
Base.decFunction.
dec(n, pad::Int=1)

Convert an integer to a decimal string, optionally specifying a number of digits to pad to.

Examples

julia> dec(20)
"20"

julia> dec(20, 3)
"020"
source
Base.octFunction.
oct(n, pad::Int=1)

Convert an integer to an octal string, optionally specifying a number of digits to pad to.

julia> oct(20)
"24"

julia> oct(20, 3)
"024"
source
Base.baseFunction.
base(base::Integer, n::Integer, pad::Integer=1)

Convert an integer n to a string in the given base, optionally specifying a number of digits to pad to.

julia> base(13,5,4)
"0005"

julia> base(5,13,4)
"0023"
source
Base.digitsFunction.
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=1:length(digits)]).

Examples

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

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

julia> digits(10, base = 2, pad = 6)
6-element Array{Int64,1}:
 0
 1
 0
 1
 0
 0
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 Array{Int64,1}:
 0
 1
 0
 1

julia> digits!([2,2,2,2,2,2], 10, base = 2)
6-element Array{Int64,1}:
 0
 1
 0
 1
 0
 0
source
Base.bitstringFunction.
bitstring(n)

A string giving the literal bit representation of a number.

Examples

julia> bitstring(4)
"0000000000000000000000000000000000000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"
source
Base.parseFunction.
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> 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.tryparseFunction.
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.bigFunction.
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.signedFunction.
signed(x)

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

source
Base.unsignedFunction.
unsigned(x) -> Unsigned

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

Examples

julia> unsigned(-2)
0xfffffffffffffffe

julia> unsigned(2)
0x0000000000000002

julia> signed(unsigned(-2))
-2
source
Base.floatMethod.
float(x)

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

source
Base.Math.significandFunction.
significand(x)

Extract the significand(s) (a.k.a. mantissa), in binary representation, of a floating-point number. If x is a non-zero finite number, then the result will be a number of the same type on the interval $[1,2)$. Otherwise x is returned.

Examples

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2
source
Base.Math.exponentFunction.
exponent(x) -> Int

Get the exponent of a normalized floating-point number.

source
Base.complexMethod.
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 Array{Complex{Int64},1}:
 1 + 0im
 2 + 0im
 3 + 0im
source
Base.bswapFunction.
bswap(n)

Byte-swap an integer. Flip the bits of its binary representation.

Examples

julia> a = bswap(4)
288230376151711744

julia> bswap(a)
4

julia> bin(1)
"1"

julia> bin(bswap(1))
"100000000000000000000000000000000000000000000000000000000"
source
Base.hex2bytesFunction.
hex2bytes(s::Union{AbstractString,AbstractVector{UInt8}})

Given a string or array s 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 s gives the value of one byte in the return vector.

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

Examples

julia> s = hex(12345)
"3039"

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

julia> a = b"01abEF"
6-element Array{UInt8,1}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Array{UInt8,1}:
 0x01
 0xab
 0xef
source
Base.hex2bytes!Function.
hex2bytes!(d::AbstractVector{UInt8}, s::Union{String,AbstractVector{UInt8}})

Convert an array s of bytes representing a hexadecimal string to its binary representation, similar to hex2bytes except that the output is written in-place in d. The length of s must be exactly twice the length of d.

source
Base.bytes2hexFunction.
bytes2hex(bin_arr::Array{UInt8, 1}) -> String

Convert an array of bytes to its hexadecimal representation. All characters are in lower-case.

Examples

julia> a = hex(12345)
"3039"

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

julia> bytes2hex(b)
"3039"
source

General Number Functions and Constants

Base.oneFunction.
one(x)
one(T::type)

Return a multiplicative identity for x: a value such that one(x)*x == x*one(x) == x. Alternatively one(T) can take a type T, in which case one returns a multiplicative identity for any x of type T.

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.

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1
source
Base.oneunitFunction.
oneunit(x::T)
oneunit(T::Type)

Returns T(one(x)), where T is either the type of the argument or (if a type is passed) the argument. 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).

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 day
source
Base.zeroFunction.
zero(x)

Get the additive identity element for the type of x (x can also specify the type itself).

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Array{Float64,2}:
 0.0  0.0
 0.0  0.0
source
Base.imConstant.
im

The imaginary unit.

Examples

julia> im * im
-1 + 0im
source
Base.MathConstants.piConstant.
π
pi

The constant pi.

julia> pi
π = 3.1415926535897...
source
ℯ
e

The constant ℯ.

julia> ℯ
ℯ = 2.7182818284590...
source
catalan

Catalan's constant.

julia> Base.MathConstants.catalan
catalan = 0.9159655941772...
source
γ
eulergamma

Euler's constant.

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...
source
φ
golden

The golden ratio.

julia> Base.MathConstants.golden
φ = 1.6180339887498...
source
Base.InfConstant.
Inf

Positive infinity of type Float64.

source
Base.Inf32Constant.
Inf32

Positive infinity of type Float32.

source
Base.Inf16Constant.
Inf16

Positive infinity of type Float16.

source
Base.NaNConstant.
NaN

A not-a-number value of type Float64.

source
Base.NaN32Constant.
NaN32

A not-a-number value of type Float32.

source
Base.NaN16Constant.
NaN16

A not-a-number value of type Float16.

source
Base.issubnormalFunction.
issubnormal(f) -> Bool

Test whether a floating point number is subnormal.

source
Base.isfiniteFunction.
isfinite(f) -> Bool

Test whether a number is finite.

julia> isfinite(5)
true

julia> isfinite(NaN32)
false
source
Base.isinfFunction.
isinf(f) -> Bool

Test whether a number is infinite.

source
Base.isnanFunction.
isnan(f) -> Bool

Test whether a floating point number is not a number (NaN).

source
Base.iszeroFunction.
iszero(x)

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

julia> iszero(0.0)
true
source
Base.isoneFunction.
isone(x)

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

julia> isone(1.0)
true
source
Base.nextfloatFunction.
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
nextfloat(x::AbstractFloat)

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

source
Base.prevfloatFunction.
prevfloat(x::AbstractFloat)

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

source
Base.isintegerFunction.
isinteger(x) -> Bool

Test whether x is numerically equal to some integer.

julia> isinteger(4.0)
true
source
Base.isrealFunction.
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(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false
source
Core.Float32Method.
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.Float64Method.
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.GMP.BigIntMethod.
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.

julia> parse(BigInt, "42")
42

julia> big"313"
313
source
Base.MPFR.BigFloatMethod.
BigFloat(x)

Create an arbitrary precision floating point number. x may be an Integer, a Float64 or a BigInt. The usual mathematical operators are defined for this type, and results are promoted to a BigFloat.

Note that because decimal literals are converted to floating point numbers when parsed, BigFloat(2.1) may not yield what you expect. You may instead prefer to initialize constants from strings via parse, or using the big string literal.

julia> BigFloat(2.1)
2.100000000000000088817841970012523233890533447265625

julia> big"2.1"
2.099999999999999999999999999999999999999999999999999999999999999999999999999986
source
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
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 may affect other types, for instance changing the rounding mode of Float64 will change the rounding mode of Float32. See RoundingMode for available modes.

Warning

This feature is still experimental, and may give unexpected or incorrect values.

source
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.

Warning

This feature is still experimental, and may give unexpected or incorrect values. A known problem is the interaction with compiler optimisations, e.g.

julia> setrounding(Float64,RoundDown) do
           1.1 + 0.1
       end
1.2000000000000002

Here the compiler is constant folding, that is evaluating a known constant expression at compile time, however the rounding mode is only changed at runtime, so this is not reflected in the function result. This can be avoided by moving constants outside the expression, e.g.

julia> x = 1.1; y = 0.1;

julia> setrounding(Float64,RoundDown) do
           x + y
       end
1.2
source
get_zero_subnormals() -> Bool

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

source
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).

source

Integers

Base.count_onesFunction.
count_ones(x::Integer) -> Integer

Number of ones in the binary representation of x.

julia> count_ones(7)
3
source
Base.count_zerosFunction.
count_zeros(x::Integer) -> Integer

Number of zeros in the binary representation of x.

julia> count_zeros(Int32(2 ^ 16 - 1))
16
source
Base.leading_zerosFunction.
leading_zeros(x::Integer) -> Integer

Number of zeros leading the binary representation of x.

julia> leading_zeros(Int32(1))
31
source
Base.leading_onesFunction.
leading_ones(x::Integer) -> Integer

Number of ones leading the binary representation of x.

julia> leading_ones(UInt32(2 ^ 32 - 2))
31
source
Base.trailing_zerosFunction.
trailing_zeros(x::Integer) -> Integer

Number of zeros trailing the binary representation of x.

julia> trailing_zeros(2)
1
source
Base.trailing_onesFunction.
trailing_ones(x::Integer) -> Integer

Number of ones trailing the binary representation of x.

julia> trailing_ones(3)
2
source
Base.isoddFunction.
isodd(x::Integer) -> Bool

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

julia> isodd(9)
true

julia> isodd(10)
false
source
Base.isevenFunction.
iseven(x::Integer) -> Bool

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

julia> iseven(9)
false

julia> iseven(10)
true
source

BigFloats

The BigFloat type implements arbitrary-precision floating-point arithmetic using the GNU MPFR library.

Base.precisionFunction.
precision(num::AbstractFloat)

Get the precision of a floating point number, as defined by the effective number of bits in the mantissa.

source
Base.precisionMethod.
precision(BigFloat)

Get the precision (in bits) currently used for BigFloat arithmetic.

source
setprecision([T=BigFloat,] precision::Int)

Set the precision (in bits) to be used for T arithmetic.

source
setprecision(f::Function, [T=BigFloat,] precision::Integer)

Change the T arithmetic precision (in bits) 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

source
Base.MPFR.BigFloatMethod.
BigFloat(x, prec::Int)

Create a representation of x as a BigFloat with precision prec.

source
Base.MPFR.BigFloatMethod.
BigFloat(x, rounding::RoundingMode)

Create a representation of x as a BigFloat with the current global precision and rounding mode rounding.

source
Base.MPFR.BigFloatMethod.
BigFloat(x, prec::Int, rounding::RoundingMode)

Create a representation of x as a BigFloat with precision prec and rounding mode rounding.

source
Base.MPFR.BigFloatMethod.
BigFloat(x::String)

Create a representation of the string x as a BigFloat.

source