Módulo cmath
2.2 Módulo cmath
El módulo math de Python se complementa con el módulo cmath, que proporciona funciones para tareas matemáticas con números complejos.
Un número imaginario o complejo se representa como la suma de un número real y un número imaginario de la forma a + bi, donde a es el número real y bi es el número imaginario, siendo i la raíz cuadrada de -1.
Los números complejos o imaginarios tienen su uso en muchas aplicaciones relacionadas con las matemáticas y Python proporciona herramientas útiles para manejarlos y manipularlos.
Las funciones de este módulo aceptan números enteros, en coma flotante y complejos. Todas las funciones de cmath siempre devuelven un número complejo, incluso si el valor de retorno se puede expresar como un número real, en cuyo caso el número complejo tiene una parte imaginaria de cero.
El motivo de que existan dos módulos distintos es evidente, cuando se utilizan únicamente números reales se desea ver errores sí se intenta calcular la raíz cuadrada de un número negativo, porque realmente es imposible. Por el contrario, cuando se utilizan números complejos dicha tarea resulta natural.
Para usar los métodos del módulo cmath debemos empezar importando el módulo.
import cmath
Vamos a ver las funciones más comunes ofrecidas por este módulo. En la documentación de Python para cmath podéis encontrar todas las funciones disponibles.
2.2.1 Constantes matemáticas
El módulo cmath de Python ofrece una serie de constantes predefinidas, que facilitan su uso y proporcionan consistencia en todo el código.
| Constante | Descripción |
|---|---|
| cmath.e | La constante de Euler (2.7182...) en coma flotante. |
| cmath.inf | Devuelve un infinito positivo en coma flotante.
Equivale a float('inf'). |
| cmath.infj | Número complejo con parte real cero y parte imaginaria infinita positiva.
Equivale a complex(0.0, float('inf')). |
| cmath.nan | El valor NaN (Not a Number – No es un número) en coma flotante. |
| cmath.nanj | Número complejo con parte real cero y parte imaginaria NaN.
Equivale a complex(0.0, float('nan')). |
| cmath.pi | La constante PI (3.1415...) en coma flotante. |
| cmath.tau | La constante tau (6.2831...) en coma flotante. |
2.2.2 Funciones matemáticas
El módulo cmath ofrece las siguientes funciones.
| Funciones | Descripción |
|---|---|
| cmath.acos(x) | Devuelve el arcocoseno de un número complejo. |
| cmath.acosh(x) | Devuelve el coseno hiperbólico inverso de un número complejo. |
| cmath.asin(x) | Devuelve el arcoseno de un número complejo. |
| cmath.asinh(x) | Devuelve el seno hiperbólico inverso de un número complejo. |
| cmath.atan(x) | Devuelve el arcotangente de un número complejo. |
| cmath.atanh(x) | Devuelve la tangente hiperbólica inversa de un número complejo. |
| cmath.cos(x) | Devuelve el coseno de un número complejo. |
| cmath.cosh(x) | Devuelve el coseno hiperbólico de un número complejo. |
| cmath.exp(x) | Devuelve e elevado a la potencia de un número complejo. |
| cmath.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) | Devuelve True si los valores complejos a y b están cerca el uno del otro y False en caso contrario.
El hecho de que dos valores se consideren cercanos se determina según las tolerancias absoluta y relativa dadas. rel_tol es la tolerancia relativa - es la máxima diferencia permitida entre a y b, en relación con el valor absoluto mayor de a o b. abs_tol es la tolerancia absoluta mínima - útil para comparaciones cercanas a cero. abs_tol debe ser al menos cero. Si no hay errores, el resultado será: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) |
| cmath.isfinite(x) | Devuelve True si el valor complejo x no es un infinito ni un NaN, y False en caso contrario. |
| cmath.isinf(x) | Devuelve True si el valor complejo x es un infinito positivo o negativo, y False en caso contrario. |
| cmath.isnan(x) | Devuelve True si el valor complejo x es un NaN, y False en caso contrario. |
| cmath.log(x [, base]) | Devuelve el logaritmo natural del número complejo x (en base e).
Con dos argumentos, devuelve el logaritmo de x en la base dada. |
| cmath.log10(x) | Devuelve el logaritmo en base 10 del número complejo x.
Suele ser más preciso que log(x, 10). |
| cmath.phase(x) | Devuelve la fase del número complejo x. |
| cmath.polar(x) | Devuelve el número complejo x en forma de coordenadas polares.
Devuelve una tupla de módulo y fase. |
| cmath.rect(x) | Devuelve las coordenadas polares x a la forma rectangular del número complejo. Crea un número complejo con fase y módulo.
Este método equivale a: r * (math.cos(phi) + math.sin(phi)*1j). El radio r es la longitud del vector, y phi (ángulo de fase) es el ángulo formado con el eje real. |
| cmath.sin(x) | Devuelve el seno de un número complejo. |
| cmath.sinh(x) | Devuelve el seno hiperbólico de un número complejo. |
| cmath.sqrt(x) | Devuelve la raíz cuadrada de un número complejo. |
| cmath.tan(x) | Devuelve la tangente de un número complejo. |
| cmath.tanh(x) | Devuelve la tangente hiperbólica de un número complejo. |
2.2.3 Uso del módulo cmath
A continuación vamos a ver unos ejemplos del uso de funciones matemáticas del modulo cmath.
2.2.3.1 Creación de números complejos
En matemáticas, la unidad imaginaria se suele denotar con i, en Python se utiliza j, como en física, para denotar los números imaginarios.
Python también proporciona la función incorporada complex() que permite crear números complejos.
El módulo de un número complejo es el número real positivo que mide su tamaño y generaliza el valor absoluto de un número real. Se puede acceder a la parte real y la imaginaria mediante los atributos real e imag respectivamente.
Podemos emplear los operadores matemáticos básicos: suma, resta, multiplicación y división (+, -, *, /) con los números complejos.
import cmath
# creación de números complejos y sus partes
print('Creación por asignación')
z = 1 + 2j
print('Número complejo:', z) # número complejo
print('Parte real:', z.real) # atributo real
print('Parte imaginaria:', z.imag) # atributo imaginario
print('Creación con la clase complex')
y = complex(3, 4)
print('Número complejo:', y)
print('Parte real:', y.real)
print('Parte imaginaria:', y.imag)
# operaciones básicas
print('\nOperaciones matemáticas')
print(f'z: {z}, y: {y}')
suma = z + y
resta = z - y
multiplicacion = z * y
division = z / y
print('Suma x+y:', suma)
print('Resta z-y:', resta)
print('Multiplicación z*y:', multiplicacion)
print('División z/y:', division)
Vemos a continuación el resultado de la ejecución del guión.
Creación por asignación Número complejo: (1+2j) Parte real: 1.0 Parte imaginaria: 2.0 Creación con la clase complex Número complejo: (3+4j) Parte real: 3.0 Parte imaginaria: 4.0 Operaciones matemáticas z: (1+2j), y: (3+4j) Suma x+y: (4+6j) Resta z-y: (-2-2j) Multiplicación z*y: (-5+10j) División z/y: (0.44+0.08j)
2.2.3.2 Coordenadas
Un número complejo se almacena internamente usando coordenadas rectangulares o cartesianas. Así, un número complejo z se representa como z = a + bj, donde a representa la parte real y b la parte imaginaria.
Otra forma de describir un número complejo es mediante coordenadas polares, donde el número complejo z se define mediante una tupla del módulo r y el ángulo de fase phi. El módulo r es la distancia de z al origen, mientras que la fase phi es el ángulo contrario a las agujas del reloj, medido en radianes, desde el eje x positivo al segmento de línea que une el origen con z. La conversión a polar se realiza mediante la función polar(), que devuelve un par(r, phi).
El rango de fase va de –cmath.pi a +cmath.pi. El signo del resultado es el mismo que el de z.imag.
El módulo se puede obtener utilizando la función incorporada abs() y la fase usando la función cmath.phase(), que toma un número complejo como entrada y devuelve un número de punto flotante que representa la fase del número complejo. Es equivalente a:
fase = cmath.phase(z) = math.atan2(z.imag, z.real)
Podemos utilizar la función cmath.rect() para convertir un número complejo en forma polar a forma rectangular pasando el módulo r y la fase phi como argumentos. Equivale a
r * (math.cos(phi) + math.sin(phi) * 1j)
Veamos un ejemplo.
import cmath
# creación de un número complejo
z = 1 + 2j
print('Número complejo:', z)
# módulo
r = abs(z)
print('Módulo:', r)
# fase
phi = cmath.phase(z)
print('Fase:', phi)
# coordenadas polares
polar = cmath.polar(z)
print('\nCoordenadas polares:', polar)
# formato rectangular
rectangular = cmath.rect(r, phi)
print('\nRectangular:', rectangular)
El resultado del script es:
Número complejo: (1+2j) Módulo: 2.23606797749979 Fase: 1.1071487177940904 Coordenadas polares: (2.23606797749979, 1.1071487177940904) Rectangular: (1.0000000000000002+2j)