EJERCICIO 1

Resuelva por el método de Euler. Para estudiar la interacción entre el alce y la población de
lobos, consideremos el siguiente modelo presa-depredador:

Donde E(t) es la población de alces y W(t) es la población de lobos. Todas las poblaciones se
miden en miles. La variable t representa el tiempo medido en años desde 1995. Determine en el
presente año la cantidad de población de alces y lobos.

import numpy as np
import matplotlib.pyplot as plt

def euler_method(f, x0, y0, h, n):

   
    t = np.zeros(n+1)
    y = np.zeros((n+1, len(y0)))
    t[0] = x0
    y[0] = y0

    for i in range(n):
        t[i+1] = t[i] + h
        y[i+1] = y[i] + h * f(t[i], y[i])

    return t, y

# Definir el sistema de ecuaciones diferenciales

def f(t, y):
    dEdt = 0.0325 * y[0] - 0.8 * y[0] * y[1]
    dWdt = -0.6 * y[1] + 0.05 * y[0] * y[1]
    return np.array([dEdt, dWdt])

# Valores iniciales
t0 = 0
y0 = np.array([18, 0.021])  # [E(0), W(0)]

# Tamaño del paso y número de iteraciones

h = 0.1
n = 100
# Resolver el sistema de ecuaciones utilizando el método de Euler
t, y = euler_method(f, t0, y0, h, n)

# Obtener la última solución en el presente año

present_year = 2023
present_year_index = int((present_year - t0) / h)

if present_year_index >= len(t):

    present_year_index = len(t) - 1

# Obtener la cantidad de población de alces y lobos en el presente año

E_present = y[present_year_index, 0]
W_present = y[present_year_index, 1]

# Mostrar la cantidad de población de alces y lobos en el presente año

print("Población de alces en el presente año:", E_present, "miles")
print("Población de lobos en el presente año:", W_present, "miles")

# Graficar la población de alces y lobos en función del tiempo

plt.plot(t, y[:, 0], label='Alces')
plt.plot(t, y[:, 1], label='Lobos')
plt.xlabel('Tiempo (miles desde 1995)')
plt.ylabel('Población (miles)')
plt.legend()
plt.show()

EJERCICIO 2

La ecuación de salto en bungee tiene la siguiente forma

La variable x representa la posición de la persona a saltar.

Calcule la distancia x que se encuentra la persona en el tiempo t=5seg. Resuelva mediante el

método de Heun y Runge Kutta 4 orden y determine el error entre ambos métodos.

import numpy as np
import matplotlib.pyplot as plt

# Definir las constantes del problema

m = 68.1
B = 12.5
k = 100
g = 9.81

# Definir la ecuación diferencial del problema

def f(t, y):
    x, v = y
    dxdt = v
    dvdt = (m*g - B*v - k*x) / m
    return [dxdt, dvdt]

# Definir los valores iniciales y el rango de tiempo

y0 = [-100, 0]
t = np.linspace(0, 5, 1000)
h = t[1] - t[0]

# Resolver la ecuación diferencial mediante el método de Heun

y = np.zeros((len(t), len(y0)))
y[0] = y0
for i in range(len(t)-1):
    k1 = f(t[i], y[i])
    k2 = f(t[i] + h, y[i] + h*np.array(k1))
    y[i+1] = y[i] + h/2 * (np.array(k1) + np.array(k2))
x_heun = y[:, 0][-1]
# Resolver la ecuación diferencial mediante el método de Runge Kutta 4
orden
y = np.zeros((len(t), len(y0)))
y[0] = y0
for i in range(len(t)-1):
    k1 = f(t[i], y[i])
    k2 = f(t[i] + h/2, y[i] + h/2*np.array(k1))
    k3 = f(t[i] + h/2, y[i] + h/2*np.array(k2))
    k4 = f(t[i] + h, y[i] + h*np.array(k3))
    y[i+1] = y[i] + h/6 * (np.array(k1) + 2*np.array(k2) +
2*np.array(k3) + np.array(k4))
x_rk4 = y[:, 0][-1]

# Calcular el error entre ambos métodos

error = abs(x_rk4 - x_heun)

# Imprimir la distancia x que se encuentra la persona en el tiempo

