Complex and Rational Numbers

Julia включает предопределенные типы как для комплексных, так и для рациональных чисел и поддерживает все стандартные Mathematical Operations and Elementary Functions на них. Conversion and Promotion определены так, чтобы операции над любой комбинацией предопределенных числовых типов, будь то примитивные или составные, работали как ожидается.

Complex Numbers

Глобальная константа im связана с комплексным числом i, представляющим собой главный квадратный корень из -1. (Использование i для математиков или j для инженеров в качестве этой глобальной константы было отклонено, поскольку это такие популярные имена переменных индекса.) Поскольку Julia позволяет числовым литералам быть juxtaposed with identifiers as coefficients, эта привязка достаточно для обеспечения удобного синтаксиса для комплексных чисел, аналогичного традиционной математической нотации:

julia> 1+2im
1 + 2im

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

julia> (1 + 2im)*(2 - 3im)
8 + 1im

julia> (1 + 2im)/(1 - 2im)
-0.6 + 0.8im

julia> (1 + 2im) + (1 - 2im)
2 + 0im

julia> (-3 + 2im) - (5 - 1im)
-8 + 3im

julia> (-1 + 2im)^2
-3 - 4im

julia> (-1 + 2im)^2.5
2.729624464784009 - 6.9606644595719im

julia> (-1 + 2im)^(1 + 1im)
-0.27910381075826657 + 0.08708053414102428im

julia> 3(2 - 5im)
6 - 15im

julia> 3(2 - 5im)^2
-63 - 60im

julia> 3(2 - 5im)^-1.0
0.20689655172413793 + 0.5172413793103449im

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

julia> 2(1 - 1im)
2 - 2im

julia> (2 + 3im) - 1
1 + 3im

julia> (1 + 2im) + 0.5
1.5 + 2.0im

julia> (2 + 3im) - 0.5im
2.0 + 2.5im

julia> 0.75(1 + 2im)
0.75 + 1.5im

julia> (2 + 3im) / 2
1.0 + 1.5im

julia> (1 - 3im) / (2 + 2im)
-0.5 - 1.0im

julia> 2im^2
-2 + 0im

julia> 1 + 3/4im
1.0 - 0.75im

Обратите внимание, что 3/4im == 3/(4*im) == -(3/4*im), поскольку буквенный коэффициент связывается более тесно, чем деление.

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

julia> z = 1 + 2im
1 + 2im

julia> real(1 + 2im) # real part of z
1

julia> imag(1 + 2im) # imaginary part of z
2

julia> conj(1 + 2im) # complex conjugate of z
1 - 2im

julia> abs(1 + 2im) # absolute value of z
2.23606797749979

julia> abs2(1 + 2im) # squared absolute value
5

julia> angle(1 + 2im) # phase angle in radians
1.1071487177940904

Как обычно, абсолютное значение (abs) комплексного числа — это его расстояние от нуля. abs2 дает квадрат абсолютного значения и особенно полезно для комплексных чисел, так как избегает извлечения квадратного корня. angle возвращает угловую фазу в радианах (также известную как аргумент или arg функция). Полный спектр других Elementary Functions также определен для комплексных чисел:

julia> sqrt(1im)
0.7071067811865476 + 0.7071067811865475im

julia> sqrt(1 + 2im)
1.272019649514069 + 0.7861513777574233im

julia> cos(1 + 2im)
2.0327230070196656 - 3.0518977991517997im

julia> exp(1 + 2im)
-1.1312043837568135 + 2.4717266720048188im

julia> sinh(1 + 2im)
-0.4890562590412937 + 1.4031192506220405im

Обратите внимание, что математические функции обычно возвращают действительные значения, когда применяются к действительным числам, и комплексные значения, когда применяются к комплексным числам. Например, sqrt ведет себя по-разному при применении к -1 и -1 + 0im, даже несмотря на то, что -1 == -1 + 0im:

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

julia> sqrt(-1 + 0im)
0.0 + 1.0im

literal numeric coefficient notation не работает при построении комплексного числа из переменных. Вместо этого умножение должно быть явно записано:

julia> a = 1; b = 2; a + b*im
1 + 2im

Однако это не рекомендуется. Вместо этого используйте более эффективную complex функцию для непосредственного построения комплексного значения из его действительной и мнимой частей:

julia> a = 1; b = 2; complex(a, b)
1 + 2im

Это построение избегает операций умножения и сложения.

Inf и NaN распространяются через комплексные числа в действительных и мнимых частях комплексного числа, как описано в разделе Special floating-point values:

julia> 1 + Inf*im
1.0 + Inf*im

julia> 1 + NaN*im
1.0 + NaN*im

Rational Numbers

Джулия имеет тип рационального числа для представления точных отношений целых чисел. Рациональные числа создаются с использованием оператора //:

julia> 2//3
2//3

Если числитель и знаменатель рационального числа имеют общие множители, они сокращаются до наименьших дробей, так чтобы знаменатель был неотрицательным:

julia> 6//9
2//3

julia> -4//8
-1//2

julia> 5//-15
-1//3

julia> -4//-12
1//3

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

julia> numerator(2//3)
2

julia> denominator(2//3)
3

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

julia> 2//3 == 6//9
true

julia> 2//3 == 9//27
false

julia> 3//7 < 1//2
true

julia> 3//4 > 2//3
true

julia> 2//4 + 1//6
2//3

julia> 5//12 - 1//4
1//6

julia> 5//8 * 3//12
5//32

julia> 6//5 / 10//7
21//25

Рациональные числа можно легко преобразовать в числа с плавающей запятой:

julia> float(3//4)
0.75

Преобразование из рационального в плавающую точку соблюдает следующую идентичность для любых целых значений a и b, за исключением случаев, когда a==0 && b <= 0:

julia> a = 1; b = 2;

julia> isequal(float(a//b), a/b)
true

julia> a, b = 0, 0
(0, 0)

julia> float(a//b)
ERROR: ArgumentError: invalid rational: zero(Int64)//zero(Int64)
Stacktrace:
[...]

julia> a/b
NaN

julia> a, b = 0, -1
(0, -1)

julia> float(a//b), a/b
(0.0, -0.0)

Конструирование бесконечных рациональных значений допустимо:

julia> 5//0
1//0

julia> x = -3//0
-1//0

julia> typeof(x)
Rational{Int64}

Пытаюсь создать рациональное значение NaN, однако оно недействительно:

julia> 0//0
ERROR: ArgumentError: invalid rational: zero(Int64)//zero(Int64)
Stacktrace:
[...]

Как обычно, система преобразования делает взаимодействие с другими числовыми типами легким:

julia> 3//5 + 1
8//5

julia> 3//5 - 0.5
0.09999999999999998

julia> 2//7 * (1 + 2im)
2//7 + 4//7*im

julia> 2//7 * (1.5 + 2im)
0.42857142857142855 + 0.5714285714285714im

julia> 3//2 / (1 + 2im)
3//10 - 3//5*im

julia> 1//2 + 2im
1//2 + 2//1*im

julia> 1 + 2//3im
1//1 - 2//3*im

julia> 0.5 == 1//2
true

julia> 0.33 == 1//3
false

julia> 0.33 < 1//3
true

julia> 1//3 - 0.33
0.0033333333333332993