s1Eva_IT2009_T1 Demanda de producto

Ejercicio: 1Eva_IT2009_T1 Demanda de producto

Desarrollo analítico

– igualar la ecuación al valor buscado, 80

200 t e^{-0.75t} = 80

– forma estándar de la ecuación para el método f(x) = 0:

f(t) = 200 t e^{-0.75t} - 80

– derivada de la ecuación

f'(t) = 200 e^{-0.75t} + 200 t (-0.75) e^{-0.75t} f'(t) = 200 e^{-0.75t}(1-0.75t)

– fórmula del método de Newton-Raphson

t_{i+1} = t_i - \frac{f(t)}{f'(t)}

– Punto inicial. Como la variable es t, tiempo, el rango de análisis es t>0
El valor inicial de búsqueda se selecciona t0 = 1

iteración 1:

t_{1} = 1 - \frac{200 (1) e^{-0.75(1)} - 80}{200 e^{-0.75(1)}(1-0.75(1))}

error = 0.6128

iteración 2:

t_{2} = 0.3872 - \frac{200 (0.3872) e^{-0.75(0.3872)} - 80}{200 e^{-0.75(0.3872)}(1-0.75(0.3872))}

error = 0.208

iteracion 3:

t_{3} = 0.5952 - \frac{200 (0.5952) e^{-0.75(0.5952)} - 80}{200 e^{-0.75(0.5952)}(1-0.75(0.5952))}

error = 5.3972e-02

tabla de iteraciones

[  xi,       xnuevo,   f(xi),   f'(xi),    tramo]
[  1.        0.3872   14.4733   23.6183   0.6128]
[  0.3872    0.5952  -22.0776  106.1511   0.208 ]
[  5.9518e-01   6.4916e-01  -3.8242e+00   7.0855e+01   5.3972e-02]
[  6.4916e-01   6.5252e-01  -2.1246e-01   6.3069e+01   3.3686e-03]
[  6.5252e-01   6.5254e-01  -7.9031e-04   6.2600e+01   1.2625e-05]
raiz:  0.65253630273

Se obtiene el valor de la raíz con 5 iteraciones, y un error de 1.2625e-05


Desarrollo con Python

Tarea: desarrollar el literal b

s1Eva_IT2018_T1 Tanque esférico canchas deportivas

Ejercicio: 1Eva_IT2018_T1 Tanque esférico canchas deportivas

a) Para seleccionar el rango para h=[a,b], se observa que el tanque puede estar vacio, a=0 o lleno al máximo, b=2R = 2(3)=6, con lo que se obtiene:

h =[0.0, 6.0]

conociendo la proporción con el valor máximo, se tiene un valor inicial para h0 para las iteraciones.

Vmax = \frac{\pi}{3} (2R)^2 (3R-2R) Vmax = \frac{4\pi }{3}R^{3}= 113.09 h_0 = (6)*30/113.09 = 1.59

b) Usar Newton-Raphson con tolerancia 1e-6

f(h) = \frac{\pi }{3}h^2 (3(3)-h)-30 f(h) = \frac{\pi }{3}(9h^2 -h^3-28.647) f'(h) = \frac{\pi }{3}(18h-3h^2)

el punto siguiente de iteración es:

h_{i+1} = h_{i} -\frac{f(h)}{f'(h)} = h_{i}-\frac{ \frac{\pi }{3}(9h^2 -h^3-28.647)}{ \frac{\pi }{3}(18h-3h^2)} h_{i+1} = h_{i} -\frac{(9h^2 -h^3-28.647)}{(18h-3h^2)}

con lo que se realiza la tabla de iteraciones:

hi hi+1 error orden
1.590 2.061 0.47 10-1
2.061 2.027 -0.034 10-2
2.027 2.02686 -0.00014 10-4
2.02686 2.0268689 -2.32E-09 10-9

En valor práctico 2.028 m usando flexómetro, a menos que use medidor laser con precisión 10-6 usará más dígitos con un tanque de 6 metros de altura ganará una precisión de una gota de agua para usar en duchas o regar el césped .

c) El orden de convergencia del error observando las tres primeras iteraciones es cuadrático

Tarea: Realizar los cálculos con Python, luego aplique otro método. Añada sus observaciones y conclusiones.

s1Eva_IT2018_T3 Temperatura en nodos de placa

Ejercicio: 1Eva_IT2018_T3 Temperatura en nodos de placa

