Числа

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

Bool Int8 UInt8 Int16 UInt16 Int32 UInt32 Int64 UInt64 Int128 UInt128 Float16 Float32 Float64 Complex64 Complex128

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

bin(n[, pad])

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

hex(n[, pad])

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

dec(n[, pad])

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

oct(n[, pad])

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

base(base, n[, pad])

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

digits([T, ]n[, base][, pad])

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

digits!(array, n[, base])

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

bits(n)

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

parse(type, str[, base])

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

tryparse(type, str[, base])

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

big(x)

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

signed(x)

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

unsigned(x) → Unsigned

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

float(x)

Преобразовать число, массив или строку в тип данных AbstractFloat. Для числовых данных используется наименьший подходящий тип AbstractFloat. Преобразует строки в Float64.

significand(x)

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

julia> significand(15.2)/15.2
0.125

julia> significand(15.2)*8
15.2

exponent(x) → Int

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

complex(r[, i])

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

bswap(n)

Переставить байты целого числа.

num2hex(f)

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

hex2num(str)

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

hex2bytes(s::AbstractString)

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

bytes2hex(bin_arr::Array{UInt8, 1})

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

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

one(x)

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

zero(x)

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

pi

π

Постоянная пи.

im

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

e

eu

Постоянная е.

catalan

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

γ

eulergamma

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

φ

golden

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

Inf

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

Inf32

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

Inf16

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

NaN

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

NaN32

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

NaN16

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

issubnormal(f) → Bool

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

isfinite(f) → Bool

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

isinf(f) → Bool

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

isnan(f) → Bool

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

nextfloat(x::AbstractFloat)

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

prevfloat(x::AbstractFloat)

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

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

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

isinteger(x) → Bool

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

isreal(x) → Bool

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

isimag(z) → Bool

Проверить, является ли z чисто мнимым, т.е. имеет действительную часть равную 0.

Float32(x[, mode::RoundingMode])

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

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

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

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

Float64(x[, mode::RoundingMode])

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

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

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

BigInt(x)

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

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

BigFloat(x)

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

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

julia> BigFloat(2.1)
2.100000000000000088817841970012523233890533447265625000000000000000000000000000

julia> big"2.1"
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

rounding(T)

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

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

setrounding(T, mode)

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

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

Предупреждение

Эта функция всё ещё находится в стадии разработки и может давать неожиданные или неверные значения.

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

get_zero_subnormals() → Bool

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

set_zero_subnormals(yes::Bool) → Bool

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

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

Целые числа

count_ones(x::Integer) → Integer

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

julia> count_ones(7)
3

count_zeros(x::Integer) → Integer

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

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

leading_zeros(x::Integer) → Integer

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

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) → Integer

Количество единиц, предшествующих двоичному представлению x.

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

trailing_zeros(x::Integer) → Integer

Количество нулей, следующих за двоичным представлением x.

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) → Integer

Количество единиц, следующих за двоичным представлением x.

julia> trailing_ones(3)
2

isodd(x::Integer) → Bool

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

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Integer) → Bool

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

julia> iseven(9)
false

julia> iseven(10)
true

BigFloats

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

precision(num::AbstractFloat)

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

precision(BigFloat)

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

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

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

Генерация случайных чисел в 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))).

srand([rng][, seed])

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

MersenneTwister([seed])

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

RandomDevice()

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

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

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

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

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

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

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

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

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

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

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

randn!([rng, ]A::AbstractArray) → A

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

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

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

randexp!([rng, ]A::AbstractArray) → A

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

randjump(r::MersenneTwister, jumps[, jumppoly]) → Vector{MersenneTwister}

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

Полином перехода по умолчанию сдвигает состояние RNG на 10^20 шагов вперёд.