s3Eva_IIT2018_T2 Drenar tanque cilíndrico

la ecuación a desarrollar es:

\frac{\delta y}{\delta t} = -k\sqrt{y}

con valores de k =0.5, y(0)=9


Formula de Taylor con término de error:

P_{n}(x) = \sum_{k=0}^{n} \frac{f^{(k)}(x_0)}{k!} (x-x_0)^k P_{n}(x) = f(x_0)+\frac{f'(x_0)}{1!} (x-x_0) + + \frac{f''(x_0)}{2!}(x-x_0)^2 + + \frac{f'''(x_0)}{3!}(x-x_0)^3 + \text{...}

Se requiere la 2da y 3ra derivadas:

\frac{\delta^2 y}{\delta t^2} = -k\frac{1}{2} y^{(\frac{1}{2}-1)} = -\frac{k}{2} y^{-\frac{1}{2}} \frac{\delta^3 y}{\delta t^3} = -\frac{k}{2}\Big(-\frac{1}{2}\Big) y^{(-\frac{1}{2}-1)} = \frac{k}{4} y^{-\frac{3}{2}}

con lo que inicia las iteraciones y cálculo del error, con avance de 0.5 para t.


t=0 , y(0) = 9


t = 0.5

\frac{\delta y(0)}{\delta t} = -(0.5)\sqrt{9} = -1.5 \frac{\delta^2 y(0)}{\delta t^2} = -\frac{0.5}{2} 9^{-\frac{1}{2}} = - 0.08333 \frac{\delta^3 y(0)}{\delta t^3} = \frac{0.5}{4} 9^{-\frac{3}{2}} = 0.004628 P_{2}(0.5) = 9 - 1.5 (0.5-0) + \frac{-0.08333}{2}(0.5-0)^2 P_{2}(0.5) = 8.2395

Error orden de:

Error = \frac{0.004628}{3!}(0.5-0)^3 = 9.641 . 10^{-5}

t = 1

\frac{\delta y(0.5)}{\delta t} = -(0.5)\sqrt{8.2395} = -1.4352 \frac{\delta^2 y(0.5)}{\delta t^2} = -\frac{0.5}{2} (8.2395)^{-\frac{1}{2}} = - 0.08709 \frac{\delta^3 y(0.5)}{\delta t^3} = \frac{0.5}{4} (8.2395)^{-\frac{3}{2}} = 0.005285 P_{2}(1) = 8.2395 - 1.4352(1-0.5) + \frac{-0.08709}{2}(1-0.5)^2 P_{2}(1) = 7.5110

Error orden de:

Error = \frac{0.005285}{3!}(1-0.5)^3 = 4.404 . 10^{-4}

t = 1.5

\frac{\delta y(1)}{\delta t} = -(0.5)\sqrt{7.5110} = -1.3703 \frac{\delta^2 y(1)}{\delta t^2} = -\frac{0.5}{2} (7.5110)^{-\frac{1}{2}} = - 0.09122 \frac{\delta^3 y(1)}{\delta t^3} = \frac{0.5}{4} (7.5110)^{-\frac{3}{2}} = 0.006072 P_{2}(1.5) = 7.5110 - 1.3703(1.5-1) + \frac{-0.09122}{2}(1.5-1)^2 P_{2}(1.5) = 6.8144

Error orden de:

Error = \frac{0.006072}{3!}(1.5-1)^3 = 1.4 . 10^{-4}

t = 2

\frac{\delta y(1.5)}{\delta t} = -(0.5)\sqrt{6.8144} = -1.3052 \frac{\delta^2 y(1.5)}{\delta t^2} = -\frac{0.5}{2} (6.8144)^{-\frac{1}{2}} = - 0.09576 \frac{\delta^3 y(1.5)}{\delta t^3} = \frac{0.5}{4} (6.8144)^{-\frac{3}{2}} = 0.007026 P_{2}(2) = 6.8144 - 1.3052 (2-1.5) - \frac{0.09576}{2}(2-1.5)^2 P_{2}(2) = 6.1498

Error orden de:

Error = \frac{0.007026}{3!}(2-1.5)^3 = 1.4637 . 10^{-4}

Se estima que el próximo término pasa debajo de 6 pies.
Por lo que estima esperar entre 2 y 2.5 minutos.

Usando Python:

