➗ SymPy: Matemáticas Simbólicas con Python #
Mientras que NumPy y SciPy se especializan en los cálculos numéricos (trabajando con números concretos y aproximaciones), SymPy se enfoca en las matemáticas simbólicas. Esto significa que SymPy no calcula un resultado numérico inmediato, sino que manipula las expresiones matemáticas de manera simbólica, al igual que lo harías a mano en un papel. Con SymPy, puedes resolver ecuaciones, derivar, integrar, expandir y simplificar expresiones de forma exacta, manteniendo las variables como símbolos.
1. Conceptos Fundamentales: Símbolos y Expresiones #
Para usar SymPy, lo primero que necesitas es definir tus variables como símbolos. Esto le dice a Python que las letras como x o y no son variables de programación a las que se les asigna un valor, sino representaciones simbólicas.
import sympy as sp
# Definir símbolos
x, y, z = sp.symbols('x y z')
t, g = sp.symbols('t g')
# Crear una expresión simbólica
expresion = x**2 + 2*x + 1
print(f"Expresión: {expresion}")
El comando sp.symbols() es esencial para todo lo que hagas en SymPy.
2. Casos de Uso en Ingeniería Mecánica #
SymPy es increíblemente útil para:
- Derivación e integración: Calcular la velocidad a partir de la posición o la energía a partir de la fuerza.
- Resolución de ecuaciones: Encontrar las raíces de un polinomio o la solución a un sistema de ecuaciones.
- Álgebra: Expandir y simplificar ecuaciones complejas.
- Dinámica de sistemas: Modelar las ecuaciones de movimiento de un sistema.
- Análisis de circuitos: Resolver las ecuaciones que rigen la respuesta de un circuito.
3. Funciones Clave y Ejemplos Prácticos #
SymPy incluye una gran cantidad de funciones para manipular expresiones matemáticas. Aquí te mostramos algunas de las más utilizadas.
Álgebra y Simplificación #
sp.simplify(): Simplifica una expresión al máximo.sp.expand(): Expande una expresión polinomial..evalf(): Evalúa una expresión numérica simbólica y la convierte a un valor de punto flotante.
import sympy as sp
from sympy.abc import x, y
# Definir una expresión
expr = (x + y)**2
expr2 = x + 3*y + x + y
# Expandir la expresión
expandida = sp.expand(expr)
print(f"Expresión expandida: {expandida}")
# Simplificar
simplificada = sp.simplify(expr2)
print(f"Expresión simplificada: {simplificada}")
# Evaluar una expresión a un valor numérico
valor_simbolico = sp.sqrt(2) + sp.pi
valor_numerico = valor_simbolico.evalf()
print(f"Valor numérico de sqrt(2) + pi: {valor_numerico:.4f}")
Cálculo (Derivadas, Integrales y Ecuaciones Diferenciales) #
sp.diff(expr, var): Calcula la derivada de una expresión con respecto a una variable.sp.integrate(expr, var): Calcula la integral indefinida de una expresión.sp.integrate(expr, (var, a, b)): Calcula la integral definida en un rango.sp.Function('f')(var): Define una variable como una función de otra (por ejemplo, \(x(t)\)). Esto es crucial para la diferenciación en cadena y la resolución de ecuaciones diferenciales.sp.dsolve(eq, f(x)): Resuelve una ecuación diferencial para la función dada.
import sympy as sp
# Ejemplo: Posición, Velocidad y Aceleración
t, v0, a0 = sp.symbols('t v0 a0')
posicion = v0*t + (1/2)*a0*t**2
# Derivada para encontrar la velocidad
velocidad = sp.diff(posicion, t)
print(f"Velocidad: {velocidad}")
# Derivada para encontrar la aceleración
aceleracion = sp.diff(velocidad, t)
print(f"Aceleración: {aceleracion}")
# Integral para encontrar la posición
posicion_integrada = sp.integrate(velocidad, t)
print(f"Posición (por integración): {posicion_integrada}")
Resolución de Ecuaciones #
sp.Eq(lhs, rhs): Crea una ecuación simbólica. Es la forma correcta de representar una igualdad (lhs = rhs) para SymPy, en lugar de usar el operador==.sp.solve(eq, var): Resuelve una ecuación para una variable específica.sp.solve((eq1, eq2), (var1, var2)): Resuelve un sistema de ecuaciones.
import sympy as sp
from sympy.abc import x, y
# Ejemplo: Solución de una ecuación cuadrática
ecuacion = sp.Eq(x**2 - 4*x + 4, 0) # La ecuación x^2 - 4x + 4 = 0
solucion = sp.solve(ecuacion, x)
print(f"Solución de la ecuación: {solucion}")
# Ejemplo: Sistema de ecuaciones
eq1 = sp.Eq(x + y, 5)
eq2 = sp.Eq(2*x - y, 1)
solucion_sistema = sp.solve((eq1, eq2), (x, y))
print(f"Solución del sistema: x = {solucion_sistema[x]}, y = {solucion_sistema[y]}")
4. Ejemplos Extendidos para Ingeniería Mecánica #
1. Análisis de Esfuerzo en una Barra Cónica #
En lugar de calcular el esfuerzo en un punto, usemos SymPy para encontrar la función de esfuerzo axial \(\sigma(x)\) a lo largo de una barra cónica sometida a una carga axial \(P\). El área de la sección transversal \(A(x)\) varía linealmente desde un radio \(r_1\) hasta \(r_2\).
Concepto: El esfuerzo axial se define como \(\sigma = P/A\). La clave es definir \(A(x)\) de forma simbólica y luego sustituirlo en la ecuación de esfuerzo.
import sympy as sp
P, r1, r2, L, x = sp.symbols('P, r1, r2, L, x')
# Definir la función del radio a lo largo del eje x
r_x = r1 + (r2 - r1) * (x / L)
# Área de la sección transversal en función de x
A_x = sp.pi * r_x**2
print(f"Área de la sección transversal A(x): {A_x}")
# Expresión del esfuerzo axial en función de x
sigma_x = P / A_x
print(f"Esfuerzo axial sigma(x): {sigma_x}")
# Evaluar el esfuerzo en los extremos (x=0 y x=L) para P=1000, r1=0.1, r2=0.2, L=1
P_val = 1000
r1_val = 0.1
r2_val = 0.2
L_val = 1
sigma_en_0 = sigma_x.subs({P: P_val, r1: r1_val, r2: r2_val, L: L_val, x: 0}).evalf()
sigma_en_L = sigma_x.subs({P: P_val, r1: r1_val, r2: r2_val, L: L_val, x: L_val}).evalf()
print(f"\nEsfuerzo en x=0: {sigma_en_0:.2f} unidades")
print(f"Esfuerzo en x=L: {sigma_en_L:.2f} unidades")
2. Ecuación de Movimiento de un Sistema Masa-Resorte #
Derivar la ecuación de movimiento de un sistema simple masa-resorte-amortiguador. La ecuación de la fuerza es \(F = m a + c v + k x\), donde \(a = \frac{d^2x}{dt^2}\) y \(v = \frac{dx}{dt}\).
Concepto: Usamos la función sp.diff para obtener la velocidad y la aceleración a partir de una función de posición genérica \(x(t)\).
import sympy as sp
from sympy.abc import m, c, k, t
# Definir la posición del resorte como una función del tiempo
x = sp.Function('x')(t)
# Derivadas para velocidad y aceleración
v = sp.diff(x, t)
a = sp.diff(v, t)
# Ecuación de la fuerza
fuerza_ecuacion = sp.Eq(m * a + c * v + k * x, 0)
print(f"Ecuación del movimiento: {fuerza_ecuacion}")
# Resolver la ecuación diferencial para encontrar la función de posición x(t)
solucion_x = sp.dsolve(fuerza_ecuacion, x)
print(f"Solución general x(t): {solucion_x}")
3. Optimización de un Proyectil #
Encontrar el ángulo de lanzamiento \(\theta\) que maximiza el alcance de un proyectil en un plano inclinado, donde la ecuación de trayectoria es una función de \(\theta\). En este caso, el alcance \(R\) es \(R(\theta) = \frac{v_0^2}{g} \left(\sin(2\theta) + \frac{1}{\tan(\alpha)} \sin^2\theta\right)\).
Concepto: Para maximizar una función, derivamos con respecto a la variable de interés \(\left(\theta\right)\), igualamos a cero y resolvemos para encontrar el valor óptimo.
import sympy as sp
v0, g, theta, alpha = sp.symbols('v0, g, theta, alpha')
# Definir la ecuación del alcance en un plano inclinado
alcance = (v0**2 / g) * (sp.sin(2 * theta) + (1 / sp.tan(alpha)) * (sp.sin(theta))**2)
# Derivar el alcance con respecto al ángulo
derivada_alcance = sp.diff(alcance, theta)
print(f"Derivada del alcance: {derivada_alcance}")
# Resolver para la derivada igual a cero
# El resultado analítico es complejo, pero SymPy lo puede manejar.
# Con valores:
v0_val = 10
g_val = 9.81
alpha_val = sp.pi / 4 # Ángulo de 45 grados
derivada_numerica = derivada_alcance.subs({v0: v0_val, g: g_val, alpha: alpha_val})
print(f"\nDerivada con valores: {derivada_numerica}")
# Nota: Resolver analíticamente para theta es complejo.
# SymPy puede hacerlo, pero el resultado es largo y no muy intuitivo.
# Por ejemplo: angulo_optimo = sp.solve(derivada_alcance, theta)[0]
# La función .evalf() sería útil para obtener un valor numérico de la solución.
4. Cálculo del Momento de Inercia #
Calcular el momento de inercia de un cilindro sólido de radio \(R\) y longitud \(L\) con respecto a un eje perpendicular que pasa por su centro. La fórmula es \(I = \int_{-L/2}^{L/2} \rho A(x) x^2 dx\), donde \(A(x) = \pi R^2\) y \(\rho\) es la densidad de masa.
Concepto: Usaremos sp.integrate para resolver la integral definida.
import sympy as sp
from sympy.abc import rho, R, L, x
# Definir la masa por unidad de longitud
masa_por_longitud = rho * sp.pi * R**2
# Expresión para la integración
expresion_integrar = masa_por_longitud * x**2
# Calcular la integral definida
momento_inercia = sp.integrate(expresion_integrar, (x, -L/2, L/2))
print(f"Momento de inercia del cilindro: {momento_inercia}")
5. Sistema de Ecuaciones de un Truss Simple #
Encontrar las fuerzas internas en un armazón (truss) simple. Usando el método de los nodos, se puede establecer un sistema de ecuaciones lineales para las fuerzas en cada miembro.
Concepto: Definimos las fuerzas como símbolos y luego usamos sp.solve para resolver el sistema de ecuaciones.
import sympy as sp
F1, F2, Fx, Fy = sp.symbols('F1, F2, Fx, Fy')
# Definir las ecuaciones de equilibrio en un nodo
# Suma de fuerzas en x:
eq_x = sp.Eq(Fx + F1*sp.cos(sp.pi/4) + F2*sp.cos(sp.pi/4), 0)
# Suma de fuerzas en y:
eq_y = sp.Eq(Fy + F1*sp.sin(sp.pi/4) - F2*sp.sin(sp.pi/4), 0)
# Resolver el sistema para F1 y F2
solucion = sp.solve((eq_x, eq_y), (F1, F2))
print(f"Solución para F1 y F2:\n{solucion}")
Ejercicios Prácticos de SymPy: Resuelve Problemas Simbólicos #
Pon a prueba tus habilidades en SymPy con estos 20 ejercicios, diseñados para reforzar los conceptos de matemáticas simbólicas aplicadas a la ingeniería.
Para todos los ejercicios, usa import sympy as sp y define tus símbolos al inicio.
1. Creación de Símbolos y Expresiones (Ejercicios 1-4) #
- Crea una expresión simbólica para el área de un triángulo,
A = (1/2) * base * altura.Haz clic para ver la solución
import sympy as sp base, altura = sp.symbols('base, altura') area = (1/2) * base * altura print(f"Área del triángulo: {area}") - Define una expresión para la fuerza de rozamiento,
F = mu * N, dondemuyNson símbolos. - Crea una expresión para el volumen de un cono,
V = (1/3) * pi * r**2 * h, usandosp.piy los símbolosryh. - Define una expresión para la energía potencial elástica,
E = (1/2) * k * x**2.
2. Simplificación y Expansión (Ejercicios 5-8) #
- Simplifica la siguiente expresión trigonométrica:
sp.sin(x)**2 + sp.cos(x)**2.Haz clic para ver la solución
import sympy as sp x = sp.symbols('x') expresion = sp.sin(x)**2 + sp.cos(x)**2 expresion_simplificada = sp.simplify(expresion) print(f"Expresión simplificada: {expresion_simplificada}") - Simplifica la siguiente expresión algebraica:
(x**2 - 4) / (x - 2). - Expande la expresión
(a + b)**3. - Simplifica la expresión
sp.sin(x + y) + sp.cos(x).
3. Derivadas e Integrales (Ejercicios 9-12) #
- Calcula la derivada de la posición de un objeto en movimiento
P(t) = 3*t**2 + 5*t - 1para encontrar su velocidad.Haz clic para ver la solución
import sympy as sp t = sp.symbols('t') posicion = 3*t**2 + 5*t - 1 velocidad = sp.diff(posicion, t) print(f"Velocidad de la posición: {velocidad}") - Calcula la segunda derivada de la función de posición del ejercicio anterior para encontrar la aceleración.
- Resuelve la integral indefinida de la función de fuerza
F(x) = k*xpara encontrar la función de trabajo. - Calcula la integral definida de la función de potencia
P(t) = 10*t**2en el rango detde 0 a 5 segundos para encontrar la energía total.
4. Resolución de Ecuaciones (Ejercicios 13-16) #
- Resuelve la siguiente ecuación cuadrática para
x:x**2 - 5*x + 6 = 0.Haz clic para ver la solución
import sympy as sp x = sp.symbols('x') ecuacion = x**2 - 5*x + 6 - 0 solucion = sp.solve(ecuacion, x) print(f"Solución de la ecuación: {solucion}") - Resuelve la siguiente ecuación lineal para
y:sp.Eq(2*y + 7, 15). - Resuelve el siguiente sistema de ecuaciones para
xyy:x + y = 102*x - y = 5
- Un resorte tiene una rigidez
k = 50 N/m. La fuerza que ejerce esF = k*x. Si la fuerza es de25 N, ¿cuál es la deformaciónx?
5. Aplicaciones en Ingeniería (Ejercicios 17-20) #
- Esfuerzo en un cable: El esfuerzo en un cable de diámetro
dessigma = P / (pi*d**2). Define la expresión para el esfuerzo y luego sustituye los valoresP = 1000 Nyd = 0.01 mpara obtener el valor numérico.Haz clic para ver la solución
import sympy as sp P, d = sp.symbols('P, d') sigma = P / (sp.pi*d**2) sigma_numerico = sigma.subs({P: 1000, d: 0.01}).evalf() print(f"Esfuerzo en un cable: {sigma_numerico:.2f} unidades") - Deflexión de una viga: La deflexión de una viga en voladizo sometida a una carga en el extremo es
delta = (P*L**3)/(3*E*I). Define esta expresión y luego calcula la derivada de la deflexión con respecto a la longitudL. - Frecuencia natural: La frecuencia natural de un sistema masa-resorte es
omega_n = sp.sqrt(k/m). Define la ecuación para la frecuencia y luego usa.evalf()para calcular el valor numérico cuandok = 1000 N/mym = 5 kg. - Cinemática: La posición de una partícula está dada por
x(t) = A*sp.cos(omega*t). Define esta función simbólicamente y luego usasp.diff()para encontrar las expresiones de la velocidadv(t)y la aceleracióna(t).