Numbers¶
Standard Numeric Types¶
Bool
Int8
UInt8
Int16
UInt16
Int32
UInt32
Int64
UInt64
Int128
UInt128
Float16
Float32
Float64
Complex64
Complex128
Data Formats¶

bin
(n[, pad])¶ Convert an integer to a binary string, optionally specifying a number of digits to pad to.

hex
(n[, pad])¶ Convert an integer to a hexadecimal string, optionally specifying a number of digits to pad to.

dec
(n[, pad])¶ Convert an integer to a decimal string, optionally specifying a number of digits to pad to.

oct
(n[, pad])¶ Convert an integer to an octal string, optionally specifying a number of digits to pad to.

base
(base, n[, pad])¶ Convert an integer to a string in the given base, optionally specifying a number of digits to pad to. The base can be specified as either an integer, or as a
UInt8
array of character values to use as digit symbols.

digits
(n[, base][, pad])¶ Returns an array of the digits of
n
in the given base, optionally padded with zeros to a specified size. More significant digits are at higher indexes, such thatn == sum([digits[k]*base^(k1) for k=1:length(digits)])
.

digits!
(array, n[, base])¶ Fills an array of the digits of
n
in the given base. More significant digits are at higher indexes. 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.

bits
(n)¶ A string giving the literal bit representation of a number.

parse
(type, str[, base])¶ Parse a string as a number. If the type is an integer type, then a base can be specified (the default is 10). If the type is a floating point type, the string is parsed as a decimal floating point number. If the string does not contain a valid number, an error is raised.

tryparse
(type, str[, base])¶ Like
parse
, but returns aNullable
of the requested type. The result will be null if the string does not contain a valid number.

big
(x)¶ Convert a number to a maximum precision representation (typically
BigInt
orBigFloat
). SeeBigFloat
for information about some pitfalls with floatingpoint numbers.

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

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.

float
(x)¶ Convert a number, array, or string to a
AbstractFloat
data type. For numeric data, the smallest suitableAbstractFloat
type is used. Converts strings toFloat64
.

significand
(x)¶ Extract the
significand(s)
(a.k.a. mantissa), in binary representation, of a floatingpoint number or array. Ifx
is a nonzero finite number, than the result will be a number of the same type on the interval \([1,2)\). Otherwisex
is returned.julia> significand(15.2)/15.2 0.125 julia> significand(15.2)*8 15.2

exponent
(x) → Int¶ Get the exponent of a normalized floatingpoint number.

complex
(r[, i])¶ Convert real numbers or arrays to complex.
i
defaults to zero.

bswap
(n)¶ Byteswap an integer

num2hex
(f)¶ Get a hexadecimal string of the binary representation of a floating point number

hex2num
(str)¶ Convert a hexadecimal string to the floating point number it represents

hex2bytes
(s::ASCIIString)¶ Convert an arbitrarily long hexadecimal string to its binary representation. Returns an
Array{UInt8,1}
, i.e. an array of bytes.

bytes2hex
(bin_arr::Array{UInt8, 1})¶ Convert an array of bytes to its hexadecimal representation. All characters are in lowercase. Returns an
ASCIIString
.
General Number Functions and Constants¶

one
(x)¶ Get the multiplicative identity element for the type of
x
(x
can also specify the type itself). For matrices, returns an identity matrix of the appropriate size and type.

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

im
¶ The imaginary unit

catalan
¶ Catalan’s constant

Inf
¶ Positive infinity of type
Float64

Inf32
¶ Positive infinity of type
Float32

Inf16
¶ Positive infinity of type
Float16

NaN
¶ A notanumber value of type
Float64

NaN32
¶ A notanumber value of type
Float32

NaN16
¶ A notanumber value of type
Float16

issubnormal
(f) → Bool¶ Test whether a floating point number is subnormal

isfinite
(f) → Bool¶ Test whether a number is finite

isinf
(f) → Bool¶ Test whether a number is infinite

isnan
(f) → Bool¶ Test whether a floating point number is not a number (NaN)

inf
(f)¶ Returns positive infinity of the floating point type
f
or of the same floating point type asf

nan
(f)¶ Returns NaN (notanumber) of the floating point type
f
or of the same floating point type asf

nextfloat
(f)¶ Get the next floating point number in lexicographic order

prevfloat
(f) → AbstractFloat¶ Get the previous floating point number in lexicographic order

isinteger
(x) → Bool¶ Test whether
x
or all its elements are numerically equal to some integer

isreal
(x) → Bool¶ Test whether
x
or all its elements are numerically equal to some real number