ti, p_i,  error
[[0.00000000e+00 9.00000000e+00 0.00000000e+00]
 [5.00000000e-01 8.23958333e+00 9.64506173e-05]
 [1.00000000e+00 7.51107974e+00 1.10105978e-04]
 [1.50000000e+00 6.81451855e+00 1.26507192e-04]
 [2.00000000e+00 6.14993167e+00 1.46391550e-04]
 [2.50000000e+00 5.51735399e+00 1.70751033e-04]]

# Tema 2. Tanque cilindrico
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
y0 = 9
t0 = 0
buscar = 6
k = 0.5
h = 0.5

dy  = lambda t,y: -k*np.sqrt(y)
d2y = lambda t,y: -(k/2)*(y**(-1/2))
d3y = lambda t,y: (k/4)*(y**(-3/2))
# PROCEDIMIENTO
resultado = [[t0,y0,0]]
yi = y0
ti = t0
while not(yi<buscar):
    ti = ti+h
    dyi = dy(ti,yi)
    d2yi = d2y(ti,yi)
    d3yi = d3y(ti,yi)
    p_i = yi +dyi*(h) + (d2yi/2)*(h**2)
    errado = (d3yi/6)*(h**3)
    yi = p_i
    resultado.append([ti,p_i,errado])
resultado = np.array(resultado)
# SALIDA
print('ti, p_i,  error')
print(resultado)
# Grafica
plt.plot(resultado[:,0],resultado[:,1])
plt.ylabel('nivel de agua')
plt.xlabel('tiempo')
plt.grid()
plt.show()

s3Eva_IT2018_T3 EDP Parabólica, temperatura en varilla

Se generan las ecuaciones usando diferencias finitas divididas centradas y hacia adelante

\frac{d^2u}{dx^2} + \frac{Kr}{\rho C} = K\frac{du}{dt}
\frac{u[i-1,j]-2u[i,j]+u[i+1,j]}{\Delta x^2}+ + \frac{Kr}{\rho C} = K \frac{u[i,j+1]-u[i,j]}{\Delta t}


\frac{\Delta t}{K\Delta x^2} \Big[u[i-1,j]-2u[i,j]+u[i+1,j] \Big] + + \frac{Kr}{\rho C} \frac{\Delta t}{K} = u[i,j+1]-u[i,j]

Se sustituye :

\lambda = \frac{\Delta t}{K\Delta x^2} \gamma = \frac{Kr}{\rho C} \frac{\Delta t}{K} = \frac{r\Delta t}{\rho C}

simplificando a:


\lambda \Big[u[i-1,j]-2u[i,j]+u[i+1,j] \Big] + +\gamma = u[i,j+1]-u[i,j]

despejando para u[i,j+1]:

\lambda u[i-1,j]-2\lambda u[i,j]+\lambda u[i+1,j] + +\gamma = u[i,j+1]-u[i,j]
u[i,j+1] =\lambda u[i-1,j]+(1-2\lambda) u[i,j]+ +\lambda u[i+1,j] +\gamma

con lo que se tiene una forma explicita de encontrar los valores de la ecuacion.

La gráfica se realizó para 20 valores de t con tamaño de paso dt


El resultado pedido en el enunciado de distribucion de temperatura para t=3k

u[:,t] para t = 0.07500000000000001
[ 0.    0.81  1.23  1.35  1.23  0.81  0.  ]

algunos valores de u[i,j]

Tabla de resultados
[[ 0.    0.    0.    0.    0.    0.    ...]
 [ 0.5   0.66  0.74  0.81  0.87  0.92  ...]
 [ 0.87  0.99  1.12  1.23  1.33  1.41  ...]
 [ 1.    1.11  1.23  1.35  1.47  1.57  ...]
 [ 0.87  0.99  1.12  1.23  1.33  1.41  ...]
 [ 0.5   0.66  0.74  0.81  0.87  0.92  ...]
 [ 0.    0.    0.    0.    0.    0.    ...]]

Desarrollo en Python

# 3ra Evaluación I Término 2018 
# Tema 3. EDP Parabólica, Temperatura en varilla
# método explícito, usando diferencias finitas
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
# Constantes
L = 1.5
K = 1.04
ro = 10.6
C = 0.056
r = 5.0
# Tamaño de paso
dx = 0.25
dt = 0.025
# longitud en x
a = 0
b = L
# iteraciones en tiempo
n = 20
# Valores de frontera
Ta = 0
Tb = 0
ux0 = lambda x: np.sin(np.pi*x/L)

# PROCEDIMIENTO
# iteraciones en longitud
xi = np.arange(a,b+dx,dx)
m = len(xi)
ultimox = m-1

