s2Eva_IT2010_T3 EDP elíptica, Placa no rectangular

Ejercicio: 2Eva_IT2010_T3 EDP elíptica, Placa no rectangular

la fórmula a resolver, siendo f(x,y)=20

\frac{\delta^2 u}{\delta x^2} + \frac{\delta^2 u}{\delta y^2} = f \frac{\delta^2 u}{\delta x^2} + \frac{\delta^2 u}{\delta y^2} = 20

Siendo las condiciones de frontera en los bordes marcados:

Se convierte a forma discreta la ecuación

\frac{u_{i+1,j}-2u_{i,j}+u_{i-1,j}}{\Delta x^2} + \frac{u_{i,j+1} -2u_{i,j}+u_{i,j-1}}{\Delta y^2} = 20 u_{i+1,j}-2u_{i,j}+u_{i-1,j} + \frac{\Delta x^2}{\Delta y^2} \Big( u_{i,j+1} -2u_{i,j}+u_{i,j-1} \Big) = 20 \Delta x^2

siendo λ = 1, al tener la malla en cuadrícula Δx=Δy

u_{i+1,j}-4u_{i,j}+u_{i-1,j} + u_{i,j+1}+u_{i,j-1} = 20 \Delta x^2

despejando u[i,j]

u_{i,j} =\frac{1}{4}\Big(u_{i+1,j}+u_{i-1,j} + u_{i,j+1}+u_{i,j-1} - 20 \Delta x^2 \Big)

Para el ejercicio, se debe usar las fronteras para los valores de cálculo que se puede hacer de dos formas:
1. Por posición del valor en la malla [i,j]
2. Por valor xi,yj que es la forma usada cuando la función es contínua.

1. Por posición del valor en la malla

Se busca la posición de la esquina derecha ubicada en xi = 0 y yj=1.5 y se la ubica como variable ‘desde’ como referencia para ubicar los valores de las fronteras usando los índices i, j.

# valores en fronteras
# busca poscición de esquina izquierda
desde = -1 
for j in range(0,m,1):
    if ((yj[j]-1.5)<tolera):
        desde = j
# llena los datos de bordes de placa
for j  in range(0,m,1):
    if (yj[j]>=1):
        u[j-desde,j] = Ta
    u[n-1,j] = Tb(xi[n-1],yj[j])
for i in range(0,n,1):
    if (xi[i]>=1):
        u[i,m-1]=Td
    u[i,desde-i] = Tc(xi[i],yj[i])
# valor inicial de iteración

2. Por valor xi, yj

Se establecen las ecuaciones que forman la frontera:

ymin = lambda x,y: 1.5-(1.5/1.5)*x
ymax = lambda x,y: 1.5+(1/1)*x

que se usan como condición para hacer el cálculo en cada nodo

if ((yj[j]-yjmin)>tolera and (yj[j]-yjmax)<-tolera):
                u[i,j] = (u[i-1,j]+u[i+1,j]+u[i,j-1]+u[i,j+1]-20*(dx**2))/4

Para minimizar errores por redondeo o truncamiento al seleccionar los puntos, la referencia hacia cero se toma como «tolerancia»; en lugar de más que cero o menos que cero.

Con lo que se obtiene el resultado mostrado en la gráfica aumentando la resolución con Δx=Δy=0.05:

converge =  1
xi=
[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65
 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35
 1.4  1.45 1.5 ]
yj=
[0.   0.05 0.1  0.15 0.2  0.25 0.3  0.35 0.4  0.45 0.5  0.55 0.6  0.65
 0.7  0.75 0.8  0.85 0.9  0.95 1.   1.05 1.1  1.15 1.2  1.25 1.3  1.35
 1.4  1.45 1.5  1.55 1.6  1.65 1.7  1.75 1.8  1.85 1.9  1.95 2.   2.05
 2.1  2.15 2.2  2.25 2.3  2.35 2.4  2.45 2.5 ]
matriz u
[[  0.     0.     0.   ...   0.     0.     0.  ]
 [  0.     0.     0.   ...   0.     0.     0.  ]
 [  0.     0.     0.   ...   0.     0.     0.  ]
 ...
 [  0.     0.     6.67 ...  96.1   98.03 100.  ]
 [  0.     3.33   5.31 ...  96.03  98.   100.  ]
 [  0.     2.     4.   ...  96.    98.   100.  ]]
>>>

Algoritmo en Python

# Ecuaciones Diferenciales Parciales
# Elipticas. Método iterativo para placa NO rectangular
import numpy as np

# INGRESO
# Condiciones iniciales en los bordes
Ta = 100
Tb = lambda x,y:(100/2.5)*y
Tc = lambda x,y: 100-(100/1.5)*x
Td = 100
# dimensiones de la placa no rectangular
x0 = 0
xn = 1.5
y0 = 0
yn = 2.5
ymin = lambda x,y: 1.5-(1.5/1.5)*x
ymax = lambda x,y: 1.5+(1/1)*x
# discretiza, supone dx=dy
dx = 0.05 
dy = 0.05 
maxitera = 100
tolera = 0.0001

# PROCEDIMIENTO
xi = np.arange(x0,xn+dx,dx)
yj = np.arange(y0,yn+dy,dy)
n = len(xi)
m = len(yj)
# Matriz u
u = np.zeros(shape=(n,m),dtype = float)

# valores en fronteras
# busca posición de esquina izquierda
desde = -1 
for j in range(0,m,1):
    if ((yj[j]-1.5)<tolera): desde = j 

# llena los datos de bordes de placa 

for j in range(0,m,1): if (yj[j]>=1):
        u[j-desde,j] = Ta
    u[n-1,j] = Tb(xi[n-1],yj[j])
for i in range(0,n,1):
    if (xi[i]>=1):
        u[i,m-1]=Td
    u[i,desde-i] = Tc(xi[i],yj[i])
# valor inicial de iteración
# se usan los valores cero

