Целые и числа с плавающей точкой

Целые и числа с плавающей точкой являются основными строительными блоками арифметики и вычислений. Встроенные представления таких значений называются числовыми примитивами, а представления целых и чисел с плавающей точкой как непосредственных значений в коде известны как числовые литералы. Например, 1 — это целочисленный литерал, а 1.0 — литерал числа с плавающей точкой; их двоичные представления в памяти как объекты являются числовыми примитивами.

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

Ниже приведены примитивные числовые типы Julia:

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

• Числа с плавающей точкой:

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

Целые числа

Литералы целых чисел представлены стандартным способом:

julia> 1
1

julia> 1234
1234

По умолчанию тип целочисленного литерала зависит от того, имеет ли целевая система 32-битную или 64-битную архитектуру:

# 32-bit system:
julia> typeof(1)
Int32

# 64-bit system:
julia> typeof(1)
Int64

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

# 32-bit system:
julia> Sys.WORD_SIZE
32

# 64-bit system:
julia> Sys.WORD_SIZE
64

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

# 32-bit system:
julia> Int
Int32
julia> UInt
UInt32

# 64-bit system:
julia> Int
Int64
julia> UInt
UInt64

Более крупные целочисленные литералы, которые нельзя представить с помощью только 32 бит, но которые можно представить в 64 бита, всегда создают 64-битные целые числа независимо от типа системы:

# 32-bit or 64-bit system:
julia> typeof(3000000000)
Int64

Беззнаковые целые числа вводятся и выводятся с префиксом 0x и шестнадцатеричными (основание 16) цифрами 0-9a-f (заглавные цифры A-F также работают для ввода). Размер беззнакового значения определяется количеством использованных шестнадцатеричных цифр:

julia> 0x1
0x01

julia> typeof(ans)
UInt8

julia> 0x123
0x0123

julia> typeof(ans)
UInt16

julia> 0x1234567
0x01234567

julia> typeof(ans)
UInt32

julia> 0x123456789abcdef
0x0123456789abcdef

julia> typeof(ans)
UInt64

julia> 0x11112222333344445555666677778888
0x11112222333344445555666677778888

julia> typeof(ans)
UInt128

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

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

Также поддерживаются двоичные и восьмеричные литералы:

julia> 0b10
0x02

julia> typeof(ans)
UInt8

julia> 0o010
0x08

julia> typeof(ans)
UInt8

julia> 0x00000000000000001111222233334444
0x00000000000000001111222233334444

julia> typeof(ans)
UInt128

Что касается шестнадцатеричных литералов, двоичные и восьмеричные литералы производят беззнаковые целые типы. Размер двоичного элемента данных — минимально необходимый размер, если ведущая цифра литерала не 0. В случае ведущих нулей размер определяется минимально необходимым размером для литерала, который имеет такую ​​же длину, но ведущая цифра 1. Это позволяет пользователю контролировать размер. Значения, которые не могут быть сохранены в UInt128, не могут быть записаны как такие литералы.

Двоичные, восьмеричные и шестнадцатеричные литералы могут быть со знаком - непосредственно перед беззнаковым литералом. Они производят беззнаковое целое число того же размера, что и беззнаковый литерал, со значением обратного дополнения:

julia> -0x2
0xfe

julia> -0x0002
0xfffe

Минимальные и максимальные представимые значения примитивных числовых типов, таких как целые числа, задаются функциями typemin и typemax:

julia> (typemin(Int32), typemax(Int32))
(-2147483648, 2147483647)

julia> for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128]
           println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
       end
   Int8: [-128,127]
  Int16: [-32768,32767]
  Int32: [-2147483648,2147483647]
  Int64: [-9223372036854775808,9223372036854775807]
 Int128: [-170141183460469231731687303715884105728,170141183460469231731687303715884105727]
  UInt8: [0,255]
 UInt16: [0,65535]
 UInt32: [0,4294967295]
 UInt64: [0,18446744073709551615]
UInt128: [0,340282366920938463463374607431768211455]

Значения, возвращаемые функциями typemin и typemax, всегда имеют указанный тип аргумента. (Вышеприведенное выражение использует несколько функций, которые мы еще не представили, включая циклы for, строки и интерполяцию, но должно быть достаточно понятным для пользователей с некоторым опытом программирования.)

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

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