# Resultados en tabla u[x,t]
u = np.zeros(shape=(m,n), dtype=float)

# valores iniciales de u[:,j]
j=0
ultimot = n-1
u[0,j]= Ta
u[1:ultimox,j] = ux0(xi[1:ultimox])
u[ultimox,j] = Tb

# factores P,Q,R
lamb = dt/(K*(dx**2))
gama = r*dt/(ro*C)
P = lamb
Q = 1 - 2*lamb
R = lamb

# Calcula U para cada tiempo + dt
j = 0
while not(j>=ultimot):
    u[0,j+1] = Ta
    for i in range(1,ultimox,1):
        u[i,j+1] = P*u[i-1,j] + Q*u[i,j] + R*u[i+1,j] + gama
    u[m-1,j+1] = Tb
    j=j+1

# SALIDA
print('Tabla de resultados')
np.set_printoptions(precision=2)
print(u)
print('u[:,t] para t =', 3*dt)
print(u[:,3])

# Gráfica
salto = 1 # int(n/10)
if (salto == 0):
    salto = 1
for j in range(0,n,salto):
    vector = u[:,j]
    plt.plot(xi,vector)
    plt.plot(xi,vector, '.r')
plt.xlabel('x[i]')
plt.ylabel('t[j]')
plt.title('Solución EDP parabólica')
plt.show()

algunos valores de u[i,j]

Tabla de resultados
[[ 0.    0.    0.    0.    0.    0.    ...]
 [ 0.5   0.66  0.74  0.81  0.87  0.92  ...]
 [ 0.87  0.99  1.12  1.23  1.33  1.41  ...]
 [ 1.    1.11  1.23  1.35  1.47  1.57  ...]
 [ 0.87  0.99  1.12  1.23  1.33  1.41  ...]
 [ 0.5   0.66  0.74  0.81  0.87  0.92  ...]
 [ 0.    0.    0.    0.    0.    0.    ...]]

s3Eva_IT2018_T1 Intersección de círculos

Literal a

Se grafica las funciones usando Python, para encontrar el rango de búsqueda de raíces.

De la gráfica se usa el ‘zoom’ y se puede aproximar los valores para la intersección de las curvas estimando raices en x=1.80 y x=3.56

Desarrollo numérico

Se usan las ecuaciones para encontrar la diferencia entre las funciones.

(x-4)^2 + (y-4)^2 = 5 x^2 + y^2 = 16

Se despeja la variable y para la primera ecuación:

(y-4)^2 = 5 - (x-4)^2 y-4 = \sqrt{5 - (x-4)^2} f(x) = y = \sqrt{5 - (x-4)^2} + 4

la segunda ecuacion se transforma en

x^2 + y^2 = 16 y^2 = 16 - x^2 g(x) = y = \sqrt{16 - x^2}

La intersección se obtiene restando las ecuaciones, para f(x) se usa la parte inferior del circulo y para g(x) la parte superior de circulo.

Para buscar las raices se analiza en el rango de existencia entre las dos funciones:

[-4,4]\text{ y } [4 -\sqrt{5} ,4 + \sqrt{5}] [-4,4] \text{ y } [1.7639 , 6.2360]

por lo que la diferencia existe en el rango:

[1.7639 ,4] \text{diferencia}(x) = f(x)-g(x)

que es el que se usa para el literal b


Literal b

Las ecuaciones para la diferencia entre las funciones son :

f_{2} (x) = -\sqrt{5-(x-4)^2}+4 g_{1} (x) = \sqrt{16-x^2}

Para el método de Newton-Raphson se requieren las derivadas:

\frac{d f_2}{dx} = \frac{x-4}{ \sqrt{5-(x-4)^2} } \frac{d g_{1}}{dx} = \frac{-x}{ \sqrt{16-x^2} }

por lo que:

\frac{d \text{diferencia}}{dx} = \frac{d f_{2}}{dx} - \frac{d g_{1}}{dx}

Usando el algoritmo con Python se obtienen las raices:

 usando Newton-Raphson
raices en:  1.80582463574 3.56917099898

Desarrollo en Python:

El desarrollo se realiza por partes, en el mismo orden del planteamiento de  los literales

# 3ra Evaluación I Término 2018
# Tema 1. Intersección de círculos
import numpy as np
import matplotlib.pyplot as plt

# literal a

fx1 = lambda x: np.sqrt(5-(x-4)**2)+4
fx2 = lambda x: -np.sqrt(5-(x-4)**2)+4
gx1 = lambda x: np.sqrt(16-x**2)
gx2 = lambda x: -np.sqrt(16-x**2)

