Ejercicios: Funciones en Python

Introducción

Las funciones son bloques fundamentales de código reutilizable que permiten organizar programas complejos en componentes más pequeños y manejables. En el contexto de la física y otras ciencias, las funciones son especialmente útiles para modelar fenómenos, realizar cálculos repetitivos y analizar datos de manera eficiente.

Trabajaremos con funciones básicas, parámetros avanzados, documentación, type hints y manejo de errores, aplicando estos conceptos a problemas físicos relevantes.

Funciones Básicas

Ejercicio 1: Conversión de Unidades

Escribe una función llamada convertir_temperatura que convierta una temperatura de una escala a otra. La función debe aceptar tres parámetros: el valor de la temperatura, la unidad de origen y la unidad de destino.

Las unidades válidas son: “C” (Celsius), “F” (Fahrenheit) y “K” (Kelvin).

Incluye las siguientes conversiones:

\[\begin{split}T_F &= T_C \times \frac{9}{5} + 32 \\ T_K &= T_C + 273.15 \\ T_C &= (T_F - 32) \times \frac{5}{9} \\ T_C &= T_K - 273.15\end{split}\]

Ejemplo de uso:

temp_celsius = convertir_temperatura(32, 'F', 'C')
print(temp_celsius)  # Debería imprimir: 0.0

temp_kelvin = convertir_temperatura(100, 'C', 'K')
print(temp_kelvin)  # Debería imprimir: 373.15

Ejercicio 2: Cálculo de la Energía Cinética

Escribe una función llamada energia_cinetica que calcule la energía cinética de un objeto dada su masa y velocidad:

\[E_k = \frac{1}{2}mv^2\]

La función debe retornar la energía cinética en joules.

Luego, escribe otra función llamada velocidad_desde_energia que calcule la velocidad de un objeto a partir de su masa y energía cinética:

\[v = \sqrt{\frac{2E_k}{m}}\]

Usa la primera función dentro de un programa que pida al usuario la masa y velocidad de varios objetos, y muestre su energía cinética.

Ejercicio 3: Distancia entre Dos Puntos

Escribe una función llamada distancia_euclidiana que calcule la distancia entre dos puntos en un espacio bidimensional:

\[d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}\]

La función debe aceptar cuatro parámetros: x1, y1, x2, y2.

Extiende tu solución escribiendo una función distancia_3d que calcule la distancia en un espacio tridimensional:

\[d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2 + (z_2 - z_1)^2}\]

Ejercicio 4: Cálculo de Movimiento Armónico Simple

Escribe una función llamada posicion_mas que calcule la posición de una partícula en movimiento armónico simple en un tiempo específico:

\[x(t) = A \cos(\omega t + \phi)\]

La función debe aceptar los siguientes parámetros:

  • A: amplitud (metros)

  • omega: frecuencia angular (radianes/segundo)

  • phi: fase inicial (radianes)

  • t: tiempo (segundos)

Además, escribe dos funciones adicionales:

  • velocidad_mas: para calcular la velocidad instantánea

  • aceleracion_mas: para calcular la aceleración instantánea

\[\begin{split}v(t) &= -A\omega \sin(\omega t + \phi) \\ a(t) &= -A\omega^2 \cos(\omega t + \phi)\end{split}\]

Parámetros Avanzados

Ejercicio 5: Caída Libre con Resistencia del Aire

Escribe una función llamada caida_con_resistencia que calcule la posición y velocidad de un objeto en caída libre considerando la resistencia del aire.

Las ecuaciones diferenciales para este sistema son:

\[\begin{split}\frac{dv}{dt} &= g - \frac{b}{m}v |v| \\ \frac{dx}{dt} &= v\end{split}\]

donde:

  • g es la aceleración de la gravedad

  • b es el coeficiente de resistencia del aire

  • m es la masa del objeto

  • v es la velocidad

  • x es la posición

Método de Euler para la Resolución Numérica

El método de Euler es una técnica numérica para resolver ecuaciones diferenciales ordinarias. Consiste en aproximar la solución usando pequeños pasos de tiempo (Δt), donde el valor de una variable en el siguiente paso se calcula a partir de su valor actual y su tasa de cambio.