julia> x = typemax(Int64)
9223372036854775807

julia> x + 1
-9223372036854775808

julia> x + 1 == typemin(Int64)
true

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

Ошибки при делении

Целочисленное деление (функция div) имеет два исключительных случая: деление на ноль и деление наименьшего отрицательного числа (typemin) на -1. В обоих этих случаях выбрасывается DivideError. Функции остатка и модуля (rem и mod) выбрасывают DivideError, когда их второй аргумент равен нулю.

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

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

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

Все приведенные выше результаты являются значениями Float64. Литералы Float32 могут быть введены, написав f вместо e.

julia> 0.5f0
0.5f0

julia> typeof(ans)
Float32

julia> 2.5f-4
0.00025f0

Значения легко преобразуются в Float32:

julia> Float32(-1.5)
-1.5f0

julia> typeof(ans)
Float32

Шестнадцатеричные литералы чисел с плавающей точкой также допустимы, но только как значения Float64, с p перед экспонентой в двоичной системе:

julia> 0x1p0
1.0

julia> 0x1.8p3
12.0

julia> 0x.4p-1
0.125

julia> typeof(ans)
Float64

Также поддерживаются числа с плавающей точкой с половинной точностью (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
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

Специальные значения чисел с плавающей точкой

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

Для дальнейшего обсуждения порядка этих бесконечных значений с плавающей точкой по отношению друг к другу и к другим числам с плавающей точкой см. Числовые сравнения. По стандарту IEEE 754 эти значения с плавающей точкой являются результатом определенных арифметических операций:

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

Функции 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> eps(Float32)
1.1920929f-7

julia> eps(Float64)
2.220446049250313e-16

julia> eps() # same as eps(Float64)
2.220446049250313e-16

Эти значения равны 2.0^-23 и 2.0^-52 как значения Float32 и 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 бита.

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"

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

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

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

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

Обзор и ссылки

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

• Определяющим руководством по арифметике с плавающей точкой является стандарт IEEE 754-2008; однако он недоступен для бесплатного онлайн-доступа.
• Для краткого, но ясного представления о том, как представляются числа с плавающей точкой, см. статью Джона Д. Кука о данной теме, а также его введение в некоторые проблемы, возникающие из-за того, как это представление отличается по поведению от идеализированной абстракции действительных чисел.
• Также рекомендуется серия блогов Брюса Доусона о числах с плавающей точкой.
• Для отличного углубленного обсуждения чисел с плавающей точкой и проблем точности вычислений с ними см. статью Дэвида Голдберга Что каждый компьютерный учёный должен знать об арифметике с плавающей точкой.
• Для более подробного анализа истории, обоснования и проблем с числами с плавающей точкой, а также для обсуждения многих других тем в области вычислительной математики, см. собранные труды Уильяма Кахана, известного как «отец арифметики с плавающей точкой». Особого внимания заслуживает интервью со стариком арифметики с плавающей точкой.

Арифметика с произвольной точностью

Для возможности вычислений с целыми числами и числами с плавающей точкой произвольной точности Julia использует GNU Многоточную библиотеку арифметики (GMP) и GNU MPFR библиотеку соответственно. Типы BigInt и BigFloat доступны в Julia для целых чисел и чисел с плавающей точкой произвольной точности соответственно.

Конструкторы существуют для создания этих типов из примитивных числовых типов, и parse может использоваться для их построения из AbstractString. После создания они участвуют в арифметических операциях со всеми другими числовыми типами благодаря механизму преобразования и продвижения типов Julia:

julia> BigInt(typemax(Int64)) + 1
9223372036854775808

julia> parse(BigInt, "123456789012345678901234567890") + 1
123456789012345678901234567891

julia> parse(BigFloat, "1.23456789012345678901")
1.234567890123456789010000000000000000000000000000000000000000000000000000000004

julia> BigFloat(2.0^66) / 3
2.459565876494606882133333333333333333333333333333333333333333333333333333333344e+19

julia> factorial(BigInt(40))
815915283247897734345611269596115894272000000000

Однако продвижение типов между примитивными типами выше и BigInt/BigFloat не является автоматическим и должно быть явно указано.

julia> x = typemin(Int64)
-9223372036854775808

julia> x = x - 1
9223372036854775807

julia> typeof(x)
Int64

julia> y = BigInt(typemin(Int64))
-9223372036854775808

julia> y = y - 1
-9223372036854775809

julia> typeof(y)
BigInt

По умолчанию точность (в количестве битов мантиссы) и режим округления операций с BigFloat могут быть изменены глобально, вызвав setprecision и setrounding, и все дальнейшие вычисления учтут эти изменения. В качестве альтернативы, точность или режим округления могут быть изменены только в рамках выполнения определённого блока кода с помощью тех же функций с do блоком:

julia> setrounding(BigFloat, RoundUp) do
           BigFloat(1) + parse(BigFloat, "0.1")
       end
1.100000000000000000000000000000000000000000000000000000000000000000000000000003

julia> setrounding(BigFloat, RoundDown) do
           BigFloat(1) + parse(BigFloat, "0.1")
       end
1.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> setprecision(40) do
           BigFloat(1) + parse(BigFloat, "0.1")
       end
1.1000000000004

Числовые литеральные коэффициенты

Для повышения ясности общих числовых формул и выражений Julia позволяет переменным сразу предшествовать числовому литералу, подразумевая умножение. Это делает написание полиномиальных выражений более удобным:

julia> x = 3
3

julia> 2x^2 - 3x + 1
10

julia> 1.5x^2 - .5x + 1
13.0

Это также делает запись экспоненциальных функций более элегантной:

julia> 2^2x
64

Приоритет числовых литеральных коэффициентов немного ниже, чем у унарных операторов, таких как отрицание. Поэтому -2x интерпретируется как (-2) * x, а √2x интерпретируется как (√2) * x. Однако числовые литеральные коэффициенты интерпретируются аналогично унарным операторам при совместном использовании с возведением в степень. Например, 2^3x интерпретируется как 2^(3x), а 2x^3 интерпретируется как 2*(x^3).

Числовые литералы также работают как коэффициенты для выражений в скобках:

julia> 2(x-1)^2 - 3(x-1) + 1
3

Кроме того, скобочные выражения могут использоваться в качестве коэффициентов для переменных, подразумевая умножение выражения на переменную:

julia> (x-1)x
6

Однако ни склеивание двух выражений в скобках, ни размещение переменной перед выражением в скобках не могут использоваться для подразумеваемого умножения:

julia> (x-1)(x+1)
ERROR: MethodError: objects of type Int64 are not callable

julia> x(x+1)
ERROR: MethodError: objects of type Int64 are not callable

Оба выражения интерпретируются как применение функций: любое выражение, которое не является числовым литералом, когда сразу за ним следует скобочное выражение, интерпретируется как применение функции к значениям в скобках (подробнее о функциях см. Функции). Таким образом, в обоих этих случаях возникает ошибка, поскольку левое значение не является функцией.

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

Синтаксические конфликты

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

• Шестнадцатеричный целочисленный литерал 0xff может быть интерпретирован как числовой литерал 0, умноженный на переменную xff.
• Литерал с плавающей точкой 1e10 может быть интерпретирован как числовой литерал 1, умноженный на переменную e10, и аналогично с эквивалентной формой E.
• Литерал 32-битного числа с плавающей точкой 1.5f22 может быть интерпретирован как числовой литерал 1.5, умноженный на переменную f22.

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

• Выражения, начинающиеся с 0x всегда являются шестнадцатеричными литералами.
• Выражения, начинающиеся с числового литерала, за которым следуют e или E всегда являются литералами чисел с плавающей точкой.
• Выражения, начинающиеся с числового литерала, за которым следует f всегда являются литералами 32-битных чисел с плавающей точкой.

В отличие от E, что эквивалентно e в числовых литералах по историческим причинам, F — это просто еще одна буква и не ведет себя как f в числовых литералах. Следовательно, выражения, начинающиеся с числового литерала, за которым следует F, интерпретируются как числовой литерал, умноженный на переменную, что означает, например, что 1.5F22 равно 1.5 * F22.

Литералы ноль и один

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

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

Примеры:

julia> zero(Float32)
0.0f0

julia> zero(1.0)
0.0

julia> one(Int32)
1

julia> one(BigFloat)
1.0