a) Plantear el sistema de ecuaciones. Usando el promedio para cada nodo interior:

a=\frac{50+c+100+b}{4} b=\frac{a+30+50+d}{4} c=\frac{a+60+100+d}{4} d=\frac{b+60+c+30}{4}

que reordenando se convierte en:

4a=150+c+b 4b=a+80+d 4c=a+160+d 4d=b+c+90

simplificando:

4a-b-c= 150 a-4b+d = -80 a-4c+d = -160 b+c-4d = -90

que a forma matricial se convierte en:

A = [[ 4, -1, -1, 0.0],
     [ 1, -4,  0, 1.0],
     [ 1,  0, -4, 1.0],
     [ 0,  1,  1,-4.0]]
B = [[ 150.0],
     [ -80.0],
     [-160.0],
     [ -90.0]]

Observación: la matriz A ya es diagonal dominante, no requiere pivotear por filas.  Se aumentó el punto decimal a los valores de la matriz A y el vector B  para que sean considerados como números reales.

El número de condición es: np.linalg.cond(A) = 3.0

que es cercano a 1 en un orden de magnitud, por lo que la solución matricial es «estable» y los cambios en los coeficientes afectan proporcionalmente a los resultados. Se puede aplicar métodos iterativos sin mayores inconvenientes.

b y c) método de Jacobi para sistemas de ecuaciones, con vector inicial

 
X(0) = [[60.0],
        [40], 
        [70],
        [50]] 

reemplazando los valores iniciales en cada ecuación sin cambios.

iteración 1
a=\frac{50+70+100+40}{4} = 65

b=\frac{60+30+50+50}{4} = 47.5 c=\frac{60+60+100+50}{4} = 67.5 d=\frac{40+60+70+30}{4} = 50
X(1) = [[65],
        [47.5],
        [67.5],
        [50]]

vector de error = 
     [|65-60|,
      |47.5-40|,
      |67.5-70|,
      |50-50|]
  = [|5|,
     |7.5|,
     |-2.5|,
     |0|]
errormax = 7.5

iteración 2
a=\frac{50+67.5+100+47.5}{4} = 66.25

b=\frac{65+30+50+50}{4} = 48.75 c=\frac{65+60+100+50}{4} = 68.75 d=\frac{47.5+60+67.7+30}{4} = 51.3
X(2) = [[66.25],
        [48.75],
        [68.75],
        [51.3]]

vector de error = 
       [|66.25-65|,
        |48.75-47.5|,
        |68.75-67.5|,
           |51.3-50|] 
  = [|1.25|,
     |1.25|,
     |1.25|,
     |1.3|]
errormax = 1.3

iteración 3
a=\frac{50+68.75+100+48.75}{4} = 66.875

b=\frac{66.25+30+50+51.3}{4} = 49.38 c=\frac{66.25+60+100+51.3}{4} = 69.3875 d=\frac{48.75+60+68.75+30}{4} = 51.875
X(2) = [[66.875],
        [49.38],
        [69.3875],
        [51.875]]

vector de error = 
      [|66.875-66.25|,
       |49.38-48.75|,
       |69.3875-68.75|,
       |51.875-51.3|]
    = [|0.655|,
       |0,63|,
       |0.6375|,
        |0.575|]
errormax = 0.655
con error relativo de:
100*0.655/66.875 = 0.97%

siguiendo las iteraciones se debería llegar a:

>>> np.linalg.solve(A,B)
array([[ 67.5],
       [ 50. ],
       [ 70. ],
       [ 52.5]])

s1Eva_IT2018_T4 El gol imposible

Ejercicio: 1Eva_IT2018_T4 El gol imposible

Tabla de datos:

ti = [0.00, 0.15, 0.30, 0.45, 0.60, 0.75, 0.90, 1.05, 1.20]
xi = [0.00, 0.50, 1.00, 1.50, 1.80, 2.00, 1.90, 1.10, 0.30]
yi = [0.00, 4.44, 8.88,13.31,17.75,22.19,26.63,31.06,35.50]
zi = [0.00, 0.81, 1.40, 1.77, 1.91, 1.84, 1.55, 1.03, 0.30]

Observe que, un gol simplificado con física básica es un tiro parabólico cuya trayectoria se compone de movimientos en los ejes, Y y Z. Sin embargo, lo «imposible» del gol mostrado es añadir el movimiento en X. (Referencia de la imagen en el enunciado)