Dada una ecuación diferencial de la forma dy/dt = f(t,y), el método de Euler aproxima la solución como:

\[y_{i+1} = y_i + f(t_i, y_i) \cdot \Delta t\]

Para nuestro problema de caída libre con resistencia, aplicamos el método de Euler a ambas ecuaciones:

  1. Para actualizar la velocidad, usamos la aceleración instantánea:

\[v_{i+1} = v_i + \left(g - \frac{b}{m}v_i |v_i|\right) \Delta t\]

  1. Para actualizar la posición, usamos la velocidad actual:

\[x_{i+1} = x_i + v_i \Delta t\]

Este proceso se repite para cada paso de tiempo hasta alcanzar el tiempo final de simulación.

La función debe aceptar los siguientes parámetros:

  • tiempo_final: tiempo total de simulación (segundos)

  • dt: paso de tiempo para la simulación (segundos)

  • altura_inicial: posición inicial (metros, valor por defecto: 0)

  • velocidad_inicial: velocidad inicial (metros/segundo, valor por defecto: 0)

  • masa: masa del objeto (kg, valor por defecto: 1)

  • coef_resistencia: coeficiente de resistencia del aire (kg/m, valor por defecto: 0.1)

  • g: aceleración de la gravedad (metros/segundo², valor por defecto: 9.8)

La función debe retornar dos listas: una con los valores de posición y otra con los valores de velocidad para cada paso de tiempo.

Ejercicio 6: Simulación de Trayectoria de Proyectil

Escribe una función llamada simular_proyectil que calcule la trayectoria de un proyectil considerando la resistencia del aire.

Las ecuaciones diferenciales para este sistema son:

\[\begin{split}\frac{dv_x}{dt} &= -\frac{b}{m}v_x\sqrt{v_x^2 + v_y^2} \\ \frac{dv_y}{dt} &= -g -\frac{b}{m}v_y\sqrt{v_x^2 + v_y^2} \\ \frac{dx}{dt} &= v_x \\ \frac{dy}{dt} &= v_y\end{split}\]

donde:

  • \(v_x\) y \(v_y\) son las componentes de la velocidad

  • x e y son las coordenadas de posición

  • g es la aceleración de la gravedad

  • b es el coeficiente de resistencia del aire

  • m es la masa del proyectil

Para resolver numéricamente estas ecuaciones, aplicaremos el método de Euler.

  1. Para actualizar las componentes de la velocidad:

\[\begin{split}v_{x,i+1} &= v_{x,i} + \left(-\frac{b}{m}v_{x,i}\sqrt{v_{x,i}^2 + v_{y,i}^2}\right) \Delta t \\ v_{y,i+1} &= v_{y,i} + \left(-g -\frac{b}{m}v_{y,i}\sqrt{v_{x,i}^2 + v_{y,i}^2}\right) \Delta t\end{split}\]

  1. Para actualizar las posiciones:

\[\begin{split}x_{i+1} &= x_i + v_{x,i} \Delta t \\ y_{i+1} &= y_i + v_{y,i} \Delta t\end{split}\]

Este proceso se repite en cada paso de tiempo hasta que el proyectil toque el suelo (y ≤ 0).

La función debe aceptar los siguientes parámetros:

  • velocidad_inicial: velocidad inicial (metros/segundo)

  • angulo: ángulo de lanzamiento (grados)

  • altura_inicial: altura inicial (metros, valor por defecto: 0)

  • masa: masa del proyectil (kg, valor por defecto: 1)

  • coef_resistencia: coeficiente de resistencia del aire (kg/m, valor por defecto: 0)

  • g: aceleración de la gravedad (metros/segundo², valor por defecto: 9.8)

  • dt: paso de tiempo para la simulación (segundos, valor por defecto: 0.01)

La función debe retornar tres listas:

  • Lista de posiciones en x

  • Lista de posiciones en y

  • Lista de tiempos

La simulación debe detenerse cuando el proyectil toque el suelo (y ≤ 0).

Ejercicio 7: Calculadora de Estadísticas

Escribe una función llamada calcular_estadisticas que calcule varias estadísticas para una lista de números.