# iterar puntos interiores
itera = 0
converge = 0
while not(itera>=maxitera and converge==1):
    itera = itera + 10000
    nueva = np.copy(u)
    for i in range(1,n-1):
        for j in range(1,m-1):
            yjmin = ymin(xi[i],yj[j])
            yjmax = ymax(xi[i],yj[j])
            if ((yj[j]-yjmin)>tolera and (yj[j]-yjmax)<-tolera):
                u[i,j] = (u[i-1,j]+u[i+1,j]+u[i,j-1]+u[i,j+1]-20*(dx**2))/4
    diferencia = nueva-u
    erroru = np.linalg.norm(np.abs(diferencia))

    if (erroru<tolera):
        converge=1

# SALIDA
np.set_printoptions(precision=2)
print('converge = ', converge)
print('xi=')
print(xi)
print('yj=')
print(yj)
print('matriz u')
print(u)

Para incorporar la gráfica en forma de superficie.

# Gráfica
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

X, Y = np.meshgrid(xi, yj)
U = np.transpose(u) # ajuste de índices fila es x
figura = plt.figure()
ax = Axes3D(figura)
ax.plot_surface(X, Y, U, rstride=1, cstride=1, cmap=cm.Reds)
plt.title('EDP elíptica')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

s2Eva_IT2012_T3_MN EDO Taylor 2 Contaminación de estanque

Ejercicio: 2Eva_IT2012_T3_MN EDO Taylor 2 Contaminación de estanque

La ecuación a resolver con Taylor es:

s'- \frac{26s}{200-t} - \frac{5}{2} = 0

Para lo que se plantea usar la primera derivada:

s'= \frac{26s}{200-t}+\frac{5}{2}

con valores iniciales de s(0) = 0, h=0.1

La fórmula de Taylor para tres términos es:

s_{i+1}= s_{i}+s'_{i}h + \frac{s''_{i}}{2}h^2 + error

Para el desarrollo se compara la solución con dos términos, tres términos y Runge Kutta.

1. Solución con dos términos de Taylor

Iteraciones

i = 0, t0 = 0, s(0)=0

s'_{0}= \frac{26s_{0}}{200-t_{0}}+\frac{5}{2} = \frac{26(0)}{200-0}+\frac{5}{2} = \frac{5}{2} s_{1}= s_{0}+s'_{0}h = 0+ \frac{5}{2}*0.1= 0.25

t1 =  t0+h = 0+0.1 = 0.1

i=1


s'_{1}= \frac{26s_{1}}{200-t_{1}}+\frac{5}{2} = \frac{26(0.25)}{200-0.1}+\frac{5}{2} = 2.5325 s_{2}= s_{1}+s'_{1}h = 0.25 + (2.5325)*0.1 = 0.5032

t2 =  t1+h = 0.1+0.1 = 0.2

i=2,

resolver como tarea


2. Resolviendo con Python

estimado
 [xi,yi Taylor,yi Runge-Kutta, diferencias]
[[ 0.0  0.0000e+00  0.0000e+00  0.0000e+00]
 [ 0.1  2.5000e-01  2.5163e-01 -1.6258e-03]
 [ 0.2  5.0325e-01  5.0655e-01 -3.2957e-03]
 [ 0.3  7.5980e-01  7.6481e-01 -5.0106e-03]
 [ 0.4  1.0197e+00  1.0265e+00 -6.7714e-03]
 [ 0.5  1.2830e+00  1.2916e+00 -8.5792e-03]
 [ 0.6  1.5497e+00  1.5601e+00 -1.0435e-02]
 [ 0.7  1.8199e+00  1.8322e+00 -1.2339e-02]
 [ 0.8  2.0936e+00  2.1079e+00 -1.4294e-02]
 [ 0.9  2.3710e+00  2.3873e+00 -1.6299e-02]
 [ 1.0  2.6519e+00  2.6703e+00 -1.8357e-02]
 [ 1.1  2.9366e+00  2.9570e+00 -2.0467e-02]
 [ 1.2  3.2250e+00  3.2476e+00 -2.2632e-02]
 [ 1.3  3.5171e+00  3.5420e+00 -2.4853e-02]
 [ 1.4  3.8132e+00  3.8403e+00 -2.7129e-02]
 [ 1.5  4.1131e+00  4.1426e+00 -2.9464e-02]
 [ 1.6  4.4170e+00  4.4488e+00 -3.1857e-02]
 [ 1.7  4.7248e+00  4.7592e+00 -3.4310e-02]
 [ 1.8  5.0368e+00  5.0736e+00 -3.6825e-02]
 [ 1.9  5.3529e+00  5.3923e+00 -3.9402e-02]
 [ 2.0  5.6731e+00  5.7152e+00 -4.2043e-02]]
error en rango:  0.04204310894163932


2. Algoritmo en Python

# EDO. Método de Taylor 3 términos 
# estima la solucion para muestras espaciadas h en eje x
# valores iniciales x0,y0
# entrega arreglo [[x,y]]
import numpy as np

