Biblioteca NumPy

🔢 NumPy: Funciones Comunes para el Ingeniero Mecánico

#

NumPy es la herramienta fundamental para el cálculo numérico en Python, y su poder reside en sus funciones optimizadas para trabajar con arrays. Aquí te presento algunas de las funciones más comunes que te serán de gran utilidad en la ingeniería mecánica, con ejemplos prácticos.

1. Creación y Manipulación de Arrays

#

Antes de realizar cálculos, necesitas crear tus arrays y saber cómo interactuar con ellos.

Creación de Arrays

#

• np.array(): Crea un array a partir de una lista o tupla. Es la forma más básica de empezar.
  • Ejemplo: np.array([100, 150, 200])

    import numpy as np 
    fuerzas = np.array([100, 150, 200])
    print(fuerzas)
    

• np.zeros() y np.ones(): Crean arrays de un tamaño específico, llenos de ceros o unos, respectivamente. Son útiles para inicializar variables o matrices.
  • Ejemplo: np.zeros((3, 3)) y np.ones((3, 3))

    import numpy as np 
    matriz_rigidez = np.zeros((3, 3))
    print(matriz_rigidez)
    
    ones = np.ones((3, 3))
    print(ones)
    

• np.arange(): Crea un array con un rango de valores. Funciona de manera similar a la función range de Python.
  • Ejemplo: tiempo = np.arange(0, 10, 0.1) (Un array de 0 a 9.9 con pasos de 0.1, importante no incluye el último valor)

    import numpy as np 
    tiempo = np.arange(0, 10, 0.1)
    print(tiempo)
    

• np.linspace(): Crea un array con un número específico de puntos distribuidos uniformemente en un intervalo. Ideal para generar datos para gráficos.
  • Ejemplo: x = np.linspace(0, 10, 50) (50 puntos entre 0 y 10)

    import numpy as np 
    x = np.linspace(0, 10, 50)
    print(x)
    

Propiedades y Acceso a Elementos

#

Una matriz en NumPy es un array bidimensional. Para acceder a sus elementos, utilizas índices de la forma [fila, columna], al igual que en matemáticas. Cabe destacar que los indices parten de 0, por lo tanto el primero elemento es el 0, el segundo es el 1 y así sucesivamente.

• Acceder a un elemento:

  import numpy as np
  matriz = np.array([[10, 20, 30],
                     [40, 50, 60],
                     [70, 80, 90]])
  
  # Acceder al elemento en la fila 1, columna 2 (índice 1, 2)
  elemento = matriz[1, 2]
  print(f"Elemento en la fila 2, columna 3: {elemento}") # Salida: 60
  

• Acceder a una fila o columna completa:

  import numpy as np
  matriz = np.array([[10, 20, 30],
                     [40, 50, 60],
                     [70, 80, 90]])
  # Acceder a la segunda fila
  fila_2 = matriz[1, :]
  print(f"La segunda fila es: {fila_2}") # Salida: [40 50 60]
  
  # Acceder a la tercera columna
  columna_3 = matriz[:, 2]
  print(f"La tercera columna es: {columna_3}") # Salida: [30 60 90]
  

• Modificar un elemento: Puedes asignar un nuevo valor a cualquier posición.

  import numpy as np
  matriz = np.array([[10, 20, 30],
                     [40, 50, 60],
                     [70, 80, 90]])
  matriz[0, 0] = 5
  print(f"Matriz modificada: \n{matriz}") # El primer elemento ahora es 5
  # '\n' es un salto de línea en la salida estandar
  

2. Funciones Matemáticas y Estadísticas

#

NumPy tiene funciones matemáticas integradas que operan directamente sobre arrays, lo que las hace increíblemente rápidas.

• np.sum(), np.mean(), np.max(), np.min(), np.std(): Calculan la suma, promedio, valor máximo, mínimo y desviación estándar de un array, respectivamente.
  • Ejemplo: Si tienes un array de lecturas de temperatura de un motor:

    import numpy as np
    temperaturas = np.array([85, 92, 88, 95, 87])
    print("Temperatura promedio:", np.mean(temperaturas))
    