La función debe aceptar como parámetro una lista de números y un parámetro booleano opcional detallado (por defecto: False).

La función debe retornar:

  • Si detallado es False: una tupla con (media, mediana, desviación estándar)

  • Si detallado es True: un diccionario con las siguientes estadísticas:

    • “media”: media aritmética

    • “mediana”: valor mediano

    • “desviacion_estandar”: desviación estándar

    • “minimo”: valor mínimo

    • “maximo”: valor máximo

    • “rango”: diferencia entre máximo y mínimo

    • “suma”: suma de todos los valores

    • “cuenta”: cantidad de elementos

Implementa los cálculos manualmente, sin usar módulos como statistics.

Documentación y Anotaciones

Ejercicio 8: Campo Eléctrico de una Distribución de Cargas

Escribe una función llamada campo_electrico que calcule el campo eléctrico en un punto del espacio debido a una distribución de cargas puntuales.

La función debe seguir la ley de Coulomb:

\[\vec{E} = \sum_i \frac{1}{4\pi\varepsilon_0} \frac{q_i}{r_i^2} \hat{r}_i\]

donde:

  • \(\varepsilon_0\) es la permitividad del vacío (8.85 × 10⁻¹² F/m)

  • \(q_i\) es la carga de la i-ésima partícula

  • \(r_i\) es la distancia desde la carga hasta el punto de interés

  • \(\hat{r}_i\) es el vector unitario en la dirección desde la carga hasta el punto

La función debe incluir:

  • Docstring completo con descripción, parámetros y retorno

  • Type hints para todos los parámetros y valor de retorno

Parámetros:

  • cargas: lista de tuplas, donde cada tupla contiene (carga, posición_x, posición_y)

  • punto: tupla con las coordenadas (x, y) donde se calculará el campo

Retorno:

  • Una tupla con las componentes (Ex, Ey) del campo eléctrico resultante

Ejercicio 9: Simulación de Circuito RLC

Escribe una función llamada respuesta_rlc que simule la respuesta de un circuito RLC (Resistor-Inductor-Capacitor) a un voltaje de entrada.

Descripción física del sistema

Un circuito RLC está compuesto por una resistencia (R), un inductor (L) y un capacitor (C) conectados en serie o en paralelo. La ecuación diferencial que gobierna el sistema en serie es:

\[L\frac{di}{dt} + Ri + \frac{1}{C}\int i \, dt = V(t)\]

donde:

  • i es la corriente en el circuito

  • V(t) es el voltaje de entrada como función del tiempo

  • R es la resistencia en ohms

  • L es la inductancia en henrios

  • C es la capacitancia en faradios

Formulación matemática

Para facilitar la simulación numérica, reescribimos la ecuación como un sistema de ecuaciones diferenciales de primer orden, introduciendo q como la carga en el capacitor (donde i = dq/dt):

\[\begin{split}\frac{di}{dt} &= \frac{1}{L}\left(V(t) - Ri - \frac{q}{C}\right) \\ \frac{dq}{dt} &= i\end{split}\]

Método de Euler para la solución numérica

Para resolver este sistema, aplicaremos el método de Euler, que nos permite aproximar la solución mediante pasos discretos en el tiempo. Partiendo de las condiciones iniciales (i₀, q₀), en cada paso de tiempo calculamos:

\[\begin{split}i_{n+1} &= i_n + \frac{dt}{L}\left(V(t_n) - R \cdot i_n - \frac{q_n}{C}\right) \\ q_{n+1} &= q_n + i_n \cdot dt\end{split}\]

Donde dt es el paso de tiempo para la simulación.

Voltajes en los componentes

En cada paso de tiempo, también calculamos los voltajes en cada componente:

\[\begin{split}V_R &= R \cdot i \\ V_C &= \frac{q}{C} \\ V_L &= V(t) - V_R - V_C = L\frac{di}{dt}\end{split}\]

Lo cual en la simulación se puede expresar como:

\[\begin{split}V_{R,n} &= R \cdot i_n \\ V_{C,n} &= \frac{q_n}{C} \\ V_{L,n} &= V(t_n) - V_{R,n} - V_{C,n}\end{split}\]

Algoritmo para la simulación

