Целые числа и числа с плавающей запятой · Язык Julia

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

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

9128 — 1 Bool Н/Д 8 ложь (0) правда (1)

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

900 19

Тип	Точность	Количество битов
Плавающая16	половина	16
Плавающий32	одинарный	32
Float64	double	64

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

Буквенные целые числа представляются стандартным образом:

 julia> 1
1
юлия> 1234
1234 

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

 # 32-битная система:
юлия> typeof(1)
Int32
# 64-битная система:
юлия> typeof(1)
Int64 

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

 # 32-разрядная система:
юлия> Sys.WORD_SIZE
32
# 64-битная система:
юлия> Sys.WORD_SIZE
64 

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

 # 32-битная система:
Юлия> Инт
Int32
Юлия> UInt
UInt32
# 64-битная система:
Юлия>  Инт
Int64
Юлия> UInt
UInt64 

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

 # 32-битная или 64-битная система:
юлия> typeof(3000000000)
Int64 

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

 julia> x = 0x1
0x01
Юлия> typeof(x)
UInt8
юлия> х = 0x123
0x0123
Юлия> typeof(x)
UInt16
Юлия> х = 0x1234567
0x01234567
Юлия> typeof(x)
UInt32
Юлия> х = 0x123456789abcdef
0x0123456789abcdef
Юлия> typeof(x)
UInt64
Юлия> х = 0x111122223333344445555666677778888
0x11112222333344445555666677778888
Юлия> typeof(x)
UInt128 

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

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

 julia> x = 0b10
0x02
Юлия> typeof(x)
UInt8
юлия> х = 0o010
0x08
Юлия> typeof(x)
UInt8
Юлия> х = 0x00000000000000001111222233334444
0x00000000000000001111222233334444
Юлия> typeof(x)
UInt128 

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

• 0x1 и 0x12 являются литералами UInt8 ,
• 0x123 и 0x1234 UInt16 литералы,
• 0x12345 и 0x12345678 UInt32 литералы,
• 0x123456789 и 0x1234567890adcdef являются UInt64 литералы и т. д.

Даже если есть начальные нулевые цифры, которые не влияют на значение, они учитываются при определении размера хранилища литерала. Итак, 0x01 — это UInt8 , а 0x0001 — это UInt16 .

Позволяет пользователю контролировать размер.

Литералы без знака (начиная с 0x ), которые кодируют целые числа, слишком большие для представления в виде значений UInt128 , вместо этого будут создавать значения

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

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

 Юлия> -0x2
0xfe
юлия> -0x0002
0xfffe 

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

 julia> (typemin(Int32), typemax(Int32))
(-2147483648, 2147483647)
julia> для T в [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128]
           println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
       конец
   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
юлия> х + 1
-9223372036854775808
julia> x + 1 == typemin(Int64)
true 

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

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

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

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

 юлия > 1.0
1,0
Юлия> 1.
1,0
юлия > 0,5
0,5
юлия> .5
0,5
юлия > -1.23
-1,23
юлия> 1e10
1.0e10
юлия> 2.5e-4
0,00025 

Приведенные выше результаты представляют собой все значения Float64 . Значения Literal Float32 можно ввести, написав f вместо e :

 julia> x = 0.5f0
0.5f0
Юлия> typeof(x)
Поплавок32
юлия> 2.5f-4
0.00025f0 

Значения можно легко преобразовать в Float32 :

 julia> x = Float32(-1.5)
-1.5f0
Юлия> typeof(x)
Float32 

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

 julia> 0x1p0
1,0
юлия> 0x1. 8p3
12,0
юлия> х = 0x.4p-1
0,125
Юлия> typeof(x)
Float64 

Числа с плавающей запятой половинной точности также поддерживаются (

Float16 ), но они реализованы в программном обеспечении и используют Float32 для вычислений.

 юлия> sizeof(Float16(4.))
2
Юлия> 2*Float16(4.)
Float16(8.0) 

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

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

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

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

 юлия> 0,0 == -0,0
истинный
юлия> битовая строка (0.0)
"00000000000000000000000000000000000000000000000000000000000000000"
юлия> битовая строка (-0.0)
"10000000000000000000000000000000000000000000000000000000000000000" 

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

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

90 030

Плавающая 16	Плавающая 32	Плавающая 64	Имя	Описание
Инф16	Инф32	Инф 90 004	положительная бесконечность	значение больше всех конечных значений с плавающей запятой
-Inf16	-Inf32	-Inf	минус бесконечность	значение меньше всех конечных значений с плавающей запятой
NaN16	NaN32	NaN	не число	значение не == к любому значению с плавающей запятой (включая само себя)

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

 julia> 1/Inf
0,0
юлия> 1/0
Инф
юлия > -5/0
-Инф
юлия> 0.000001/0
Инф
юлия> 0/0
NaN
юлия > 500 + Инф
Инф
юлия> 500 - инф
-Инф
Юлия> Инф+Инф
Инф
julia> Инф - Инф
NaN
Юлия> Инф * Инф
Инф
юлия> Инф / Инф
NaN
юлия> 0 * инф
NaN
julia> NaN == NaN
ЛОЖЬ
julia> NaN != NaN
истинный
Юлия> NaN < NaN
ЛОЖЬ
julia> NaN > NaN
ложь 

Функции typemin и typemax также применяются к типам с плавающей запятой:

 julia> (typemin(Float16),typemax(Float16))
(-Inf16, Inf16)
Юлия> (typemin(Float32),typemax(Float32))
(-Inf32, Inf32)
Юлия> (typemin(Float64),typemax(Float64))
(-Inf, Inf) 

Машинный эпсилон

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

 julia> eps( 1.0)
