Числа

Стандартные числовые типы

Абстрактные числовые типы

Core.NumberТип

Number

Абстрактный супертип для всех числовых типов.

Core.RealТип

Real <: Number

Абстрактный супертип для всех вещественных чисел.

Core.AbstractFloatТип

AbstractFloat <: Real

Абстрактный супертип для всех чисел с плавающей точкой.

Core.IntegerТип

Integer <: Real

Абстрактный супертип для всех целых чисел.

Core.SignedТип

Signed <: Integer

Абстрактный супертип для всех целых чисел со знаком.

Core.UnsignedТип

Unsigned <: Integer

Абстрактный супертип для всех целых чисел без знака.

Конкретные числовые типы

Core.Float16Тип

Float16 <: AbstractFloat

Числовой тип с плавающей точкой 16 бит.

Core.Float32Тип

Float32 <: AbstractFloat

Числовой тип с плавающей точкой 32 бит.

Core.Float64Тип

Float64 <: AbstractFloat

Числовой тип с плавающей точкой 64 бит.

Base.MPFR.BigFloatТип

BigFloat <: AbstractFloat

Числовой тип с плавающей точкой произвольной точности.

Core.BoolТип

Bool <: Integer

Булевый тип.

Core.Int8Тип

Int8 <: Signed

Целый тип со знаком 8 бит.

Core.UInt8Тип

UInt8 <: Unsigned

Целый тип без знака 8 бит.

Core.Int16Тип

Int16 <: Signed

Целый тип со знаком 16 бит.

Core.UInt16Тип

UInt16 <: Unsigned

Целый тип без знака 16 бит.

Core.Int32Тип

Int32 <: Signed

Целый тип со знаком 32 бит.

Core.UInt32Тип

UInt32 <: Unsigned

Целый тип без знака 32 бит.

Core.Int64Тип

Int64 <: Signed

Целый тип со знаком 64 бит.

Core.UInt64Тип

UInt64 <: Unsigned

Целый тип без знака 64 бит.

Core.Int128Тип

Int128 <: Signed

Целый тип со знаком 128 бит.

Core.UInt128Тип

UInt128 <: Unsigned

Целый тип без знака 128 бит.

Base.GMP.BigIntТип

BigInt <: Integer

Целый тип произвольной точности.

Base.ComplexТип

Complex{T<:Real} <: Number

Тип комплексного числа с вещественной и мнимой частями типа T.

Complex32, Complex64 и Complex128 являются псевдонимами соответственно для Complex{Float16}, Complex{Float32} и Complex{Float64}.

Base.RationalТип

Rational{T<:Integer} <: Real

Тип рационального числа, с числителем и знаменателем типа T.

Base.IrrationalТип

Irrational <: Real

Тип иррационального числа.

Форматы данных

Base.binФункция

bin(n, pad::Int=1)

Преобразовать целое число в двоичную строку, необязательно задав количество цифр для дополнения.

julia> bin(10,2)
"1010"

julia> bin(10,8)
"00001010"

Base.hexФункция

hex(n, pad::Int=1)

Преобразовать целое число в шестнадцатеричную строку, необязательно задав количество цифр для дополнения.

julia> hex(20)
"14"

julia> hex(20, 3)
"014"

Base.decФункция

dec(n, pad::Int=1)

Преобразовать целое число в десятичную строку, необязательно задав количество цифр для дополнения.

Примеры

julia> dec(20)
"20"

julia> dec(20, 3)
"020"

Base.octФункция

oct(n, pad::Int=1)

Преобразовать целое число в восьмеричную строку, необязательно задав количество цифр для дополнения.

julia> oct(20)
"24"

julia> oct(20, 3)
"024"

Base.baseФункция

base(base::Integer, n::Integer, pad::Integer=1)

Преобразовать целое число n в строку в заданном base, необязательно задав количество цифр для дополнения.

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

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

Base.digitsФункция

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

Возвращает массив с типом элементов T (по умолчанию Int) цифр n в заданном основании, необязательно дополненных нулями до заданного размера. Более значимые цифры находятся в индексах выше, так что n == sum([digits[k]*base^(k-1) for k=1:length(digits)]).