def edo_taylor2t(d1y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    x = x0
    y = y0
    for i in range(1,tamano,1):
        y = y + h*d1y(x,y) # + ((h**2)/2)*d2y(x,y)
        x = x+h
        estimado[i] = [x,y]
    return(estimado)

def rungekutta2(d1y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    xi = x0
    yi = y0
    for i in range(1,tamano,1):
        K1 = h * d1y(xi,yi)
        K2 = h * d1y(xi+h, yi + K1)

        yi = yi + (K1+K2)/2
        xi = xi + h
        
        estimado[i] = [xi,yi]
    return(estimado)

# PROGRAMA PRUEBA
# 2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

# INGRESO.
# d1y = y' = f, d2y = y'' = f'
d1y = lambda x,y: 26*y/(200-x)+5/2
x0 = 0
y0 = 0
h = 0.1
muestras = 20

# PROCEDIMIENTO
puntos = edo_taylor2t(d1y,x0,y0,h,muestras)
xi = puntos[:,0]
yi = puntos[:,1]

# Con Runge Kutta
puntosRK2 = rungekutta2(d1y,x0,y0,h,muestras)
xiRK2 = puntosRK2[:,0]
yiRK2 = puntosRK2[:,1]

# diferencias
diferencias = yi-yiRK2
error = np.max(np.abs(diferencias))
tabla = np.copy(puntos)
tabla = np.concatenate((puntos,np.transpose([yiRK2]),
                        np.transpose([diferencias])),
                       axis = 1)

# SALIDA
np.set_printoptions(precision=4)
print('estimado[xi,yi Taylor,yi Runge-Kutta, diferencias]')
print(tabla)
print('error en rango: ', error)

# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi[0],yi[0],'o',
         color='r', label ='[x0,y0]')
plt.plot(xi[0:],yi[0:],'-',
         color='g',
         label ='y Taylor 2 términos')
plt.plot(xiRK2[0:],yiRK2[0:],'-',
         color='blue',
         label ='y Runge-Kutta 2Orden')
plt.axhline(y0/2)
plt.title('EDO: Taylor 2T vs Runge=Kutta 2Orden')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

Usando Taylor con 3 términos

estimado
 [xi,        yi,        d1yi,      d2yi      ]
[[0.         0.         2.5        0.325     ]
 [0.1        0.251625   2.53272761 0.32958302]
 [0.2        0.50654568 2.56591685 0.33423301]
 [0.3        0.76480853 2.59957447 0.33895098]
 [0.4        1.02646073 2.63370731 0.34373796]
 [0.5        1.29155015 2.66832233 0.348595  ]
 [0.6        1.56012536 2.70342658 0.35352316]
 [0.7        1.83223563 2.73902723 0.35852351]
 [0.8        2.10793097 2.77513155 0.36359715]
 [0.9        2.38726211 2.81174694 0.36874519]
 [1.         2.67028053 2.84888087 0.37396876]
 [1.1        2.95703846 2.88654098 0.37926901]
 [1.2        3.24758891 2.92473497 0.3846471 ]
 [1.3        3.54198564 2.96347069 0.39010422]
 [1.4        3.84028323 3.00275611 0.39564157]
 [1.5        4.14253705 3.04259931 0.40126036]
 [1.6        4.44880328 3.08300849 0.40696184]
 [1.7        4.75913894 3.12399199 0.41274727]
 [1.8        5.07360187 3.16555827 0.41861793]
 [1.9        5.39225079 3.2077159  0.42457511]
 [2.         5.71514526 0.         0.        ]]

 

s2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

Ejercicio: 2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

La solución obtenida se realiza con h=0.5 y usando dos métodos para comparar resultados.

\frac{dy}{dt} = -k \sqrt{y}

1. EDO con Taylor

Usando una aproximación con dos términos de Taylor:

y_{i+1}=y_{i}+ y'_{i} h+\frac{y"_{i}}{2}h^{2}

Por lo que se obtienen las derivadas necesarias:

y'_i= -k (y_i)^{1/2} y"_i= \frac{-k}{2}(y_i)^{-1/2}

1.1 iteraciones

i=0, y0=3, t0=0

y'_0= -k(y_0)^{1/2} =-0.06(3)^{1/2} = -0.1039 y"_0= \frac{-0.06}{2}(3)^{-1/2} = -0.0173 y_{1}=y_{0}+ y'_{0} (1)+\frac{y"_{0}}{2}(1)^{2} y_{1}=3+ (-0.1039) (0.5)+\frac{-0.0173}{2}(0.5)^{2}= 2.9458

t1=t0+h = 0+0.5= 0.5

i=1, y1=2.9458, t1=0.5

y'_1= -k(y_1)^{1/2} =-0.06(2.887)^{1/2} =-0.1029 y"_1= \frac{-0.06}{2}(2.887)^{-1/2} = -0.0174 y_{2}=y_{1}+ y'_{1} (1)+\frac{y"_{1}}{2}(1)^{2} y_{1}=2.9458+ (-0.1029) (1)+\frac{-0.0174}{2}(1)^{2}= 2.8921

t2=t1+h = 0.5+0.5 = 1.0

i=2, y2=2.8921, t2=1.0

Resolver como Tarea

1.2 Resultados con Python

Realizando una tabla de valores usando Python y una gráfica, encuentra que el valor buscado del tanque a la mitad se obtiene en 16 minutos.

estimado[xi,yi]
[[ 0.          3.        ]
 [ 0.5         2.94587341]
 [ 1.          2.89219791]
 [ 1.5         2.83897347]
 [ 2.          2.7862001 ]
 ...
 [14.          1.65488507]
 [14.5         1.61337731]
 [15.          1.57231935]
 [15.5         1.53171109]
 [16.          1.49155239]
 [16.5         1.45184313]
 [17.          1.41258317]
 [17.5         1.37377234]
 [18.          1.33541049]
 [18.5         1.29749744]
 [19.          1.26003297]
 [19.5         1.22301689]
 [20.          1.18644897]]

Algoritmo en Python para Solución EDO con tres términos:

# EDO. Método de Taylor 3 términos 
# estima la solucion para muestras espaciadas h en eje x
# valores iniciales x0,y0
# entrega arreglo [[x,y]]
import numpy as np

def edo_taylor3t(d1y,d2y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    x = x0
    y = y0
    for i in range(1,tamano,1):
        y = y + h*d1y(x,y) + ((h**2)/2)*d2y(x,y)
        x = x+h
        estimado[i] = [x,y]
    return(estimado)

# PROGRAMA PRUEBA
# 2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

# INGRESO.
k=0.06
# d1y = y' = f, d2y = y'' = f'
d1y = lambda x,y: -k*(y**0.5)
d2y = lambda x,y: -(k/2)*(y**(-0.5))
x0 = 0
y0 = 3
h = 1/2
muestras = 40

# PROCEDIMIENTO
puntos = edo_taylor3t(d1y,d2y,x0,y0,h,muestras)
xi = puntos[:,0]
yi = puntos[:,1]

# SALIDA
print('estimado[xi,yi]')
print(puntos)
# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi[0],yi[0],'o', color='r', label ='[x0,y0]')
plt.plot(xi[1:],yi[1:],'o', color='g', label ='y estimada')
plt.axhline(y0/2)
plt.title('EDO: Solución con Taylor 3 términos')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

2. EDO con Runge-Kutta de 2do Orden dy/dx

Para éste método no se requiere desarrollar la segunda derivada, se usa el mismo h =0.5 con fines de comparación de resultados

2.1 ITeraciones

i = 1, y0=3, t0=0

K_1 = h y'(x_0,y_0) = (0.5)*(-0.06)(3)^{1/2} =-0.05196 K_2 = h y'(x_0+h,y_0+K_1) = (0.5)* y'(0.5,3-0.05196) = -0.05150 y_1 = y_0+\frac{K1+K2}{2} = 3+\frac{-0.05196-0.05150}{2} = 2.9482

i = 2, y1=2.9482, t1=0.5

K_1 = h y'(x_1,y_1) = (0.5)*(-0.06)(2.9482)^{1/2} =-0.05149 K_2 = h y'(x_1+h,y_1+K_1) = (0.5)* y'(0.5,2.9482-0.05149) = -0.05103 y_1 = y_0+\frac{K1+K2}{2} = 3+\frac{-0.05149-0.05103}{2} = -2.8946

i = 3,  y1=2.8946, t1=1.0

Resolver como Tarea

2.2 Resultados con Python

Si comparamos con los resultados anteriores en una tabla, y obteniendo las diferencias entre cada iteración se tiene que:

estimado[xi,yi Taylor, yi Runge-Kutta, diferencias]
[[ 0.0  3.00000000  3.00000000  0.00000000e+00]
 [ 0.5  2.94587341  2.94826446 -2.39104632e-03]
 [ 1.0  2.89219791  2.89697892 -4.78100868e-03]
 [ 1.5  2.83897347  2.84614338 -7.16990106e-03]
 [ 2.0  2.78620010  2.79575783 -9.55773860e-03]
...
 [ 14.0  1.65488507  1.72150488 -6.66198112e-02]
 [ 14.5  1.61337731  1.68236934 -6.89920328e-02]
 [ 15.0  1.57231935  1.64368380 -7.13644510e-02]
 [ 15.5  1.53171109  1.60544826 -7.37371784e-02]
 [ 16.0  1.49155239  1.56766273 -7.61103370e-02]
 [ 16.5  1.45184313  1.53032719 -7.84840585e-02]
 [ 17.0  1.41258317  1.49344165 -8.08584854e-02]
 [ 17.5  1.37377234  1.45700611 -8.32337718e-02]
 [ 18.0  1.33541049  1.42102058 -8.56100848e-02]
 [ 18.5  1.29749744  1.38548504 -8.79876055e-02]
 [ 19.0  1.26003297  1.35039950 -9.03665304e-02]
 [ 19.5  1.22301689  1.31576397 -9.27470733e-02]
 [ 20.0  1.18644897  1.28157843 -9.51294661e-02]]
error en rango:  0.09512946613018003

# EDO. Método de Taylor 3 términos 
# estima la solucion para muestras espaciadas h en eje x
# valores iniciales x0,y0
# entrega arreglo [[x,y]]
import numpy as np

def edo_taylor3t(d1y,d2y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    x = x0
    y = y0
    for i in range(1,tamano,1):
        y = y + h*d1y(x,y) + ((h**2)/2)*d2y(x,y)
        x = x+h
        estimado[i] = [x,y]
    return(estimado)

def rungekutta2(d1y,x0,y0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,2),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0]
    xi = x0
    yi = y0
    for i in range(1,tamano,1):
        K1 = h * d1y(xi,yi)
        K2 = h * d1y(xi+h, yi + K1)

        yi = yi + (K1+K2)/2
        xi = xi + h
        
        estimado[i] = [xi,yi]
    return(estimado)

# PROGRAMA PRUEBA
# 2Eva_IIT2016_T3_MN EDO Taylor 2, Tanque de agua

# INGRESO.
k=0.06
# d1y = y' = f, d2y = y'' = f'
d1y = lambda x,y: -k*(y**0.5)
d2y = lambda x,y: -(k/2)*(y**(-0.5))
x0 = 0
y0 = 3
h = 1/2
muestras = 40

# PROCEDIMIENTO
puntos = edo_taylor3t(d1y,d2y,x0,y0,h,muestras)
xi = puntos[:,0]
yi = puntos[:,1]

# Con Runge Kutta
puntosRK2 = rungekutta2(d1y,x0,y0,h,muestras)
xiRK2 = puntosRK2[:,0]
yiRK2 = puntosRK2[:,1]

# diferencias
diferencias = yi-yiRK2
error = np.max(np.abs(diferencias))
tabla = np.copy(puntos)
tabla = np.concatenate((puntos,np.transpose([yiRK2]),
                        np.transpose([diferencias])),
                       axis = 1)

# SALIDA
print('estimado[xi,yi Taylor,yi Runge-Kutta,diferencias]')
print(tabla)
print('error en rango: ', error)

# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi[0],yi[0],'o',
         color='r', label ='[x0,y0]')
plt.plot(xi[1:],yi[1:],'o',
         color='g',
         label ='y Taylor 3 terminos')
plt.plot(xiRK2[1:],yiRK2[1:],'o',
         color='blue',
         label ='y Runge-Kutta 2Orden')
plt.axhline(y0/2)
plt.title('EDO: Taylor 3T vs Runge=Kutta 2Orden')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

s2Eva_IIT2018_T3 EDP

Ejercicio: 2Eva_IIT2018_T3 EDP

Se indica en el enunciado que b = 0

\frac{\delta u}{\delta t} = \frac{\delta ^2 u}{\delta x^2} + b\frac{\delta u}{\delta x}

simplificando la ecuación a:

\frac{\delta u}{\delta t} = \frac{\delta ^2 u}{\delta x^2}

Reordenando la ecuación a la forma estandarizada:

\frac{\delta ^2 u}{\delta x^2} = \frac{\delta u}{\delta t}

Seleccione un método: explícito o implícito.
Si el método es explícito, las diferencias finitas a usar son hacia adelante y centrada:

U'(x_i,t_j) = \frac{U(x_i,t_{j+1})-U(x_i,t_j)}{\Delta t} + O(\Delta t) U''(x_i,t_j) = \frac{U(x_{i+1},t_j)-2U(x_{i},t_j)+U(x_{i-1},t_j)}{\Delta x^2} + O(\Delta x^2)

como referencia se usa la gráfica.

Se selecciona la esquina inferior derecha como 0,  por la segunda ecuación de condiciones y facilidad de cálculo. (No hubo indicación durante el examen que muestre lo contrario)

condiciones de frontera U(0,t)=0, U(1,t)=1
condiciones de inicio U(x,0)=0, 0≤x≤1

aunque lo más recomendable sería cambiar la condición de inicio a:

condiciones de inicio U(x,0)=0, 0<x<1

Siguiendo con el tema de la ecuación, al reemplazar las diferencias finitas en la ecuación:


\frac{U(x_{i+1},t_j)-2U(x_{i},t_j)+U(x_{i-1},t_j)}{\Delta x^2} = = \frac{U(x_i,t_{j+1})-U(x_i,t_j)}{\Delta t}

se reagrupan los términos que son constantes y los términos de error se acumulan:

\frac{\Delta t}{\Delta x^2} \Big[U(x_{i+1},t_j)-2U(x_i,t_j)+U(x_{i-1},t_j) \Big] = U(x_i,t_{j+1})-U(x_i,t_j)

siendo,

\lambda= \frac{\Delta t}{\Delta x^2} error \cong O(\Delta t) + O(\Delta x^2)

continuando con la ecuación, se simplifica la escritura usando sólo los índices i,j y se reordena de izquierda a derecha como en la gráfica

\lambda \Big[U[i-1,j]-2U[i,j]+U[i+1,j] \Big] = U[i,j+1]-U]i,j] \lambda U[i-1,j]+(-2\lambda+1)U[i,j]+\lambda U[i+1,j] = U[i,j+1] U[i,j+1] = \lambda U[i-1,j]+(-2\lambda+1)U[i,j]+\lambda U[i+1,j] U[i,j+1] = P U[i-1,j]+QU[i,j]+R U[i+1,j] P=R = \lambda Q = -2\lambda+1

En las iteraciones, el valor de P,Q y R se calculan a partir de λ ≤ 1/2

iteraciones: j=0, i=1

U[1,1] = P*0+Q*0+R*0 = 0

j=0, i=2

U[2,1] = P*0+Q*0+R*0=0

j=0, i=3

U[3,1] = P*0+Q*0+R*1=R=\lambda=\frac{1}{2}

iteraciones: j=1, i=1

U[1,2] = P*0+Q*0+R*0 = 0

j=1, i=2

U[2,2] = P*0+Q*0+R*\lambda = \lambda ^2 = \frac{1}{4}

j=1, i=3

U[3,2] = P*0+Q*\frac{1}{4}+R (\lambda) U[3,2] = (-2\lambda +1) \frac{1}{4}+\lambda^2 = \Big(-2\frac{1}{2}+1\Big) \frac{1}{4}+\Big(\frac{1}{2}\Big)^2 U[3,2] =0\frac{1}{4} + \frac{1}{4} = \frac{1}{4}

Literal b. Para el cálculo del error:

\lambda \leq \frac{1}{2} \frac{\Delta t}{\Delta x^2} \leq \frac{1}{2} \Delta t \leq \frac{\Delta x^2}{2}

en el enunciado se indica h = 0.25 = ¼ = Δ x

\Delta t \leq \frac{(1/4)^2}{2} = \frac{1}{32} error \cong O(\Delta t) + O(\Delta x^2) error \cong \frac{\Delta x^2}{2}+ \Delta x^2 error \cong \frac{3}{2}\Delta x^2 error \cong \frac{3}{2}( \frac{1}{4})^2 error \cong \frac{3}{32} = 0.09375

s2Eva_IIT2018_T2 Kunge Kutta 2do Orden x»

Ejercicio: 2Eva_IIT2018_T2 Kunge Kutta 2do Orden x»

\frac{\delta ^2 x}{\delta t^2} + 5t\frac{\delta x}{\delta t} +(t+7)\sin (\pi t) = 0 x'' + 5tx' +(t+7)\sin (\pi t) = 0 x'' = -5tx' +(t+7)\sin (\pi t) = 0

si se usa z=x’

z' = -5tz +(t+7)\sin (\pi t) = 0

se convierte en:
f(t,x,z) = x’ = z
g(t,x,z) = x» = z’ = -5tz +(t+7)sin (π t) = 0

Donde se aplica el algoritmo de Runge Kutta
http://blog.espol.edu.ec/analisisnumerico/8-2-2-runge-kutta-d2y-dx2/

   t,              x,              z
[[ 0.00000000e+00  6.00000000e+00  1.50000000e+00]
 [ 2.00000000e-01  6.30000000e+00  1.77320538e+00]
 [ 4.00000000e-01  6.70381805e+00  2.26987703e+00]
 [ 6.00000000e-01  7.20775473e+00  2.41163944e+00]
 [ 8.00000000e-01  7.68994485e+00  1.90531839e+00]
 [ 1.00000000e+00  8.01027755e+00  9.52659193e-01]
 [ 1.20000000e+00  8.10554347e+00 -5.65431040e-03]
 [ 1.40000000e+00  8.00869435e+00 -6.09147239e-01]
 [ 1.60000000e+00  7.81236802e+00 -7.16247408e-01]
 [ 1.80000000e+00  7.62013640e+00 -3.92947221e-01]
 [ 2.00000000e+00  7.50882725e+00  1.63598524e-01]]

Instrucciones en Python

# 2Eva_IIT2018_T2 Kunge Kutta 2do Orden x''
import numpy as np

def rungekutta2_fg(f,g,x0,y0,z0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,3),dtype=float)
    # incluye el punto [x0,y0]
    estimado[0] = [x0,y0,z0]
    xi = x0
    yi = y0
    zi = z0
    for i in range(1,tamano,1):
        K1y = h * f(xi,yi,zi)
        K1z = h * g(xi,yi,zi)
        
        K2y = h * f(xi+h, yi + K1y, zi + K1z)
        K2z = h * g(xi+h, yi + K1y, zi + K1z)

        yi = yi + (K1y+K2y)/2
        zi = zi + (K1z+K2z)/2
        xi = xi + h
        
        estimado[i] = [xi,yi,zi]
    return(estimado)

