Математические операции и элементарные функции

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

Арифметические операторы

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

а также отрицание для Bool типов:

Система повышения типа Julia делает арифметические операции над смешанными типами аргументов «работать» естественным и автоматическим образом. Подробнее о системе повышения типа см. в разделе Преобразование и повышение.

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

julia> 1 + 2 + 3
6

julia> 1 - 2
-1

julia> 3*2/12
0.5

(По соглашению, мы склонны размещать операторы более плотно, если они применяются до других близлежащих операторов. Например, мы обычно пишем -x + 2 для отражения того, что сначала x отрицается, а затем 2 добавляется к этому результату.)

Побитовые операторы

Следующие побитовые операторы поддерживаются для всех примитивных целочисленных типов:

Вот несколько примеров с побитовыми операторами:

julia> ~123
-124

julia> 123 & 234
106

julia> 123 | 234
251

julia> 123 $ 234
145

julia> ~UInt32(123)
0xffffff84

julia> ~UInt8(123)
0x84

Операторы обновления

Каждый бинарный арифметический и побитовый оператор также имеет версию обновления, которая присваивает результат операции обратно в свой левый операнд. Обновленная версия бинарного оператора образуется путем размещения = сразу после оператора. Например, запись x += 3 эквивалентна записи x = x + 3:

julia> x = 1
1

julia> x += 3
4

julia> x
4

Обновленные версии всех бинарных арифметических и побитовых операторов:

+=  -=  *=  /=  \=  ÷=  %=  ^=  &=  |=  $=  >>>=  >>=  <<=

julia> x = 0x01; typeof(x)
UInt8

julia> x *= 2 #Same as x = x * 2
2

julia> isa(x, Int)
true

Числовые сравнения

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

Вот несколько простых примеров:

julia> 1 == 1
true

julia> 1 == 2
false

julia> 1 != 2
true

julia> 1 == 1.0
true

julia> 1 < 2
true

julia> 1.0 > 3
false

julia> 1 >= 1.0
true

julia> -1 <= 1
true

julia> -1 <= -1
true

julia> -1 <= -2
false

julia> 3 < -0.5
false

Целые числа сравниваются стандартным способом — путем сравнения битов. Вещественные числа сравниваются в соответствии со стандартом IEEE 754:

• Конечные числа упорядочиваются обычным образом.
• Положительный ноль равен, но не больше отрицательного нуля.
• Inf равен самому себе и больше всего остального, кроме NaN.
• -Inf равен самому себе и меньше всего остального, кроме NaN.
• NaN не равен, не меньше и не больше ничего, включая себя.

Последний пункт потенциально неожиданный и поэтому заслуживает внимания:

julia> NaN == NaN
false

julia> NaN != NaN
true

julia> NaN < NaN
false

julia> NaN > NaN
false

и может вызвать особые трудности с Массивами:

julia> [1 NaN] == [1 NaN]
false

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

isequal() считает NaN равными друг другу:

julia> isequal(NaN,NaN)
true

julia> isequal([1 NaN], [1 NaN])
true

julia> isequal(NaN,NaN32)
true

isequal() также может использоваться для различения знакомых нулей:

julia> -0.0 == 0.0
true

julia> isequal(-0.0, 0.0)
false

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

Для других типов isequal() по умолчанию вызывает ==(), поэтому если вы хотите определить равенство для своих типов, то вам нужно добавить метод ==(). Если вы определите свою собственную функцию равенства, то, вероятно, вы должны определить соответствующий метод hash(), чтобы гарантировать, что isequal(x,y) подразумевает hash(x) == hash(y).

Цепочки сравнений

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

julia> 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
true

Цепочки сравнений часто бывают удобны в численном коде. Цепочки сравнений используют оператор && для скалярных сравнений и оператор & для поэлементных сравнений, что позволяет им работать с массивами. Например, 0 .< A .< 1 дает булевый массив, чьи элементы равны true там, где соответствующие элементы A находятся между 0 и 1.

Оператор .< предназначен для объектов массивов; операция A .< B допустима только если A и B имеют одинаковые размеры. Оператор возвращает массив с логическими значениями и теми же размерами, что и A и B. Такие операторы называются элементными; Julia предоставляет набор элементных операторов: .*, .+ и т.д. Некоторые элементные операторы могут принимать скалярный операнд, как в примере 0 .< A .< 1 в предыдущем абзаце. Эта запись означает, что скалярный операнд должен быть продублирован для каждого элемента массива.

Обратите внимание на поведение вычисления цепочки сравнений:

julia> v(x) = (println(x); x)
v (generic function with 1 method)

julia> v(1) < v(2) <= v(3)
2
1
3
true

julia> v(1) > v(2) <= v(3)
2
1
false

Среднее выражение вычисляется только один раз, а не дважды, как если бы выражение было записано как v(1) < v(2) && v(2) <= v(3). Однако порядок вычислений в цепочке сравнений не определён. Сильно рекомендуется не использовать выражения со побочными эффектами (такие как вывод на печать) в цепочках сравнений. Если требуются побочные эффекты, следует явно использовать оператор короткого замыкания && (см. Вычисление с коротким замыканием).

Приоритет операторов

Julia применяет следующий порядок операций, от наивысшего приоритета к наименьшему:

Элементарные функции

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

Кроме того, эти функции (как и любая функция Julia) могут применяться «векторно» к массивам и другим коллекциям с синтаксисом f.(A), например, sin.(A) вычислит элементную синус каждой позиции массива A. См. Точка синтаксиса для векторизации функций:

Числовые преобразования

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

• Запись T(x) или convert(T,x) преобразует x в значение типа T.
  • Если T — тип с плавающей точкой, результат — ближайшее представимое значение, которое может быть положительной или отрицательной бесконечностью.
  • Если T — целочисленный тип, возникает InexactError исключение, если x не представимо типом T.
• 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()
 in Int8(::Int64) at ./sysimg.jl:53
 ...

julia> Int8(127.0)
127

julia> Int8(3.14)
ERROR: InexactError()
 in Int8(::Float64) at ./sysimg.jl:53
 ...

julia> Int8(128.0)
ERROR: InexactError()
 in Int8(::Float64) at ./sysimg.jl:53
 ...

julia> 127 % Int8
127

julia> 128 % Int8
-128

julia> round(Int8,127.4)
127

julia> round(Int8,127.6)
ERROR: InexactError()
 in trunc(::Type{Int8}, ::Float64) at ./float.jl:458
 in round(::Type{Int8}, ::Float64) at ./float.jl:211
 ...

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

Функции округления

Функции деления

Функции знака и абсолютного значения

Возведение в степень, логарифмы и корни

Для обзора того, почему функции, такие как hypot(), expm1() и log1p() необходимы и полезны, см. отличные посты Джона Д. Кука в блоге на эту тему: expm1, log1p, erfc и hypot.

Тригонометрические и гиперболические функции

Определены также все стандартные тригонометрические и гиперболические функции:

sin    cos    tan    cot    sec    csc
sinh   cosh   tanh   coth   sech   csch
asin   acos   atan   acot   asec   acsc
asinh  acosh  atanh  acoth  asech  acsch
sinc   cosc   atan2

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

Кроме того, sinpi(x) и cospi(x) предоставляются для более точных вычислений sin(pi*x) и cos(pi*x) соответственно.

Для вычисления тригонометрических функций в градусах вместо радиан, добавьте суффикс d. Например, sind(x) вычисляет синус x где x указано в градусах. Полный список тригонометрических функций с вариантами в градусах:

sind   cosd   tand   cotd   secd   cscd
asind  acosd  atand  acotd  asecd  acscd

Специальные функции