La simulación seguirá los siguientes pasos:

  1. Inicializar todas las variables y arreglos para almacenar los resultados

  2. Establecer las condiciones iniciales para t, i y q

  3. Para cada paso de tiempo hasta alcanzar el tiempo final:

    1. Guardar los valores actuales (t, i, q) en sus respectivos arreglos

    2. Calcular los voltajes en cada componente (R, L, C)

    3. Calcular las derivadas di/dt y dq/dt

    4. Actualizar i y q usando el método de Euler

    5. Avanzar al siguiente paso de tiempo

  4. Construir y retornar un diccionario con todos los resultados

La función debe usar type hints y tener una docstring completa explicando su funcionamiento.

Parámetros:

  • R: resistencia (ohms)

  • L: inductancia (henrios)

  • C: capacitancia (faradios)

  • V_func: función que describe el voltaje de entrada en función del tiempo

  • tiempo_final: tiempo total de simulación (segundos)

  • dt: paso de tiempo para la simulación (segundos, valor por defecto: 0.001)

  • i_inicial: corriente inicial (amperios, valor por defecto: 0)

  • q_inicial: carga inicial en el capacitor (coulombs, valor por defecto: 0)

Retorno: - Un diccionario con las siguientes listas:

  • “tiempo”: lista de tiempos

  • “corriente”: lista de valores de corriente

  • “carga”: lista de valores de carga

  • “voltaje_r”: lista de voltajes en la resistencia

  • “voltaje_l”: lista de voltajes en el inductor

  • “voltaje_c”: lista de voltajes en el capacitor

Ejercicio 10: Cálculo de Energía Potencial

Escribe una función llamada energia_potencial que calcule la energía potencial de diferentes sistemas físicos.

La función debe incluir type hints completos y documentación exhaustiva.

Parámetros:

  • sistema: string que indica el tipo de sistema (“gravitacional”, “elastico”, “coulomb”)

  • parámetros: diccionario con los parámetros específicos de cada sistema

Parámetros específicos para cada sistema:

  • Sistema gravitacional: {“masa”: float, “altura”: float, “g”: float (opcional)}

  • Sistema elástico: {“k”: float, “x”: float}

  • Sistema coulombiano: {“q1”: float, “q2”: float, “r”: float}

Retorno:

  • La energía potencial calculada (joules)

Las ecuaciones para cada sistema son:

\[\begin{split}U_{grav} &= mgh \\ U_{elast} &= \frac{1}{2}kx^2 \\ U_{coul} &= \frac{1}{4\pi\varepsilon_0}\frac{q_1 q_2}{r}\end{split}\]

Manejo de Errores en Funciones

Ejercicio 11: Calculadora de Divisiones Segura

Escribe una función llamada division_segura que realice la división entre dos números, manejando adecuadamente posibles errores:

  • División por cero

  • Tipos de datos incorrectos

La función debe aceptar dos parámetros: numerador y denominador.

Si la división no puede realizarse, la función debe retornar un valor por defecto (por ejemplo, None) y mostrar un mensaje explicativo.

Ejercicio 12: Raíz Cuadrada con Validación

Escribe una función llamada raiz_cuadrada que calcule la raíz cuadrada de un número, validando que el parámetro de entrada sea adecuado:

  • El número debe ser no negativo

  • El parámetro debe ser numérico

La función debe usar try-except para manejar excepciones y validar cuidadosamente la entrada.

Ejercicio 13: Calculadora de la Ley de Ohm con Validación

Escribe una función calcular_ley_ohm que implemente la ley de Ohm:

\[V = IR\]

La función debe aceptar tres parámetros: voltaje (V), corriente (I) y resistencia (R), pero sólo dos deben proporcionarse (el tercero debe ser None).

La función debe calcular el parámetro faltante basándose en los dos proporcionados, verificando:

  • Que exactamente un parámetro sea None

  • Que los valores proporcionados sean positivos

  • Que los valores proporcionados sean numéricos

Utiliza manejo de excepciones para validar las entradas y proporcionar mensajes de error claros.

Ejercicio 14: Calculadora de Fuerza con Manejo de Unidades

Escribe una función llamada calcular_fuerza que calcule la fuerza según la segunda ley de Newton:

