s1Eva_IT2019_T2 Catenaria cable

Las fórmulas con las que se requiere trabajar son:

y = \frac{T_A}{w} cosh \Big( \frac{w}{T_A}x \Big) + y_0 - \frac{T_A}{w}

Donde la altura y del cable está en función de la distancia x.

Además se tiene que:

cosh(z) = \frac{e^z+ e^{-z}}{2}

que sustituyendo la segunda en la primera se convierte en:

y = \frac{T_A}{w} \frac{e^{\frac{w}{T_A}x}+ e^{-\frac{w}{T_A}x}}{2} + y_0 - \frac{T_A}{w}
y usando los valores del enunciado w=12, y0=6 , y=15, x=50 se convierte en:

15 = \frac{T_A}{12} \frac{e^{\frac{12}{T_A}50}+ e^{-\frac{12}{T_A}50}}{2} + 6 - \frac{T_A}{12}

simplificando, para usar el método de búsqueda de raices:
\frac{1}{2}\frac{T_A}{12} e^{\frac{12}{T_A}50} + \frac{1}{2}\frac{T_A}{12} e^{-\frac{12}{T_A}50} - \frac{T_A}{12} - 9 = 0

cambiando la variable \frac{12}{T_A}=x

\frac{1}{2x} e^{50x} + \frac{1}{2x} e^{-50x} - \frac{1}{x}-9=0

la función a usar para la búsqueda de raices es:

f(x)=\frac{1}{2x} e^{50x} + \frac{1}{2x} e^{-50x} - \frac{1}{x}-9

Para el méodo de Newton-Raphson se tiene que:

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

por lo que se determina:

f'(x)= - \frac{1}{2x^2}e^{50x} + \frac{1}{2x}(50) e^{50x} + - \frac{1}{2x^2} e^{-50x} + \frac{1}{2x}(-50)e^{-50x} + \frac{1}{x^2} f'(x)= -\frac{1}{2x^2}[e^{50x}+e^{-50x}] + + \frac{25}{x}[e^{50x}-e^{-50x}] +\frac{1}{x^2} f'(x)= \Big[\frac{25}{x} -\frac{1}{2x^2}\Big]\Big[e^{50x}+e^{-50x}\Big] +\frac{1}{x^2}

Con lo que se puede inicar las iteraciones.

Por no disponer de valor inicial para TA, considere que el cable colgado no debería tener tensión TA=0 N, pues en la forma x=12/TA se crea una indeterminación. Si no dispone de algún criterio para seleccionar el valor de TA puede iniciar un valor positivo, por ejemplo 120 con lo que el valor de x0=12/120=0.1

Iteración 1

f(0.1)=\frac{1}{2(0.1)} e^{50(0.1)} + \frac{1}{2(0.1)} e^{-50(0.1)} - \frac{1}{0.1}-9 =723.0994 f'(0.1)=\Big[\frac{25}{0.1} - \frac{1}{2(0.1)^2}\Big]\Big[e^{50(0.1)}+e^{-50(0.1)}\Big] + +\frac{1}{(0.1)^2} = 29780.61043 x_{1} = 0.1 -\frac{723.0994}{29780.61043} = 0.07571

error = | x1 – x0| = | 0.07571 – 0.1| = 0.02428

Iteración 2

f(0.07571)=\frac{1}{2(0.07571)} e^{50(0.07571)}+ + \frac{1}{2(0.07571)} e^{-50(0.07571)} - \frac{1}{0.07571}-9 = 269.0042 f'(0.07571)= \Big[\frac{25}{0.07571} -\frac{1}{2(0.07571)^2}\Big]. .\Big[e^{50(0.07571)}+e^{-50(0.07571)}\Big] + +\frac{1}{(0.07571)^2} = 10874.0462 x_{2} = 0.07571 -\frac{269.0042}{10874.0462} = 0.05098

error = | x2 – x1| = |0.05098- 0.02428| = 0.02473

Iteración 3

f(0.05098) = 97.6345 f'(0.05098) = 4144.1544 x_{3} = 0.0274

error = | x3 – x2| = |0.05098- 0.0274| = 0.0236

finalmente después de varias iteraciones, la raiz se encuentra en: 0.007124346154337298

que conviertiendo
T_A = \frac{12}{x} = \frac{12}{0.0071243461} = 1684.36 N


Revisión de resultados

Usando como base los algoritmos desarrollados en clase:

['xi', 'xnuevo', 'tramo']
[0.1    0.0757 0.0243]
[0.0757 0.051  0.0247]
[0.051  0.0274 0.0236]
[0.0274 0.0111 0.0163]
[0.0111 0.0072 0.0039]
[7.2176e-03 7.1244e-03 9.3199e-05]
[7.1244e-03 7.1243e-03 3.8351e-08]
raiz en:  0.007124346154337298
TA = 12/x =  1684.365096815854

Algoritmos Python usando el procedimiento de:

http://blog.espol.edu.ec/matg1013/2-3-1-newton-raphson-ejemplo01/

