Типы данных Julia

В языках программирования существуют базовые математические операции и научные вычисления. Их обычно используемые типы данных — этоцелые числаис плавающей запятойчисла.

Кроме того, существует также"литерал"термин. Литерал — это нотация, используемая для выражения фиксированного значения в исходном коде. Целые числа, числа с плавающей запятой, строки и т.д. — все они являются литералами.

Например:

a=1 // a - переменная, 1 - целочисленный литерал b=1.0 // b - переменная, 1.0 - литерал с плавающей запятой

Julia предоставляет богатый набор примитивных числовых типов и определяет полный набор арифметических операций на их основе. Кроме того, она также предоставляет побитовые операторы и некоторые стандартные математические функции.


Целочисленные типы

В следующей таблице перечислены целочисленные типы, поддерживаемые Julia:

Type Со знаком? Количество бит Минимальное значение Максимальное значение
Int8 ✓ 8 -2^7 2^7 – 1
UInt8 8 0 2^8 – 1
Int16 ✓ 16 -2^15 2^15 – 1
UInt16 16 0 2^16 – 1
Int32 ✓ 32 -2^31 2^31 – 1
UInt32 32 0 2^32 – 1
Int64 ✓ 64 -2^63 2^63 – 1
UInt64 64 0 2^64 – 1
Int128 ✓ 128 -2^127 2^127 – 1
UInt128 128 0 2^128 – 1
Bool N/A 8 false (0) true (1)

Формы целочисленных литералов:

Пример

julia> 1
1

julia> 1234
1234

Тип по умолчанию для целочисленного литерала зависит от того, является ли целевая система 32-bit или 64-bit архитектурой (большинство современных систем — 64-bit):

Пример

# 32-bit система:
julia> typeof(1)
Int32

# 64-bit система:
julia> typeof(1)
Int64

Встроенная переменная JuliaSys.WORD_SIZEуказывает, является ли целевая система 32-bit или 64-bit архитектурой:

Пример

# 32-bit система:
julia> Sys.WORD_SIZE
32

# 64-bit система:
julia> Sys.WORD_SIZE
64

Julia также определяет типы Int и UInt, которые являются псевдонимами для знаковых и беззнаковых собственных целочисленных типов системы соответственно.

Пример

# 32-bit система:
julia> Int
Int32
julia> UInt
UInt32

# 64-bit система:
julia> Int
Int64
julia> UInt
UInt64

Поведение при переполнении

В Julia превышение максимального значения, представимого типом, вызывает циклическое переполнение:

Пример

julia> x = typemax(Int64)
9223372036854775807

julia> x + 1
-9223372036854775808

julia> x + 1 == typemin(Int64)
истина

Следовательно, целочисленная арифметика Julia на самом деле представляет собой разновидность модульной арифметики, отражающую особенности реализации низкоуровневой арифметики современными компьютерами. В программах, где может возникнуть переполнение, необходимы явные проверки циклического переполнения на границах экстремальных значений. В противном случае в качестве альтернативы рекомендуется тип BigInt из арифметики произвольной точности.

Ниже приведён пример поведения при переполнении и способа устранения переполнения:

Пример

julia> 10^19
-8446744073709551616

julia> big(10)^19
10000000000000000000

Ошибки деления

Целочисленное деление вызывает DivideError в следующих двух исключительных случаях:
  • Деление на ноль
  • Деление на наименьшее отрицательное число

remФункция остатка иmodфункция модуля выбрасывают DivideError при делении на ноль. Вот пример:

Пример

julia> mod(1, 0)
ОШИБКА: DivideError: ошибка целочисленного деления
Трассировка стека:
 [1] div at .\int.jl:260 [inlined]
 [2] div at .\div.jl:217 [inlined]
 [3] div at .\div.jl:262 [inlined]
 [4] fld at .\div.jl:228 [inlined]
 [5] mod(::Int64, ::Int64) at .\int.jl:252
 [6] область верхнего уровня в REPL[52]:1
 
 
julia> rem(1, 0)
ОШИБКА: DivideError: ошибка целочисленного деления
Трассировка стека:
 [1] rem(::Int64, ::Int64) at .\int.jl:261
 [2] область верхнего уровня в REPL[54]:1

