Números complejos y racionales en Julia
En este capítulo nos centraremos principalmente en aprender los números complejos y racionales de Julia.
El lenguaje Julia contiene tipos predefinidos de números complejos y racionales, y admite sus diversas operaciones matemáticas estándar y funciones elementales.
Números complejos
Los números complejos son una extensión de los números reales que permiten que cualquier ecuación polinómica tenga raíces.
Llamamos a la formaz=a+bi(donde a y b son números reales) número complejo. Entre ellos, a se llama parte real, b se llama parte imaginaria, e i se llama unidad imaginaria, que tiene la propiedad. Cuando la parte imaginaria b = 0 de z, entonces z es un número real; cuando la parte imaginaria b ≠ 0 de z y la parte real a = 0, z se denomina a menudo número imaginario puro.
La constante global im está vinculada al número complejo i, que representa la raíz cuadrada principal de -1.
Dado que Julia permite que los literales numéricos actúen como coeficientes de literales numéricos, este enlace es suficiente para proporcionar una sintaxis muy conveniente para números complejos, similar a la notación matemática tradicional:
Ejemplo
1 + 2im
También podemos realizar varias operaciones aritméticas con números complejos:
Ejemplo
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.20689655172413796 + 0.5172413793103449im
El mecanismo de promoción de tipos también garantiza que puedas usar combinaciones de operandos de diferentes tipos:
Ejemplo
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
Nota3/4im == 3/(4*im) == -(3/4*im), porque el coeficiente tiene mayor prioridad que la división.
Julia proporciona algunas funciones estándar para operar con números complejos:
Ejemplo
1 + 2im
julia> real(1 + 2im) # parte real de z
1
julia> imag(1 + 2im) # parte imaginaria de z
2
julia> conj(1 + 2im) # conjugado complejo de z
1 - 2im
julia> abs(1 + 2im) # valor absoluto de z
2.23606797749979
julia> abs2(1 + 2im) # valor absoluto al cuadrado
5
julia> angle(1 + 2im) # ángulo de fase en radianes
1.1071487177940904
Por convención, el valor absoluto (abs) de un número complejo es su distancia desde el punto cero. abs2 proporciona el cuadrado del valor absoluto y es muy útil cuando se aplica a números complejos, porque evita calcular la raíz cuadrada. angle devuelve el ángulo de fase en radianes (también llamado función argumento). Todas las demás funciones elementales también están completamente definidas para números complejos:
Ejemplo
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
Ten en cuenta que las funciones matemáticas generalmente devuelven valores reales cuando se aplican a números reales, y valores complejos cuando se aplican a números complejos. Por ejemplo, cuando sqrt se aplica a -1 y a -1 + 0im, se comporta de manera diferente, aunque -1 == -1 + 0im:
Ejemplo
ERROR: DomainError with -1.0:
sqrt 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
Al construir números complejos a partir de variables, la notación de coeficiente numérico literal ya no es aplicable. En su lugar, la multiplicación debe escribirse explícitamente:
Ejemplo
1 + 2im
Sin embargo, no recomendamos hacer esto; en su lugar, deberías usar la función complex, más eficiente, para construir un valor complejo directamente a partir de la parte real y la parte imaginaria:
Ejemplo
1 + 2im
Esta construcción evita las operaciones de multiplicación y suma.
Inf y NaN pueden aparecer en las partes real e imaginaria de los números complejos, como se describe en el capítulo de valores de punto flotante especiales:
Ejemplo
1.0 + Inf*im
julia> 1 + NaN*im
1.0 + NaN*im
Números racionales
Los números racionales son el término general para enteros (enteros positivos, 0, enteros negativos) y fracciones, y son el conjunto de enteros y fracciones.
Matemáticamente, los números que pueden expresarse como la razón de dos enteros (Julia tiene un tipo de fracción para representar razones exactas de enteros. Las fracciones se construyen mediante el operador//:
Ejemplo
2//3
Si el numerador y el denominador de una fracción tienen factores comunes, se reducen a su forma más simple y el denominador no es negativo:
Ejemplo
2//3
julia> -4//8
-1//2
julia> 5//-15
-1//3
julia> -4//-12
1//3
Esta forma estandarizada de la razón de enteros es única, por lo que la igualdad de valores fraccionarios puede probarse verificando que tanto el numerador como el denominador sean iguales. El numerador y el denominador estandarizados de un valor fraccionario pueden obtenerse usando las funciones numerator y denominator:
Ejemplo
2
julia> denominator(2//3)
3
La comparación directa de numeradores y denominadores generalmente no es necesaria, porque las operaciones aritméticas y de comparación estándar también están definidas para valores fraccionarios:
Ejemplo
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
Las fracciones pueden convertirse fácilmente a números de punto flotante:
Ejemplo
0.75
Para cualquier valor entero a y b (excepto cuando a == 0 y b == 0), la conversión de fracciones a números de punto flotante sigue la siguiente consistencia:
Ejemplo
julia> isequal(float(a//b), a/b)
true
Julia acepta construir valores fraccionarios infinitos:
Ejemplo
1//0
julia> x = -3//0
-1//0
julia> typeof(x)
Rational{Int64}
Pero no acepta intentar construir un valor fraccionario NaN:
Ejemplo
ERROR: ArgumentError: invalid rational: zero(Int64)//zero(Int64)
Stacktrace:
[...]
Como es habitual, el sistema de promoción de tipos permite que las fracciones interactúen fácilmente con otros tipos numéricos:
Ejemplo
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