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^(k-1) for k=1:length(digits)])
.
-
bits
(n)¶ A string giving the literal bit representation of a number.
-
parseint
([type, ]str[, base])¶ Parse a string as an integer in the given base (default 10), yielding a number of the specified type (default
Int
).
-
parsefloat
([type, ]str)¶ Parse a string as a decimal floating point number, yielding a number of the specified type.
-
big
(x)¶ Convert a number to a maximum precision representation (typically
BigInt
orBigFloat
). SeeBigFloat
for information about some pitfalls with floating-point numbers.
-
bool
(x)¶ Convert a number or numeric array to boolean
-
int
(x)¶ Convert a number or array to the default integer type on your platform. Alternatively,
x
can be a string, which is parsed as an integer.
-
uint
(x)¶ Convert a number or array to the default unsigned integer type on your platform. Alternatively,
x
can be a string, which is parsed as an unsigned integer.
-
integer
(x)¶ Convert a number or array to integer type. If
x
is already of integer type it is unchanged, otherwise it converts it to the default integer type on your platform.
-
signed
(x)¶ Convert a number to a signed integer
-
unsigned
(x) → Unsigned¶ Convert a number to an unsigned integer
-
int8
(x)¶ Convert a number or array to
Int8
data type
-
int16
(x)¶ Convert a number or array to
Int16
data type
-
int32
(x)¶ Convert a number or array to
Int32
data type
-
int64
(x)¶ Convert a number or array to
Int64
data type
-
int128
(x)¶ Convert a number or array to
Int128
data type
-
uint8
(x)¶ Convert a number or array to
Uint8
data type
-
uint16
(x)¶ Convert a number or array to
Uint16
data type
-
uint32
(x)¶ Convert a number or array to
Uint32
data type
-
uint64
(x)¶ Convert a number or array to
Uint64
data type
-
uint128
(x)¶ Convert a number or array to
Uint128
data type
-
float16
(x)¶ Convert a number or array to
Float16
data type
-
float32
(x)¶ Convert a number or array to
Float32
data type
-
float64
(x)¶ Convert a number or array to
Float64
data type
-
float32_isvalid
(x, out::Vector{Float32}) → Bool¶ Convert a number or array to
Float32
data type, returning true if successful. The result of the conversion is stored inout[1]
.
-
float64_isvalid
(x, out::Vector{Float64}) → Bool¶ Convert a number or array to
Float64
data type, returning true if successful. The result of the conversion is stored inout[1]
.
-
float
(x)¶ Convert a number, array, or string to a
FloatingPoint
data type. For numeric data, the smallest suitableFloatingPoint
type is used. Converts strings toFloat64
.This function is not recommended for arrays. It is better to use a more specific function such as
float32
orfloat64
.
-
significand
(x)¶ Extract the significand(s) (a.k.a. mantissa), in binary representation, of a floating-point number or array.
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.
-
complex64
(r[, i])¶ Convert to
r + i*im
represented as aComplex64
data type.i
defaults to zero.
-
complex128
(r[, i])¶ Convert to
r + i*im
represented as aComplex128
data type.i
defaults to zero.
-
complex
(r[, i])¶ Convert real numbers or arrays to complex.
i
defaults to zero.
-
char
(x)¶ Convert a number or array to
Char
data type
-
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::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 lower-case. Returns an ASCIIString.
Numbers¶
-
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
-
e
¶ The constant e
-
catalan
¶ Catalan’s constant
-
γ
¶ Euler’s constant
-
φ
¶ 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)
-
inf
(f)¶ Returns positive infinity of the floating point type
f
or of the same floating point type asf
-
nan
(f)¶ Returns NaN (not-a-number) 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) → FloatingPoint¶ 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
-
BigInt
(x)¶ Create an arbitrary precision integer.
x
may be anInt
(or anything that can be converted to anInt
) or aString
. The usual mathematical operators are defined for this type, and results are promoted to aBigInt
.
-
BigFloat
(x)¶ Create an arbitrary precision floating point number.
x
may be anInteger
, aFloat64
, aString
or aBigInt
. The usual mathematical operators are defined for this type, and results are promoted to aBigFloat
. Note that because floating-point numbers are not exactly-representable in decimal notation,BigFloat(2.1)
may not yield what you expect. You may prefer to initialize constants using strings, e.g.,BigFloat("2.1")
.
-
get_rounding
(T)¶ Get the current floating point rounding mode for type
T
. Valid modes areRoundNearest
,RoundToZero
,RoundUp
,RoundDown
, andRoundFromZero
(BigFloat
only).
-
set_rounding
(T, mode)¶ Set the rounding mode of floating point type
T
. Note that this may affect other types, for instance changing the rounding mode ofFloat64
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.
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(int32(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
-
primes
(n)¶ Returns a collection of the prime numbers <=
n
.
-
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(10) true julia> iseven(9) false
BigFloats¶
The BigFloat type implements arbitrary-precision floating-point aritmetic using the GNU MPFR library.
-
precision
(num::FloatingPoint)¶ 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 of
f
. 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. Julia has a global RNG, which is used by default. Multiple RNGs can be plugged in using the AbstractRNG
object, which can then be used to have multiple streams of random numbers. Currently, only MersenneTwister
is supported.
-
srand
([rng, ]seed)¶ Seed the RNG with a
seed
, which may be an unsigned integer or a vector of unsigned integers.seed
can even be a filename, in which case the seed is read from a file. If the argumentrng
is not provided, the default global RNG is seeded.
-
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.
-
rand
() → Float64¶ Generate a
Float64
random number uniformly in [0,1)
-
rand!
([rng, ]A)¶ Populate the array A with random number generated from the specified RNG.
-
rand
(rng::AbstractRNG[, dims...]) Generate a random
Float64
number or array of the size specified by dims, using the specified RNG object. Currently,MersenneTwister
is the only available Random Number Generator (RNG), which may be seeded using srand.
-
rand
(dims or [dims...]) Generate a random
Float64
array of the size specified by dims
-
rand
(Int32|Uint32|Int64|Uint64|Int128|Uint128[, dims...]) Generate a random integer of the given type. Optionally, generate an array of random integers of the given type by specifying dims.
-
rand
(r[, dims...]) Generate a random integer in the range
r
(for example,1:n
or0:2:10
). Optionally, generate a random integer array.
-
randbool
([dims...])¶ Generate a random boolean value. Optionally, generate an array of random boolean values.
-
randbool!
(A)¶ Fill an array with random boolean values. A may be an
Array
or aBitArray
.
-
randn
([rng], dims or [dims...])¶ Generate a normally-distributed random number with mean 0 and standard deviation 1. Optionally generate an array of normally-distributed random numbers.
-
randn!
([rng, ]A::Array{Float64, N})¶ Fill the array A with normally-distributed (mean 0, standard deviation 1) random numbers. Also see the rand function.