# PROGRAMA
# INGRESO
f = lambda t,x,z: z
g = lambda t,x,z: -5*t*z+(t+7)*np.sin(np.pi*t)
t0 = 0
x0 = 6
z0 = 1.5
h = 0.2
muestras = 10

# PROCEDIMIENTO
tabla = rungekutta2_fg(f,g,t0,x0,z0,h,muestras)

# SALIDA
print(tabla)
# GRAFICA
import matplotlib.pyplot as plt
plt.plot(tabla[:,0],tabla[:,1])
plt.xlabel('t')
plt.ylabel('x(t)')
plt.show()

s2Eva_IIT2018_T1 Masa entra o sale de un reactor

Ejercicio: 2Eva_IIT2018_T1 Masa entra o sale de un reactor

a) Se pueden combinar los métodos para realizar la integral. Se usa el método de Simpson 1/3 para los primeros dos tramos y Simpson 3/8 para los 3 tramos siguientes.  Siendo f(x) equivalente a Q(t)C(t). El tamaño de paso h es constante para todo el ejercicio con valor 5.

a.1 Simpson 1/3, tramos 2, puntos 3:

I_1 \cong \frac{h}{3}[f(x_0)+4f(x_1) + f(x_2)] I_1 \cong \frac{5}{3}[(10)(4)+4(18)(6) + (27)(7)] I_1 \cong 1101,66