t=5seg y el error entre ambos métodos
print("La distancia x que se encuentra la persona en el tiempo t=5seg
mediante el método de Heun es:", x_heun)
print("La distancia x que se encuentra la persona en el tiempo t=5seg
mediante el método de Runge Kutta 4 orden es:", x_rk4)
print("El error entre ambos métodos es:", error)

La distancia x que se encuentra la persona en el tiempo t=5seg

mediante el método de Heun es: -57.556124158913846
La distancia x que se encuentra la persona en el tiempo t=5seg
mediante el método de Runge Kutta 4 orden es: -57.55588696172875
El error entre ambos métodos es: 0.00023719718509340737

EJERCICIO 3

Una enfermedad contagiosa se propaga en una pequeña comunidad, con una población fija de n
personas, por contacto entre individuos infectados y personas que son susceptibles a la
enfermedad y que nadie sale de la comunidad mientras se propaga la epidemia. Sea s(t) número
de personas medido en cientos que son suceptibles a la enfermedad pero que aún no están
infectados, i(t) número de personas infectadas con la enfermedad y s(t) número de personas
que se han recuperado.
Utilice uno de los métodos numéricos para determinar en qué tiempo se alcanza el pico de
contagio de la epidemia.

import numpy as np
import matplotlib.pyplot as plt

def euler_method(f, s0, i0, r0, k1, k2, h, n):

    """
    Implementa el método de Euler para resolver un sistema de
ecuaciones diferenciales de primer orden.

    Args:
        f: Función que representa el sistema de ecuaciones
diferenciales.
           Debe tener la forma f(t, s, i, r), donde t es el tiempo, s
es el número de susceptibles,
           i es el número de infectados y r es el número de
recuperados.
        s0: Valor inicial de susceptibles.
        i0: Valor inicial de infectados.
        r0: Valor inicial de recuperados.
        k1: Coeficiente k1.
        k2: Coeficiente k2.
        h: Tamaño del paso.
        n: Número de iteraciones.

    Returns:
        Tres arrays con las soluciones aproximadas para susceptibles,
infectados y recuperados en cada iteración.
    """
    t = np.zeros(n+1)
    s = np.zeros(n+1)
    i = np.zeros(n+1)
    r = np.zeros(n+1)
    t[0] = 0
    s[0] = s0
    i[0] = i0
    r[0] = r0

    for j in range(n):
        t[j+1] = t[j] + h
        s[j+1] = s[j] + h * f(t[j], s[j], i[j], r[j])[0]
        i[j+1] = i[j] + h * f(t[j], s[j], i[j], r[j])[1]
        r[j+1] = r[j] + h * f(t[j], s[j], i[j], r[j])[2]

    return t, s, i, r

# Parámetros del sistema

k1 = 0.2  # Coeficiente k1
k2 = 0.7  # Coeficiente k2

# Valores iniciales
s0 = 20  # Número inicial de susceptibles
i0 = 1  # Número inicial de infectados
r0 = 0  # Número inicial de recuperados

# Tamaño del paso y número de iteraciones

h = 0.01  # Tamaño del paso
n = 1000  # Número de iteraciones

# Sistema de ecuaciones diferenciales

def f(t, s, i, r):
    ds_dt = -k1 * s * i
    di_dt = -k2 * i + k1 * s * i
    dr_dt = k2 * i
    return ds_dt, di_dt, dr_dt

# Resolver el sistema utilizando el método de Euler

t, s, i, r = euler_method(f, s0, i0, r0, k1, k2, h, n)

# Encontrar el índice del pico de contagio

peak_index = np.argmax(i)
peak_time = t[peak_index]
print(peak_time)

# Graficar las soluciones

plt.plot(t, s, label='Susceptibles')
plt.plot(t, i, label='Infectados')
plt.plot(t, r, label='Rec')
EJERCICIO 4

Resuelva la siguiente ecuación de puente Tacoma Narrow

Utilice los métodos de Heun y Ringe Kutta para obtener la gráfica de solución en el intervalo de 0 a
3π/2

import numpy as np
import matplotlib.pyplot as plt

def f(t, y):

    if t < np.pi/2:
        return 4 * y
    else:
        return y

def heun_method(t0, y0, y1, h):

    t_values = [t0]
    y_values = [y0]
   
    while t0 < 3 * np.pi / 2:
        k1 = h * (y1 + f(t0, y0))
        k2 = h * (y1 + f(t0 + h, y0 + k1))
       
        y1 = y0 + (k1 + k2) / 2
        y0 = y1
       
        t0 += h
        t_values.append(t0)
        y_values.append(y0)
       
    return t_values, y_values

def runge_kutta_method(t0, y0, y1, h):

    t_values = [t0]
    y_values = [y0]
   
    while t0 < 3 * np.pi / 2:
        k1 = h * (y1 + f(t0, y0))
        k2 = h * (y1 + f(t0 + h/2, y0 + k1/2))
        k3 = h * (y1 + f(t0 + h/2, y0 + k2/2))
        k4 = h * (y1 + f(t0 + h, y0 + k3))
       
        y1 = y0 + (k1 + 2*k2 + 2*k3 + k4) / 6
        y0 = y1
       
        t0 += h
        t_values.append(t0)
        y_values.append(y0)
       
    return t_values, y_values

# Parámetros iniciales
t0 = 0
y0 = 0
y1 = 1
h = 0.01

# Resolución utilizando el método de Heun

t_values_heun, y_values_heun = heun_method(t0, y0, y1, h)

# Resolución utilizando el método de Runge-Kutta

t_values_rk, y_values_rk = runge_kutta_method(t0, y0, y1, h)

# Gráfica de la solución
plt.plot(t_values_heun, y_values_heun, label='Heun')
plt.plot(t_values_rk, y_values_rk, label='Runge-Kutta')
plt.xlabel('t')
plt.ylabel('y(t)')
plt.legend()
plt.grid(True)
plt.show()

EJERCICIO 5

Resuelva por el método de Runge Kutta 4 Orden. Grafique los resultados. La reacción A->b tiene
lugar en dos reactores en serie. Los reactores están bien mezclados, pero no en estado estable.
El balance de masa de estado no estable para cada tanque de agitadores es el siguiente:

Donde CA0 = concentración de A en la entrada del primer reactor, CA1 = concentración de A a la

salida del primer reactor (y en la entrada del segundo), CA2 = concentración de A en la salida del
segundo reactor. CB1 = concentración de B en la salida del primer reactor (y en la entrada del
segundo), CB2 = concentración de B en el segundo reactor, 𝜏 = tiempo de residencia de cada
reactor y k= tasa constante para la reacción de A para producir B. Si CA0 es igual a 20, encuentre
las concentraciones de A y B durante sus primeros 10 minutos de operación. Utilice k=0.12/min
y 𝜏 = 5 𝑚𝑖𝑛, suponga que las condiciones de todas las variables dependientes son cero.

import numpy as np
import matplotlib.pyplot as plt

def runge_kutta_4(func, t0, y0, h, num_steps):

    t = np.zeros(num_steps+1)
    y = np.zeros((num_steps+1, len(y0)))
    t[0] = t0
    y[0] = y0
   
    for i in range(num_steps):
        k1 = func(t[i], y[i])
        k2 = func(t[i] + 0.5*h, y[i] + 0.5*h*k1)
        k3 = func(t[i] + 0.5*h, y[i] + 0.5*h*k2)
        k4 = func(t[i] + h, y[i] + h*k3)
       
        t[i+1] = t[i] + h
        y[i+1] = y[i] + (h/6)*(k1 + 2*k2 + 2*k3 + k4)
   
    return t, y

def reactor_system(t, y):

    k = 0.12 / 60  # tasa constante para la reacción de A para
producir B (por minuto)
    tau = 5  # tiempo de residencia de cada reactor (minutos)

    CA0 = 20  # concentración de A en la entrada del primer reactor

    CA1, CB1, CA2, CB2 = y
   
    dCA1_dt = (1/tau) * (CA0 - CA1) - k * CA1
    dCB1_dt = (1/tau) * CB1 + k * CA1
    dCA2_dt = (1/tau) * (CA1 - CA2) - k * CA2
    dCB2_dt = (1/tau) * (CB1 - CB2) - k * CA2
   
    return np.array([dCA1_dt, dCB1_dt, dCA2_dt, dCB2_dt])

# Condiciones iniciales y parámetros

t0 = 0
y0 = np.array([0, 0, 0, 0])  # CA1, CB1, CA2, CB2
h = 0.01  # tamaño del paso
num_steps = int(10 / h)  # número de pasos

# Resuelve el sistema de ecuaciones diferenciales

t, y = runge_kutta_4(reactor_system, t0, y0, h, num_steps)

# Grafica los resultados

plt.plot(t, y[:, 0], label='CA1')
plt.plot(t, y[:, 1], label='CB1')
plt.plot(t, y[:, 2], label='CA2')
plt.plot(t, y[:, 3], label='CB2')
plt.xlabel('Tiempo (min)')
plt.ylabel('Concentración')
plt.legend()
plt.show()

EJERCICIO 6

Terremotos que sacuden edificios. Sea que x represente el desplazamiento horizontal del i-
ésimo piso a partir de su posición de equilibrio. La posición de equilibrio será un punto fijo en el
suelo, de forma que x0=0. Como ejemplo sencillo considere un edificio de dos pisos

Halle la solución por runge kutta cuarto orden y grafique desde t=0 hasta t=20. Compare con la
gráfica de la solución analítica.

import numpy as np
import matplotlib.pyplot as plt

def runge_kutta_4(func, t0, y0, h, num_steps):

    t = np.zeros(num_steps+1)
    y = np.zeros((num_steps+1, len(y0)))
    t[0] = t0
    y[0] = y0
   
    for i in range(num_steps):
        k1 = func(t[i], y[i])
        k2 = func(t[i] + 0.5*h, y[i] + 0.5*h*k1)
        k3 = func(t[i] + 0.5*h, y[i] + 0.5*h*k2)
        k4 = func(t[i] + h, y[i] + h*k3)
       
        t[i+1] = t[i] + h
        y[i+1] = y[i] + (h/6)*(k1 + 2*k2 + 2*k3 + k4)
   
    return t, y

def building_system(t, y):

    c2 = 0.0317
    c4 = 0.0317
    w1 = 2.288
    w2 = 0.874

    x1, x1_prime, x2, x2_prime = y

   
    x1_double_prime = -4*x1 + 2*x2
    x2_double_prime = 2*x1 - 2*x2
   
    return np.array([x1_prime, x1_double_prime, x2_prime,
x2_double_prime])

# Condiciones iniciales y parámetros

t0 = 0
y0 = np.array([0, 0.2, 0, 0.2])  # x1, x1', x2, x2'
h = 0.01  # tamaño del paso
num_steps = int(20 / h)  # número de pasos

# Resuelve el sistema de ecuaciones diferenciales

t, y = runge_kutta_4(building_system, t0, y0, h, num_steps)

# Solución analítica
c2 = 0.0317
c4 = 0.0317
w1 = 2.288
w2 = 0.874

x1_analytical = 2 * c2 * np.sin(w1 * t) + 2 * c4 * np.sin(w2 * t)

x2_analytical = (4 - w1**2) * c2 * np.sin(w1 * t) + (4 - w2**2) * c4 *
np.sin(w2 * t)

# Grafica los resultados

plt.plot(t, y[:, 0], label='x1 (Runge-Kutta)')
plt.plot(t, y[:, 2], label='x2 (Runge-Kutta)')
plt.plot(t, x1_analytical, label='x1 (Analítica)')
plt.plot(t, x2_analytical, label='x2 (Analítica)')
plt.xlabel('Tiempo')
plt.ylabel('Desplazamiento')
plt.legend()
plt.show()

EJERCICIO 7

Del tanque cónico circular recto que se muestra en la figura, sale agua por un agujero circular
que está en el fondo. Resuelva la ecuación diferencial para la altura h en función del tiempo t. El
radio del agujero es 2 7.5pulg, g=32pies/s A r  , el factor fricción contracción es c  3.7 .

import math
from scipy.integrate import odeint

# Parámetros
ra = 7.5 # Radio del agujero en pulgadas
g = 32 # Aceleración debida a la gravedad en pies/(s^2)
c = 3.7 # Factor de fricción contracción
R = 8 # Radio del tanque en pies
H = 20 # Altura total del tanque en pies
h0 = 18 # Altura inicial del líquido en pies
t = 3.5 # Tiempo en segundos

# Área del agujero

Ag = math.pi * ra**2

# Función para la ecuación diferencial

def dh_dt(h, t):
    return c * Ag * math.sqrt(2 * g * h)

# Resolución de la ecuación diferencial

t_span = [0, t]
h = odeint(dh_dt, h0, t_span)[-1][0]

# Altura del nivel del líquido a los 3.5 segundos

print(f"La altura del nivel del líquido a los {t} segundos es: {h}
pies.")

La altura del nivel del líquido a los 3.5 segundos es:

83870030.63751936 pies.

EJERCICIO 8

Resuelva la ecuación diferencial por el método de Heun. Grafique los resultados. Las dinámicas
de un sistema forzado resorte-masa-amortiguador se representa con la EDO de segundo orden
siguiente:

Donde m=1kg, c=0.4Ns/m, P=0.5N y w=0.5/s. Determine cuál es el desplazamiento (x) y la

velocidad (v=dx/dt) como función del tiempo con condiciones iniciales x=v=0. Haga simulaciones
para un resorte a) lineal (k1=1; k3=0) y b) no lineal (k1=1; k3=0.5)

import numpy as np
import matplotlib.pyplot as plt

# Parámetros del sistema

m = 1.0  # Masa en kg
c = 0.4  # Coeficiente de amortiguación en Ns/m
k1_linear = 1.0  # Constante del resorte lineal en N/m
k1_nonlinear = 1.0  # Constante del resorte no lineal en N/m
k3_nonlinear = 0.5  # Constante de no linealidad del resorte no lineal
en N/m^3
P = 0.5  # Amplitud de la fuerza externa en N
w = 0.5  # Frecuencia angular de la fuerza externa en 1/s

# Condiciones iniciales
x0 = 0.0  # Posición inicial
v0 = 0.0  # Velocidad inicial

# Definición de la función que representa la EDO de segundo orden

def spring_mass_damper(t, y, m, c, k1, k3, P, w):
    x, v = y
    dvdt = (P * np.cos(w * t) - c * v - k1 * x - k3 * x**3) / m
    return dvdt

# Método de Heun para resolver la EDO

def heun(f, y0, t0, t_max, h, m, c, k1, k3, P, w):
    t = np.arange(t0, t_max + h, h)
    y = np.zeros((t.size, len(y0)))
    y[0] = y0
    for i in range(1, t.size):
        y_intermediate = y[i-1] + h * f(t[i-1], y[i-1], m, c, k1, k3,
P, w)
        y[i] = y[i-1] + (h / 2) * (f(t[i-1], y[i-1], m, c, k1, k3, P,
w) + f(t[i], y_intermediate, m, c, k1, k3, P, w))
    return t, y

# Parámetros para la simulación

t0 = 0.0  # Tiempo inicial
tf = 10.0  # Tiempo final
h = 0.01  # Tamaño del paso

# Resolución de la EDO para el resorte lineal

t_linear, y_linear = heun(spring_mass_damper, [x0, v0], t0, tf, h, m,
c, k1_linear, 0.0, P, w)
x_linear = y_linear[:, 0]
v_linear = y_linear[:, 1]

# Resolución de la EDO para el resorte no lineal

t_nonlinear, y_nonlinear = heun(spring_mass_damper, [x0, v0], t0, tf,
h, m, c, k1_nonlinear, k3_nonlinear, P, w)
x_nonlinear = y_nonlinear[:, 0]
v_nonlinear = y_nonlinear[:, 1]

# Gráficas
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(t_linear, x_linear, label='Resorte lineal')
plt.plot(t_nonlinear, x_nonlinear, label='Resorte no lineal')
plt.xlabel('Tiempo')
plt.ylabel('Desplazamiento')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(t_linear, v_linear, label='Resorte lineal')
plt.plot(t_nonlinear, v_nonlinear, label='Resorte no lineal')
plt.xlabel('Tiempo')
plt.ylabel('Velocidad')
plt.legend()

plt.tight_layout()
plt.show()

EJERCICIO 9

La temperatura ambiente Tm podría ser una función del tiempo t. Suponga que, en un medio
ambiente controlado, Tm(t) es periódica con un periodo de 24 horas. Diseñe un modelo
matemático para la temperatura T(t) de un cuerpo dentro de este medio ambiente. K=0.25
Resuelva mediante el método de Heun, realice la gráfica de T desde 0 hasta 48 horas

import numpy as np
import matplotlib.pyplot as plt

# Parámetros del sistema

K = 0.25  # Coeficiente de transferencia de calor en 1/h

# Función que representa la temperatura ambiente periódica Tm(t)

def Tm(t):
    return np.sin(2 * np.pi * t / 24)

# Ecuación diferencial a resolver: dT/dt = -K * (T - Tm(t))

def heat_transfer(t, T):
    return -K * (T - Tm(t))

# Método de Heun para resolver la EDO

def heun(f, y0, t0, t_max, h):
    t = np.arange(t0, t_max + h, h)
    y = np.zeros(t.size)
    y[0] = y0
    for i in range(1, t.size):
        y_intermediate = y[i-1] + h * f(t[i-1], y[i-1])
        y[i] = y[i-1] + (h / 2) * (f(t[i-1], y[i-1]) + f(t[i],
y_intermediate))
    return t, y

# Parámetros para la simulación

t0 = 0.0  # Tiempo inicial
tf = 48.0  # Tiempo final
h = 0.01  # Tamaño del paso

# Resolución de la EDO mediante el método de Heun

t, T = heun(heat_transfer, Tm(t0), t0, tf, h)

# Gráfica de la temperatura T en función del tiempo

plt.plot(t, T)
plt.xlabel('Tiempo (horas)')
plt.ylabel('Temperatura (°C)')
plt.title('Temperatura en función del tiempo')
plt.grid(True)
plt.show()

EJERCICIO 10

Realice pruebas de media, varianza y uniformidad a los 50 números aleatorios siguiente con un
nivel de aceptación del 95%.

PRUEBA DE MEDIAS
Z ALFA/2 5%
PROMEDIO 0,515906
1,9599639
VALOR DE ALFA 8
0,4199848
LIMITE INFERIOR 1
0,5171458
LIMITE SUPERIOR 1
PRUEBA DE VARIANZA
VARIANZA 0,07107468
VALOR DE CHI CUADRADA PARA EL LIMITE INFERIOR
58,1200597
L. INFERIOR 0,12418816

VALOR DE CHI CUADRADA PARA LIMITE SUPERIOR

23,6543246
L. SUPERIOR 0,05054343

PRUEBA DE UNIFORMIDAD

CALCULANDO M 7,07106781

INTERVALOS
TOTAL 0,3831
ANCHO DE CLASE 0,05472857

FRECUENCI (Ei
INTERVALOS A Ei=n/m -Oi)^2/Ei
0,0007142
0,054728571 7 7,07106781 7
3,6367532
0,209457143 2 7,07106781 4
6,7896536
0,364185714 14 7,07106781 3
0,1622366
0,518914286 6 7,07106781 4
0,0007142
0,673642857 7 7,07106781 7
0,0007142
0,828371429 7 7,07106781 7
0,0007142
0,9831 7 7,07106781 7

10,591500
6
2,3659738
ESTADISTICO EN TABLAS 8

import numpy as np
from scipy import stats

# Lista de números aleatorios

numbers = [0.6069, 0.5316, 0.5929, 0.4231, 0.2991, 0.6848, 0.8291,
0.1233, 0.2947, 0.9481,
           0.4411, 0.4029, 0.1926, 0.6367, 0.8195, 0.2549, 0.0266,
0.9543, 0.3521, 0.1003,
           0.5696, 0.5385, 0.8068, 0.5523, 0.7504, 0.2574, 0.1062,
0.1897, 0.8542, 0.2396,
           0.5384, 0.8725, 0.6045, 0.3468, 0.9287, 0.4439, 0.2269,
0.4105, 0.7954, 0.6056,
           0.7970, 0.5143, 0.7271, 0.8310, 0.3738, 0.2014, 0.5739,
0.4709, 0.1284, 0.9900]

# Nivel de aceptación del 95%

alpha = 0.05

# Prueba de media
mean = np.mean(numbers)
t_stat, p_value = stats.ttest_1samp(numbers, 0.5)
mean_accept = p_value > alpha

# Prueba de varianza
variance = np.var(numbers)
chi2_stat, p_value = stats.chisquare(numbers)
variance_accept = p_value > alpha

# Prueba de uniformidad
uniform_stat, p_value = stats.kstest(numbers, 'uniform')
uniform_accept = p_value > alpha

# Resultados
print("Prueba de media:")
print(f"Media: {mean}")
print(f"Estadístico t: {t_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {mean_accept}")
print()
print("Prueba de varianza:")
print(f"Varianza: {variance}")
print(f"Estadístico chi-cuadrado: {chi2_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {variance_accept}")
print()
print("Prueba de uniformidad:")
print(f"Estadístico de Kolmogorov-Smirnov: {uniform_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {uniform_accept}")
Prueba de media:
Media: 0.5152059999999999
Estadístico t: 0.40613111638335886
Valor p: 0.7826147471183716
Aceptado: True

Prueba de varianza:
Varianza: 0.06869000096399999
Estadístico chi-cuadrado: 6.666265626176714
Valor p: 0.7826147471183716
Aceptado: True

Prueba de uniformidad:
Estadístico de Kolmogorov-Smirnov: 0.0897
Valor p: 0.7826147471183716
Aceptado: True

EJERCICIO 11

Determine si la siguiente lista de 100 números de dos dígitos tiene distribución uniforme con
nivel de aceptación de 90%

n 100
m 10
Intervalos Oi Ei=n/m Ei-Oi)^2/Ei
0 0,1 7 10 0,9
0,1 0,2 16 10 3,6
0,2 0,3 12 10 0,4
0,3 0,4 5 10 2,5
0,4 0,5 14 10 1,6
0,5 0,6 8 10 0,4
0,6 0,7 8 10 0,4
0,7 0,8 11 10 0,1
0,8 0,9 7 10 0,9
 0,9 1 12 10 0,4
