Типы данных 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) |
Формы целочисленных литералов:
Пример
1
julia> 1234
1234
Тип по умолчанию для целочисленного литерала зависит от того, является ли целевая система 32-bit или 64-bit архитектурой (большинство современных систем — 64-bit):
Пример
julia> typeof(1)
Int32
# 64-bit система:
julia> typeof(1)
Int64
Встроенная переменная JuliaSys.WORD_SIZEуказывает, является ли целевая система 32-bit или 64-bit архитектурой:
Пример
julia> Sys.WORD_SIZE
32
# 64-bit система:
julia> Sys.WORD_SIZE
64
Julia также определяет типы Int и UInt, которые являются псевдонимами для знаковых и беззнаковых собственных целочисленных типов системы соответственно.
Пример
julia> Int
Int32
julia> UInt
UInt32
# 64-bit система:
julia> Int
Int64
julia> UInt
UInt64
Поведение при переполнении
В Julia превышение максимального значения, представимого типом, вызывает циклическое переполнение:
Пример
9223372036854775807
julia> x + 1
-9223372036854775808
julia> x + 1 == typemin(Int64)
истина
Следовательно, целочисленная арифметика Julia на самом деле представляет собой разновидность модульной арифметики, отражающую особенности реализации низкоуровневой арифметики современными компьютерами. В программах, где может возникнуть переполнение, необходимы явные проверки циклического переполнения на границах экстремальных значений. В противном случае в качестве альтернативы рекомендуется тип BigInt из арифметики произвольной точности.
Ниже приведён пример поведения при переполнении и способа устранения переполнения:
Пример
-8446744073709551616
julia> big(10)^19
10000000000000000000
Ошибки деления
Целочисленное деление вызывает DivideError в следующих двух исключительных случаях:- Деление на ноль
- Деление на наименьшее отрицательное число
remФункция остатка иmodфункция модуля выбрасывают DivideError при делении на ноль. Вот пример:
Пример
ОШИБКА: 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, чтобы выразить это.
Пример
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:
Пример
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:
Пример
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)
Знак подчёркивания_можно использовать в качестве разделителя цифр:
Пример
(10000, 5.0e-9, 0xdeadbeef, 0xb2)
Ноль в числах с плавающей запятой
Числа с плавающей запятой имеют два вида нуля: положительный ноль и отрицательный ноль. Они равны друг другу, но имеют разные двоичные представления, которые можно посмотреть с помощью функции bitstring:
Пример
истина
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) |
Ниже приведены некоторые примеры операций над числами с плавающей запятой:
Пример
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:
Пример
(-Inf16, Inf16)
julia> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)
julia> (typemin(Float64),typemax(Float64))
(-Inf, Inf)
Машинная точность
Большинство вещественных чисел не могут быть точно представлены числами с плавающей запятой, поэтому необходимо знать расстояние между двумя соседними представимыми числами с плавающей запятой, которое обычно называется машинной точностью.
Julia предоставляет функциюeps, которая возвращает разницу между 1.0 и следующим числом с плавающей запятой, которое может представить Julia:
Пример
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:
Пример
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, которые возвращают соответственно следующее большее или меньшее представимое число с плавающей запятой в зависимости от аргумента:
Пример
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, что означает округление до ближайшего представимого значения, при этом округлённое значение использует как можно меньше значащих цифр.
Пример
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 |
Эти функции можно использовать в числовых сравнениях, чтобы избежать накладных расходов на ненужные преобразования типов.
Например:
Пример
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))сокращённая форма.
Пример
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)
Трассировка стека:
[...]