# 1Eva_IT2019_T2 Catenaria cable
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
a = 0.001
b = 0.1
muestras = 51

x0 = 0.1
tolera = 0.00001

fx = lambda x: 0.5*(1/x)*np.exp(50*x) + 0.5*(1/x)*np.exp(-50*x)-1/x -9
dfx = lambda x: -0.5*(1/(x**2))*(np.exp(50*x)+np.exp(-50*x)) + (25/x)*(np.exp(50*x)-np.exp(-50*x)) + 1/(x**2)

# PROCEDIMIENTO
tabla = []
tramo = abs(2*tolera)
xi = x0
while (tramo>=tolera):
    xnuevo = xi - fx(xi)/dfx(xi)
    tramo = abs(xnuevo-xi)
    tabla.append([xi,xnuevo,tramo])
    xi = xnuevo

tabla = np.array(tabla)
n=len(tabla)

TA = 12/xnuevo

# para la gráfica
xp = np.linspace(a,b,muestras)
fp = fx(xp)

# SALIDA
print(['xi', 'xnuevo', 'tramo'])
np.set_printoptions(precision = 4)
for i in range(0,n,1):
    print(tabla[i])
print('raiz en: ', xi)
print('TA = 12/x = ', TA)

# Grafica
plt.plot(xp,fp)
plt.xlabel('x=12/TA')
plt.ylabel('f(x)')
plt.axhline(0, color = 'green')
plt.grid()
plt.show()

1Eva_IT2019_T3 Vector perpendicular a plano

1ra Evaluación I Término 2019-2020. 2/Julio/2019. MATG1013

Tema 2. ( 30 puntos) Considere los siguientes vectores:
V1 = (2,-3,a)
V2=(b,1,-4)
V3= (3,c,2)

Se sabe que V1 es perpendicular a V y V3.

También se sabe que V2.V3=2.

Use un método para encontrar el valor de las incógnitas a,b,c

a) Plantee el sistema

b) Resuelva con el método de eliminación de Gauss

c) Vuelva a resolver con el método de Jacobi con x(0) = [0,0,0], realice tres iteraciones

d) Encuentre el residuo, cota del error absoluto y relativo

Rúbrica: literal a (5 puntos), literal b, ordenar las ecuaciones(5 puntos), método Gauss (10 puntos);  literal c, aplicarJacobi (5 puntos), literal d (5 puntos)


Notas:
– Todos los temas deben mostrar evidencia del desarrollo del método numérico planteado.
– En geometría euclídea se tiene, dos vectores v1 y v2 que son ortogonales forman un ángulo recto, por lo tanto v1 ⋅ v2 = 0. https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)

Referencia: Chapra 5ed. problema 10.18 p304, pdf 328.

s1Eva_IT2019_T3 Vector perpendicular a plano

Literal a

Para que un vector sea perpendicular a otro, se debe cumplir que
V1.V2 =0.

\begin{bmatrix} 2 \\ -3 \\ a \end{bmatrix} . \begin{bmatrix} b \\ 1 \\ -4 \end{bmatrix} = 0

se obtiene entonces la ecuación:

(2)(b)+(-3)(1)+(a)(-4)=0
2b -3 -4a =0

procediendo de la misma forma con los siguientes pares de vectores:

\begin{bmatrix} 2 \\ -3 \\ a \end{bmatrix} . \begin{bmatrix} 3 \\ c \\ 2 \end{bmatrix} = 0

se obtiene entonces la ecuación:

(2)(3)+(-3)(c)+(a)(2)=0
6 -3c +2a = 0
\begin{bmatrix} b \\ 1 \\ -4 \end{bmatrix} . \begin{bmatrix} 3 \\ c \\ 2 \end{bmatrix} = 2

se obtiene entonces la ecuación:

(b)(3)+(1)(c)+(-4)(2)=2
3b +c -8 =2

se obtiene el sistema de ecuaciones:

\begin{cases}-4a+2b=3 \\ 2a-3c=-6 \\3b+c=10 \end{cases}

Literal b

Se convierte a la forma matricial Ax=B

\begin{bmatrix} -4 && 2 && 0 \\ 2 && 0 && -3 \\ 0 && 3 && 1\end{bmatrix}.\begin{bmatrix} a \\b\\c \end{bmatrix} = \begin{bmatrix} 3 \\ -6 \\ 10 \end{bmatrix}

se crea la matriz aumentada:

\begin{bmatrix} -4 && 2 && 0 && 3 \\ 2 && 0 && -3 &&-6 \\ 0 && 3 && 1 && 10 \end{bmatrix}

se pivotea por filas buscando hacerla diagonal dominante:

\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 2 && 0 && -3 &&-6 \end{bmatrix}

se aplica el algoritmo de eliminación hacia adelante:
1ra Iteración

la eliminación del primer término columna es necesario solo para la tercera fila:

\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 2 -(-4)\Big( \frac{2}{-4}\Big) && 0-2\Big(\frac{2}{-4}\Big) && -3 -0\Big(\frac{2}{-4}\Big) &&-6 -3\Big(\frac{2}{-4}\Big) \end{bmatrix} \begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 1 && -3 && -4.5 \end{bmatrix}

2da Iteración

\begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 1 -3\Big(\frac{1}{3}\Big) && -3-(1)\Big(\frac{1}{3}\Big) && -4.5-10\Big(\frac{1}{3}\Big) \end{bmatrix} \begin{bmatrix} -4 && 2 && 0 && 3 \\ 0 && 3 && 1 && 10 \\ 0 && 0 && -\frac{10}{3} && -7.8333 \end{bmatrix}

Aplicando eliminación hacia atras

(-10/3)c = -7.8333
c = -7.8333(-3/10) = 2.35

3b +c = 10
b= (10-c)/3 = (10-2.35)/3 = 2.55

-4a +2b =3
a= (3-2b)/(-4) = (3-2(2.55))/(-4) = 0.525

como resultado, los vectores buscados:

v1 = (2,-3,0.525)
v2 = (2.55,1,-4)
v3 = (3,2.35,2)

comprobando resultados:

>>> np.dot((2,-3,0.525),(2.55,1,-4))
-4.440892098500626e-16
>>> np.dot((2,-3,0.525),(3,2.35,2))
-6.661338147750939e-16
>>> np.dot((2.55,1,-4),(3,2.35,2))
2.0

Los dos primeros resultados son muy cercanos a cero, por lo que se los considera válidos

literal c

Para usar el método de Jacobi, se despeja una de las variables de cada ecuación:

\begin{cases} a = \frac{2b -3}{4} \\b = \frac{10-c}{3} \\c = \frac{2a+6}{3} \end{cases}

usando el vector x(0) = [0,0,0]

1ra iteración

a = \frac{2b -3}{4} = \frac{2(0) -3}{4} = -\frac{3}{4} b = \frac{10-c}{3} = \frac{10-0}{3} = \frac{10}{3} c = \frac{2a+6}{3 }= \frac{2(0)+6}{3} = 2

x(1) = [-3/4,10/3,2]
diferencias = [-3/4-0,10/3-0,2-0] = [-3/4,10/3,2]
error = max|diferencias| = 10/3 = 3.3333

2da iteración

a = \frac{2b -3}{4} = \frac{2(10/3) -3}{4} = \frac{11}{12} b = \frac{10-c}{3} = \frac{10-2}{3} = \frac{8}{3} c = \frac{2a+6}{3} = \frac{2(-3/4)+6}{3} = \frac{3}{2}

x(2) = [11/12,8/3,3/2]
diferencias = [11/12-(-3/4),8/3-10/3,3/2-2] = [20/12, -2/3, -1/2]
error = max|diferencias| = 5/3= 1.666

3ra iteración

a = \frac{2b -3}{4} = \frac{2(8/3)-3}{4} = \frac{7}{12} b = \frac{10-c}{3} = \frac{10-3/2}{3} = \frac{17}{6} c = \frac{2a+6}{3} = \frac{2(11/12)+6}{3} = 2.6111

x(3) = [7/12, 17/6, 2.6111]
diferencias = [7/12-11/12, 17/6-8/3, 2.6111-3/2] = [-1/3, 1/6, 1.1111]
error = max|diferencias| = 1.1111

Los errores disminuyen en cada iteración, por lo que el método converge,
si se analiza en número de condición de la matriz A es 2, lo que es muy cercano a 1, por lo tanto el método converge.


Revisión de resultados

Resultados usando algoritmos desarrollados en clase:

matriz aumentada: 
[[-4.   2.   0.   3. ]
 [ 0.   3.   1.  10. ]
 [ 2.   0.  -3.  -6. ]]
Elimina hacia adelante
[[-4.   2.   0.   3. ]
 [ 0.   3.   1.  10. ]
 [ 0.   1.  -3.  -4.5]]
Elimina hacia adelante
[[-4.   2.   0.        3.      ]
 [ 0.   3.   1.       10.      ]
 [ 0.   0.  -3.333333 -7.833333]]
Elimina hacia adelante
[[-4.   2.   0.        3.      ]
 [ 0.   3.   1.       10.      ]
 [ 0.   0.  -3.333333 -7.833333]]
Elimina hacia atras
[[ 1.  -0.  -0.   0.525]
 [ 0.   1.   0.   2.55 ]
 [-0.  -0.   1.   2.35 ]]
el vector solución X es:
[[0.525]
 [2.55 ]
 [2.35 ]]
verificar que A.X = B
[[ 3.]
 [10.]
 [-6.]]

Número de condición de A: 2.005894

los resultados para [a,b,c]:
[0.525 2.55  2.35 ]

producto punto entre vectores:
v12:  0.0
v13:  1.3322676295501878e-15
v23:  2.0

Algoritmos en Python:

# 1Eva_IT2019_T3 Vector perpendicular a plano
import numpy as np

# INGRESO
A = np.array([[-4.,2,0],
              [ 0., 3,1],
              [ 2.,0,-3]])