11,2

14,683656
TABLA CHI CUADRADO 6

import numpy as np
from scipy import stats

# Lista de números de dos dígitos

numbers = [0.1108, 0.9082, 0.4738, 0.1181, 0.7422, 0.5005, 0.6438,
0.1873, 0.7379, 0.4999,
           0.3316, 0.2974, 0.2480, 0.0048, 0.9841, 8.873, 6.742,
4.242, 2.729, 5.008]

# Nivel de aceptación del 90%

alpha = 0.1

# Prueba de uniformidad
uniform_stat, p_value = stats.kstest(numbers, 'uniform')
uniform_accept = p_value > alpha

# Resultados
print("Prueba de uniformidad:")
print(f"Estadístico de Kolmogorov-Smirnov: {uniform_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {uniform_accept}")

Prueba de uniformidad:
Estadístico de Kolmogorov-Smirnov: 0.2841
Valor p: 0.06383055017259676
Aceptado: False

EJERCICIO 12

Utilice la prueba chi cuadrado para determinar qué tipo de distribución siguen los siguientes
datos.

PRUEBA DE UNIFORMIDAD
CALCULANDO M 10

INTERVALOS TOTAL 19,8450

ANCHO DE CLASE 1,9845

Intervalos Oi Ei=n/m Ei-Oi)^2/Ei

