Advertisement
  1. Code
  2. Python

Módulos Matemáticos en Python: Math y Cmath

Scroll to top
Read Time: 8 min
This post is part of a series called Mathematical Modules in Python.
Mathematical Modules in Python: Random

Spanish (Español) translation by Rafael Chavarría (you can also view the original English article)

Cuando escribimos programas en nuestra vida diaria, usualmente nos encontramos con situaciones en donde necesitamos usar un poco de matemáticas para hacer una tarea. Como otros lenguajes de programación, Python proporciona varios operadores para realizar cálculos básicos como * para multiplicación, % para módulos y // para división.

Si estás escribiendo un programa para realizar tareas específicas como estudiar movimiento periódico o simular circuitos eléctricos, necesitarás trabajar con funciones trigonométricas así como números complejos. Mientras que no puedes usar estas funciones directamente, puedes acceder a ellas incluyendo dos módulos matemáticos primero. Estos módulos son math y cmath.

El primero te da acceso a funciones hiperbólicas, trigonométricas y logarítmicas para números reales mientras que la última te permite trabajar con números complejos. En este tutorial, recorreré todas las funciones importantes ofrecidas por estos módulos. A menos que se mencione explícitamente, todos los valores devueltos son flotantes.

Funciones Aritméticas

Estas funciones realizan varias operaciones aritméticas como calcular el valor superior, inferior o absoluto de un número usando las funciones floor(x)ceil(x), y fabs(x) respectivamente. La función ceil(x) devolverá el entero más pequeño que sea mayor qué o igual a x. De manera similar, floor(x) devuelve el entero más grande menor qué o igual a x. La función fabs(x) devuelve el valor absoluto de x.

También puedes realizar operaciones no triviales como calcular el factorial de un número usando factorial(x). Un factorial es el producto de un entero y todos los enteros positivos menores que este. Es usado extensivamente cuando se trabaja con combinaciones y permutaciones. También puede ser usado para calcular el valor de las funciones seno y coseno.

1
import math
2
3
def getsin(x):
4
5
    multiplier = 1
6
    result = 0
7
    
8
  for i in range(1,20,2):
9
		result += multiplier*pow(x,i)/math.factorial(i)
10
		multiplier *= -1
11
		
12
	return result
13
    
14
15
getsin(math.pi/2) # returns 1.0

16
getsin(math.pi/4) # returns 0.7071067811865475

Otra función útil en el módulo math es gcd(x,y), la cuál te da el máximo común divisor (MCD) de dos números x y y. Cuando x y y no son cero, esta función regresa el entero positivo más grande que divida tanto a x como a y. Puedes usarlo indirectamente para calcular el mínimo común múltiplo de dos números usando la siguiente fórmula:

1
gcd(a, b) x lcm(a, b) = a x b

Aquí hay unas cuantas de las funciones aritméticas que Python ofrece:

1
import math
2
3
math.ceil(1.001)    # returns 2

4
math.floor(1.001)   # returns 1

5
math.factorial(10)  # returns 3628800

6
math.gcd(10,125)    # returns 5

7
8
math.trunc(1.001)   # returns 1

9
math.trunc(1.999)   # returns 1

Funciones Trigonométricas

Estas funciones relacionan los ángulos de un triángulo a sus lados. Tienen muchas aplicaciones, incluyendo el estudio de triángulos y el modelado de fenómenos periódicos como el sonido y ondas de luz. Ten en mente que el ángulo que proporcionas está en radianes.

Puedes calcular sin(x)cos(x), y tan(x) directamente usando este módulo. Sin embargo, no hay fórmula directa para calcular cosec(x)sec(x), y cot(x), pero su valor es igual al recíproco del valor devuelto por sin(x), cos(x), y tan(x) respectivamente.

En lugar de calcular el valor de funciones trigonométricas como cierto ángulo, también puedes hacer el cálculo inverso y calcular el ángulo al que tienen un valor dado usando asin(x)acos(x), and atan(x).

¿Estás familiarizado con el teorema de Pitágoras? Este establece que el cuadrado de la hipotenusa (el lado opuesto del ángulo derecho) es igual a la suma de los cuadrados de los otros dos lados. La hipotenusa es también el lado más grande de un triángulo rectángulo. El módulo math proporciona la función hypot(a,b) para calcular la longitud de la hipotenusa.

1
import math
2
3
math.sin(math.pi/4)    # returns 0.7071067811865476

4
math.cos(math.pi)      # returns -1.0

5
math.tan(math.pi/6)    # returns 0.5773502691896257

6
math.hypot(12,5)       # returns 13.0

7
8
math.atan(0.5773502691896257) # returns 0.5235987755982988

9
math.asin(0.7071067811865476) # returns 0.7853981633974484

Funciones Hiperbólicas

Las funciones hiperbólicas son análogas a las funciones trigonométricas que están basadas en una hipérbole en lugar de un círculo. En trigonometría, los puntos (cos b, sin b) representan los puntos de un círculo unitario. En caso de funciones hiperbólicas, los puntos (cosh b, sinh b) representan los puntos que forman la mitad derecha de una hipérbola equilátera.

Justo como las funciones trigonométricas, puedes calcular el valor de sinh(x)cosh(x), y tanh(x) directamente. El resto de los valores pueden ser calculados usando varias relaciones entra estos tres valores. También hay otras funciones como asinh(x)acosh(x), and atanh(x), lac cuales pueden ser usadas para culcular la inversa de los valores hiperbólicos correspondientes.

1
import math
2
3
math.sinh(math.pi)    # returns 11.548739357257746

4
math.cosh(math.pi)    # returns 11.591953275521519

5
math.cosh(math.pi)    # returns 0.99627207622075