Типы с плавающей запятой

В следующей таблице перечислены типы с плавающей запятой, поддерживаемые Julia:

Type Precision Количество бит
Float16 Половинная точность 16
Float32 Одинарная точность 32
Float64 Двойная точность 64

Кроме того, полная поддержка комплексных и рациональных чисел построена на основе этих примитивных типов данных.

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

Пример

julia> 1.0
1.0

julia> 1.
1.0

julia> 0.5
0.5

julia> .5
0.5

julia> -1.23
-1.23

julia> 1e10
1.0e10

julia> 2.5e-4
0.00025

Примечание:

В научной нотации, чтобы упростить формулы, можно использовать формат сEдля представления. Например, 1.03 умножить на 10 в 8-й степени можно сокращённо записать как "1.03E+08", где "E" — сокращение от экспоненты.

Приведённые выше результаты — все значения Float64. Использование f вместо e даёт литералы Float32:

Пример

julia> x = 0.5f0
0.5f0

julia> typeof(x)
Float32

julia> 2.5f-4
0.00025f0
Числа можно легко преобразовать вFloat32тип:

julia> x = Float32(-1.5)
-1.5f0

julia> typeof(x)
Float32

Существуют также шестнадцатеричные литералы с плавающей запятой, но они применимы только к значениям типа Float64. Обычно они представляются с использованием префикса p и экспоненты по основанию 2:

Пример

julia> 0x1p0
1.0

julia> 0x1.8p3
12.0

julia> x = 0x.4p-1
0.125

julia> typeof(x)
Float64
Julia также поддерживает числа с плавающей запятой половинной точности (Float16), но ониFloat32реализованы через программную эмуляцию.

julia> sizeof(Float16(4.))
2

julia> 2*Float16(4.)
Float16(8.0)

Знак подчёркивания_можно использовать в качестве разделителя цифр:

Пример

julia> 10_000, 0.000_000_005, 0xdead_beef, 0b1011_0010
(10000, 5.0e-9, 0xdeadbeef, 0xb2)

Ноль в числах с плавающей запятой

Числа с плавающей запятой имеют два вида нуля: положительный ноль и отрицательный ноль. Они равны друг другу, но имеют разные двоичные представления, которые можно посмотреть с помощью функции bitstring:

Пример

julia> 0.0 == -0.0
истина

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

Особые значения с плавающей запятой

Существуют три особых стандартных значения с плавающей запятой, которые не соответствуют ни одной точке на вещественной числовой прямой:

Float16 Float32 Float64 Name Описание
Inf16 Inf32 Inf Положительная бесконечность Namba tamainit naammaktunit floating-point nambanit anginerusuk
-Inf16 -Inf32 -Inf Inf nukitaq Namba tamainit naammaktunit floating-point nambanit mikinerusuk
NaN16 NaN32 NaN Не число Nalliut taanna floating-point nalliutimut (==) atausimangitsoq (imminik ilaliutigillugu)

Ниже приведены некоторые примеры операций над числами с плавающей запятой:

Пример

julia> 1/Inf
0.0

julia> 1/0
Inf

julia> -5/0
-Inf

julia> 0.000001/0
Inf

julia> 0/0
NaN

julia> 500 + Inf
Inf

julia> 500 - Inf
-Inf

julia> Inf + Inf
Inf

julia> Inf - Inf
NaN

julia> Inf * Inf
Inf

julia> Inf / Inf
NaN

julia> 0 * Inf
NaN

julia> NaN == NaN
false

julia> NaN != NaN
истина

julia> NaN < NaN
false

julia> NaN > NaN
false

Мы также можем использовать функции typemin и typemax:

Пример

julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)

julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)

julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)

Машинная точность

Большинство вещественных чисел не могут быть точно представлены числами с плавающей запятой, поэтому необходимо знать расстояние между двумя соседними представимыми числами с плавающей запятой, которое обычно называется машинной точностью.

Julia предоставляет функциюeps, которая возвращает разницу между 1.0 и следующим числом с плавающей запятой, которое может представить Julia:

Пример

julia> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

julia> eps() # То же, что eps(Float64)
2.220446049250313e-16