0 1 9 10 0,1
1 2 14 10 1,6
2 3 12 10 0,4
3 4 10 10 0
4 5 7 10 0,9
5 6 5 10 2,5
6 7 9 10 0,1
7 8 5 10 2,5
8 9 1 10 8,1
9 10 14 10 1,6

17,8

Tabla chi cuadrado 14,6836566

import numpy as np
from scipy import stats

# Datos proporcionados
data = [17.392, 8.110, 4.078, 3.151, 3.528, 2.440, 5.924, 3.461,
2.052, 10.369,
        3.690, 10.870, 4.793, 2.498, 0.569, 8.281, 0.154, 5.959,
3.384, 12.877,
        13.602, 5.244, 16.677, 5.977, 4.313, 4.767, 2.381, 6.443,
1.392, 1578,
        8.115, 4.891, 6.720, 7.728, 2.717, 10.451, 5.901, 0.818,
7.088, 2.637,
        4.714, 3.032, 1.495, 15.733, 7.768, 2.333, 7.822, 3.708,
6.412, 1.290,
        3.957, 5.285, 7.094, 3.078, 1.264, 2.630, 10.177, 2.155,
2.945, 7552,
        11.094, 4.772, 7.281, 14.344, 19.867, 0.119, 2.072, 1.486,
3.791, 4.214,
        1.611, 1.781, 1530, 3.280, 4.301, 0.202, 7.489, 1.422, 1.413,
0.022,
        6.001, 9.269, 8.477, 3.043, 0.877, 6.966, 2.103, 1.816, 0.433,
2.547,
        0.843, 1.182, 8.121, 2.007, 1.395, 4.661, 7.378, 5.300,
17.066, 12.171]