• np.sqrt() y np.sin(), np.cos(): Calculan la raíz cuadrada, el seno y el coseno de cada elemento de un array.
  • Ejemplo: Calcular la componente de una fuerza:

    import numpy as np
    angulo_rad = np.pi / 4 # 45 grados en radianes
    fuerza_total = 100
    componente_x = fuerza_total * np.cos(angulo_rad)
    print("Componente en X:", componente_x)
    

3. Álgebra Lineal

#

Aquí es donde NumPy brilla para los ingenieros. Ofrece un módulo completo (numpy.linalg) para resolver problemas de álgebra lineal de manera eficiente.

• np.dot() o @: Calcula el producto punto de dos arrays. Es fundamental para la multiplicación de matrices.
  • Ejemplo: Si A es una matriz de rigidez y x es un vector de desplazamiento, el producto A @ x te da el vector de fuerza.

    import numpy as np
    matriz_rigidez = np.array([[200, -50],
                               [-50, 150]])
    desplazamientos = np.array([0.1, 0.2])
    fuerzas = matriz_rigidez @ desplazamientos
    print("Vector de fuerzas:", fuerzas)
    

• np.linalg.inv(): Calcula la inversa de una matriz cuadrada.
  • Ejemplo: Resolver un sistema de ecuaciones lineales de la forma \(Ax = b\) se puede hacer con np.linalg.inv(A) @ b.
• np.linalg.solve(): Esta función es la forma más recomendada y estable para resolver un sistema de ecuaciones lineales \(Ax = b\). Es más rápida y precisa que calcular la inversa.
  • Ejemplo:

    import numpy as np
    # Sistema de ecuaciones
    # 3x + 1y = 9
    # 1x + 2y = 8
    A = np.array([[3, 1],
                  [1, 2]])        # Matriz de coeficientes
    b = np.array([9, 8])          # Vector de resultados
    x = np.linalg.solve(A, b)     # Resuelve para x
    print("Solución para [x, y]:", x)
    

4. Indexación y Slicing Avanzados

#

Una de las ventajas más grandes de NumPy es su poderosa forma de acceder y manipular elementos en arrays.

• Slicing: Acceder a un subconjunto de un array utilizando el operador :.
  • Ejemplo: datos[1:5] (Elementos del índice 1 al 4)
• Indexación Booleana: Acceder a elementos de un array que cumplen una condición.
  • Ejemplo: Encontrar todas las lecturas de temperatura por encima de un umbral.

    import numpy as np
    temperaturas = np.array([85, 92, 88, 95, 87, 101])
    altas_temperaturas = temperaturas[temperaturas > 95]
    print("Lecturas sobre 95°C:", altas_temperaturas)
    

🔩 10 Ejemplos Prácticos de NumPy en Ingeniería Mecánica

#

Las funciones que acabas de aprender en NumPy no son solo teoría; son herramientas poderosas para resolver problemas reales. Aquí te presento 10 ejemplos de cómo puedes aplicar NumPy en diferentes áreas de la ingeniería mecánica.

1. Análisis de Esfuerzo y Deformación

#

Calcula el esfuerzo a partir de un array de fuerzas y áreas.

import numpy as np

fuerzas_N = np.array([1000, 1200, 950, 1100])
areas_m2 = np.array([0.005, 0.006, 0.004, 0.0055])

esfuerzos_Pa = fuerzas_N / areas_m2
print(f"Esfuerzos (Pa): {esfuerzos_Pa}")

2. Cálculo de Potencia de Múltiples Motores

#

Calcula la potencia de un array de torques y velocidades angulares.

import numpy as np

torques_Nm = np.array([50, 55, 60, 48])
velocidades_rad_s = np.array([100, 110, 95, 105])

potencias_W = torques_Nm * velocidades_rad_s
print(f"Potencias (W): {potencias_W}")

3. Análisis de Datos de Vibración

#

Calcula la media y la desviación estándar de un conjunto de lecturas de acelerómetros.

import numpy as np

lecturas_aceleracion = np.array([9.81, 10.1, 9.75, 10.05, 9.98])
aceleracion_promedio = np.mean(lecturas_aceleracion)
desviacion_estandar = np.std(lecturas_aceleracion)