2.220446049250313э-16
юлия> eps(1000.)
1.1368683772161603e-13
юлия> eps(1e-27)
1.793662034335766е-43
юлия> eps(0.0)
5.0e-324 

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

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

 julia> x = 1.25f0
1.25f0
юлия> nextfloat(x)
1.2500001f0
юлия> prevfloat(x)
1.2499999f0
юлия> битовая строка (prevfloat (x))
"00111111100111111111111111111111"
юлия> битовая строка(x)
"001111111010000000000000000000000"
Юлия> битовая строка (следующий поплавок (х))
"00111111101000000000000000000001" 

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

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

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

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

Общие сведения и ссылки

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

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

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

Существуют конструкторы для создания этих типов из примитивных числовых типов, и строковый литерал @big_str или parse можно использовать для создания их из AbstractString s. BigInt также можно вводить как целочисленные литералы, если они слишком велики для других встроенных целочисленных типов. Обратите внимание, что, поскольку в 9 нет целочисленного типа без знака произвольной точности0003 Base (в большинстве случаев достаточно BigInt ), могут использоваться шестнадцатеричные, восьмеричные и двоичные литералы (в дополнение к десятичным литералам).

После создания они участвуют в арифметике со всеми другими числовыми типами благодаря механизму продвижения и преобразования типов Julia:

 julia> BigInt(typemax(Int64)) + 1
9223372036854775808
юлия> большой"12345678456784567890" + 1
12345678456784567891
юлия> parse(BigInt, "123456784567845678966) / 3
2.45956587649460688213333333333333333333333333333333333333333333333333333333344e+19
Юлия> факториал (BigInt (40))
815915283247897734345611269596115894272000000000 

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

 юлия> х = типмин (Int64)
-9223372036854775808
Юлия> х = х - 1
9223372036854775807
Юлия> typeof(x)
Int64
Юлия> y = BigInt(typemin(Int64))
-9223372036854775808
Юлия> у = у - 1
-9223372036854775809
юлия> typeof(y)
BigInt 

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

 julia> setrounding(BigFloat, RoundUp) do
           BigFloat(1) + разбор(BigFloat, "0.1")
       конец
1.100000000000000000000000000000000000000000000000000000000000000000000000000000003
julia> setrounding(BigFloat, RoundDown) сделать
           BigFloat(1) + разбор(BigFloat, "0.1")
       конец
1.099999999999999999999999999999999999999999999999999999999999999999999999999986
julia> setprecision(40) сделать
           BigFloat(1) + разбор(BigFloat, "0. 1")
       конец
1.1000000000004 92 - 3(х-1) + 1
3 

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

 julia> (x-1)x
6 

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

 julia> (x-1)(x+1)
ОШИБКА: MethodError: объекты типа Int64 не могут быть вызваны
Джулия> х(х+1)
ОШИБКА: MethodError: объекты типа Int64 не могут быть вызваны 

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

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

Конфликты синтаксиса

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

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

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

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

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

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

9003 2 один(х)

Функция	Описание
ноль(x)	Буквенный ноль типа x или типа переменной x
Буквенный один типа x или тип переменной x

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

Примеры:

 julia> ноль (Float32)
0.0f0
юлия> ноль(1.0)
0,0
юлия> один (Int32)
1
Юлия> один (BigFloat)
1,0 

Координация страны, часть II « Буквальное мышление

В моем последнем посте я обещал еще одну необычную координацию, которую я заметил в кантри-песне. Я думал об этом с 1992 года; это из «Друзей на дне» Гарта Брукса. Рефрен звучит так:

У меня есть друзья в низинах,
там, где виски тонет, а пиво прогоняет
мою тоску.
И я буду в порядке.

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

1. Виски тонет.
2. Пиво прогоняет хандру Гарта.

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

1. Виски заглушает блюз Гарта.
2. Пиво прогоняет хандру Гарта.

При обоих разборах часть про пиво в порядке. При обоих разборах часть о виски решительно однозначна. Виски не тонет. И даже если вы утопите кого-то, и его тело исчезнет, ​​говорить, что вы утопили его, просто неправильно.

Конечно, подразумевается, что эти происходят две вещи (предположительно в обратном порядке):

1. Виски топит блюз Гарта.
2. Пиво прогоняет хандру Гарта.

Но для этого прочь должно появиться перед мой блюз : где виски тонет, а пиво преследует прочь мой блюз . Но если бы вы это сделали, то вам пришлось бы избавиться от строки «Я буду в порядке» и заменить ее чем-то, что будет рифмоваться с 9.0817 блюз . Так что в течение 11 лет я воспринимал лирику как случай поэтической вольности.

Но год назад я начал сомневаться в своем предположении. Я прочитал новость от 16 октября 2003 года, написанную Генри Чу и Меган К. Стэк из LA Times, в которой говорилось:

Взрыв перевернул бронированный Chevrolet Suburban и чуть не разрубил его пополам….

чуть не разрезал Suburban пополам в порядке, точно так же, как прогоняет мою грусть . Буквально, первая половина согласования означает либо «Взрыв перевернулся», либо «Взрыв перевернул Suburban пополам». Ни то, ни другое не работает: взрыв не может просто перевернуться с ног на голову; это должно перевернуться что-то . И даже если то, что он переворачивает, в результате развалится пополам, вы все равно не можете сказать, что взрыв перевернул его пополам . Upend просто так не используется.

Очевидно, предполагается, что взрыв перевернул Suburban. Это можно было бы написать более ясно: «Взрыв перевернул и чуть не разрубил пополам бронированный Chevrolet Suburban», и, поскольку это предложение не является лирикой песни, поэтическая вольность не может объяснить это. Это могло быть ошибкой, но теперь, когда я дважды видел такую ​​координацию, я должен задаться вопросом, является ли это частью грамматики некоторых людей, которая не является частью моей.