# Nivel de significancia del 95% (nivel de aceptación del 90%)

alpha = 0.1

# Dividir los datos en intervalos

n_bins = 10
hist, bin_edges = np.histogram(data, bins=n_bins)

# Calcular las frecuencias esperadas

expected_freq = len(data) / n_bins

# Realizar la prueba chi cuadrado

chi2_stat, p_value = stats.chisquare(hist, f_exp=expected_freq)

# Comparar con el nivel de significancia

chi2_accept = p_value > alpha

# Resultados
print("Prueba de chi cuadrado:")
print(f"Estadístico chi cuadrado: {chi2_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {chi2_accept}")

import numpy as np
from scipy import stats

# Datos proporcionados
data = [17.392, 8.110, 4.078, 3.151, 3.528, 2.440, 5.924, 3.461,
2.052, 10.369,
        3.690, 10.870, 4.793, 2.498, 0.569, 8.281, 0.154, 5.959,
3.384, 12.877,
        13.602, 5.244, 16.677, 5.977, 4.313, 4.767, 2.381, 6.443,
1.392, 1578,
        8.115, 4.891, 6.720, 7.728, 2.717, 10.451, 5.901, 0.818,
7.088, 2.637,
        4.714, 3.032, 1.495, 15.733, 7.768, 2.333, 7.822, 3.708,
6.412, 1.290,
        3.957, 5.285, 7.094, 3.078, 1.264, 2.630, 10.177, 2.155,
2.945, 7552,
        11.094, 4.772, 7.281, 14.344, 19.867, 0.119, 2.072, 1.486,
3.791, 4.214,
        1.611, 1.781, 1530, 3.280, 4.301, 0.202, 7.489, 1.422, 1.413,
0.022,
        6.001, 9.269, 8.477, 3.043, 0.877, 6.966, 2.103, 1.816, 0.433,
2.547,
        0.843, 1.182, 8.121, 2.007, 1.395, 4.661, 7.378, 5.300,
17.066, 12.171]

