Bool
Int8
UInt8
Int16
UInt16
Int32
UInt32
Int64
UInt64
Int128
UInt128
Float16
Float32
Float64
Complex64
Complex128
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.
digits([T, ]n[, base][, pad])
Returns 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 indexes, such that n == sum([digits[k]*base^(k-1) 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 a Nullable
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
or BigFloat
). See BigFloat
for information about some pitfalls with floating-point 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 suitable AbstractFloat
type is used. Converts strings to Float64
.
significand(x)
Extract the significand(s)
(a.k.a. mantissa), in binary representation, of a floating-point number or array. 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.
julia> significand(15.2)/15.2 0.125 julia> significand(15.2)*8 15.2
exponent(x) → Int
Get the exponent of a normalized floating-point number.
complex(r[, i])
Convert real numbers or arrays to complex. i
defaults to zero.
bswap(n)
Byte-swap 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::AbstractString)
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 lower-case. Returns a String
.
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).
pi
π
The constant pi.
im
The imaginary unit.
e
eu
The constant e.
catalan
Catalan’s constant.
γ
eulergamma
Euler’s constant.
φ
golden
The golden ratio.
Inf
Positive infinity of type Float64
.
Inf32
Positive infinity of type Float32
.
Inf16
Positive infinity of type Float16
.
NaN
A not-a-number value of type Float64
.
NaN32
A not-a-number value of type Float32
.
NaN16
A not-a-number 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).
nextfloat(x::AbstractFloat)
Returns 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 returns x
.
prevfloat(x::AbstractFloat)
Returns 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 returns x
.
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
.
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.
isimag(z) → Bool
Test whether z
is purely imaginary, i.e. has a real part equal to 0.
Float32(x[, mode::RoundingMode])
Create a Float32 from x
. If x
is not exactly representable then mode
determines how x
is rounded.
julia> Float32(1/3, RoundDown) 0.3333333f0 julia> Float32(1/3, RoundUp) 0.33333334f0
See RoundingMode
for available rounding modes.
Float64(x[, mode::RoundingMode])
Create a Float64 from x
. If x
is not exactly representable then mode
determines how x
is rounded.
julia> Float64(pi, RoundDown) 3.141592653589793 julia> Float64(pi, RoundUp) 3.1415926535897936
See RoundingMode
for available rounding modes.
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.
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.100000000000000088817841970012523233890533447265625000000000000000000000000000 julia> big"2.1" 2.099999999999999999999999999999999999999999999999999999999999999999999999999986
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.
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.
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
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.
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)
.
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
isodd(x::Integer) → Bool
Returns true
if x
is odd (that is, not divisible by 2), and false
otherwise.
julia> isodd(9) true julia> isodd(10) false
iseven(x::Integer) → Bool
Returns true
is x
is even (that is, divisible by 2), and false
otherwise.
julia> iseven(9) false julia> iseven(10) true
The BigFloat
type implements arbitrary-precision floating-point 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.
precision(BigFloat)
Get the precision (in bits) currently used for BigFloat
arithmetic.
setprecision([T=BigFloat, ]precision::Int)
Set the precision (in bits) to be used for T
arithmetic.
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
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. For MersenneTwister
, the seed
may be a non-negative integer, a vector of UInt32
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
1:n
or ['x','y','z']
), ortypemin(S):typemax(S)
for integers (this is not applicable to BigInt
), and to \([0, 1)\) for floating point numbers;S
defaults to Float64
.
rand!([rng, ]A[, coll])
Populate the array A
with random values. If the indexable collection coll
is specified, the values are picked randomly from coll
. This is equivalent to copy!(A, rand(rng, coll, size(A)))
or copy!(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][, T=Float64][, dims...])
Generate a normally-distributed random number of type T
with mean 0 and standard deviation 1. Optionally generate an array of normally-distributed random numbers. The Base
module currently provides an implementation for the types Float16
, Float32
, and Float64
(the default).
randn!([rng, ]A::AbstractArray) → A
Fill the array A
with normally-distributed (mean 0, standard deviation 1) random numbers. Also see the rand
function.
randexp([rng][, T=Float64][, dims...])
Generate a random number of type T
according to the exponential distribution with scale 1. Optionally generate an array of such random numbers. The Base
module currently provides an implementation for the types Float16
, Float32
, and Float64
(the default).
randexp!([rng, ]A::AbstractArray) → A
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 initialized MersenneTwister
RNG objects where the first RNG object given as a parameter and following MersenneTwister
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 polynomial jumppoly
.
Default jump polynomial moves forward MersenneTwister
RNG state by 10^20 steps.
© 2009–2016 Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors
Licensed under the MIT License.
http://docs.julialang.org/en/release-0.5/stdlib/numbers/