B = np.array([3.,10,-6])

# PROCEDIMIENTO
B = np.transpose([B])

casicero = 1e-15 # 0
AB = np.concatenate((A,B),axis=1)
tamano = np.shape(AB)
n = tamano[0]
m = tamano[1]

print('matriz aumentada: ')
print(AB)
# Gauss elimina hacia adelante
# tarea: verificar términos cero
for i in range(0,n,1):
    pivote = AB[i,i]
    adelante = i+1 
    for k in range(adelante,n,1):
        if (np.abs(pivote)>=casicero):
            factor = AB[k,i]/pivote
            AB[k,:] = AB[k,:] - factor*AB[i,:]
    print('Elimina hacia adelante')
    print(AB)

# Gauss-Jordan elimina hacia atras
ultfila = n-1
ultcolumna = m-1
for i in range(ultfila,0-1,-1):
    # Normaliza a 1 elemento diagonal
    AB[i,:] = AB[i,:]/AB[i,i]
    pivote = AB[i,i] # uno
    # arriba de la fila i
    atras = i-1 
    for k in range(atras,0-1,-1):
        if (np.abs(AB[k,i])>=casicero):
            factor = pivote/AB[k,i]
            AB[k,:] = AB[k,:]*factor - AB[i,:]
        else:
            factor= 'division para cero'
print('Elimina hacia atras')
print(AB)

X = AB[:,ultcolumna]

# Verifica resultado
verifica = np.dot(A,X)

# SALIDA
print('el vector solución X es:')
print(np.transpose([X]))

print('verificar que A.X = B')
print(np.transpose([verifica]))

numcond = np.linalg.cond(A)

# para comprobar respuestas

v1 = [2,-3,X[0]]
v2 = [X[1],1,-4]
v3 = [3,X[2],2]

v12 = np.dot(v1,v2)
v13 = np.dot(v1,v3)
v23 = np.dot(v2,v3)
      
# SALIDA
print('\n Número de condición de A: ', numcond)

print('\n los resultados para [a,b,c]:')
print(X)

print('\n productos punto entre vectores:')
print('v12: ',v12)
print('v13: ',v13)
print('v23: ',v23)

Tarea, usar el algoritmo de Jacobi usado en el taller correspondiente.

1Eva_IT2019_T2 Catenaria cable

1ra Evaluación I Término 2019-2020. 2/Julio/2019. MATG1013

Tema 2. (30 puntos) Un cable en forma catenaria es aquel que cuelga entre dos puntos que no se encuentran sobre la misma línea vertical. Como se muestra en la figura 1, no está sujeta a más carga que su propio peso. Así, su peso en N/m actúa como una carga uniforme por unidad de longitud a lo largo del cable. 

En la figura 2, se ilustra un diagrama de cuerpo libre de una sección AB, donde TA y TB son las fuerzas de tensión en el extremo.

Con base en los balances de fuerzas horizontal y vertical, se obtiene para el cable el siguiente modelo:

y = \frac{T_A}{w} cosh \Big( \frac{w}{T_A}x \Big) + y_0 - \frac{T_A}{w}

Donde la altura y del cable está en función de la distancia x.

Además se tiene que:

cosh(z) = \frac{e^z+ e^{-z}}{2}

Utilice el método de Newton-Raphson para hallar el valor del parámetro TA dado los valores de los parámetros w=12, y0=6 de modelo que el cable tenga una altura de 15 metros para x=50

Rúbrica: Planteamiento del problema (10 puntos), obtener la derivada (5 puntos), plantear el método (5 puntos), iteraciones (5 puntos), verificar tolerancia (5 puntos)


Nota: Todos los temas deben mostrar evidencia del desarrollo del método numérico planteado.

Referencia: Chapra 5Ed Problema 8.17 p219 pdf243. Sears&Zemanski Vol1 12Ed problema 5.63. Cuerda con masa p173. https://es.wikipedia.org/wiki/Catenaria

s1Eva_IT2019_T2 Catenaria cable2

Desarrollo con error en fórmula ‘y’, en argumento Cosh(), revisar fórmulas en referencia del problema por error de tipografía:
————————-
Las fórmulas con las que se requiere trabajar son:

y = \frac{T_A}{w} cosh \Big( \frac{T_A}{w}x \Big) + y_0 - \frac{T_A}{w}

Donde la altura y del cable está en función de la distancia x.

Además se tiene que:

cosh(z) = \frac{e^z+ e^{-z}}{2}

que sustituyendo la segunda en la primera se convierte en:

y = \frac{T_A}{w} \frac{e^{\Big( \frac{T_A}{w}x \Big)} + e^{-\Big( \frac{T_A}{w}x \Big)}}{2} + y_0 - \frac{T_A}{w}

y usando los valores del enunciado w=12, y0=6 , y=15, x=50 se convierte en:

15 = \frac{T_A}{12} \frac{e^{\Big( \frac{T_A}{12}50 \Big)} + e^{-\Big( \frac{T_A}{12}50 \Big)}}{2} + 6 - \frac{T_A}{12}