# Nivel de significancia del 95% (nivel de aceptación del 90%)

alpha = 0.1

# Dividir los datos en intervalos

n_bins = 10
hist, bin_edges = np.histogram(data, bins=n_bins)

# Calcular las frecuencias esperadas

expected_freq = len(data) / n_bins

# Realizar la prueba chi cuadrado

chi2_stat, p_value = stats.chisquare(hist, f_exp=expected_freq)

# Comparar con el nivel de significancia

chi2_accept = p_value > alpha

# Resultados
print("Prueba de chi cuadrado:")
print(f"Estadístico chi cuadrado: {chi2_stat}")
print(f"Valor p: {p_value}")
print(f"Aceptado: {chi2_accept}")

EJERCICIO 13

A) Obtenga con el método de la transformada inversa, la expresión matemática para generar

variables aleatorias que sigan las funciones de densidad indicadas.

B) Genere mediante el método de transformada inversa 40 números aleatorios para las

siguientes distribuciones de probabilidad

# Literal A
import numpy as np
import matplotlib.pyplot as plt
# Función de densidad
def density_func(x):
    return 36 * (x**2) * np.exp(-12 * x**2)

# Función de distribución acumulada (CDF)

def cdf_func(x):
    return np.cumsum(density_func(x))

# Generar variables aleatorias utilizando el método de la transformada

inversa
def generate_random_variables(n):
    u = np.random.uniform(0, 1, n)
    x = np.zeros(n)

    for i in range(n):
        x[i] = np.searchsorted(cdf_func(np.linspace(0, 5, 1000)),
u[i])

    return x

# Generar 1000 variables aleatorias

random_variables = generate_random_variables(1000)

# Graficar el histograma de las variables aleatorias generadas

plt.hist(random_variables, bins=20, density=True, alpha=0.7,
label='Variables aleatorias generadas')
x = np.linspace(0, 5, 1000)
plt.plot(x, density_func(x), 'r', label='Función de densidad')
plt.xlabel('x')
plt.ylabel('Densidad de probabilidad')
plt.legend()
plt.show()
#Literal B
import numpy as np
import matplotlib.pyplot as plt

# Función de probabilidad
def probability_func(x):
    return (1/2) * (1/2)**x

# Función de distribución acumulada (CDF)

def cdf_func(x):
    return np.cumsum(probability_func(np.arange(x+1)))

# Generar variables aleatorias utilizando el método de la transformada

inversa
def generate_random_variables(n):
    u = np.random.uniform(0, 1, n)
    x = np.zeros(n)

    for i in range(n):
        x[i] = np.searchsorted(cdf_func(10), u[i])

    return x