\[F = ma\]

La función debe aceptar los siguientes parámetros:

  • masa: la masa del objeto

  • aceleracion: la aceleración del objeto

  • unidad_masa: la unidad en que se proporciona la masa (“kg”, “g”, etc.)

  • unidad_aceleracion: la unidad de la aceleración (“m/s²”, “cm/s²”, etc.)

  • unidad_resultado: la unidad deseada para el resultado (“N”, “dyn”, etc.)

La función debe:

  • Validar que todas las unidades sean válidas y compatibles

  • Convertir las unidades correctamente

  • Manejar posibles errores con try-except

  • Retornar el resultado en la unidad solicitada

Ejercicio 15: Calculadora de Momento de Inercia

Escribe una función llamada momento_inercia que calcule el momento de inercia de diferentes formas geométricas.

La función debe aceptar los siguientes parámetros:

  • forma: string que indica la forma (“cilindro”, “esfera”, “anillo”, etc.)

  • parámetros: diccionario con los parámetros específicos de cada forma

La función debe verificar:

  • Que la forma especificada esté soportada

  • Que todos los parámetros necesarios se hayan proporcionado

  • Que los valores sean físicamente posibles (positivos, no nulos, etc.)

Utiliza try-except para manejar todos los posibles errores y proporcionar mensajes claros.

Las ecuaciones para algunos momentos de inercia son:

\[\begin{split}I_{cilindro} &= \frac{1}{2}mR^2 \quad \text{(respecto al eje del cilindro)} \\ I_{esfera} &= \frac{2}{5}mR^2 \quad \text{(respecto a un diámetro)} \\ I_{anillo} &= mR^2 \quad \text{(respecto al eje perpendicular al plano del anillo)}\end{split}\]

Funciones con Aplicaciones Avanzadas

Ejercicio 16: Análisis de Datos Experimentales

Escribe una función llamada analizar_experimento que procese los datos de un experimento físico y calcule resultados relevantes.

La función debe aceptar:

  • datos_x: lista de valores independientes (por ejemplo, tiempo)

  • datos_y: lista de valores dependientes (por ejemplo, posición)

  • tipo_analisis: string que indica el tipo de análisis (“ajuste_lineal”, “ajuste_cuadratico”, etc.)

  • parametros: diccionario con parámetros adicionales para el análisis

La función debe implementar:

  • Validación de que las listas de datos tienen la misma longitud

  • Manejo de diferentes tipos de análisis

  • Cálculo de estadísticas relevantes (incertidumbre, coeficiente de correlación, etc.)

  • Retorno de resultados en un formato estructurado (diccionario)

Ejercicio 17: Simulación de Lanzamiento de Dado

Implementa una función llamada simular_dados que simule el lanzamiento de dados y calcule estadísticas sobre los resultados.

La función debe aceptar:

  • num_dados: número de dados a lanzar en cada experimento

  • num_caras: número entero que indica cuántas caras tiene cada dado (valor por defecto: 6). Todos los dados tendrán el mismo número de caras.

  • num_lanzamientos: número de lanzamientos a simular (valor por defecto: 1000)

  • calcular_probabilidad: función opcional que evalúa si un lanzamiento cumple cierta condición

Sobre el parámetro calcular_probabilidad:

  • Es una función que tú defines y pasas como argumento

  • Esta función debe aceptar como parámetro una lista de enteros (resultados de un lanzamiento)

  • Debe retornar un valor booleano: True si el lanzamiento cumple cierta condición, False si no la cumple

  • La función simular_dados usará esta función para calcular la probabilidad empírica de la condición

Por ejemplo, si quieres calcular la probabilidad de obtener una suma mayor que 10 con dos dados, podrías definir:

def es_mayor_que_diez(resultados):
    return sum(resultados) > 10

# La pasarías a tu función así:
resultado = simular_dados(2, 6, 1000, calcular_probabilidad=es_mayor_que_diez)

La función debe usar el módulo random para simular los lanzamientos y retornar:

  • Un diccionario con la distribución de frecuencia de las sumas obtenidas

  • Si se proporciona calcular_probabilidad, también incluir la probabilidad empírica del evento

La probabilidad empírica se calcula como:

\[P(\text{evento}) = \frac{\text{Número de lanzamientos que cumplen la condición}}{\text{Número total de lanzamientos}}\]

Implementación:

  • Usa random.randint(1, num_caras) para simular el lanzamiento de un dado

  • Para cada lanzamiento, genera num_dados resultados aleatorios

  • Lleva un registro de la frecuencia de cada suma posible

  • Si se proporciona una función calcular_probabilidad, aplícala a cada lanzamiento y cuenta cuántos retornan True

Incluye manejo de errores para validar que:

  • num_dados, num_caras y num_lanzamientos sean enteros positivos

  • calcular_probabilidad, si se proporciona, sea realmente una función

Ejemplo de retorno:

{
    'distribucion': {
        2: 28,    # La suma 2 apareció 28 veces
        3: 56,    # La suma 3 apareció 56 veces
        # ... otras sumas y sus frecuencias
        12: 27    # La suma 12 apareció 27 veces
    },
    'probabilidad_evento': 0.167  # Solo si se proporcionó calcular_probabilidad
}

Esta simulación ilustra el concepto de la Ley de los Grandes Números: a medida que aumentas el número de lanzamientos, las frecuencias relativas observadas tienden a acercarse a las probabilidades teóricas.

Ejercicio 18: Calculadora de Órbitas

Implementa una función llamada calcular_orbita que determine los parámetros orbitales de un cuerpo celeste a partir de su posición y velocidad instantáneas.

La función debe aceptar:

  • posicion: tupla (x, y, z) con la posición del cuerpo (metros)

  • velocidad: tupla (vx, vy, vz) con la velocidad del cuerpo (metros/segundo)

  • masa_central: masa del cuerpo central (kilogramos, valor por defecto: masa solar)

  • G: constante de gravitación universal (valor por defecto: 6.67430 × 10⁻¹¹ m³ kg⁻¹ s⁻²)

Sugerencias para la solución:

Para calcular los parámetros orbitales, puedes utilizar directamente las ecuaciones de la mecánica orbital. Aunque estas ecuaciones parecen complejas, se pueden implementar paso a paso:

  1. Vector de momento angular (h):

    \[\vec{h} = \vec{r} \times \vec{v}\]

    donde \(\vec{r}\) es el vector de posición y \(\vec{v}\) es el vector de velocidad.

  2. Excentricidad (e):

    \[\vec{e} = \frac{\vec{v} \times \vec{h}}{\mu} - \frac{\vec{r}}{|\vec{r}|}\]

    donde \(\mu = GM\) es el parámetro gravitacional y la magnitud de \(\vec{e}\) da la excentricidad.

  3. Semieje mayor (a):

    \[a = \frac{h^2}{\mu(1-e^2)}\]

    Para órbitas parabólicas (e=1) o hiperbólicas (e>1), esta fórmula debe ajustarse.

  4. Período orbital (T):

    \[T = 2\pi\sqrt{\frac{a^3}{\mu}}\]

    Esta fórmula solo aplica para órbitas elípticas (e<1).

  5. Energía mecánica total (E):

    \[E = \frac{v^2}{2} - \frac{\mu}{|\vec{r}|} = -\frac{\mu}{2a}\]

Implementación recomendada:

  • Primero calcula el producto vectorial y las normas de los vectores implementando las funciones necesarias

  • Identifica qué tipo de órbita es (elíptica, parabólica o hiperbólica) basándote en la excentricidad

  • Para órbitas elípticas, calcula todos los parámetros; para otros tipos, calcula lo que tenga sentido físico

  • Asegúrate de manejar casos especiales (como e ≈ 0 para órbitas casi circulares)

La función debe calcular y retornar:

  • Semieje mayor de la órbita (metros)

  • Excentricidad (adimensional)

  • Período orbital (segundos, solo para órbitas elípticas)

  • Energía mecánica total (joules por kilogramo)

  • Tipo de órbita (“elíptica”, “parabólica”, “hiperbólica”)

Incluye validación de datos, documentación completa y type hints.

Ejemplo de uso:

# Para la Tierra orbitando alrededor del Sol
# Valores aproximados
posicion_tierra = (1.496e11, 0, 0)  # 1 UA en metros
velocidad_tierra = (0, 29800, 0)    # m/s

parametros = calcular_orbita(posicion_tierra, velocidad_tierra)
print(parametros)
# Debería dar aproximadamente:
# {'semieje_mayor': 1.496e11, 'excentricidad': cercano a 0,
#  'periodo_orbital': cercano a 365.25 días en segundos,
#  'energia': valor negativo, 'tipo_orbita': 'elíptica'}

Ejercicio 19: Resolución Numérica de Ecuaciones

Implementa una función llamada encontrar_cero que encuentre una raíz de una función utilizando diferentes métodos numéricos.

La función debe aceptar:

  • f: función cuya raíz se busca

  • metodo: string que indica el método a utilizar (“biseccion”, “newton”, “secante”)

  • x0: valor inicial para los métodos de Newton y secante; no usado en bisección

  • a, b: límites del intervalo para el método de bisección; no usados en Newton o secante

  • tolerancia: precisión deseada (valor por defecto: 1e-6)

  • max_iter: número máximo de iteraciones (valor por defecto: 100)

  • h: incremento para la aproximación numérica de la derivada en Newton o

    para generar el segundo punto en el método de la secante (valor por defecto: 1e-5)

Aclaraciones importantes sobre los métodos:

  1. Método de bisección: Requiere un intervalo [a, b] donde f(a) y f(b) tengan signos opuestos.

    \[c = \frac{a + b}{2}\]

    En cada iteración, se reemplaza a o b por c, manteniendo la condición de que f(a) y f(b) tengan signos opuestos.

  2. Método de Newton: Requiere un valor inicial x0 y aproxima la derivada numéricamente:

    \[f'(x) \approx \frac{f(x+h) - f(x)}{h}\]

    La iteración de Newton se define como:

    \[x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}\]

  3. Método de la secante: Requiere un valor inicial x0, y utiliza x1 = x0 + h como segundo valor.

    \[x_{n+1} = x_n - f(x_n) \frac{x_n - x_{n-1}}{f(x_n) - f(x_{n-1})}\]

    donde inicialmente x₀ = x0 y x₁ = x0 + h.

La función debe:

  • Validar los parámetros de entrada según el método elegido

  • Implementar los diferentes métodos numéricos

  • Manejar casos de no convergencia

  • Retornar la raíz encontrada y el número de iteraciones realizadas

Ejemplo de uso:

def f(x):
    return x**2 - 2  # Buscamos la raíz de f(x) = x² - 2 (solución: √2)

# Método de bisección
raiz1, iter1 = encontrar_cero(f, metodo='biseccion', a=0, b=2)

# Método de Newton
raiz2, iter2 = encontrar_cero(f, metodo='newton', x0=1.0)

# Método de la secante
raiz3, iter3 = encontrar_cero(f, metodo='secante', x0=1.0)  # x1 será 1.0 + 1e-5

print(f"Bisección: {raiz1} en {iter1} iteraciones")
print(f"Newton: {raiz2} en {iter2} iteraciones")
print(f"Secante: {raiz3} en {iter3} iteraciones")

Conclusión

Estos ejercicios te permiten practicar la creación y uso de funciones en Python aplicadas a problemas de física. Las funciones son componentes esenciales en la programación científica, ya que permiten modularizar el código, hacerlo más legible y reutilizable, y encapsular la lógica de cálculos complejos.

Al resolver estos problemas, estarás desarrollando habilidades cruciales para:

  1. Diseñar funciones con interfaces claras y bien definidas

  2. Documentar adecuadamente el código para facilitar su comprensión y uso

  3. Implementar validación de parámetros y manejo de errores robusto

  4. Aplicar conceptos físicos a través de implementaciones computacionales

Recuerda seguir las buenas prácticas:

  • Nombres de funciones descriptivos y en minúsculas con palabras separadas por guiones bajos

  • Docstrings claras que expliquen el propósito, parámetros y valores de retorno

  • Type hints para mejorar la legibilidad y facilitar la detección de errores

  • Manejo adecuado de casos especiales y validación de entradas

  • Código limpio y bien organizado

¡Buena suerte con los ejercicios!