simplificando, para usar el método de búsqueda de raices:

\frac{T_A}{24} e^{\Big( \frac{50}{12} T_A\Big)} + \frac{T_A}{24} e^{-\Big( \frac{50}{12} T_A\Big)} - \frac{T_A}{12} -9 =0

estandarizando a TA/12 =x

\frac{x}{2}e^{50x} + \frac{x}{2} e^{-50x} - x -9 =0

la función a usar es:

f(x) = \frac{x}{2}e^{50x} + \frac{x}{2} e^{-50x} - x -9

Para el méodo de Newton-Raphson se tiene que:

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

por lo que se determina:

f'(x) = \frac{x}{2}(50)e^{50x} + \frac{1}{2}e^{50x} + + \frac{x}{2}(-50) e^{-50x} + \frac{1}{2} e^{-50x} - 1 f'(x) = 25x(e^{50x}-e^{-50x}) + + \frac{1}{2}(e^{50x} +e^{-50x}) - 1

 

 

1Eva_IT2019_T1 Oxígeno y temperatura en mar

1ra Evaluación I Término 2019-2020. 2/Julio/2019. MATG1013

Tema 1. (40 puntos) La concentración de oxígeno disuelto a nivel del mar en agua dulce es función de la temperatura o(T)

T (℃) 0 8 16 24 32 40
o (mg/L) 14.6 11.5 9.9 8.4 7.3 6.4

a) Con los siguientes datos, encuentre un modelo polinómico de grado 3 y estime la concentración para la temperatura de 15 grados y estime el error.

b) Usando el polinomio del literal a, aproxime la derivada de la concentración de oxígeno en función de la temperatura en T = 16 grados.

c) Usando el polinomio del literal a y el método de la bisección encuentre T cuando o=9 mg/L, con una tolerancia de 10-3

Rúbrica: literal a, plantear polinomio (15 puntos), interpolar (5 puntos), literal b obtener derivada (5puntos), evaluar derivada (5 puntos) literal c, selección de rángo de búsqueda (3 puntos) desarrollo de al menos tres iteraciones (7 puntos)


Nota: Todos los temas deben mostrar evidencia del desarrollo del método numérico planteado.

tm = [0.,8,16,24,32,40]
ox = [14.6,11.5,9.9,8.4,7.3,6.4]

Referencia: Chapra 5ed, problema 19.15 p576, pdf600.  1Eva_IIT2014_T3 Oxigeno y temperatura en mar, http://blog.espol.edu.ec/matg1013/1eva_iit2014_t3-oxigeno-y-temperatura-en-mar/. La «gigantesca» reserva de agua dulce hallada bajo el océano Atlántico (y qué esperanzas brinda para las zonas áridas del planeta). eluniverso.com 25/junio/2019. https://www.eluniverso.com/noticias/2019/06/25/nota/7394484/gigantesca-reserva-agua-dulce-hallada-bajo-oceano-atlantico-que

 

 

s1Eva_IT2019_T1 Oxígeno y temperatura en mar

Literal a

Se requiere un polinomio de grado 3 siendo el eje x correspondiente a temperatura. Son necesarios 4 puntos de referencia alrededor de 15 grados, dos a la izquierda y dos a la derecha.

Se observa que los datos en el eje x son equidistantes, h=8, y ordenados en forma ascendente, se cumple con los requisitos para usar diferencias finitas avanzadas. que tiene la forma de:

p_n (x) = f_0 + \frac{\Delta f_0}{h} (x - x_0) + + \frac{\Delta^2 f_0}{2!h^2} (x - x_0)(x - x_1) + + \frac{\Delta^3 f_0}{3!h^3} (x - x_0)(x - x_1)(x - x_2) + \text{...}

Tabla

xi f[xi] f[x1,x0] f[x2,x1,x0] f[x2,x1,x0] f[x3,x2,x1,x0]
8 11.5 9.9-11.5=
-1.6
-1.5-(-1.6) =
0.1
0.4-0.1=
0.3
16 9.9 8.4-9.9=
-1.5
-1.1-(1.5)=
0.4
24 8.4 7.3-8.4=
-1.1
32 7.3

Con lo que el polinomio buscado es:

p_3 (x) = 11.5 + \frac{-1.6}{8} (x - 8) + + \frac{0.1}{2!8^2} (x - 8)(x - 16) + \frac{0.3}{3!8^3} (x - 8)(x - 16)(x - 24)

Resolviendo y simplificando el polinomio, se puede observar que al aumentar el grado, la constante del término disminuye.

p_3(x)=12.9- 0.15 x - 0.00390625 x^2 + 0.00009765625 x^3

para el cálculo del error se puede usar un término adicional del polinomio, añadiendo un punto más a la tabla de diferencia finitas. Se evalúa éste término y se estima el error que dado que el término de grado 3 es del orden de 10-5, el error será menor. (Tarea)