# Generar 40 variables aleatorias

random_variables = generate_random_variables(40)

# Graficar el histograma de las variables aleatorias generadas

plt.hist(random_variables, bins=10, density=True, alpha=0.7,
label='Variables aleatorias generadas')
x = np.arange(10)
plt.plot(x, probability_func(x), 'r', label='Función de probabilidad')
plt.xlabel('x')
plt.ylabel('Probabilidad')
plt.legend()
plt.show()

EJERCICIO 14

Genere 10 variables aleatorias con la siguiente distribución de probabilidad, 5 en el intervalo de

0 a 1 y 5 en el intervalo de 1 a 2

import numpy as np

# Generar 10 variables aleatorias con la distribución de probabilidad

dada
def generate_random_variables():
    random_variables = []

    for _ in range(5):
        u = np.random.uniform(0, 1)
        x = np.sqrt(u)
        random_variables.append(x)

    for _ in range(5):
        u = np.random.uniform(0, 1)
        x = 2 - np.sqrt(2 - u)
        random_variables.append(x)

    return random_variables

# Generar 10 variables aleatorias

random_variables = generate_random_variables()

# Imprimir las variables aleatorias generadas

for i, x in enumerate(random_variables):
    print(f"Variable {i+1}: {x}")

Variable 1: 0.6667061265262845
Variable 2: 0.9008470121016751
Variable 3: 0.9946135185366567
Variable 4: 0.5641642368435492
Variable 5: 0.8814705330486429
Variable 6: 0.7669372020545449
Variable 7: 0.9214664769359049
Variable 8: 0.9822598850754294
Variable 9: 0.9929163809265047
Variable 10: 0.9615240393004187

EJERCICIO 15

Mediante cualquier hoja de cálculo genere 20 variables aleatorias.

a) Distribución exponencial con 𝜆 = 1.75

b) Distribución triangular con límite inferior = 4, valor más probable = 10 y límite superior = 16

c) Distribución normal con media 40 y varianza 8. Use la fórmula x=5z+30

d) Distribución poisson con 𝜆 = 2

import numpy as np
from scipy.stats import triang, expon, norm, poisson

# a) Distribución exponencial con 𝜆 = 1.75

exponential_samples = expon(scale=1/1.75).rvs(size=20)

# b) Distribución triangular con límite inferior = 4, valor más

probable = 10 y límite superior = 16
triangular_samples = triang(loc=4, c=(10-4)/(16-4), scale=16-
4).rvs(size=20)

# c) Distribución normal con media 40 y varianza 8. Use la fórmula

x=5z+30
normal_samples = norm(loc=40, scale=np.sqrt(8)).rvs(size=20)
transformed_normal_samples = 5 * normal_samples + 30

# d) Distribución de Poisson con 𝜆 = 2

poisson_samples = poisson(mu=2).rvs(size=20)

print("Exponential samples:", exponential_samples)

print("Triangular samples:", triangular_samples)
print("Transformed normal samples:", transformed_normal_samples)
print("Poisson samples:", poisson_samples)

Exponential samples: [0.22543856 0.07116275 0.27236953 0.09921226

1.73679634 0.08569017
0.24633378 0.35558459 0.2913235 1.42522717 0.47511864 0.76967911
0.59618052 0.24656409 0.55616083 0.23695581 0.19759847 0.55717307
0.86361218 0.69887344]
Triangular samples: [14.55693019 11.74296231 10.02877395 12.40839
12.57969842 10.48937576
9.15222257 15.54712848 7.67887237 9.95897684 9.87217892
9.5684035
10.84750271 8.64551136 8.88353589 5.97276477 8.32158697
10.64729068
7.84664802 10.97649087]
Transformed normal samples: [248.64810771 234.15376467 227.23525578
237.17947898 263.90659028
223.19914518 218.30295045 207.67900697 222.33851145 215.21258903
234.32250999 212.72565456 226.41876261 219.69311761 241.23621333
210.31260405 207.87084884 232.62086566 235.62262335 198.78737531]
Poisson samples: [2 2 5 1 1 1 2 5 0 2 2 2 4 1 2 1 2 0 2 2]

EJERCICIO 16

Clasifique las siguientes variables aleatorias como discretas o continuas y justifique él porque:

a) X: el número de accidentes automovilísticos que ocurren al año en Virginia.

b) Y: el tiempo para jugar 18 hoyos de golf.

c) M: la cantidad de leche que una vaca específica produce anualmente.

d) N: el número de huevos que una gallina pone mensualmente.

e) P: el número de permisos para construcción que los funcionarios de una ciudad emiten cada
mes.

f) Q: el peso del grano producido por acre.

# a) X: el número de accidentes automovilísticos que ocurren al año en

Virginia.
# Clasificación: Discreta
# Justificación: El número de accidentes automovilísticos es una
cantidad contable y finita, por lo que se trata de una variable
discreta.
x = "Discreta"
# b) Y: el tiempo para jugar 18 hoyos de golf.
# Clasificación: Continua
# Justificación: El tiempo para jugar 18 hoyos de golf puede tomar
cualquier valor en un rango continuo, por lo que se trata de una
variable continua.
y = "Continua"

# c) M: la cantidad de leche que una vaca específica produce

anualmente.
# Clasificación: Continua
# Justificación: La cantidad de leche puede variar en un rango
continuo, desde 0 hasta un valor máximo. Por lo tanto, se trata de una
variable continua.
m = "Continua"

# d) N: el número de huevos que una gallina pone mensualmente.

# Clasificación: Discreta
# Justificación: El número de huevos es una cantidad contable y
finita, por lo que se trata de una variable discreta.
n = "Discreta"

# e) P: el número de permisos para construcción que los funcionarios