a.2 Simpson de 3/8, tramos 3, puntos 4:

I_2 \cong \frac{3h}{8}[f(x_0)+3f(x_1) +3 f(x_2)+f(x_3)] I_2 \cong \frac{3(5)}{8}[(27)(7)+3(35)(6) +3(40)(5)+(30)(5)] I_2 \cong 2941,88 I_1 + I_2 \cong 4043,54

b) El error se calcula por tramo y se acumula.

b.1 se puede estimar como la diferencia entre la parábola del primer tramo y simpson 1/3
b.2 siguiendo el ejemplo anterior, como la diferencia entre la interpolación de los tramos restantes y simpson 3/8.

s2Eva_IT2010_T2 Movimiento angular

Ejercicio: 2Eva_IT2010_T2 Movimiento angular

Para resolver, se usa Runge-Kutta_fg de segundo orden como ejemplo

y'' + 10 \sin (y) =0

se hace

y' = z = f(t,y,z)

y se estandariza:

y'' =z'= -10 \sin (y) = g(t,y,z)

teniendo como punto de partida t0=0, y0=0 y z0=0.1

y(0)=0, y'(0)=0.1

Se desarrolla el algotitmo para obtener los valores:

 [ t, 		 y, 	 dyi/dti=z]
[[ 0.          0.          0.1       ]
 [ 0.2         0.02        0.08000133]
 [ 0.4         0.03200053  0.02401018]
 [ 0.6         0.03040355 -0.04477916]
 [ 0.8         0.01536795 -0.09662411]
 [ 1.         -0.00703034 -0.10803459]]