p_3(15)=12.9- 0.15 (15) - 0.00390625 (15)^2 + 0.00009765625 (15)^3

Evaluando el polinomio en temperatura = 15:

p3(15) = 10.1006835937500

literal b

se deriva el polinomio del literal anterior y se evalua en 16:

p'_3(x)=0- 0.15 - 0.00390625 (2) x + 0.00009765625 (3)x^2 p'_3(16)=0- 0.15 - 0.00390625 (2)(16) + 0.00009765625 (3)(16)^2

p’3(16) = -0.20

literal c

El valor de oxígeno usado como referencia es 9, cuyos valores de temperatura se encuentran entre 16 y 24 que se toman como rango inicial de búsqueda [a,b]. Por lo que el polinomio se iguala a 9 y se crea la forma estandarizada del problema:

p_3(x)=9 9 = 12.9- 0.15 x - 0.00390625 x^2 + 0.00009765625 x^3 12.9- 0.15 x - 0.00390625 x^2 + 0.00009765625 x^3 -9 = 0 f(x) = 3.9- 0.15 x - 0.00390625 x^2 + 0.00009765625 x^3

Para mostrar el procedimiento se realizan solo tres iteraciones,

1ra Iteración
a=16 , b = 24, c = (16+24)/2 = 20
f(a) = 0.9, f(b) = -0.6, f(c) = 0.011
error = |24-16| = 8
como f(c) es positivo, se mueve el extremo f(x) del mismo signo, es decir a

2da Iteración
a=20 , b = 24, c = (20+24)/2 = 22
f(a) = 0.119, f(b) = -0.6, f(c) = -0.251
error = |24-20|= 4
como f(c) es negativo, se mueve el extremo f(x) del mismo signo, b

3ra Iteración
a=20 , b = 22, c = (20+22)/2 = 21
f(a) = 0.119, f(b) = -0.251, f(c) = -0.068
error = |22-20| = 2
como f(c) es negativo, se mueve el extremo f(x) del mismo signo, b
y así sucesivamente hasta que error< que 10-3

Usando el algoritmo en python se obtendrá la raiz en 20.632 con la tolerancia requerida.


Revisión de resultados

Usando como base los algoritmos desarrollados en clase:

Literal a
[[ 1.   8.  11.5 -1.6  0.1  0.3  0. ]
 [ 2.  16.   9.9 -1.5  0.4  0.   0. ]
 [ 3.  24.   8.4 -1.1  0.   0.   0. ]
 [ 4.  32.   7.3  0.   0.   0.   0. ]]
9.765625e-5*x**3 - 0.00390625*x**2 - 0.15*x + 12.9
p(15) =  10.1006835937500
Literal b
0.00029296875*x**2 - 0.0078125*x - 0.15
dp(16) = -0.200000000000000

literal c
[ i, a, c, b, f(a), f(c), f(b), paso]
1 16.000 20.000 24.000 0.900 0.119 -0.600 8.000 
2 20.000 22.000 24.000 0.119 -0.251 -0.600 4.000 
3 20.000 21.000 22.000 0.119 -0.068 -0.251 2.000 
4 20.000 20.500 21.000 0.119 0.025 -0.068 1.000 
5 20.500 20.750 21.000 0.025 -0.022 -0.068 0.500 
6 20.500 20.625 20.750 0.025 0.001 -0.022 0.250 
7 20.625 20.688 20.750 0.001 -0.010 -0.022 0.125 
8 20.625 20.656 20.688 0.001 -0.004 -0.010 0.062 
9 20.625 20.641 20.656 0.001 -0.002 -0.004 0.031 
10 20.625 20.633 20.641 0.001 -0.000 -0.002 0.016 
11 20.625 20.629 20.633 0.001 0.001 -0.000 0.008 
12 20.629 20.631 20.633 0.001 0.000 -0.000 0.004 
13 20.631 20.632 20.633 0.000 0.000 -0.000 0.002 
14 20.632 20.632 20.633 0.000 0.000 -0.000 0.001 
raiz:  20.63232421875

Algoritmos Python usando la funcion de interpolación y un procedimiento encontrado en:

http://blog.espol.edu.ec/matg1013/5-1-1-diferencias-finitas-avanzadas-polinomio/

http://blog.espol.edu.ec/matg1013/2-1-1-biseccion-ejemplo01/

# 1Eva_IT2019_T1 Oxígeno y temperatura en mar
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym

def interpola_dfinitas(xi,fi):
    '''
    Interpolación de diferencias finitas avanzadas
    resultado: polinomio en forma simbólica
    '''
    # Tabla de diferencias finitas
    titulo = ['i','xi','fi']
    n = len(xi)
    # cambia a forma de columnas
    i = np.arange(1,n+1,1)
    i = np.transpose([i])
    xi = np.transpose([xi])
    fi = np.transpose([fi])
    # Añade matriz de diferencias
    dfinita = np.zeros(shape=(n,n),dtype=float)
    tabla = np.concatenate((i,xi,fi,dfinita), axis=1)
    # Sobre matriz de diferencias, por columnas
    [n,m] = np.shape(tabla)
    c = 3
    diagonal = n-1
    while (c<m):
        # Aumenta el título para cada columna
        titulo.append('df'+str(c-2))
        # calcula cada diferencia por fila
        f = 0
        while (f < diagonal):
            tabla[f,c] = tabla[f+1,c-1]-tabla[f,c-1]
            f = f+1
        
        diagonal = diagonal - 1
        c = c+1

    # POLINOMIO con diferencias finitas
    # caso: puntos en eje x equidistantes
    dfinita = tabla[:,3:]
    n = len(dfinita)
    x = sym.Symbol('x')
    h = xi[1,0]-xi[0,0]
    polinomio = fi[0,0]
    for c in range(1,n,1):
        denominador = np.math.factorial(c)*(h**c)
        factor = dfinita[0,c-1]/denominador
        termino=1
        for f  in range(0,c,1):
            termino = termino*(x-xi[f])
        polinomio = polinomio + termino*factor
    # simplifica polinomio, multiplica los (x-xi)
    polinomio = polinomio.expand()
    
    return(tabla, polinomio)

# INGRESO
tm = [0.,8,16,24,32,40]
ox = [14.6,11.5,9.9,8.4,7.3,6.4]

xi = [8,16,24,32]
fi = [11.5,9.9,8.4,7.3]

# PROCEDIMIENTO
x = sym.Symbol('x')
# literal a
tabla, polinomio = interpola_dfinitas(xi,fi)
p15 = polinomio.subs(x,15)
# literal b
deriva = polinomio.diff(x,1)
dp16 = deriva.subs(x,16)

px =  sym.lambdify(x,polinomio)
xk = np.linspace(np.min(xi),np.max(xi))
pk = px(xk)

# SALIDA
print('Literal a')
print(tabla)
print(polinomio)
print('p(15) = ',p15)
print('Literal b')
print(deriva)
print('dp(16) =', dp16)

# gráfica
plt.plot(tm,ox,'ro')
plt.plot(xk,pk)
plt.axhline(9,color="green")
plt.xlabel('temperatura')
plt.ylabel('concentracion de oxigeno')
plt.grid()
plt.show()

# --------literal c ------------

# Algoritmo de Bisección
# [a,b] se escogen de la gráfica de la función
# error = tolera

# se convierte forma de símbolos a numéricos
buscar = polinomio-9
fx = sym.lambdify(x,buscar)

# INGRESO
a = 16
b = 24
tolera = 0.001

# PROCEDIMIENTO
tabla = []
tramo = b-a

fa = fx(a)
fb = fx(b)
i = 1
while (tramo > tolera):
    c = (a+b)/2
    fc = fx(c)
    tabla.append([i,a,c,b,fa,fc,fb,tramo])
    i = i+1
                 
    cambia = np.sign(fa)*np.sign(fc)
    if (cambia<0):
        b = c
        fb = fc
    else:
        a=c
        fa = fc
    tramo = b-a
c = (a+b)/2
fc = fx(c)
tabla.append([i,a,c,b,fa,fc,fb,tramo])
tabla = np.array(tabla)

raiz = c

# SALIDA
print('\n literal c')
np.set_printoptions(precision = 4)
print('[ i, a, c, b, f(a), f(c), f(b), paso]')
# print(tabla)

# Tabla con formato
n=len(tabla)
for i in range(0,n,1):
    unafila = tabla[i]
    formato = '{:.0f}'+' '+(len(unafila)-1)*'{:.3f} '
    unafila = formato.format(*unafila)
    print(unafila)
    
print('raiz: ',raiz)

s1Eva_IT2010_T1_MN Demanda y producción sin,log

Desarrollo Analítico

Para la demanda, el intervalo de existencia es [0,3]

demanda(t) = sin(t)

Para la oferta, el intervalo de existencia inicia en 1, limitado por la demanda [1,3]

oferta(t) = ln(t)

la oferta satisface la demanda cuando ambas son iguales

demanda(t) = oferta(t) sin(t) = ln(t)

por lo que el tiempo t se encuentra con algun método para determinar la raiz de:

sin(t) - ln(t) = 0 f(t) = sin(t) - ln(t)

Observe que las curvas de oferta y demanda se intersectan en el mismo punto en el eje x que la función f(t).

Use un método para encontrar el valor t que satisface la ecuación.


instrucciones para la gráfica, no para el algoritmo de búsqueda de raiz que es tarea.

# 1Eva_IT2010_T1_MN Demanda y producción sin,log
# Solo para analizar el problema
# Tarea: Añadir algoritmo de buscar raiz.
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
# demanda
ad = 0
bd = 3
muestrasd = 31
# oferta
ao = 1
bo = 3
muestras0  = 21

demanda = lambda t: np.sin(t)
oferta = lambda t: np.log(t)
f = lambda t: demanda(t)-oferta(t)

# PROCEDIMIENTO
tid = np.linspace(ad,bd,muestrasd)
demandai = demanda(tid)