El movimiento de «profundidad» o dirección hacia el arco y(t) es semejante a un polinomio de primer grado, y el movimiento de «altura» z(t) es un polinomio de segundo grado. El movimiento «imposible» en el eje X, podría ser descrito por un polinomio de segundo o mayor grado.

a) Encontrar t para altura máxima, que se encuentra al igualar la derivada dz/dt a cero. Para interpolar el polinomio z(t), de segundo grado, se puede usar tres puntos de los sugeridos: 0, 0.3 y 0.6, que además son equidistantes en t (facilita usar cualquier método de interpolación).

Por ejemplo, con diferencias finitas avanzadas:

t z(t) d1 d2 d3
0.00 0.00 1.40 -0.89
0.30 1.40 0.51
0.60 1.91
z(t) = 0 + 1.40\frac{(t-0)}{1!(0.3)} - 0.89 \frac{(t-0)(t-0.3)}{2!(0.3)^2} = 0 + 4.66 t - 4.94(t^2-0.3t) = 4.66 t + 1.48 t - 4.94 t^2 z(t) = 6.42 t - 4.94 t^2

para encontrar el valor máximo se encuentra \frac{dz}{dt} = 0

\frac{dz}{dt} = 6.42 - 2(4.94) t 6.42 - 2(4.94) t = 0 t = \frac{6.42}{2(4.94)} t = 0.649

Observe que el resultado tiene sentido, pues según la tabla, el máximo debería estar entre 0.60 y 0.75

b) El cruce por la «barrera», corresponde al desplazamiento del balón en el eje Y a 9 metros: y(t) = 9.
El polinomio modelo de primer grado usa dos puntos para la interpolación, de los sugeridos se escogen dos, por ejemplo: 0.0 y 0.3.

Usando diferencias finitas avanzadas :

d1 = (8.88-0) = 8.88 y(t) = 0 + 8.88\frac{(t-0)}{1!(0.3)} y(t) = 29.6 t

usando y(t) = 9

29.6 t = 9
t = 0.30
z(0.30) = 1.40
(de la tabla de datos)

cuya respuesta con solo dos dígitos decimales es coherente, al estar cercano el valor a una distancia y=8.88 o aproximado a 9.
La respuesta puede ser mejorada usando más digitos significativos en las operaciones.

c)  La desviación máxima en eje X.
Determine un polinomio para la trayectoria en el eje X y obtenga el máximo igualando la derivada del polinomio x(t) a cero.

Por simplicidad, se usa un polinomio de segundo grado, alrededor de los valores máximos en el eje X

t x(t) d1 d2 d3
0.60 1.80 0.20 -0.30
0.75 2.00 -0.10
0.90 1.90
x(t) = 1.80 + 0.20 \frac{(t-0.60)}{1!(0.15)} -0.30 \frac{(t-0.60)(t-0.75)}{2!(0.15)^2} x(t) = 1.80 + 1.33 (t-0.60) - 6.67(t-0.60)(t-0.75)

como se busca el máximo, se usa la derivada \frac{dx}{dt} = 0

\frac{dx}{dt} = 1.33 - 6.67(2t +(-0.60-0.75)) 1.33 - 13.34t + 9.00 = 0 -13.34t + 10.33 = 0

t = 0.77

x(0.77) = 1.80 + 1.33(0.77-0.60) - 6.67(0.77-0.60)(0.77-0.75) x(0.77) = 2.003

lo que es coherente con la tabla para el eje x, pues el máximo registrado es 2, y el próximo valor es menor, la curva será decreciente.


Desarrollo extra para observar y verificar resultados:

Usando los puntos y un graficador 3D se puede observar la trayectoria:

Tarea: Realice el ejercicio usando los algoritmos en Python, muestre los polinomios obtenidos y compare.

Nota: La gráfica 3D presentada usa interpolación de Lagrange con todos los puntos. Realice las observaciones y recomendaciones necesarias y presente su propuesta como tarea.

s1Eva_IT2010_T2_MN Uso de televisores

Ejercicio: 1Eva_IT2010_T2_MN Uso de televisores

El enunciado indica encontrar el máximo y luego el mínimo, por lo que la curva bajo análisis es la derivada de la función dp(x)/dx.