que permiten generar la gráfica de respuesta:


Algoritmo en Python

# 2Eva_IT2010_T2 Movimiento angular
import numpy as np
import matplotlib.pyplot as plt

def rungekutta2_fg(f,g,x0,y0,z0,h,muestras):
    tamano = muestras + 1
    estimado = np.zeros(shape=(tamano,3),dtype=float)
    # incluye el punto [x0,y0,z0]
    estimado[0] = [x0,y0,z0]
    xi = x0
    yi = y0
    zi = z0
    for i in range(1,tamano,1):
        K1y = h * f(xi,yi,zi)
        K1z = h * g(xi,yi,zi)
        
        K2y = h * f(xi+h, yi + K1y, zi + K1z)
        K2z = h * g(xi+h, yi + K1y, zi + K1z)

        yi = yi + (K1y+K2y)/2
        zi = zi + (K1z+K2z)/2
        xi = xi + h
        
        estimado[i] = [xi,yi,zi]
    return(estimado)

# INGRESO theta = y
ft = lambda t,y,z: z
gt = lambda t,y,z: -10*np.sin(y)

t0 = 0
y0 = 0
z0 = 0.1
h=0.2
muestras = 5

# PROCEDIMIENTO
tabla = rungekutta2_fg(ft,gt,t0,y0,z0,h,muestras)

# SALIDA
print(' [ t, \t\t y, \t dyi/dti=z]')
print(tabla)

# Grafica
ti = np.copy(tabla[:,0])
yi = np.copy(tabla[:,1])
zi = np.copy(tabla[:,2])
plt.subplot(121)
plt.plot(ti,yi)
plt.xlabel('ti')
plt.title('yi')
plt.subplot(122)
plt.plot(ti,zi, color='green')
plt.xlabel('ti')
plt.title('dyi/dti')
plt.show()

s2Eva_IT2018_T3 EDP Eliptica

Ejercicio: 2Eva_IT2018_T3 EDP Eliptica

Generar las ecuaciones a resolver usando diferencias finitas divididas centradas:

\frac{\partial ^2 u}{\partial x^2} + \frac{\partial ^2 u}{\partial y^2} = 2(x^2+y^2)

por facilidad se sustituye también en la forma discreta de la ecuación:

f[i,j] = f(x_i,y_j) = 2(x_{i} ^2+y_{j} ^2)
\frac{u[i-1,j]-2u[i,j]+u[i+1,j]}{\Delta x^2} + + \frac{u[i,j-1]-2u[i,j]+u[i,j+1]}{\Delta y^2} = f[i,j]
\frac{\Delta y^2}{\Delta x^2}\Big(u[i-1,j]-2u[i,j]+u[i+1,j]\Big) + + u[i,j-1]-2u[i,j]+u[i,j+1] = \Delta y^2 f[i,j]

dado que hx = hy = 1/3

\frac{\Delta y^2}{\Delta x^2} = 1
(u[i-1,j]-2u[i,j]+u[i+1,j]) + + u[i,j-1]-2u[i,j]+u[i,j+1] = = \Delta y^2 f[i,j]
u[i-1,j]-4u[i,j]+u[i+1,j] + + u[i,j-1]+u[i,j+1] = \Delta y^2 f[i,j]
4u[i,j] = u[i-1,j]+u[i+1,j] + + u[i,j-1]+u[i,j+1]-\Delta y^2 f[i,j]
u[i,j] = \frac{1}{4} \Big(u[i-1,j]+u[i+1,j] + + u[i,j-1]+u[i,j+1]-\Delta y^2 f[i,j] \Big)