tio = np.linspace(ao,bo,muestras0)
ofertai = oferta(tio)

fi = f(tio)

# SALIDA
plt.plot(tid,demandai, label='demanda')
plt.plot(tio,ofertai, label ='oferta')
plt.plot(tio,fi,label='f(t)= demanda-oferta')
plt.axhline(0,color='black')
plt.axvline(2.2185, color = 'magenta')
plt.xlabel('tiempo')
plt.ylabel('unidades')
plt.legend()
plt.grid()
plt.show()

s1Eva_IT2017_T4 Componentes eléctricos

Desarrollo Analítico

Solo puede usar las cantidades disponibles de material indicadas, por lo que las cantidades desconocidas de produccion por componente se convieren en las incógnitas x0, x1, x2. Se usa el índice cero por compatibilidad con las instrucciones python.

Material 1 Material 2 Material 3
Componente 1 5 x0 9 x0 3 x0
Componente 2 7 x1 7 x1 16 x1
Componente 3 9 x2 3 x2 4 x2
Total 945 987 1049

Se plantean las fórmulas a resolver:

5 x0 +  7 x1 + 9 x2 = 945
9 x0 +  7 x1 + 3 x2 = 987
3 x0 + 16 x1 + 4 x2 = 1049

Se reescriben en la forma matricial AX=B

\begin{bmatrix} 5 & 7 & 9\\ 9 & 7 & 3 \\ 3& 16 & 4\end{bmatrix} \begin{bmatrix} x_0 \\ x_1 \\ x_2 \end{bmatrix}= \begin{bmatrix} 945 \\ 987 \\ 1049 \end{bmatrix}

Se reordena, pivoteando por filas para tener la matriz diagonalmente dominante:

\begin{bmatrix} 9 & 7 & 3\\ 3 & 16 & 4 \\ 5& 7 & 9\end{bmatrix} \begin{bmatrix} x_0 \\ x_1 \\ x_2 \end{bmatrix}= \begin{bmatrix} 987 \\ 1049 \\ 945 \end{bmatrix}

Se determina el número de condición de la matriz. Por facilidad con python:

numero de condicion: 4.396316324708121

Obtenido con:

# 1Eva_IT2017_T4 Componentes eléctricos
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
A = np.array([[9., 7.,3.],
              [3.,16.,4.],
              [5., 7.,9.]])

B = np.array([987.,1049.,945.])
# PROCEDIMIENTO

# numero de condicion
ncond = np.linalg.cond(A)

# SALIDA
print('numero de condicion:', ncond)

Recordando que la matriz debe ser tipo real, se añade un punto a los dígitos.

El número de condición es cercano a 1, por lo que el sistema si debería converger a la solución.

Desarrollo con Python

La forma AX=B permite usar los algoritmos desarrollados, obteniendo la solución. Se verifica el resultado al realizar la multiplicación de A con el vector respuesta, debe ser el vector B con un error menor al tolerado.

respuesta con Jacobi
[[62.99996585]
 [44.99998037]
 [34.9999594 ]]
verificando:
[[ 986.99943346]
 [1048.99942111]
 [ 944.99932646]]

Si interpreta el resultado, se debe obtener solo la parte entera [63,45,35] pues las unidades producidas son números enteros.

instrucciones:

# 1Eva_IT2017_T4 Componentes eléctricos
import numpy as np

def jacobi(A,B,tolera,X,iteramax=100):
    tamano = np.shape(A)
    n = tamano[0]
    m = tamano[1]
    diferencia = np.ones(n, dtype=float)
    errado = np.max(diferencia)
    xnuevo = np.copy(X)

    itera = 0
    print(itera, X)
    while not(errado<=tolera or itera>iteramax):
        
        for i in range(0,n,1):
            nuevo = B[i]
            for j in range(0,m,1):
                if (i!=j): # excepto diagonal de A
                    nuevo = nuevo-A[i,j]*X[j]
            nuevo = nuevo/A[i,i]
            xnuevo[i] = nuevo
        diferencia = np.abs(xnuevo-X)
        errado = np.max(diferencia)
        print(itera, xnuevo)
        X = np.copy(xnuevo)
        itera = itera + 1
    # Vector en columna
    X = np.transpose([X])
    # No converge
    if (itera>iteramax):
        X=itera
    return(X)


# INGRESO
A = np.array([[9., 7.,3.],
              [3.,16.,4.],
              [5., 7.,9.]])

B = np.array([987.,1049.,945.])
tolera = 1e-4

X = [0.,0.,0.]

# PROCEDIMIENTO

# numero de condicion
ncond = np.linalg.cond(A)

respuesta = jacobi(A,B,tolera,X)

verifica = np.dot(A,respuesta)

# SALIDA
print('numero de condicion:', ncond)
print('respuesta con Jacobi')
print(respuesta)
print('verificando:')
print(verifica)

al ejecutar el algoritmo se determina que se requieren 83 iteraciones para cumplir con con el valor de error tolerado.