print(f"Aceleración promedio: {aceleracion_promedio:.2f} m/s^2")
print(f"Desviación estándar: {desviacion_estandar:.2f} m/s^2")

4. Resolución de un Sistema de Ecuaciones

#

Resuelve un sistema de ecuaciones lineales que describe las fuerzas en un armazón estáticamente indeterminado.

import numpy as np

A = np.array([[2, 1, 1], [4, -6, 0], [-2, 7, 2]])  # Matriz de coeficientes
b = np.array([8, -10, 1])                          # Vector de resultados

x = np.linalg.solve(A, b)
print(f"Solución del sistema: {x}")

5. Transformación de Coordenadas de un Robot

#

Realiza una rotación y traslación de puntos en un espacio 3D.

import numpy as np

# Punto original (x, y, z)
punto = np.array([1, 2, 3])

# Matriz de rotación (rotación 90 grados alrededor del eje Z)
matriz_rotacion = np.array([
    [0, -1, 0],
    [1,  0, 0],
    [0,  0, 1]
])

punto_rotado = matriz_rotacion @ punto
print(f"Punto rotado: {punto_rotado}")

6. Cálculo del Esfuerzo Cortante en un perno

#

Calcula los esfuerzos cortantes en un conjunto de pernos a partir de un array de fuerzas y la geometría de la sección transversal.

import numpy as np

# Datos de del perno
diametro_m = 0.1
fuerzas_corte_N = np.array([1000, 1500, 2000])

# Suponiendo una sección circular
area_seccion_m2 = diametro_m**2 * np.pi / 4  
esfuerzos_cortantes_Pa = (fuerzas_corte_N / area_seccion_m2)

print(f"Esfuerzos cortantes (Pa): {esfuerzos_cortantes_Pa}")

7. Detección de Valores Extremos en Datos de Fatiga

#

Identifica las cargas máximas que superan un umbral crítico.

import numpy as np

cargas_ensayo = np.array([200, 250, 310, 290, 350, 240])
umbral_critico = 300

cargas_superiores = cargas_ensayo[cargas_ensayo > umbral_critico]
print(f"Cargas que superan el umbral: {cargas_superiores}")

8. Generación de Datos para Gráficos

#

Crea arrays de puntos uniformemente espaciados para graficar curvas de rendimiento o trayectorias.

import numpy as np
import matplotlib.pyplot as plt

# Genera 100 puntos entre 0 y 2*pi para una función sinusoidal
x = np.linspace(0, 2 * np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title("Onda sinusoidal")
plt.show()

9. Cálculo de la Energía Cinética de un Sistema con Múltiples Masas

#

Usa el producto punto para calcular la energía total de un sistema con varias masas y velocidades.

import numpy as np

masas = np.array([2, 5, 3])   # en kg
velocidades = np.array([10, 5, 8]) # en m/s

energia_total = 0.5 * np.sum(masas * velocidades**2)
print(f"Energía cinética total: {energia_total} J")

10. Interpolación de Datos de una Curva de Material

#

Utiliza la función np.interp para estimar un valor entre dos puntos conocidos, útil para tablas de propiedades de materiales.

import numpy as np

# Datos de una curva de esfuerzo-deformación
deformacion_conocida = np.array([0.0, 0.05, 0.1, 0.15, 0.2])
esfuerzo_conocido = np.array([0, 100, 180, 230, 250])

# Valor de deformación a estimar
deformacion_a_estimar = 0.08

esfuerzo_estimado = np.interp(deformacion_a_estimar, deformacion_conocida, esfuerzo_conocido)
print(f"El esfuerzo estimado para la deformación {deformacion_a_estimar} es: {esfuerzo_estimado} MPa")

Aquí tienes 25 ejercicios para complementar el estudio de NumPy, enfocados en la práctica para estudiantes de ingeniería mecánica.

Ejercicios Propuestos: ¡Domina NumPy!

#

Nivel 1: Creación y Propiedades de Arrays

#

1. Crea un array de NumPy llamado longitudes con los valores [10.5, 12.2, 8.9, 15.1]. Imprime el array.
   Haz clic para ver la solución

   import numpy as np
   longitudes = np.array([10.5, 12.2, 8.9, 15.1])
   print(longitudes)
   

2. Crea un array de ceros de 4x4 llamado matriz_identidad. Luego, modifica sus elementos para que se convierta en una matriz identidad.
3. Usa np.arange() para crear un array de tiempo que vaya de 0 a 5 segundos, con pasos de 0.25 segundos.
4. Crea un array de 15 valores espaciados uniformemente entre 0 y 100, utilizando np.linspace().
5. Dada una matriz M = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), accede y modifica el elemento en la fila 1, columna 2 (índices 1 y 2) a 99.