La última ecuación puede ser usada de forma iterativa, para lo cual hay que definir los valores iniciales de la matriz u.

Al conocer el rango de operación para los ejes x, y, hx, hy se realizan los cálculos para:

1. Evaluar los valores para cada eje x[i], y[j]

x[i]:
[ 0.    0.33  0.67  1.  ]
y[j]:
[ 0.    0.33  0.67  1.  ]

2. Evaluar en cada punto generando una matriz f(i,j):

f[i,j]:
[[ 0.    0.22  0.89  2.  ]
 [ 0.22  0.44  1.11  2.22]
 [ 0.89  1.11  1.78  2.89]
 [ 2.    2.22  2.89  4.  ]]

3. Se evaluan las funciones indicadas para la frontera y se tiene la matriz inicial para u:

matriz inicial u[i,j]:
[[ 1.    1.33  1.67  2.  ]
 [ 1.33  0.    0.    2.44]
 [ 1.67  0.    0.    3.11]
 [ 2.    2.44  3.11  4.  ]]

con lo que se puede trabajar cada punto i,j de forma iterativa, teniendo como resultado para la matriz u:

resultado para u, iterando: 
converge =  1
[[ 1.    1.33  1.67  2.  ]
 [ 1.33  1.68  2.05  2.44]
 [ 1.67  2.05  2.53  3.11]
 [ 2.    2.44  3.11  4.  ]]

La gráfica usando una mayor resolución para tener una idea de la solución:


Los resultados se obtienen usando las siguientes instrucciones:

# 2da Evaluación I Término 2018
# Tema 3. EDP Eliptica
import numpy as np

# INGRESO
# ejes x,y
x0 = 0 ; xn = 1 ; hx = (1/3)# (1/3)/10
y0 = 0 ; yn = 1 ; hy = (1/3) # (1/3)/10
# Fronteras
fux0 = lambda x: x+1
fu0y = lambda y: y+1
fux1 = lambda x: x**2 + x + 2
fu1y = lambda y: y**2 + y + 2

fxy = lambda x,y: 2*(x**2+y**2)

# PROCEDIMIENTO
xi = np.arange(x0,xn+hx,hx)
yj = np.arange(y0,yn+hy,hy)
n = len(xi)
m = len(yj)
# funcion f[xi,yi]
fij = np.zeros(shape=(n,m), dtype = float)
for i in range(0,n,1):
    for j in range(0,m,1):
        fij[i,j]=fxy(xi[i],yj[j])
# matriz inicial u[i,j]
u = np.zeros(shape=(n,m), dtype = float)
u[:,0] = fux0(xi)
u[0,:] = fu0y(yj)
u[:,m-1] = fux1(xi)
u[n-1,:] = fu1y(yj)

uinicial = u.copy()

# Calcular de forma iterativa
maxitera = 100
tolera = 0.0001
# valor inicial de iteración
promedio = (np.max(u)+np.min(u))/2
u[1:n-1,1:m-1] = promedio
# iterar puntos interiores
itera = 0
converge = 0
erroru = 2*tolera # para calcular al menos una matriz
while not(erroru=maxitera):
    itera = itera +1
    nueva = np.copy(u)
    for i in range(1,n-1):
        for j in range(1,m-1):
            u[i,j] = (u[i-1,j]+u[i+1,j]+u[i,j-1]+u[i,j+1]-(hy**2)*fij[i,j])/4
    diferencia = nueva-u
    erroru = np.linalg.norm(np.abs(diferencia))
if (erroru<tolera):
    converge=1

# SALIDA
np.set_printoptions(precision=2)
print('x[i]:')
print(xi)
print('y[j]:')
print(yj)
print('f[i,j]:')
print(fij)
print('matriz inicial u[i,j]:')
print(uinicial)
print('resultado para u, iterando: ')
print('converge = ', converge)
print('iteraciones = ', itera)
print(u)

para obtener la gráfica se debe añadir:

# Gráfica
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

X, Y = np.meshgrid(xi, yj)
figura = plt.figure()
ax = Axes3D(figura)
U = np.transpose(u) # ajuste de índices fila es x
ax.plot_surface(X, Y, U, rstride=1, cstride=1, cmap=cm.Reds)
plt.title('EDP elíptica')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

s2Eva_IT2018_T2 Deducir Simpson 1/3

Ejercicio: 2Eva_IT2018_T2 Deducir Simpson 1/3

Para el problema, se usan los puntos:  [a,f(a)], [b,f(b)] y [c,f(c)]
por donde pasa la curva f(x) aproximada a un polinomio de grado 2, f(x) \approx p(x)

\int_a^b f(x) dx \approx \int_a^b p(x) dx p(x) = L_a f(a) + L_c f(c) + L_b f(b) \int_a^b p(x) dx = \int_a^b \Big[ L_a f(a) +L_c f(c) + L_b f(b) \Big] dx = = \int_a^b L_a f(a) dx + \int_a^b L_c f(c) dx + \int_a^b L_b f(b) dx \int_a^b p(x) dx = I_1 + I_2 + I_3

Como referencia se usa la gráfica para relacionar a, b, c y h:


Primer Integral

Para el primer integral I_1= \int_a^b L_a f(a) dx se tiene que:

L_a = \frac{(x-b)(x-c)}{(a-b)(a-c)} = \frac{(x-b)(x-c)}{(-2h)(-h)} L_a = \frac{(x-b)(x-c)}{2h^2}

se convierte en:

I_1 = \int_a^b \frac{(x-b)(x-c)}{2h^2} f(a) dx = \frac{f(a)}{2h^2} \int_a^b (x-b)(x-c)dx

Para dejar la parte del integral en función de h, a y b, teniendo que c está en la mitad de [a,b], es decir c = (a+b)/2 , se usa:

u = x-a

por lo que \frac{du}{dx}=1 y du = dx

x-c = (u+a) - \frac{a+b}{2} = u+ \frac{a-b}{2} = u - \frac{b-a}{2} x-c = u-h x-b = (u+a)-b = u-2\Big(\frac{b-a}{2}\Big) = u-2h

Se actualiza el integral de x entre [a,b]  usando u = x-a, que se convierte el rango para u en [0, b-a] que es lo mismo que [0,2h]