Adicionalmente, para encontrar los puntos se requiere usar el método de Newton-Raphson que corresponden a las raíces de dp(x)/dx. La función bajo análisis ahora es la derivada y para el método se su la derivada: d2p(x)/dx2.

Al usar el computador para las fórmulas, se usa la forma simbólica de la función p(x), para obtener dpx y d2px.

primera derivada: 
-3.13469387755102*x*exp(-8*x/7) + 2.74285714285714*exp(-8*x/7) + 13.7142857142857*exp(-24*x/7)*sin(12*x/7) - 6.85714285714286*exp(-24*x/7)*cos(12*x/7)
segunda derivada: 
(3.58250728862974*x - 6.26938775510204 - 35.265306122449*exp(-16*x/7)*sin(12*x/7) + 47.0204081632653*exp(-16*x/7)*cos(12*x/7))*exp(-8*x/7)

La gráfica requiere la evaluación las funciones, que por simplicidad de evaluación, su formas simbólicas se convierten a su forma ‘lambda’.

Con la gráfica se verifica que la raiz de dp(x)/dx (en naranja) pasa por el máximo y mínimo de p(x) (en azul).

que se obtienen con las siguientes instrucciones en python:

# 1ra Evaluación I Término 2010
# tema 2. encendido tv
# Tarea: aplicar el método de Newton-Raphson
# solo se muestra la función y sus derivadas 1 y 2
import numpy as np
import sympy as sp
import matplotlib.pyplot as plt

# función bajo análisis en forma simbólica
x = sp.Symbol('x')
pxs = (1/2.5)*(-10*sp.sin(12*x/7)*sp.exp(-24*x/7) + (48*x/7)*sp.exp(-8*x/7)+0.8)

# derivadas
dpxs = pxs.diff(x,1)
d2pxs = pxs.diff(x,2)

# SALIDA
print('primera derivada: ')
print(dpxs)
print('segunda derivada: ')
print(d2pxs)

# conversion a lambda
pxn = sp.utilities.lambdify(x,pxs, 'numpy')
dpxn = sp.utilities.lambdify(x,dpxs, 'numpy')
d2pxn = sp.utilities.lambdify(x,d2pxs, 'numpy')

# observar gráfica
a = 0
b = 4
muestras
tolera = 0.0001

xi = np.linspace(a,b, muestras)
pxi = pxn(xi)
dpxi = dpxn(xi)
d2pxi = d2pxn(xi)

# Gráfica
plt.plot(xi,pxi, label = 'pxi')
plt.plot(xi,dpxi, label = 'dpxi')
plt.plot(xi,d2pxi, label = 'd2pxi')
plt.axhline(0)
plt.legend()
plt.show()

# Tarea: encontrar la raiz de dpxn
# usando el método de Newton-Raphson

s1Eva_IT2011_T1_MN Fondo de inversión

Ejercicio: 1Eva_IT2011_T1_MN Fondo de inversión

Se desarrolla para la función:

C(t)=Ate^{-t/3}

siguiento las instrucciones por partes, se obtienen los siguientes resultados:
los valores resultantes:

derivada de la función: 
-x*exp(-x/3)/3 + exp(-x/3)
valor maximo en : 
3.0000001192092896
A para un millon: 
906093.94282
el valor de t para la meta es: 
11.0779035867

las instrucciones en python para observar la función son:

# 1ra Evaluación I Término 2011
# Tema 1. Fondo de Inversion
import numpy as np
import matplotlib.pyplot as plt

ft = lambda t: t*np.exp(-t/3)

a=0
b=20
tolera = 0.000001
muestras = 101
meta = 0.25
# PROCEDIMIENTO
# Observar la función entre [a,b]
ti = np.linspace(a,b,muestras)
fti = ft(ti)

# Salida
# Gráfica
plt.plot(ti,fti, label='f(t)')
plt.axhline(meta, color = 'r')
plt.axhline(0, color = 'k')
plt.legend()
plt.show()


Para desarrollar el literal a), donde se busca el valor máximo, usando la derivada de la función cuando existe el cruce por cero.
Para la derivada se usa la forma simbólica de la función, que se convierte a forma numérica lambda para evaluarla de forma más fácil.

# Literal a) usando derivada simbólica
import sympy as sp
x = sp.Symbol('x')
fxs = x*sp.exp(-x/3)
dfxs = fxs.diff(x,1)