Nivel 2: Funciones Matemáticas y Estadísticas

#

6. Calcula el promedio y la desviación estándar de un array de presiones [100, 105, 98, 110, 102].
   Haz clic para ver la solución

   import numpy as np
   presiones = np.array([100, 105, 98, 110, 102])
   print("Promedio:", np.mean(presiones))
   print("Desviación estándar:", np.std(presiones))
   

7. Encuentra el valor máximo y mínimo en un array de datos de temperatura [25.5, 26.1, 24.9, 27.0].
8. Calcula la raíz cuadrada de cada elemento en un array de áreas [16, 25, 36, 49].
9. Convierte un array de ángulos de grados a radianes. Usa np.deg2rad().
10. Saca el coseno de cada elemento en un array de ángulos [np.pi/2, np.pi, 2*np.pi].

Nivel 3: Álgebra Lineal

#

11. Realiza el producto punto entre dos vectores: v1 = np.array([1, 2]) y v2 = np.array([3, 4]).
    Haz clic para ver la solución

    import numpy as np
    v1 = np.array([1, 2])
    v2 = np.array([3, 4])
    print("Producto punto:", v1 @ v2)
    

12. Multiplica una matriz A = np.array([[2, 3], [1, 4]]) por un vector b = np.array([5, 6]) para obtener un nuevo vector.
13. Resuelve el sistema de ecuaciones lineales \(2x + y = 7\) y \(3x + 4y = 12\) utilizando np.linalg.solve().
14. Calcula la inversa de una matriz de rigidez: K = np.array([[3, -1], [-1, 2]]).
15. Calcula la transpuesta de una matriz M = np.array([[1, 2], [3, 4], [5, 6]]).

Nivel 4: Indexación y Slicing Avanzados

#

16. Dada una lista de lecturas de presión presiones = np.array([10, 12, 11, 15, 18, 20]), extrae los elementos del índice 2 al 4.
    Haz clic para ver la solución

    import numpy as np
    presiones = np.array([10, 12, 11, 15, 18, 20])
    print(presiones[2:5])
    

17. Extrae la segunda columna de una matriz 3x3.
18. Utiliza indexación booleana para encontrar todos los valores en un array de vibraciones [0.1, 0.5, 0.8, 0.2, 0.9, 1.2] que sean mayores a 0.7.
19. Asigna el valor 0 a todos los elementos de un array de datos que sean mayores a 100.
20. Reemplaza todos los valores negativos en un array [-5, 2, -8, 10, -1] por cero.

Nivel 5: Aplicaciones Combinadas

#

21. Análisis de Lotes de Esfuerzo: Dados arrays de fuerzas y áreas, calcula el esfuerzo para cada par de valores.
    Haz clic para ver la solución

    import numpy as np
    fuerzas_N = np.array([1000, 1200, 950, 1100])
    areas_m2 = np.array([0.005, 0.006, 0.004, 0.0055])
    esfuerzos_Pa = fuerzas_N / areas_m2
    print(f"Esfuerzos (Pa): {esfuerzos_Pa}")
    

22. Energía de un Resorte: Calcula la energía potencial de un resorte \(\left(E = \frac{1}{2}kx^2\right)\) para un array de deformaciones x y una constante k = 100.
23. Simulación de Caída Libre: Genera un array de tiempo de 0 a 5 segundos y calcula la velocidad \(\left(v = gt\right)\) y la posición \(\left(p = \frac{1}{2}gt^2\right)\) en cada instante. Usa g = 9.81.
24. Promedio de Columnas: Calcula el promedio de cada columna en una matriz que contiene lecturas de diferentes sensores.
25. Filtrado de Datos: Filtra un array de lecturas para eliminar los valores atípicos (por encima de 20 y por debajo de 5).