Float32
(x[, mode::RoundingMode])¶ Create a Float32 from
x
. Ifx
is not exactly representable thenmode
determines howx
is rounded.julia> Float32(1/3, RoundDown) 0.3333333f0 julia> Float32(1/3, RoundUp) 0.33333334f0
See
get_rounding
for available rounding modes.

Float64
(x[, mode::RoundingMode])¶ Create a Float64 from
x
. Ifx
is not exactly representable thenmode
determines howx
is rounded.julia> Float64(pi, RoundDown) 3.141592653589793 julia> Float64(pi, RoundUp) 3.1415926535897936
See
get_rounding
for available rounding modes.

BigInt
(x)¶ Create an arbitrary precision integer.
x
may be anInt
(or anything that can be converted to anInt
). The usual mathematical operators are defined for this type, and results are promoted to aBigInt
.Instances can be constructed from strings via
parse()
, or using thebig
string literal.

BigFloat
(x)¶ Create an arbitrary precision floating point number.
x
may be anInteger
, aFloat64
or aBigInt
. The usual mathematical operators are defined for this type, and results are promoted to aBigFloat
.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 viaparse()
, or using thebig
string literal.julia> BigFloat(2.1) 2.100000000000000088817841970012523233890533447265625000000000000000000000000000 julia> big"2.1" 2.099999999999999999999999999999999999999999999999999999999999999999999999999986

get_rounding
(T)¶ Get the current floating point rounding mode for type
T
, controlling the rounding of basic arithmetic functions (+()
,()
,*()
,/()
andsqrt()
) and type conversion.Valid modes are
RoundNearest
,RoundToZero
,RoundUp
,RoundDown
, andRoundFromZero
(BigFloat
only).

set_rounding
(T, mode)¶ Set the rounding mode of floating point type
T
, controlling the rounding of basic arithmetic functions (+()
,()
,*()
,/()
andsqrt()
) and type conversion.Note that this may affect other types, for instance changing the rounding mode of
Float64
will change the rounding mode ofFloat32
. Seeget_rounding
for available modes

with_rounding
(f::Function, T, mode)¶ Change the rounding mode of floating point type
T
for the duration off
. It is logically equivalent to:old = get_rounding(T) set_rounding(T, mode) f() set_rounding(T, old)
See
get_rounding
for available rounding modes.

get_zero_subnormals
() → Bool¶ Returns
false
if operations on subnormal floatingpoint values (“denormals”) obey rules for IEEE arithmetic, andtrue
if they might be converted to zeros.

set_zero_subnormals
(yes::Bool) → Bool¶ If
yes
isfalse
, subsequent floatingpoint operations follow rules for IEEE arithmetic on subnormal values (“denormals”). Otherwise, floatingpoint operations are permitted (but not required) to convert subnormal inputs or outputs to zero. Returnstrue
unlessyes==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(xy==0) == (x==y)
.
Integers¶

count_ones
(x::Integer) → Integer¶ Number of ones in the binary representation of
x
.julia> count_ones(7) 3

count_zeros
(x::Integer) → Integer¶ Number of zeros in the binary representation of
x
.julia> count_zeros(Int32(2 ^ 16  1)) 16

leading_zeros
(x::Integer) → Integer¶ Number of zeros leading the binary representation of
x
.julia> leading_zeros(Int32(1)) 31

leading_ones
(x::Integer) → Integer¶ Number of ones leading the binary representation of
x
.julia> leading_ones(UInt32(2 ^ 32  2)) 31

trailing_zeros
(x::Integer) → Integer¶ Number of zeros trailing the binary representation of
x
.julia> trailing_zeros(2) 1

trailing_ones
(x::Integer) → Integer¶ Number of ones trailing the binary representation of
x
.julia> trailing_ones(3) 2

isprime
(x::Integer) → Bool¶ Returns
true
ifx
is prime, andfalse
otherwise.julia> isprime(3) true

isprime
(x::BigInt[, reps = 25]) → Bool Probabilistic primality test. Returns
true
ifx
is prime; andfalse
ifx
is not prime with high probability. The false positive rate is about0.25^reps
.reps = 25
is considered safe for cryptographic applications (Knuth, Seminumerical Algorithms).julia> isprime(big(3)) true

primes
([lo, ]hi)¶ Returns a collection of the prime numbers (from
lo
, if specified) up tohi
.

primesmask
([lo, ]hi)¶ Returns a prime sieve, as a
BitArray
, of the positive integers (fromlo
, if specified) up tohi
. Useful when working with either primes or composite numbers.