Примеры

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

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

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

Base.digits!Функция

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

Заполняет массив цифрами n в заданном основании. Более значимые цифры находятся в индексах с более высокими значениями. Если длина массива недостаточна, наименее значимые цифры заполняются до длины массива. Если длина массива избыточна, избыточная часть заполняется нулями.

Примеры

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

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

Base.bitsФункция

bits(n)

Строка, представляющая буквальное двоичное представление числа.

Пример

julia> bits(4)
"0000000000000000000000000000000000000000000000000000000000000100"

julia> bits(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

Base.parseМетод

parse(type, str, [base])

Парсинг строки в число. Если тип — целочисленный, можно указать основание (по умолчанию 10). Если тип — вещественный, строка парсится как десятичное число с плавающей точкой. Если строка не содержит корректного числа, возникает ошибка.

julia> parse(Int, "1234")
1234

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

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

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

Base.tryparseФункция

tryparse(type, str, [base])

Аналогично parse, но возвращает Nullable запрошенного типа. Результат будет нулевым, если строка не содержит корректного числа.

Base.bigФункция

big(x)

Преобразовать число в представление с максимальной точностью (обычно BigInt или BigFloat). См. BigFloat для информации о некоторых подводных камнях с числами с плавающей точкой.

Base.signedФункция

signed(x)

Преобразовать число в целое со знаком. Если аргумент беззнаковый, он переинтерпретируется как со знаком без проверки переполнения.

Base.unsignedФункция

unsigned(x) -> Unsigned

Преобразовать число в целое без знака. Если аргумент со знаком, он переинтерпретируется как без знака без проверки на отрицательные значения.

Примеры

julia> unsigned(-2)
0xfffffffffffffffe

julia> unsigned(2)
0x0000000000000002

julia> signed(unsigned(-2))
-2

Base.floatМетод

float(x)

Преобразование числа или массива в тип с плавающей точкой. При передаче строки эта функция эквивалентна parse(Float64, x).

Base.Math.significandФункция

significand(x)

Извлечь significand(s) (также известную как мантиссу) в двоичном представлении из числа с плавающей точкой. Если x — ненулевое конечное число, то результат будет числом того же типа на интервале $[1,2)$. Иначе возвращается x.

Примеры

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2

Base.Math.exponentФункция

exponent(x) -> Int

Получить показатель степени нормализованного числа с плавающей точкой.

Base.complexМетод

complex(r, [i])

Преобразование вещественных чисел или массивов в комплексные. i по умолчанию равно нулю.

Base.bswapФункция

bswap(n)

Перестановка байтов целого числа. Переворачивает биты его двоичного представления.

Примеры

julia> a = bswap(4)
288230376151711744

julia> bswap(a)
4

julia> bin(1)
"1"

julia> bin(bswap(1))
"100000000000000000000000000000000000000000000000000000000"

Base.num2hexФункция

num2hex(f)

Получение шестнадцатеричной строки двоичного представления числа с плавающей точкой.

Пример

julia> num2hex(2.2)
"400199999999999a"

Base.hex2numФункция

hex2num(str)

Преобразование шестнадцатеричной строки в число с плавающей точкой, которое она представляет.

Base.hex2bytesФункция

hex2bytes(s::AbstractString)

Преобразовать произвольно длинную шестнадцатеричную строку в её двоичное представление. Возвращает Array{UInt8,1}, т.е. массив байтов.

julia> a = hex(12345)
"3039"

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

Base.bytes2hexФункция

bytes2hex(bin_arr::Array{UInt8, 1}) -> String

Преобразовать массив байтов в его шестнадцатеричное представление. Все символы в нижнем регистре.

julia> a = hex(12345)
"3039"

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

julia> bytes2hex(b)
"3039"

Общие функции и константы для чисел

Base.oneФункция

one(x)
one(T::type)

Возвращает мультипликативную единицу для x: значение, такое что one(x)*x == x*one(x) == x. Кроме того, one(T) может принимать тип T, в этом случае one возвращает мультипликативную единицу для любого x типа T.

Если возможно, one(x) возвращает значение того же типа, что и x, а one(T) возвращает значение типа T. Однако это может быть не так для типов, представляющих величины с размерностью (например, время в днях), поскольку мультипликативная единица должна быть безразмерной. В этом случае one(x) должно возвращать значение единицы с той же точностью (и формой, для матриц), что и x.

Если вам нужна величина того же типа, что и x, или типа T, даже если x имеет размерность, используйте oneunit вместо этого.

julia> one(3.7)
1.0

julia> one(Int)
1

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

Base.oneunitФункция

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

Возвращает T(one(x)), где T — это либо тип аргумента, либо (если передан тип) сам аргумент. Это отличается от one для величин с размерностью: one безразмерна (мультипликативная единица), а oneunit имеет размерность (того же типа, что и x, или типа T).

julia> oneunit(3.7)
1.0

julia> oneunit(Dates.Day)
1 day

Base.zeroФункция

zero(x)

Получить аддитивную единицу для типа x (x также может указать сам тип).

julia> zero(1)
0

julia> zero(big"2.0")
0.000000000000000000000000000000000000000000000000000000000000000000000000000000

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

Base.piКонстанта

pi
π

Константа пи.

julia> pi
π = 3.1415926535897...

Base.imКонстанта

im

Мнимая единица.

Base.euКонстанта

e
eu

Константа е.

julia> e
e = 2.7182818284590...

Base.catalanКонстанта

catalan

Постоянная Каталана.

julia> catalan
catalan = 0.9159655941772...

Base.eulergammaКонстанта

γ
eulergamma

Постоянная Эйлера.

julia> eulergamma
γ = 0.5772156649015...

Base.goldenКонстанта

φ
golden

Золотое сечение.

julia> golden
φ = 1.6180339887498...

Base.InfКонстанта

Inf

Положительная бесконечность типа Float64.

Base.Inf32Константа

Inf32

Положительная бесконечность типа Float32.

Base.Inf16Константа

Inf16

Положительная бесконечность типа Float16.

Base.NaNКонстанта

NaN

Значение «не число» (NaN) типа Float64.

Base.NaN32Константа

NaN32

Значение «не число» (NaN) типа Float32.

Base.NaN16Константа

NaN16

Значение «не число» (NaN) типа Float16.

Base.issubnormalФункция

issubnormal(f) -> Bool

Проверка, является ли число с плавающей запятой субнормальным.

Base.isfiniteФункция

isfinite(f) -> Bool

Проверка, является ли число конечным.

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

Base.isinfФункция

isinf(f) -> Bool

Проверка, является ли число бесконечным.

Base.isnanФункция

isnan(f) -> Bool

Проверка, является ли число с плавающей запятой «не числом» (NaN).

Base.iszeroФункция

iszero(x)

Возвращает true, если x == zero(x); если x является массивом, проверяет, равны ли все элементы x нулю.

Base.nextfloatФункция

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

Результат n итерационных применений nextfloat к x, если n >= 0, или -n применений prevfloat, если n < 0.

nextfloat(x::AbstractFloat)

Возвращает наименьшее число с плавающей запятой y того же типа, что и x, такое что x < y. Если такого числа не существует (например, если x равно Inf или NaN), то возвращает x.

Base.prevfloatФункция

prevfloat(x::AbstractFloat)

Возвращает наибольшее число с плавающей запятой y того же типа, что и x, такое что y < x. Если такого числа не существует (например, если x равно -Inf или NaN ), то возвращает x.

Base.isintegerФункция

isinteger(x) -> Bool

Проверка, численно ли x равно целому числу.

julia> isinteger(4.0)
true

Base.isrealФункция

isreal(x) -> Bool

Проверка, численно ли x или все его элементы равны некоторому вещественному числу.

julia> isreal(5.)
true

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

Core.Float32Метод

Float32(x [, mode::RoundingMode])

Создание Float32 из x. Если x не представимо точно, то mode определяет, как x округляется.

Примеры

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

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

См. RoundingMode для доступных режимов округления.

Core.Float64Метод

Float64(x [, mode::RoundingMode])

Создание Float64 из x. Если x не представимо точно, то mode определяет, как x округляется.

Примеры

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

См. RoundingMode для доступных режимов округления.

Base.GMP.BigIntМетод

BigInt(x)

Создание целого числа произвольной точности. x может быть Int (или чем-либо, что может быть преобразовано в Int). Обычные математические операторы определены для этого типа, и результаты приводятся к типу BigInt.

Экземпляры могут быть созданы из строк с помощью parse или с использованием литерала строки big.

julia> parse(BigInt, "42")
42

julia> big"313"
313

Base.MPFR.BigFloatМетод

BigFloat(x)

Создание числа с плавающей запятой произвольной точности. x может быть Integer, Float64 или BigInt. Обычные математические операторы определены для этого типа, и результаты приводятся к типу BigFloat.

Обратите внимание, что, поскольку десятичные литералы преобразуются в числа с плавающей запятой при разборе, BigFloat(2.1) может не дать ожидаемого результата. Вместо этого вы можете предпочесть инициализировать константы из строк с помощью parse или с использованием литерала строки big.

julia> BigFloat(2.1)
2.100000000000000088817841970012523233890533447265625000000000000000000000000000

julia> big"2.1"
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

Base.Rounding.roundingФункция

rounding(T)

Получение текущего режима округления чисел с плавающей запятой для типа T, контролирующего округление основных арифметических функций (+, -, *, / и sqrt) и преобразование типов.

См. RoundingMode для доступных режимов.

Base.Rounding.setroundingМетод

setrounding(T, mode)

Установите режим округления для типа с плавающей запятой T, управляющий округлением основных арифметических функций (+, -, *, / и sqrt) и преобразованием типов. Другие числовые функции могут давать некорректные или недопустимые значения при использовании режимов округления, отличных от стандартного RoundNearest.

Обратите внимание, что это может повлиять и на другие типы, например, изменение режима округления для Float64 изменит режим округления для Float32. Доступные режимы см. в RoundingMode.

Base.Rounding.setroundingМетод

setrounding(f::Function, T, mode)

Изменить режим округления для типа с плавающей запятой T на время f. Логически эквивалентно:

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

Доступные режимы округления см. в RoundingMode.

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

julia> x = 1.1; y = 0.1;

julia> setrounding(Float64,RoundDown) do
           x + y
       end
1.2

Base.Rounding.get_zero_subnormalsФункция

get_zero_subnormals() -> Bool

Возвращает false, если операции с субнормальными значениями с плавающей запятой ("денормы") подчиняются правилам IEEE арифметики, и true, если они могут быть преобразованы в нули.

Base.Rounding.set_zero_subnormalsФункция

set_zero_subnormals(yes::Bool) -> Bool

Если yes равно false, последующие операции с плавающей запятой следуют правилам IEEE арифметики для субнормальных значений ("денормов"). В противном случае операции с плавающей запятой могут (но не обязаны) преобразовывать субнормальные входные или выходные значения в ноль. Возвращает true, если yes==true, но аппаратное обеспечение не поддерживает обнуление субнормальных чисел.

set_zero_subnormals(true) может ускорить некоторые вычисления на некоторых аппаратных платформах. Однако это может нарушить тождества, такие как (x-y==0) == (x==y).

Целые числа

Base.count_onesФункция

count_ones(x::Integer) -> Integer

Количество единиц в двоичном представлении x.

julia> count_ones(7)
3

Base.count_zerosФункция

count_zeros(x::Integer) -> Integer

Количество нулей в двоичном представлении x.

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

Base.leading_zerosФункция

leading_zeros(x::Integer) -> Integer

Количество нулей, стоящих в начале двоичного представления x.

julia> leading_zeros(Int32(1))
31

Base.leading_onesФункция

leading_ones(x::Integer) -> Integer

Количество единиц, стоящих в начале двоичного представления x.

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

Base.trailing_zerosФункция

trailing_zeros(x::Integer) -> Integer

Количество нулей, стоящих в конце двоичного представления x.

julia> trailing_zeros(2)
1

Base.trailing_onesФункция

trailing_ones(x::Integer) -> Integer

Количество единиц, стоящих в конце двоичного представления x.

julia> trailing_ones(3)
2

Base.isoddФункция

isodd(x::Integer) -> Bool

Возвращает true, если x нечётно (то есть не делится на 2), и false в противном случае.

julia> isodd(9)
true

julia> isodd(10)
false

Base.isevenФункция

iseven(x::Integer) -> Bool

Возвращает true, если x чётно (то есть делится на 2), и false в противном случае.

julia> iseven(9)
false

julia> iseven(10)
true

Большие числа с плавающей точкой

Тип BigFloat реализует арифметику чисел с плавающей точкой произвольной точности, используя библиотеку GNU MPFR.

Base.precisionФункция

precision(num::AbstractFloat)

Получение точности числа с плавающей запятой, определённой эффективным количеством бит в мантиссе.

Base.precisionМетод

precision(BigFloat)

Получение точности (в битах), используемой в настоящее время для арифметики BigFloat.

Base.MPFR.setprecisionФункция

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

Установить точность (в битах), которая должна использоваться для арифметики T.

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

Изменить точность арифметики T (в битах) на время f. Логически эквивалентно:

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

Часто используется как setprecision(T, precision) do ... end

Base.MPFR.BigFloatМетод

BigFloat(x, prec::Int)

Создать представление x как BigFloat с точностью prec.

Base.MPFR.BigFloatМетод

BigFloat(x, rounding::RoundingMode)

Создать представление x как BigFloat с текущей глобальной точностью и режимом округления rounding.

Base.MPFR.BigFloatМетод

BigFloat(x, prec::Int, rounding::RoundingMode)

Создать представление x как BigFloat с точностью prec и режимом округления rounding.

Base.MPFR.BigFloatМетод

BigFloat(x::String)

Создать представление строки x как BigFloat.

Случайные числа

Генерация случайных чисел в Julia использует библиотеку Mersenne Twister через объекты MersenneTwister. Julia имеет глобальный генератор случайных чисел (ГСЧ), который используется по умолчанию. Другие типы ГСЧ могут быть подключены, наследуя тип AbstractRNG; они затем могут быть использованы для получения нескольких потоков случайных чисел. Помимо MersenneTwister, Julia также предоставляет тип ГСЧ RandomDevice, который является оболочкой над предоставляемой ОС энтропией.

Большинство функций, связанных с генерацией случайных чисел, принимают необязательный AbstractRNG в качестве первого аргумента, rng, который по умолчанию является глобальным, если не указан. Кроме того, некоторые из них принимают необязательные спецификации размерности dims... (которые могут быть заданы как кортеж) для генерации массивов случайных значений.

ГСЧ типа MersenneTwister или RandomDevice может генерировать случайные числа следующих типов: Float16, Float32, Float64, Bool, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, BigInt (или комплексные числа этих типов). Случайные числа с плавающей запятой генерируются равномерно в $[0, 1)$. Поскольку BigInt представляет неограниченные целые числа, интервал должен быть указан (например, rand(big(1:6))).

Base.Random.srandФункция

srand([rng=GLOBAL_RNG], [seed]) -> rng
srand([rng=GLOBAL_RNG], filename, n=4) -> rng

Перезапустить генератор случайных чисел. Если seed указан, ГСЧ выдаст воспроизводимую последовательность чисел, иначе Julia получит энтропию из системы. Для MersenneTwister, seed может быть целым неотрицательным числом, вектором UInt32 целых чисел или именем файла, в котором случайное число считывается из файла (4n байт считывается из файла, где n является необязательным аргументом). RandomDevice не поддерживает инициализацию.

Base.Random.MersenneTwisterТип

MersenneTwister(seed)

Создает объект ГСЧ MersenneTwister. У разных объектов ГСЧ могут быть свои семена, что может быть полезно для генерации различных потоков случайных чисел.

Пример

julia> rng = MersenneTwister(1234);

Base.Random.RandomDeviceТип

RandomDevice()

Создает объект ГСЧ RandomDevice. Два таких объекта всегда будут генерировать разные потоки случайных чисел.

Base.Random.randФункция

rand([rng=GLOBAL_RNG], [S], [dims...])

Выбирает случайный элемент или массив случайных элементов из набора значений, указанных S; S может быть

• индексируемым набором (например, 1:n или ['x','y','z']), или

• типом: набор значений для выбора эквивалентен typemin(S):typemax(S) для целых чисел (это не относится к BigInt), и $[0, 1)$ для чисел с плавающей запятой;

S по умолчанию Float64.

Base.Random.rand!Функция

rand!([rng=GLOBAL_RNG], A, [coll])

Заполняет массив A случайными значениями. Если указан индексируемый набор coll, значения выбираются случайным образом из coll. Это эквивалентно copy!(A, rand(rng, coll, size(A))) или copy!(A, rand(rng, eltype(A), size(A))), но без выделения нового массива.

Пример

julia> rng = MersenneTwister(1234);

julia> rand!(rng, zeros(5))
5-element Array{Float64,1}:
 0.590845
 0.766797
 0.566237
 0.460085
 0.794026

Base.Random.bitrandФункция

bitrand([rng=GLOBAL_RNG], [dims...])

Генерирует BitArray случайных логических значений.

Пример

julia> rng = MersenneTwister(1234);

julia> bitrand(rng, 10)
10-element BitArray{1}:
  true
  true
  true
 false
  true
 false
 false
  true
 false
  true

Base.Random.randnФункция

randn([rng=GLOBAL_RNG], [T=Float64], [dims...])

Генерирует случайное число типа T с нормальным распределением со средним 0 и стандартным отклонением 1. Необязательно генерировать массив случайных чисел с нормальным распределением. Модуль Base в настоящее время предоставляет реализацию для типов Float16, Float32 и Float64 (по умолчанию).

Примеры

julia> rng = MersenneTwister(1234);

julia> randn(rng, Float64)
0.8673472019512456

julia> randn(rng, Float32, (2, 4))
2×4 Array{Float32,2}:
 -0.901744  -0.902914  2.21188   -0.271735
 -0.494479   0.864401  0.532813   0.502334

Base.Random.randn!Функция

randn!([rng=GLOBAL_RNG], A::AbstractArray) -> A

Заполняет массив A случайными числами с нормальным распределением (среднее 0, стандартное отклонение 1). Также см. функцию rand.

Пример

julia> rng = MersenneTwister(1234);

julia> randn!(rng, zeros(5))
5-element Array{Float64,1}:
  0.867347
 -0.901744
 -0.494479
 -0.902914
  0.864401

Base.Random.randexpФункция

randexp([rng=GLOBAL_RNG], [T=Float64], [dims...])

Генерирует случайное число типа T в соответствии с экспоненциальным распределением со масштабом 1. Необязательно генерирует массив таких случайных чисел. Модуль Base в настоящее время предоставляет реализацию для типов Float16, Float32 и Float64 (по умолчанию).

Примеры

julia> rng = MersenneTwister(1234);

julia> randexp(rng, Float32)
2.4835055f0

julia> randexp(rng, 3, 3)
3×3 Array{Float64,2}:
 1.5167    1.30652   0.344435
 0.604436  2.78029   0.418516
 0.695867  0.693292  0.643644

Base.Random.randexp!Функция

randexp!([rng=GLOBAL_RNG], A::AbstractArray) -> A

Заполняет массив A случайными числами, следующими экспоненциальному распределению (со масштабом 1).

Пример

julia> rng = MersenneTwister(1234);

julia> randexp!(rng, zeros(5))
5-element Array{Float64,1}:
 2.48351
 1.5167
 0.604436
 0.695867
 1.30652

Base.Random.randjumpФункция

randjump(r::MersenneTwister, jumps::Integer, [jumppoly::AbstractString=dSFMT.JPOLY1e21]) -> Vector{MersenneTwister}

Создает массив размера jumps инициализированных объектов MersenneTwister ГСЧ. Первый объект ГСЧ, заданный как параметр, и последующие объекты ГСЧ в массиве инициализируются таким образом, что состояние объекта ГСЧ в массиве будет сдвинуто вперёд (без генерации чисел) из предыдущего элемента массива RNG на определённое количество шагов, закодированных полиномом прыжка jumppoly.

По умолчанию полином прыжка сдвигает состояние ГСЧ MersenneTwister на 10^20 шагов.