de una ciudad emiten cada mes.
# Clasificación: Discreta
# Justificación: El número de permisos para construcción es una
cantidad contable y finita, por lo que se trata de una variable
discreta.
p = "Discreta"

# f) Q: el peso del grano producido por acre.

# Clasificación: Continua
# Justificación: El peso del grano puede variar en un rango continuo,
desde 0 hasta un valor máximo. Por lo tanto, se trata de una variable
continua.
q = "Continua"

print("a) X:", x)
print("b) Y:", y)
print("c) M:", m)
print("d) N:", n)
print("e) P:", p)
print("f) Q:", q)

a) X: Discreta
b) Y: Continua
c) M: Continua
d) N: Discreta
e) P: Discreta
f) Q: Continua

EJERCICIO 17

El tiempo que pasa, en horas, para que un radar detecte entre conductores sucesivos a los que
exceden los límites de velocidad es una variable aleatoria continua con una función de
distribución acumulativa

Calcule la probabilidad de que el tiempo que pase para que el radar detecte entre conductores
sucesivos a los que exceden los límites de velocidad sea menor de 12 minutos.

import math

def probability_less_than_12_minutes():
    x = 12 / 60  # Convertir 12 minutos a horas
    probability = 1 - math.exp(-8 * x)
    return probability

probability = probability_less_than_12_minutes()
print("La probabilidad de que el tiempo sea menor de 12 minutos es:",
probability)

La probabilidad de que el tiempo sea menor de 12 minutos es:

0.7981034820053446

Ejercicio 18

Considere la función densidad

a) Evalúe k
b) Calcule F(x) y utilice el resultado para evaluar P(0.3<X<0.6)

import math

def evaluate_k():
    integral = 1 / (2/3)
    k = math.sqrt(integral)
    return k

def cumulative_distribution_function(x, k):

    if x >= 0 and x <= 1:
        return k * math.sqrt(x)
    else:
        return 0

def calculate_probability():
    k = evaluate_k()
    f_0_3 = cumulative_distribution_function(0.3, k)
    f_0_6 = cumulative_distribution_function(0.6, k)
    probability = f_0_6 - f_0_3
    return probability

k = evaluate_k()
print("El valor de k es:", k)

probability = calculate_probability()
print("La probabilidad P(0.3 < X < 0.6) es:", probability)

El valor de k es: 1.224744871391589

La probabilidad P(0.3 < X < 0.6) es: 0.27786290480057696

Ejercicio 19

Suponga que cierto tipo de pequeñas empresas de procesamiento de datos están tan
especializadas que algunas tienen dificultades para obtener utilidades durante su primer año de
operación. La función de densidad de probabilidad que caracteriza la proporción Y que obtiene
utilidades está dada por:

a) ¿Cuál es el valor de k que hace de la anterior una función de densidad válida?

b) Calcule la probabilidad de que al menos 50% de las empresas tenga utilidades durante el primer
año.
c) Calcule la probabilidad de que al menos 80% de las empresas tenga utilidades durante el primer
año.

import scipy.integrate as spi

def evaluate_k():
    integral, _ = spi.quad(lambda y: y**4 * (1-y)**3, 0, 1)
    k = 1 / integral
    return k

def calculate_probability(minimum_proportion):
    k = evaluate_k()
    integral, _ = spi.quad(lambda y: k * y**4 * (1-y)**3,
minimum_proportion, 1)
    probability = 1 - integral
    return probability

k = evaluate_k()
print("El valor de k es:", k)

probability_50 = calculate_probability(0.5)
print("La probabilidad de que al menos el 50% de las empresas tenga
utilidades durante el primer año es:", probability_50)

probability_80 = calculate_probability(0.8)
print("La probabilidad de que al menos el 80% de las empresas tenga
utilidades durante el primer año es:", probability_80)
El valor de k es: 280.00000000000006
La probabilidad de que al menos el 50% de las empresas tenga
utilidades durante el primer año es: 0.3632812499999999
La probabilidad de que al menos el 80% de las empresas tenga
utilidades durante el primer año es: 0.9437184000000001

Ejercicio 20

Las mediciones en los sistemas científicos siempre están sujetas a variación, algunas veces más
que otras. Hay muchas estructuras para los errores de medición y los estadísticos pasan mucho
tiempo modelándolos. Suponga que el error de medición X de cierta cantidad física es
determinado por la siguiente función de densidad:

a) Determine k, que representa f (x), una función de densidad válida.

b) Calcule la probabilidad de que un error aleatorio en la medición sea menor que ½.

c) Para esta medición específica, resulta indeseable si la magnitud del error (es decir, |x|) es
mayor que 0.8. ¿Cuál es la probabilidad de que esto ocurra?

import scipy.integrate as spi

def evaluate_k():
    integral, _ = spi.quad(lambda x: 3 - x**2, -1, 1)
    k = 1 / integral
    return k

def calculate_probability_less_than(value):
    k = evaluate_k()
    integral, _ = spi.quad(lambda x: k * (3 - x**2), -1, value)
    probability = integral
    return probability

def calculate_probability_greater_than(value):
    k = evaluate_k()
    integral, _ = spi.quad(lambda x: k * (3 - x**2), value, 1)
    probability = integral
    return probability

k = evaluate_k()
print("El valor de k es:", k)

probability_less_than_half = calculate_probability_less_than(1/2)
print("La probabilidad de que un error aleatorio en la medición sea
menor que 1/2 es:", probability_less_than_half)

probability_greater_than_08 = calculate_probability_greater_than(0.8)
print("La probabilidad de que la magnitud del error sea mayor que 0.8
es:", probability_greater_than_08)

El valor de k es: 0.1875

La probabilidad de que un error aleatorio en la medición sea menor que
1/2 es: 0.7734375
La probabilidad de que la magnitud del error sea mayor que 0.8 es:
0.08199999999999998