# Rango inicial de análisis (visual)
a = -5; b = 7
muestras = 501

# PROCEDIMIENTO
# Evalua los puntos en el rango
xi = np.linspace(a,b,muestras)
fx1i = fx1(xi)
fx2i = fx2(xi)
gx1i = gx1(xi)
gx2i = gx2(xi)

# SALIDA - Gráfica
plt.plot(xi,fx1i)
plt.plot(xi,fx2i)
plt.plot(xi,gx1i)
plt.plot(xi,gx2i)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Intersección de círculos')
plt.grid()
plt.show()

# GRAFICAR las diferencias
a = 4 - np.sqrt(5)
b = 4 + np.sqrt(5)
# PROCEDIMIENTO
xi = np.linspace(a,b,muestras)
diferencia = fx2(xi) - gx1(xi)
# GRAFICA
plt.plot(xi,diferencia)
plt.axhline(0)
plt.xlabel('x')
plt.ylabel('y')
plt.title('diferencia entre círculos')
plt.grid()
plt.show()

# literal b -----------------------
def newton_raphson(funcionx, fxderiva, xi, tolera):
    # funciónx y fxderiva en forma numérica
    # xi es el punto inicial de búsqueda
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = xi - funcionx(xi)/fxderiva(xi)
        tramo = abs(xnuevo-xi)
        xi = xnuevo
    return(xi)

funcionx = lambda x: fx2(x) - gx1(x)
fxderiva = lambda x: (x-4)/np.sqrt(5-(x-4)**2)+x/np.sqrt(16-x**2)

tolera = 0.001
xi1 = a + tolera
xi2 = 3.5

raiz1 = newton_raphson(funcionx, fxderiva, xi1, tolera)
raiz2 = newton_raphson(funcionx, fxderiva, xi2, tolera)

# SALIDA
print('\n usando Newton-Raphson')
print('raices en: ', raiz1,raiz2)

s3Eva_IT2018_T2 Drenaje de estanque

literal a

Se usa interpolación para encontrar los polinomios que pasan por los puntos seleccionados.

El error de A(5) se obtiene como la diferencia entre el valor de la tabla y el polinomio del tramo [4,6] evaluado en el punto.

ordenado:  [6 5 4 3 2 1 0]
hi:  [0 1 2 3 4 5 6]
Ai:  [ 0.02  0.18  0.32  0.45  0.67  0.97  1.17]

puntos seleccionados:
h1:  [0, 2, 4, 6]
A1:  [ 0.02  0.32  0.67  1.17]

Polinomios por tramos: 
 x = [0,2]
0.000416666666666669*x**3 + 0.148333333333333*x + 0.02
 x = [2,4]
0.00416666666666666*x**3 - 0.0224999999999999*x**2 + 0.193333333333333*x - 0.00999999999999984
 x = [4,6]
-0.00458333333333333*x**3 + 0.0824999999999999*x**2 - 0.226666666666666*x + 0.549999999999999

error en px(5):  0.0637499999999998

se observa que la evaluación se realiza para el polinomio entre [4,6]

Desarrollo en Python

# 3ra Evaluación I Término 2018
# Tema 2. Drenaje de Estanque

import numpy as np
import matplotlib.pyplot as plt
import sympy as sym