# convierte la expresión a lambda
dfxn = sp.utilities.lambdify(x,dfxs,'numpy')
dfxni = dfxn(ti)
print('derivada de la función: ')
print(dfxs)
# Gráfica de la derivada.
plt.plot(ti,dfxni, label='df(t)/dt')
plt.axhline(0, color = 'k')
plt.legend()
plt.show()

derivada de la función: 
-x*exp(-x/3)/3 + exp(-x/3)

Se busca la raiz con algún método, por ejemplo bisección.

# Busca el máximo en dfxni
def biseccion(funcionx,a,b,tolera):
    fa = funcionx(a)
    fb = funcionx(b)
    tramo = np.abs(b-a)
    while (tramo>=tolera):
        c = (a+b)/2
        fc = funcionx(c)
        cambia = np.sign(fa)*np.sign(fc)
        if (cambia<0):
            b = c
            fb = fc
        else:
            a = c
            fa = fc
        tramo = np.abs(b-a)
    return(c)

# usa función para encontrar el máximo
raizmax = biseccion(dfxn, a, b, tolera)
verifica =  dfxn(raizmax)
print('valor maximo en : ')
print(raizmax)

# que el máximo sea un millon
tmax = raizmax
A = (1000000)/ft(tmax)
print('A para un millon: ')
print(A)
valor maximo en : 3.0000001192092896
A para un millon: 906093.94282

Para el literal b, se busca la laiz usando el metodo de Newton-Raphson como se indica en el enunciado.
En la función nueva se usa el valor de A encontrado, y la meta establecida.
Se obtiene la misa derivada del problema anterio multiplicada por A, por ser solo un factor que multiplica a la función original. El valor de meta es una constante, que se convierte en cero al derivar.

# literal b), buscar cumplir meta de 0.25 millones
def newtonraphson(funcionx, fxderiva, c, tolera):
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = c - funcionx(c)/fxderiva(c)
        tramo = abs(xnuevo-c)
        c = xnuevo
    return(c)

ft1 = lambda t: A*t*np.exp(-t/3) - 250000
# usar método de newton,
# puede usar la misma derivada multiplicada por A
dft1s = A*(fxs.diff(x,1))
dft1 = sp.utilities.lambdify(x,dft1s,'numpy')
c = 10

raiz4 = newtonraphson(ft1, dft1, c, tolera)
ft1i = ft1(ti)

print('el valor de t para la meta es: ')
print(raiz4)

# Gráfica
plt.plot(ti,ft1i, label = 'f(t) con A>1')
plt.axhline(meta, color = 'r')
plt.axhline(0, color = 'k')
plt.axvline(raiz4, color = 'm')
plt.legend()
plt.show()

el valor de t para la meta es: 11.0779035867

s1Eva_IIT2017_T1 Aproximar a polinomio usando puntos

Ejercicio: 1Eva_IIT2017_T1 Aproximar a polinomio usando puntos

Se dispone de tres puntos para la gráfica.

x  f(x)
 0  1
 0.2  1.6
 0.4  2.0

Si el polinomio de Taylor fuera de grado 0, sería una constante, que si se evalua en x0 = 0 para eliminar los otros términos, se encuentra que sería igual a 1

Como se pide el polinomio de grado 2, se tiene la forma:

p(x) = a + bx + c x 2

p(x) = 1 + bx + c x 2

Se disponen de dos puntos adicionales que se pueden usar para determinar b y c:

p(0.2) = 1 + 0.2 b + (0.2)2 c = 1.6
p(0.4) = 1 + 0.4 b + (0.4)2 c = 2.0
simplificando:
0.2 b + (0.2)2 c = 1.6 - 1 = 0.6
0.4 b + (0.4)2 c = 2.0 - 1 = 1

multiplicando la primera ecuación de 2 y restandole la segunda ecuación:

// - 0.08 c =  1.2-1 = 0.2
c = - 0.2/0.08 = -2.5

0.2 b + 0.04(-2.5) = 0.6
0.2 b = 0.6 + 0.04*2.5 = 0.6 + 0.1 = 0.7
    b =  0.7/0.2 =  3.5

con lo que el polinomio queda:
p(x) = 1 + 3.5 x – 2.5 x2

validando con python:
tomando los puntos de prueba:

[ 0.   0.2  0.4]
[ 1.   1.6  2. ]
>>>

se obtiene la gráfica:

se adjunta las instrucciones usadas para validar