6
7
math.asinh(11.548739357257746)   # returns 3.141592653589793

8
math.acosh(11.591953275521519)   # returns 3.141592653589793

9
math.atanh(0.99627207622075)     # returns 3.141592653589798

Ya que math.pi es igual a alrededor de 3.141592653589793, cuando usamos asinh() en el valor devuelto por sinh(math.pi), obtuvimos nuestro π de vuelta.

Funciones Exponenciales y Logaritmicas

Probablemente estarás lidiando con exponentes y logaritmos más seguido que con funciones hiperbólicas y trigonométricas. Afortunadamente, el módulo math proporciona muchas funciones para ayudarnos a calcular logaritmos.

Puedes usar log(x,[base]) para calcular el log de un número dado x a la base dada. Si dejas fuera el argumento opcional de base, el log de x es calculado a la base e. Aquí, e es una constante matemática cuyo valor es 2.71828182.... y puede ser accedida usando math.e. Por cierto, Python también te permite acceder a otra constante π usando math.pi.

Si quieres calcular los valores logarítmicos base 2 o base 10, usar log2(x) y log10(x) revolverá resultados más precisos que log(x, 2) y log(x, 10). Ten en mente que no hay función log3(x), así que tendrás que seguir usando log(x, 3) para calcular valores logarítmicos log(x,3). Lo mismo aplica para todas las demás bases.

Si el valor cuyo logaritmo estás calculando es bastante cercano a 1, puedes usar log1p(x). El 1p en log1p significa 1 más. Así pues, log1p(x) calcula log(1+x) en donde x es cercano a cero. Sin embargo, los resultados son más precisos con loglp(x).

También puedes calcular el valor de un número x elevado a la potencia y usando pow(x, y). Antes de computar las potencias, esta función convierte ambos argumentos a tipo float. Si quieres que el resultado final se compute en potencias enteras exactas, deberías usar la función integrada pow() o el operador **.

También puedes computar la raíz cuadrada de cualquier número dado x usando sqrt(x), pero la misma cosa también puede ser lograda usando pow(x, 0.5).

1
import math
2
3
math.exp(5)                      # returns 148.4131591025766

4
math.e**5                        # returns 148.4131591025765

5
6
math.log(148.41315910257657)     # returns 5.0

7
math.log(148.41315910257657, 2)  # returns 7.213475204444817

8
math.log(148.41315910257657, 10) # returns 2.171472409516258

9
10
math.log(1.0000025)              # returns 2.4999968749105643e-06

11
math.log1p(0.0000025)            # returns 2.4999968750052084e-06

12
13
math.pow(12.5, 2.8)              # returns 1178.5500657314767

14
math.pow(144, 0.5)               # returns 12.0

15
math.sqrt(144)                   # returns 12.0

Números Complejos

Los números complejos son almacenados inicialmente usando coordenadas rectangulares o Cartesianas. Un número complejo z será representado en coordenadas Cartesianas como z = x + iy, en donde x representa la parte real y y representa la parte imaginaria. Otra manera de representarlos es usando coordenadas polares.

En este caso, el número complejo sería definido por una combinación de los módulos r y ángulo de fase phi. El módulo r es la distancia entre el número complejo z y el origen. El ángulo phi es el ángulo contrario medido en radianes desde el eje x positivo al segmento de línea uniendo a z y el origen.

Mientras lidiamos con números complejos, el módulo cmath puede ser de gran ayuda. El módulo de un número complejo puede ser calculado usando la función integrada abs() y su fase puede ser calculada usando la función phase(z) disponible en el módulo cmath. Puedes convertir un número complejo en forma rectangular a forma polar usando polar(z), la cuál devolverá un par (r, phi), en donde r es abs(z) y phi es phase(z).

De manera similar, puedes convertir un número complejo en forma polar a rectangular usando rect(r, phi). El número complejo devuelto por esta función es r * (math.cos(phi) + math.sin(phi)*1j).

1
import cmath
2
3
cmath.polar(complex(1.0, 1.0))
4
# returns (1.4142135623730951, 0.7853981633974483)

5
6
cmath.phase(complex(1.0, 1.0))
7
# returns 0.7853981633974483

8
9
abs(complex(1.0, 1.0))
10
# returns 1.4142135623730951

El módulo cmath también nos permite usar funciones matemáticas regulares con números complejos. Por ejemplo, puedes calcular la raíz cuadrada de un número complejo usando sqrt(z) o su coseno usando cos(z).

1
import cmath
2
3
cmath.sqrt(complex(25.0, 25.0))
4
# returns (5.49342056733905+2.2754493028111367j)

5
6
cmath.cos(complex(25.0, 25.0))
7
# returns (35685729345.58163+4764987221.458499j)

Los números complejos tienen muchas aplicaciones como modelado de circuitos eléctricos, dinámica de fluidos, y análisis de señales. Si necesitas trabajar en cualquiera de estas cosas, el módulo cmath no te decepcionará.

Ideas Finales

Todas estas funciones que discutimos arriba tienen sus aplicaciones específicas. Por ejemplo, puedes usar la función factorial (x) para resolver problemas de permutación. Puedes usar las funciones trigonométricas para resolver un vector en coordenadas Cartesianas. También puedes usar funciones trigonométricas para simular funciones periódicas como sonido y ondas de luz.

De manera similar, la curva de una cuerda colgando entre dos postes puede ser determinada usando una función hiperbólica. Ya que todas estas funciones están disponibles directamente en el módulo math, hace más fácil crear pequeños programas que realicen estas tareas.

Espero que hayas disfrutado este tutorial. Si tienes alguna pregunta, házmelo saber en los comentarios.

Advertisement
Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.