Эти значения равны 2.0^-23 в Float32 и 2.0^-52 в Float64 соответственно. Функция eps также может принимать значение с плавающей запятой в качестве аргумента и возвращать абсолютную разницу между этим значением и следующим представимым значением с плавающей запятой. То есть eps(x) возвращает значение того же типа, что и x, а x + eps(x) — это ровно следующее представимое значение с плавающей запятой, большее x:

Пример

julia> eps(1.0)
2.220446049250313e-16

julia> eps(1000.)
1.1368683772161603e-13

julia> eps(1e-27)
1.793662034335766e-43

julia> eps(0.0)
5.0e-324

Расстояние между двумя соседними представимыми числами с плавающей запятой не постоянно: чем меньше число, тем меньше промежуток; чем больше число, тем больше промежуток. Иными словами, представимые числа с плавающей запятой наиболее плотно расположены вблизи нуля на вещественной числовой прямой и становятся всё более разреженными экспоненциально по мере удаления от нуля. По определению, eps(1.0) равно eps(Float64), поскольку 1.0 — это 64-bit значение с плавающей запятой.

Julia также предоставляет две функции, nextfloat и prevfloat, которые возвращают соответственно следующее большее или меньшее представимое число с плавающей запятой в зависимости от аргумента:

Пример

julia> x = 1.25f0
1.25f0

julia> nextfloat(x)
1.2500001f0

julia> prevfloat(x)
1.2499999f0

julia> bitstring(prevfloat(x))
"00111111100111111111111111111111"

julia> bitstring(x)
"00111111101000000000000000000000"

julia> bitstring(nextfloat(x))
"00111111101000000000000000000001"

Этот пример иллюстрирует общий принцип: соседние представимые числа с плавающей запятой также имеют соседние двоичные целочисленные представления.


Режимы округления

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

Режим по умолчанию, используемый Julia, всегдаRoundNearest, что означает округление до ближайшего представимого значения, при этом округлённое значение использует как можно меньше значащих цифр.

Пример

julia> BigFloat("1.510564889",2,RoundNearest)
1.5

julia> BigFloat("1.550564889",2,RoundNearest)
1.5

julia> BigFloat("1.560564889",2,RoundNearest)
1.5

Литералы нуля и единицы

Julia предоставляет функции литералов для 0 и 1, которые могут возвращать литерал определённого типа или тип заданной переменной.

ФункцияОписание
zero(x)Литерал нуля типа x или типа переменной x
one(x)Литерал единицы типа x или типа переменной x

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

Например:

Пример

julia> zero(Float32)
0.0f0

julia> zero(1.0)
0.0

julia> one(Int32)
1

julia> one(BigFloat)
1.0

Преобразование типов

Преобразование типов — это процесс преобразования переменной из одного типа в другой тип данных. Например, если вы хотите сохранить значение с плавающей запятой в простом целом числе, необходимо привести тип float к типу int. Вы можете использовать оператор приведения для явного преобразования значения из одного типа в другой, как показано ниже:

Julia поддерживает три вида числового преобразования, которые различаются обработкой неточных преобразований.

Первый вид:

T(x) 
或
convert(T,x) 

Все вышеперечисленные преобразуют x в тип T.

  • Если T — тип с плавающей запятой, результатом является ближайшее представимое значение, которое может быть положительной или отрицательной бесконечностью.
  • Если T — целочисленный тип, то при невозможности представить x типом T выбрасывается InexactError.

Второй вид:

x % TТакже возможно преобразовать целое число x в целочисленный тип T в соответствии с результатом x по модулю 2^n, где n — количество битов в T.

Третий вид:

Функции округления принимают необязательный аргумент типа T. Например, round(Int,x) — этоInt(round(x))сокращённая форма.

Пример

julia> Int8(127)
127

julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Трассировка стека:
[...]

julia> Int8(127.0)
127

julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Трассировка стека:
[...]

julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Трассировка стека:
[...]

julia> 127 % Int8
127

julia> 128 % Int8
-128

julia> round(Int8,127.4)
127

julia> round(Int8,127.6)
ERROR: InexactError: trunc(Int8, 128.0)
Трассировка стека:
[...]
Другие расширения