import numpy as np
import matplotlib.pyplot as plt

xi = np.linspace(-0.5,1,51)
px = lambda x: 1+ 3.5*x - 2.5*(x**2)
pxi = px(xi)
prueba = np.array([0,0.2,0.4])
puntos = px(prueba)

# Salida
print(prueba)
print(puntos)

# Gráfica
plt.plot(xi,pxi)
plt.plot(prueba,puntos,'*')
plt.show()

Nota: Se puede intentar realizar los polinomios aumentando el grado, sin embargo cada término agrega un componente adicional a los términos anteriores por la forma (x – x0)k

s1Eva_IIT2008_T1_MN Bacterias contaminantes

Ejercicio: 1Eva_IIT2008_T1_MN Bacterias contaminantes

a.  Planteamiento del problema

estandarizar la fórmula a la forma f(x) = 0

c = 70 e^{-1.5t} + 25 e^{-0.075t}

el valor que debe tomar c = 9, por lo que la función a desarrollar se convierte en:

9 = 70 e^{-1.5t} + 25 e^{-0.075t}

y la que se usará en el algoritmo de búsqueda de raices es:

70 e^{-1.5t} + 25 e^{-0.075t} -9 = 0 f(t) = 70 e^{-1.5t} + 25 e^{-0.075t} -9 = 0

b. Intervalo de búsqueda [a,b]

Como la variable t representa el tiempo, se inicia el análisis con cero por la izquierda o un poco mayor. a=0

Para verificar que existe raíz se evalua f(a) y f(b) buscando valores donde se presenten cambios de signo.

La función depende de tiempo, por lo que a = 0, y b seleccionar un valor mayor.

Para el caso de b,  si fuesen minutos, se pueden probar con valores consideranto el tiempo que duraría un «experimento» en el laboratorio durante una clase. Por ejemplo 60 minutos, 30 minutos, etc, para obtener un punto «b» donde se garantice un cambio de signo f(a) y f(b)

Para el ejemplo, se prueba con b = 15

a = 0
b = 15
f(a) = f(0) = 70*e0 + 25 e0 -9 = 86
f(b) = f(15) = 70*e-1.5*15. + 25 e-0.075*15 -9 = - 0.0036

c. Número de iteraciones

Calcular el número de iteraciones para llegar a la raíz con el error tolerado

error = 0.001

\frac{|15-0|}{2^n} = 0.001 15/0.001 = 2^n log(15/0.001) = nlog(2) n = \frac{log(15/0.001)}{log(2)} = 13.87 n = 14

Verificando la selección usando una gráfica, usando 50 tramos entre [a,b] o 51 muestras en el rango.


d. Calcular la raíz:

Usando el algoritmo se encuentra que la raiz está en:

raiz en:  13.62213134765625
f(raiz) = -7.733799068e-05
si realiza la tabla:

[i,a,b,c,sign(fa),sign(fb),sign(fc),paso]
[[1, 0, 15, 7.5, 1.0, -1.0, 1.0, 15], 
 [2, 7.5, 15, 11.25, 1.0, -1.0, 1.0, 7.5], 
 [3, 11.25, 15, 13.125, 1.0, -1.0, 1.0, 3.75], 
 [4, 13.125, 15, 14.0625, 1.0, -1.0, -1.0, 1.875], 
 [5, 13.125, 14.0625, 13.59375, 1.0, -1.0, 1.0, 0.9375], 
 [6, 13.59375, 14.0625, 13.828125, 1.0, -1.0, -1.0, 0.46875], 
 [7, 13.59375, 13.828125, 13.7109375, 1.0, -1.0, -1.0, 0.234375], 
 [8, 13.59375, 13.7109375, 13.65234375, 1.0, -1.0, -1.0, 0.1171875], 
 [9, 13.59375, 13.65234375, 13.623046875, 1.0, -1.0, -1.0, 0.05859375], 
 [10, 13.59375, 13.623046875, 13.6083984375, 1.0, -1.0, 1.0, 0.029296875],
 [11, 13.6083984375, 13.623046875, 13.61572265625, 1.0, -1.0, 1.0, 0.0146484375], 
 [12, 13.61572265625, 13.623046875, 13.619384765625, 1.0, -1.0, 1.0, 0.00732421875], 
 [13, 13.619384765625, 13.623046875, 13.6212158203125, 1.0, -1.0, 1.0, 0.003662109375], 
 [14, 13.6212158203125, 13.623046875, 13.62213134765625, 1.0, -1.0, -1.0, 0.0018310546875]]