def traza3natural(xi,yi):
    # Trazador cúbico natural, splines
    # resultado: polinomio en forma simbólica
    n = len(xi)
    # Valores h
    h = np.zeros(n-1, dtype = float)
    for j in range(0,n-1,1):
        h[j] = xi[j+1] - xi[j]
    
    # Sistema de ecuaciones
    A = np.zeros(shape=(n-2,n-2), dtype = float)
    B = np.zeros(n-2, dtype = float)
    S = np.zeros(n, dtype = float)
    A[0,0] = 2*(h[0]+h[1])
    A[0,1] = h[1]
    B[0] = 6*((yi[2]-yi[1])/h[1] - (yi[1]-yi[0])/h[0])
    for i in range(1,n-3,1):
        A[i,i-1] = h[i]
        A[i,i] = 2*(h[i]+h[i+1])
        A[i,i+1] = h[i+1]
        B[i] = 6*((yi[i+2]-yi[i+1])/h[i+1] - (yi[i+1]-yi[i])/h[i])
    A[n-3,n-4] = h[n-3]
    A[n-3,n-3] = 2*(h[n-3]+h[n-2])
    B[n-3] = 6*((yi[n-1]-yi[n-2])/h[n-2] - (yi[n-2]-yi[n-3])/h[n-3])
    
    # Resolver sistema de ecuaciones
    r = np.linalg.solve(A,B)
    # S
    for j in range(1,n-1,1):
        S[j] = r[j-1]
    S[0] = 0
    S[n-1] = 0
    
    # Coeficientes
    a = np.zeros(n-1, dtype = float)
    b = np.zeros(n-1, dtype = float)
    c = np.zeros(n-1, dtype = float)
    d = np.zeros(n-1, dtype = float)
    for j in range(0,n-1,1):
        a[j] = (S[j+1]-S[j])/(6*h[j])
        b[j] = S[j]/2
        c[j] = (yi[j+1]-yi[j])/h[j] - (2*h[j]*S[j]+h[j]*S[j+1])/6
        d[j] = yi[j]
    
    # Polinomio trazador
    x = sym.Symbol('x')
    polinomio = []
    for j in range(0,n-1,1):
        ptramo = a[j]*(x-xi[j])**3 + b[j]*(x-xi[j])**2 + c[j]*(x-xi[j])+ d[j]
        ptramo = ptramo.expand()
        polinomio.append(ptramo)
    
    return(polinomio)

# PROGRAMA -------------------------

hi = np.array([6, 5, 4, 3, 2, 1, 0])
Ai = np.array([1.17, 0.97, 0.67, 0.45, 0.32, 0.18, 0.02])
xk = 5

# PROCEDIMIENTO LITERAL a
# reordena en forma ascendente
ordenado = np.argsort(hi)
hi = hi[ordenado]
Ai = Ai[ordenado]

# Selecciona puntos
xi = [0,2,4,6]
fi = Ai[xi]
n = len(xi)

polinomio = traza3natural(xi,fi)

# literal a, estima error
px = polinomio[2]
pxk = px.subs('x',xk)
errado = np.abs(Ai[xk] - pxk)

# SALIDA
print('ordenado: ', ordenado)
print('hi: ', hi)
print('Ai: ', Ai)
print('puntos seleccionados:')
print('h1: ', xi)
print('A1: ', fi)

print('Polinomios por tramos: ')
for tramo in range(1,n,1):
    print(' x = ['+str(xi[tramo-1])+','+str(xi[tramo])+']')
    print(str(polinomio[tramo-1]))

print('error en px(5): ', errado)

# GRAFICA
# Puntos para grafica en cada tramo
resolucion = 10 # entre cada par de puntos
xtrazado = np.array([])
ytrazado = np.array([])
tramo = 1
while not(tramo>=n):
    a = xi[tramo-1]
    b = xi[tramo]
    xtramo = np.linspace(a,b,resolucion)
    
    ptramo = polinomio[tramo-1]
    pxtramo = sym.lambdify('x',ptramo)
    ytramo = pxtramo(xtramo)
    
    xtrazado = np.concatenate((xtrazado,xtramo))
    ytrazado = np.concatenate((ytrazado,ytramo))
    tramo = tramo + 1

# GRAFICA
# puntos originales
plt.plot(hi,Ai,'o',label = 'Ai')
# Trazador cúbico
plt.plot(xtrazado,ytrazado, label = 'p(h)')
plt.plot(xi,fi,'o', label = 'Apx')
plt.title('Trazador cúbico natural (splines)')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()

Literal b

TAREA

s3Eva_IT2009_T3 Integrar Simpson compuesta

la fórmula a integrar es:

\int_0^1 \frac{\cos (2x)}{x^{1/3}} \delta x

Que tiene la forma:

da como resultado:

el área bajo la curva es:  0.879822622256
# 3ra Evaluación I Término 2009
# Tema 3
import numpy as np
import matplotlib.pyplot as plt

funcionx = lambda x: np.cos(2*x)/(x**(1/3))

# INGRESO
a = 0.00001
b = 1
tramos = 10000

# PROCEDIMIENTO
h = (b-a)/tramos
x = a
area = 0
for i in range(0,tramos,2):
    deltaA = (h/3)*(funcionx(x)+4*funcionx(x+h)+funcionx(x+2*h))
    area = area + deltaA
    x = x + 2*h
# para la gráfica
xi = np.linspace(a,b,tramos+1)
fxi = funcionx(xi)

print('el área bajo la curva es: ', area)
# Gráfica
plt.plot(xi,fxi)
plt.title('Funcion a integrar')
plt.grid()
plt.xlabel('x')
plt.show()

Tarea: convertir a función el cálculo de Simpson

