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

julia> 1+2im
1 + 2im

También podemos realizar varias operaciones aritméticas con números complejos:

Ejemplo

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.20689655172413796 + 0.5172413793103449im

El mecanismo de promoción de tipos también garantiza que puedas usar combinaciones de operandos de diferentes tipos:

Ejemplo

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

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

julia> z = 1 + 2im
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

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

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

julia> sqrt(-1)
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

julia> a = 1; b = 2; a + b*im
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

julia> a = 1; b = 2; complex(a, b)
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

julia> 1 + Inf*im
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 (, ) se definen como números racionales, por ejemplo, 0.75 (que puede expresarse como). Los enteros y las fracciones se denominan colectivamente números racionales. Lo opuesto a los números racionales son los números irracionales, comoque no puede representarse como una razón de enteros.

Julia tiene un tipo de fracción para representar razones exactas de enteros. Las fracciones se construyen mediante el operador//:

Ejemplo

julia> 2//3
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

julia> 6//9
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

julia> numerator(2//3)
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

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

Las fracciones pueden convertirse fácilmente a números de punto flotante:

Ejemplo

julia> float(3//4)
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> a = 1; b = 2;

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

Julia acepta construir valores fraccionarios infinitos:

Ejemplo

julia> 5//0
1//0

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

julia> typeof(x)
Rational{Int64}

Pero no acepta intentar construir un valor fraccionario NaN:

Ejemplo

julia> 0//0
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

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
Otras extensiones