Cálculos con  Newton –  Raphson

Se encuentra la derivada f'(t) y se aplica el algoritmo Newton-Raphson con valor inicial cero.

f'(t) = 70(-1.5) e^{-1.5t} + 25(-0.075) e^{-0.075t}
raiz en:  13.622016772385583

Se usa el algoritmo en python para encontrar el valor. El algoritmo newton Raphson mostrado es más pequeño que por ejemplo la bisección, pero requiere realizar un trabajo previo para encontrar la derivada de la función.

# 1ra Eval II Termino 2008 tema 1
# Método de Newton-Raphson
import numpy as np

def newtonraphson(funcionx, fxderiva, c, tolera):
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = c - funcionx(c)/fxderiva(c)
        tramo = abs(xnuevo-c)
        c = xnuevo
    return(c)


# PROGRAMA ---------------------------------
funcionx = lambda t: 70*(np.e**(-1.5*t)) +25*(np.e**(-0.075*t))-9
fxderiva = lambda t: -70*1.5*(np.e**(-1.5*t)) -25*0.075*(np.e**(-0.075*t))

# INGRESO
c = 0.1
tolera = 0.001

# PROCEDIMIENTO
raiz = newtonraphson(funcionx, fxderiva, c, tolera)

# SALIDA
print('raiz en: ', raiz)

# Gráfica
import matplotlib.pyplot as plt
xi = np.linspace(0,15,100)
yi = funcionx(xi)
plt.plot(xi,yi)
plt.axhline(0, color = 'k')
plt.show()

Tarea: Para el problema, realice varios métodos y compare el número de iteraciones y el trabajo realizado al plantear el problema al implementar cada uno.

s1Eva_IIT2007_T3 Interpolación inversa

Ejercicio: 1Eva_IIT2007_T3 Interpolación inversa

f(0.50) = 1.648
f(0.65) = 1.915
f( x  ) = 2.117
f(0.80) = 2.225
f(0.95) = 2.5857

Para el algoritmo se intercambian las variables previo a usarlo.
Luego se evalua en el punto buscado, en éste caso: fi=2.117, obteniendo que x es: 0.750321134121361

fi = np.array([0.50 , 0.65 , 0.80,  0.95   ])
x = np.array([1.648, 1.915, 2.225, 2.5857 ])
Polinomio de Lagrange
0.924124055152463*(-3.74531835205992*x + 7.17228464419475)*(x - 2.5857)*(x - 2.225) + 3.12624749298999*(x - 2.5857)*(x - 2.225)*(3.74531835205992*x - 6.17228464419475) - 7.15454716188057*(x - 2.5857)*(x - 1.915)*(1.73310225303293*x - 2.85615251299827) + 3.92689380344011*(x - 2.225)*(x - 1.915)*(1.06643915964594*x - 1.75749173509651)
Expandiendo: 
0.0358848473081501*x**3 - 0.342756582990887*x**2 + 1.44073214117566*x - 1.10404634485226
>>> px
0.0358848473081501*x**3 - 0.342756582990887*x**2 + 1.44073214117566*x - 1.10404634485226
>>> px.subs(x,2.117)
0.750321134121361

El algortmo modificado usado es:

# Interpolacion de Lagrange
import numpy as np
import matplotlib.pyplot as plt
import sympy as sp

# INGRESO , Datos de prueba
fi = np.array([0.50 , 0.65 , 0.80,  0.95   ])
xi = np.array([1.648, 1.915, 2.225, 2.5857 ])

# PROCEDIMIENTO
n = len(xi)
x = sp.Symbol('x')
# Polinomio
polinomio = 0
for i in range(0,n,1):
    # Termino de Lagrange
    termino = 1
    for j  in range(0,n,1):
        if j!=i:
            termino = termino*(x-xi[j])/(xi[i]-xi[j])
    polinomio = polinomio + termino*fi[i]
    
# Expande el polinomio
px = polinomio.expand()

# Salida
print('Polinomio de Lagrange')
print(polinomio)
print('Expandiendo: ')
print(px)

para visualizar el resultado, intercambiando nuevamente los ejes:

