Complex and Rational Numbers¶
Julia é estruturado com tipos predefinidos que representa ambos os números complexos e os números racionais, e suporta todas as operações matemáticas discutido no Operadores Matemáticos sobre eles. Os desevolvimentos são definidos de modo que as operações em qualquer combinação de tipos numéricos predefinidos, primitivas ou composto, se comportam como esperado.
Números Complexos¶
A constante global im
está vinculada ao complexo conjunto i , que representa uma das raízes quadradas de -1. Ela foi considerada prejudicial por a co-optar o nome “i” como constante global , uma vez que, nome de variável é um índice popular. Uma vez que Julia permite literais numéricos para ser juxtaposed with identifiers as coefficients, esta ligação é suficiente para permitir uma fácil sintaxe de Notação matemática de números complexos, semelhante ao tradicional. :
julia> 1 + 2im 1 + 2im
Você pode executar todas as operações padrão aritméticas com números complexo na forma:
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
A mecanismo de execução garante que a combinação de operandos de tipos diferentes apenas funcione:
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
Observe que 3/4im == 3/(4*im) == -(3/4*im)
, Uma vez que o coeficiente literal une mais intimamente a divisão.
Funções padrão forncedias para manipular valores complexos:
julia> real(1 + 2im)
1
julia> imag(1 + 2im)
2
julia> conj(1 + 2im)
1 - 2im
julia> abs(1 + 2im)
2.23606797749979
julia> abs2(1 + 2im)
5
Como é comum, o valor absoluto de um número complexo é sua distância do zero. A função “abs2” retorna ao quadrado o valor absoluto, e é de uso particular de números complexos, onde se evita ter uma raiz quadrada. Toda uma gama de outras funções matemáticas são também definidas por números complexos:
julia> sqrt(im) 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.1312043837568138 + 2.471726672004819im
julia> sinh(1 + 2im) -0.48905625904129374 + 1.4031192506220407im
Note que funções matemáticas tipicas retornam valores reais quando aplicado aos números reais e valores complexos quando aplicado aos números complexos. Por exemplo, `` sqrt``, por exemplo, se comporta de modo diferente quando aplicado a `` -1`` contra `` -1 + 0im`` mesmo que `` -1 == -1 + 0im``
julia> sqrt(-1)
ERROR: DomainError()
in sqrt at math.jl:111
julia> sqrt(-1 + 0im)
0.0 + 1.0im
Se você precisa para construir um número complexo usando variáveis,a notação numérica do coeficiente literal não vai funcionar, embora escrito explicitamente, a operação de multiplicação será
julia> a = 1; b = 2; a + b*im
1 + 2im
Construir números complexos de valores de variáveis como este acima, no entanto, não é recomendado. Use a função complex
para construir um complexo diretamente a partir do seu valor real e imaginário compondo as peças no lugar. Essa construção é a melhor escolha para o argumentos de uma variável porque é mais eficiente do que a construir de multiplicação e adição , mas também porque alguns dos valores da b
pode produzir resultados inesperados:
julia> complex(a,b) 1 + 2im
Inf
e NaN
são utilizados, nas partes real e o imaginário de um número complexo conforme aritmética do IEEE-754 :
julia> 1 + Inf*im complex(1.0,Inf)
julia> 1 + NaN*im complex(1.0,NaN)
Rational Numbers¶
Julia tem um tipo de número racional para representar proporções exatas de números inteiros. Racionais são construídas utilizando a // `` operador ``
julia> 2//3
2//3
Se o numerador eo denominador de uma racional têm fatores comuns, eles são reduzidos a termos mais baixos de tal forma que o denominador é não negativo
julia> 6//9
2//3
julia> -4//8
-1//2
julia> 5//-15
-1//3
julia> -4//-12
1//3
Esta forma normalizada para uma relação de números inteiros é único, por isso a igualdade racional de valores podem ser testados, verificando a igualdade do numerador e denominador. O numerador e denominador racional padronizado de um valor pode ser extraído usando o “num lock” e “den” funções: :
julia> num(2//3) 2
julia> den(2//3) 3
Direct comparison of the numerator and denominator is generally not necessary, since the standard arithmetic and comparison operations are defined for rational values:
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
Rationals can be easily converted to floating-point numbers:
julia> float(3//4)
0.75
Conversion from rational to floating-point respects the following
identity for any integral values of a
and b
, with the exception
of the case a == 0
and b == 0
:
julia> isequal(float(a//b), a/b)
true
Constructing infinite rational values is acceptable:
julia> 5//0
Inf
julia> -3//0
-Inf
julia> typeof(ans)
Rational{Int64}
Trying to construct a NaN rational value, however, is not:
julia> 0//0
invalid rational: 0//0
As usual, the promotion system makes interactions with other numeric types effortless:
julia> 3//5 + 1
8//5
julia> 3//5 - 0.5
0.1
julia> 2//7 * (1 + 2im)
2//7 + 4//7im
julia> 2//7 * (1.5 + 2im)
0.42857142857142855 + 0.5714285714285714im
julia> 3//2 / (1 + 2im)
3//10 - 3//5im
julia> 1//2 + 2im
1//2 + 2//1im
julia> 1 + 2//3im
1//1 + 2//3im
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