isodd
(x::Integer) → Bool¶ Returns
true
ifx
is odd (that is, not divisible by 2), andfalse
otherwise.julia> isodd(9) true julia> isodd(10) false

iseven
(x::Integer) → Bool¶ Returns
true
isx
is even (that is, divisible by 2), andfalse
otherwise.julia> iseven(9) false julia> iseven(10) true
BigFloats¶
The BigFloat
type implements arbitraryprecision floatingpoint arithmetic using the GNU MPFR library.

precision
(num::AbstractFloat)¶ Get the precision of a floating point number, as defined by the effective number of bits in the mantissa.

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

set_bigfloat_precision
(x::Int64)¶ Set the precision (in bits) to be used to
BigFloat
arithmetic.

with_bigfloat_precision
(f::Function, precision::Integer)¶ Change the
BigFloat
arithmetic precision (in bits) for the duration off
. It is logically equivalent to:old = get_bigfloat_precision() set_bigfloat_precision(precision) f() set_bigfloat_precision(old)
Random Numbers¶
Random number generation in Julia uses the Mersenne Twister library via MersenneTwister
objects.
Julia has a global RNG, which is used by default. Other RNG types can be plugged in by inheriting the AbstractRNG
type;
they can then be used to have multiple streams of random numbers.
Besides MersenneTwister
, Julia also provides the RandomDevice
RNG type, which is a wrapper over the OS provided entropy.
Most functions related to random generation accept an optional AbstractRNG
as the first argument, rng
, which defaults to the global one if not provided.
Morever, some of them accept optionally dimension specifications dims...
(which can be given as a tuple) to generate arrays of random values.
A MersenneTwister
or RandomDevice
RNG can generate random numbers of the following types:
Float16
, Float32
, Float64
, Bool
, Int8
, UInt8
, Int16
, UInt16
,
Int32
, UInt32
, Int64
, UInt64
, Int128
, UInt128
, BigInt
(or complex numbers of those types). Random floating point numbers are generated uniformly in \([0, 1)\).
As BigInt
represents unbounded integers, the interval must be specified (e.g. rand(big(1:6))
).

srand
([rng][, seed])¶ Reseed the random number generator. If a
seed
is provided, the RNG will give a reproducible sequence of numbers, otherwise Julia will get entropy from the system. ForMersenneTwister
, theseed
may be a nonnegative integer, a vector ofUInt32
integers or a filename, in which case the seed is read from a file.RandomDevice
does not support seeding.

MersenneTwister
([seed])¶ Create a
MersenneTwister
RNG object. Different RNG objects can have their own seeds, which may be useful for generating different streams of random numbers.

RandomDevice
()¶ Create a
RandomDevice
RNG object. Two such objects will always generate different streams of random numbers.

rand
([rng][, S][, dims...])¶ Pick a random element or array of random elements from the set of values specified by
S
;S
can be an indexable collection (for example
1:n
or['x','y','z']
), or  a type: the set of values to pick from is then equivalent to
typemin(S):typemax(S)
for integers (this is not applicable toBigInt
), and to \([0, 1)\) for floating point numbers;
S
defaults toFloat64
. an indexable collection (for example

rand!
([rng, ]A[, coll])¶ Populate the array
A
with random values. If the indexable collectioncoll
is specified, the values are picked randomly fromcoll
. This is equivalent tocopy!(A, rand(rng, coll, size(A)))
orcopy!(A, rand(rng, eltype(A), size(A)))
but without allocating a new array.

bitrand
([rng][, dims...])¶ Generate a
BitArray
of random boolean values.

randn
([rng][, dims...])¶ Generate a normallydistributed random number with mean 0 and standard deviation 1. Optionally generate an array of normallydistributed random numbers.

randn!
([rng, ]A::Array{Float64, N})¶ Fill the array
A
with normallydistributed (mean 0, standard deviation 1) random numbers. Also see the rand function.

randexp
([rng][, dims...])¶ Generate a random number according to the exponential distribution with scale 1. Optionally generate an array of such random numbers.

randexp!
([rng, ]A::Array{Float64, N})¶ Fill the array
A
with random numbers following the exponential distribution (with scale 1).

randjump
(r::MersenneTwister, jumps[, jumppoly]) → Vector{MersenneTwister}¶ Create an array of the size
jumps
of initializedMersenneTwister
RNG objects where the first RNG object given as a parameter and followingMersenneTwister
RNGs in the array initialized such that a state of the RNG object in the array would be moved forward (without generating numbers) from a previous RNG object array element on a particular number of steps encoded by the jump polynomialjumppoly
.Default jump polynomial moves forward
MersenneTwister
RNG state by 10^20 steps.