\int_a^b (x-b)(x-c)dx = \int_0^{2h} (u-2h)(u-h)du = = \int_0^{2h} \Big( u^2 - 2hu - uh + 2h^2 \Big) du = \int_0^{2h} \Big( u^2 - 3hu + 2h^2 \Big) du = \frac{u^3}{3}- 3h\frac{u^2}{2}+ 2h^2u \Big|_0^{2h} = \frac{(2h)^3}{3}- 3h\frac{(2h)^2}{2} + 2h^2(2h) -(0-0+0) = \frac{8h^3}{3}- 6h^3 + 4h^3 =\frac{8h^3}{3}- 2h^3 = \frac{2h^3}{3}

resultado que se usa en I1

I_1= \frac{f(a)}{2h^2}\frac{2h^3}{3} =\frac{h}{3} f(a)

que es el primer término de la fórmula general de Simpson 1/3


Segundo Integral

Para el Segundo integral I_2= \int_a^b L_c f(c) dx se tiene que:

L_c = \frac{(x-a)(x-b)}{(c-a)(c-b)} = \frac{(x-a)(x-b)}{(h)(-h)} L_c = \frac{(x-a)(x-b)}{-h^2}

se convierte en:

I_2 = \frac{f(c)}{-h^2} \int_a^b (x-a)(x-b) dx = \frac{f(c)}{-h^2} \int_0^{2h} (u)(u-2h) du

siendo:

\int_0^{2h}(u^2-2hu)du=\Big(\frac{u^3}{3}-2h\frac{u^2}{2}\Big)\Big|_0^{2h} =\frac{(2h)^3}{3}-h(2h)^2-(0-0) =\frac{8h^3}{3}-4h^3 = -\frac{4h^3}{3}

usando en I2

I_2 = \frac{f(c)}{-h^2}\Big(-\frac{4h^3}{3}) = \frac{h}{3}4f(c)

Tarea: Continuar las operaciones para y tercer integral para llegar a la fórmula general de Simpson 1/3:

I = \frac{h}{3} \Big( f(a)+4f(c) + f(b) \Big)

s2Eva_IT2018_T4 Dragado acceso marítimo

Ejercicio: 2Eva_IT2018_T4 Dragado acceso marítimo

a) La matriz para remover sedimentos se determina como la diferencia entre la profundidad y la matriz de batimetría.

Considere el signo de la profundidad para obtener el resultado:

matriz remover sedimentos: 
[[ 4.21  0.    0.96  0.    3.76  3.09]
 [ 2.15  0.11  2.05  3.77  0.    3.07]
 [ 0.    1.14  1.65  0.    1.62  1.35]
 [ 3.7   0.    0.59  2.33  0.    4.23]
 [ 0.    1.38  3.53  4.49  1.98  1.4 ]
 [ 0.    0.77  0.32  1.06  4.24  3.54]]

se obtiene con la instrucciones:

# 2da Evaluación I Término 2018
# Tema 4. canal acceso a Puertos de Guayaquil
import numpy as np

# INGRESO
profcanal = 11

xi = np.array([ 0.,  50., 100., 150., 200., 250.])
yi = np.array([ 0., 100., 200., 300., 400., 500.])

batimetria = [[ -6.79,-12.03,-10.04,-11.60, -7.24,-7.91],
              [ -8.85,-10.89, -8.95, -7.23,-11.42,-7.93],
              [-11.90, -9.86, -9.35,-12.05, -9.38,-9.65],
              [ -7.30,-11.55,-10.41, -8.67,-11.84,-6.77],
              [-12.17, -9.62, -7.47, -6.51, -9.02,-9.60],
              [-11.90,-10.23,-10.68, -9.94, -6.76,-7.46]]

batimetria = np.array(batimetria)
# PROCEDIMIENTO
[n,m] = np.shape(batimetria)

# Matriz remover sedimentos
remover = batimetria + profcanal
for i in range(0,n,1):
    for j in range(0,m,1):
        if remover[i,j]<0:
            remover[i,j]=0
# SALIDA
print('matriz remover sedimentos: ')
print(remover)

b) el volumen se calcula usando el algoritmo de Simpson primero por un eje, y luego con el resultado se continúa con el otro eje,

Considere que existen 6 puntos, o 5 tramos integrar en cada eje.

  • Al usar Simpson de 1/3 que usan tramos pares, faltaría integrar el último tramo.
  • En el caso de Simpson de 3/8 se requieren tramos multiplos de 3, porl que faltaría un tramo para volver a usar la fórmula.

La solución por filas se implementa usando una combinación de Simpson 3/8 para los puntos entre remover[i, 0:3] y Simpson 1/3 para los puntos entre remover[i, 3:5].

Luego se completa el integral del otro eje con el resultado anterior, aplicando el mismo método.

Se obtuvieron los siguientes resultados:

Integral en eje x: 
[ 219.1   309.83  260.44  217.75  511.21  137.85]
Volumen:  160552.083333

que se obtiene usando las instrucciones a continuación de las anteriores:

# literal b) ---------------------------
def simpson13(fi,h):
    s13 = (h/3)*(fi[0] + 4*fi[1] + fi[2])
    return(s13)
def simpson38(fi,h):
    s38 = (3*h/8)*(fi[0] + 3*fi[1] + 3*fi[2]+ fi[3])
    return(s38)

Integralx = np.zeros(n,dtype = float)

for i in range(0,n,1):
    hx = xi[1]-xi[0]
    fi = remover[i, 0:(0+4)]
    s38 = simpson38(fi,hx)
    fi = remover[i, 3:(3+3)]
    s13 = simpson13(fi,hx)
    Integralx[i] = s38 + s13

hy = yi[1] - yi[0]
fj = Integralx[0:(0+4)]
s38 = simpson38(fj,hy)
fj = Integralx[3:(3+3)]
s13 = simpson13(fj,hy)
volumen = s38 + s13

# Salida
np.set_printoptions(precision=2)
print('Integral en eje x: ')
print(Integralx)
print('Volumen: ', volumen)

Para el examen escrito, se requieren realizar al menos 3 iteraciones/ filas para encontrar el integral.