s3Eva_IT2017_T3 Sustancia en lago

El ejercicio se divide en dos partes: sección transversal con la derivada y concentración promedio con integrales.

Sección transversal

Se calcula la derivada con  una aproximación básica con error O(h)

f'(x_i) = \frac{f(x_{i+1})-f(x_i)}{h} + O(h)

repidiendo la fórmula entre cada par de puntos consecutivos

dv/dz: [-1.1775  -0.7875  -0.39175 -0.09825  0.     ]

Concentración promedio

Para los integrales usamos la regla del trapecio:

I = (b-a) \frac{f(a)+f(b)}{2}
numerador:  224.38960000000003
denominador:  29.852
concentracion promedio:  7.516735897092323

Aplicando los algoritmos en Python para todos los puntos:

# 3Eva_IT2017_T3 Sustancia en lago
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
zi = np.array([0.  , 4   , 8   , 12    , 16])
vi = np.array([9.82, 5.11, 1.96,  0.393,  0.])
ci = np.array([10.2, 8.5 , 7.4 ,  5.2  ,  4.1])

# PROCEDIMIENTO
n = len(zi)
# primera derivada hacia adelante con error O(h)
dv = np.zeros(n,dtype=float)
for i in range(0,n-1,1):
    h = zi[i+1]-zi[i]
    dv[i]=(vi[i+1]-vi[i])/h

As = -dv*zi

# integrales por rectángulo
numerador = 0
for i in range(0,n-1,1):
    altura = (ci[i]*As[i]+ci[i+1]*As[i+1])/2
    numerador = numerador +altura*(zi[i+1]-zi[i])

denominador = 0
for i in range(0,n-1,1):
    altura = (As[i]+As[i+1])/2
    denominador = denominador +altura*(zi[i+1]-zi[i])

cpromedio = numerador/denominador

# SALIDA
print('dv/dz: ')
print(dv)
print('numerador: ',numerador)
print('denominador: ',denominador)
print('concentracion promedio: ',cpromedio)

# Grafica
plt.subplot(121)
plt.plot(zi,vi)
plt.plot(zi,vi,'bo')
plt.xlabel('profundidad z')
plt.ylabel('Volumen')
plt.grid()
plt.subplot(122)
plt.plot(zi,ci, color = 'orange')
plt.plot(zi,ci,'ro')
plt.xlabel('profundidad z')
plt.ylabel('concentración')
plt.grid()
plt.show()

s3Eva_IT2010_T1 Envase cilíndrico

Se conoce que el volumen del cilindro es 1000 cm3
que se calcula como:

Volumen = area_{base} . altura = \pi r^2 h \pi r^2 h = 1000 h = \frac{1000}{\pi r^2}

con lo que la altura queda en función del radio, pues el volumen es una constante.

Para conocer el área de la hoja de material para el envase se conoce que las tapas cilíndricas deben ser 0.25 mas que el radio para sellar el recipiente

Area de una tapa circular:

Area_{tapa} = \pi (r+ 0.25)^2

para la hoja lateral:

Area_{lateral} = base * altura = (2 \pi r + 0.25) h

que en función del radio, usando la fórmula para h(r) se convierte en:

Area_{lateral} = (2 \pi r + 0.25) \frac{1000}{\pi r^2}

por lo que el total de material de hoja a usar corresponde a dos tapas circulares y una hoja lateral.

Area total = 2 \pi (r+ 0.25)^2 + (2 \pi r + 0.25) \frac{1000}{\pi r^2}

la gráfica permite observar el comportamiento entre el área de la hoja necesaria para fabricar el envase y el radio de las tapas circulares.

El objetivo es encontrar el área mínima para consumir menos material. Con la fórmula mostrada se pued aplicar uno de los métodos para encontrar raíces a partir de la derivada de la fórmula.

Tarea: Encontrar el valor requerido para r con la tolerancia indicada para el examen.


Instrucciones para la gráfica:

# 3Eva_IT2010_T1 Envase cilíndrico
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
a = 0.5
b = 20
muestras = 51

Area = lambda r: (2*np.pi)*(r+0.25)**2 +(2*np.pi*r+0.25)*1000/(np.pi*(r**2))

# PROCEDIMIENTO
ri = np.linspace(a,b,muestras)
Areai = Area(ri)

# SALIDA
plt.plot(ri,Areai)
plt.xlabel('r (cm)')
plt.ylabel('Area (cm2)')
plt.title('Area hoja para material cilindro')
plt.show()