>>> px
0.0358848473081501*x**3 - 0.342756582990887*x**2 + 1.44073214117566*x - 1.10404634485226
>>> px.subs(x,2.117)
0.750321134121361
>>> px
0.0358848473081501*x**3 - 0.342756582990887*x**2 + 1.44073214117566*x - 1.10404634485226

para revisar con la gráfica, se añaden las líneas,

# GRAFICA
polinomio = sp.lambdify(x,px)
y = np.linspace(1,3,100)
pyi= polinomio(y)
plt.plot(pyi,y)
plt.show()

s1Eva_IIT2007_T1 Distribución binomial acumulada

Ejercicio: 1Eva_IIT2007_T1 Distribución binomial acumulada

Dado F=0.4, dado que n=5 y k=1

Con lo que la fórmula para el objetivo se convierte en:

F = \Bigg( \begin{array}{c} 5 \\ 0 \end{array} \Bigg) p ^0 (1-p)^{(5-0)} + \Bigg( \begin{array}{c} 5 \\ 1 \end{array} \Bigg) p ^1 (1-p)^{(5-1)} = 0.4

para buscar la raíz:

f(p) = (1-p)^{5} + 5p (1-p)^{4} - 0.4

Los valores de las combinatorias se calculan como:

>>> import scipy.special as sts
>>> sts.comb(5,0,repetition=False)
1.0
>>> sts.comb(5,1,repetition=False)
5.0
>>> 

como referencia se revisa la gráfica para f(p)

# 1ra Eval II Término 2007
# Tema 1. Distribución binomial acumulada
import numpy as np
import matplotlib.pyplot as plt
import scipy.special as sts

fp = lambda p: (1-p)**5 + 5*p*((1-p)**4) - 0.4

a = 0
b = 1
pasos = 100

# PROCEDIMIENTO
xi = np.linspace(a,b,pasos+1)
p_i = fp(xi)

# SALIDA
plt.plot(xi,p_i)
plt.axhline(0)
plt.show()
f(p) = (1-p)^5 + 5p(1-p)^4 - 0.4 = (1-p)^4 (1 - p + 5p) - 0.4 = (1-p)^4 (1 + 4p) - 0.4 = (1-p)^2 (1-p)^2 (1 + 4p) - 0.4 = (1-2p+p^2) (1-2p+p^2) (1 + 4p) - 0.4 = (1 - 4p + 6p^2 - 4p^3 +p^4 ) (1 + 4p) - 0.4 = 1 - 10p^2 + 20p^3 + 15p^4 + 4p^5 - 0.4 = 0.6 - 10p^2 + 20p^3 + 15p^4 + 4p^5

y su derivada:

f'(p) = - 20p + 60p^2 + 60p^3 +20p^4
con lo que se puede desarrollar Newton-Raphson…

Verificando el polinomio a usar con python:

>>> import sympy as sp
>>> p = sp.Symbol('p')
>>> poli = (1-p)**5 + 5*p*((1-p)**4) - 0.4
>>> pol = poli.expand()
>>> pol
4*p**5 - 15*p**4 + 20*p**3 - 10*p**2 + 0.6
>>> pol.diff(p,1)
20*p**4 - 60*p**3 + 60*p**2 - 20*p

Tarea: con lo que puede continuar con el procedimiento para encontrar la raiz…

verificar con raiz: 0.3649852264049102


Newton-Raphson

# Método de Newton-Raphson
# Ejemplo 1 (Burden ejemplo 1 p.51/pdf.61)
import numpy as np

def newtonraphson(funcionx, fxderiva, c, tolera):
    tramo = abs(2*tolera)
    while (tramo>=tolera):
        xnuevo = c - funcionx(c)/fxderiva(c)
        tramo = abs(xnuevo-c)
        c = xnuevo
    return(c)


# PROGRAMA #######################
import matplotlib.pyplot as plt

funcionx = lambda p: 4*p**5 - 15*p**4 + 20*p**3 - 10*p**2 + 0.6
fxderiva = lambda p: 20*p**4 - 60*p**3 + 60*p**2 - 20*p

# INGRESO
c = 0.2
tolera = 0.0000001

# PROCEDIMIENTO
raiz = newtonraphson(funcionx, fxderiva, c, tolera)

# SALIDA
print('raiz en: ', raiz)

el resultado es:

raiz en:  0.3649852264049102
>>> funcionx(0.3649852264049102)
1.4099832412739488e-14
>>>