Tarea 3

Sistema de Ecuaciones Lineales, Regresión lineal e Interpolación

Presentado Por:
JOSE BISMER CARVAJAL 79249920
ALVARO JAVIER CELIS 1097332975

CURSO:
METODOS NUMERICOS
100401_48

Presentado a:
EDGAR ANDRES VILLABON

Universidad Nacional Abierta y a Distancia UNAD

Noviembre de 2020
23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

Ejercicio 1: Sistema de Ecuaciones Lineales

4𝑥1 + 𝑥2 − 𝑥3 = 3
𝑥1 + 6𝑥2 − 2𝑥3 + 𝑥4 − 𝑥5 = −6
𝑥2 + 5𝑥3 − 𝑥5 + 𝑥6 = −5
2𝑥2 + 5𝑥4 − 𝑥5 − 𝑥7 − 𝑥8 = 0
−𝑥3 − 𝑥4 + 6𝑥5 − 𝑥6 − 𝑥8 = 12
−𝑥3 − 𝑥5 + 5𝑥6 = −12
−𝑥4 + 4𝑥7 − 𝑥8 = −2
−𝑥4 − 𝑥5 − 𝑥7 + 5𝑥8 = 2
Resolver los Sistema de Ecuaciones Lineales por los siguientes metodos :

Gauss – Seidel
Jacobi
S.O.R.

Funciones generales

FUNCIÓN TRUNCADO

In [8]: def truncar(f, n):

import math
return math.floor(f * 10 ** n) / 10 ** n

FUNCIONES PARA GRAFICAR

In [108]: def graficar_individual(vector,color,nombre,name='ERROR ABSOLUTO'): #crea la funcion 'graficar'

import matplotlib.pyplot as plt
import numpy as g
import math
plt.figure(figsize=(15,2)) # define el tamaño de la grafica
plt.title(name)
plt.ylabel('Error')
plt.xlabel('Iteracion')

iterar = g.arange(0, len(vector), 1) #vector para determinar el rango de la grafica

plt.plot(iterar,iterar*0,'r.') #graficamos el eje de x

plt.plot(iterar, vector,color, label = nombre) #graficamos el vector ingresado
plt.legend() #identificar graficas por nombres

In [109]: def graficar_tres(vector_1,vector_2,vector_3,nombre_1,nombre_2,nombre_3,name='ERROR ABSOLUTO'):

import matplotlib.pyplot as plt
import numpy as g
import math
plt.figure(figsize=(15,8)) #se define el tamaño de la grafica
plt.title(name)
plt.ylabel('Error')
plt.xlabel('Iteracion')

iterar = g.arange(0, len(vector_1), 1) #creamos un vector para determinar el rango de la grafica

plt.plot(iterar,iterar*0,'r.') #eje de x
plt.plot(iterar, vector_1,'y', label = nombre_1) #graficamos el vector ingresado
plt.plot(iterar, vector_2,'b', label = nombre_2)
plt.plot(iterar, vector_3,'r', label = nombre_3)
plt.legend()

FUNCIÓN PARA HALLAR LA MATRIZ ERROR

In [7]: def matriz_error(vector_original,matriz_metodo,iteracion):

import numpy as np
errores = np.zeros((iteracion+1,7+1)) #define el tamaño de la matriz
for j in range(iteracion+1):
for k in range(7+1):
errores[j][k]=truncar(abs((float(vector_original[k])-matriz_metodo[j][k])),6) #se calcula el error absoluto
return errores #retorna la matriz del error absoluto

DESCRIPCIÓN DEL SISTEMA DE ECUACIONES

In [26]: a = []
b = []
# incicia en cero
inicio = [0, 0, 0, 0, 0, 0, 0, 0]
#matriz del sistema de ecuaciones
a = [[4, 1, -1, 0, 0, 0, 0, 0],[1, 6, -2, 1, -1, 0, 0, 0],[0, 1, 5, 0, -1, 1, 0, 0],[0, 2, 0, 5, -1, 0, -1, -1],
[0, 0, -1, -1, 6, -1, 0, -1],[0, 0, -1, 0, -1, 5, 0, 0],[0, 0, 0, -1, 0, 0, 4, -1],[0, 0, 0, -1, -1, 0, -1, 5] ]
# los terminos independientes lo guardamos en 'b'
b = [3, -6, -5, 0, 12, -12 ,-2 ,2]

METODO DE GAUSS-SEIDEL

4𝑥1 + 𝑥2 − 𝑥3 = 3
𝑥1 + 6𝑥2 − 2𝑥3 + 𝑥4 − 𝑥5 = −6
𝑥2 + 5𝑥3 − 𝑥5 + 𝑥6 = −5
2𝑥2 + 5𝑥4 − 𝑥5 − 𝑥7 − 𝑥8 = 0
−𝑥3 − 𝑥4 + 6𝑥5 − 𝑥6 − 𝑥8 = 12
−𝑥3 − 𝑥5 + 5𝑥6 = −12
−𝑥4 + 4𝑥7 − 𝑥8 = −2
localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 1/12
23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

−𝑥4 − 𝑥5 − 𝑥7 + 5𝑥8 = 2
Si la diagonal de la matriz no es 0, podemos despejar el sistema de ecuaciones para cada incognita de la siguiente forma:

𝑥1 = (3 − 𝑥42 + 𝑥3 )
𝑥2 = (−6 − 𝑥1 + 2𝑥63 + −𝑥4 + 𝑋5 )
𝑥3 = (−5 − 𝑥2 +5 𝑥5 − 𝑥6 )
𝑥4 = (−𝑥2 + 𝑥5 5+ 𝑥7 + 𝑋8 )
𝑥5 = (12 + 𝑋3 + 𝑥64 + 𝑥6 + 𝑥8 )
𝑥6 = (−12 + 5𝑥3 + 𝑥5 )
𝑥7 = (−2 + 𝑥44 + 𝑥8 )
𝑥8 = (2 + 𝑋4 +5𝑋5 + 𝑥7 )
los valores que no se conocen se reemplaza por cero y los nuevos toman valores anteriores de los puntos, como por ejemplo en la siguiente ecuación:

Iteracion cero:

𝑥1 = (3 − 04 + 0) = 0.750000
𝑥2 = (−6 − (−0.750000) + 0 − 0 + 0) = −1.125000
6 + 0 − 0)
𝑥3 = (−5 − (−1.125000) = −0.775000
5
𝑥4 = (−(−1.125000)5 + 0 + 0 + 0) = 0.450000
𝑥5 = (12 + −0.775000 +6 0.450000 + 0 + 0) = 1.945833
𝑥6 = (−12 + −0.775000 + 1.945833) = −2.165833
5 + 0)
𝑥7 = (−2 + 0.450000 = −0.387500
4
𝑥8 = (2 + 0.450000 + 1.945833
5
− 0.387500) = 0.801667
FUNCIÓN DEL METODO GAUSS-SEIDEL

In [15]: def seidel(A, x ,b,iteracion=1,trunca=8):

import numpy as np
import math
matriz = np.zeros((iteracion+1,8)) #matriz ceros de n dimension
n = len(A) # tamaño del vector

# convergencia
for j in range(n):
dominio = 0.0
for i in range(j+1, n):
if j != i:
dominio += math.fabs(a[i][j])
if A[i][i] < dominio:
exit('No converge la matriz ')

for k in range(iteracion+1):

for j in range(0, n):

# variable temporal de b[j]
temp = truncar(b[j],trunca)
for i in range(0, trunca):
if(j != i):
temp-=A[j][i] * x[i]
temp=truncar(temp, trunca)
x[j] =truncar( temp / A[j][j],trunca)
# guarda los vectores en la matriz que va retornar la funcion
matriz[:][k]=x
return matriz

TABLA DE LAS SOLUCIONES DE CADA VARIABLE VS EL NUMERO DE ITERACIONES

In [27]: import pandas

iteracion=12 #iteracion maxima
inicio = [0, 0, 0, 0, 0, 0, 0, 0]
solucion_seidel = seidel(a, inicio, b,iteracion,8) #se guarda la solucion del metodo seidel en 'sol_seidel'
nombres=['x1','x2','x3','x4','x5','x6','x7','x8']
pandas.DataFrame(solucion_seidel,range(iteracion+1),nombres) #imprimimos la matriz en froma de cuadro

Out[27]:
x1 x2 x3 x4 x5 x6 x7 x8

0 0.750000 -1.125000 -7.750000e-01 0.450000 1.945833 -2.165833 -3.875000e-01 0.801667

1 0.837500 -1.148611 5.205555e-02 0.931444 1.936556 -2.002278 -6.672223e-02 0.960256

2 1.050167 -0.990157 -1.420186e-02 0.962081 1.984309 -2.005978 -1.941594e-02 0.985395

3 0.993989 -1.000027 -1.936960e-03 0.990069 1.994591 -2.001469 -6.134150e-03 0.995705

4 0.999523 -0.999812 -8.254500e-04 0.996757 1.998361 -2.000493 -1.884370e-03 0.998647

5 0.999747 -0.999966 -2.360500e-04 0.999011 1.999488 -2.000150 -5.855400e-04 0.999583

6 0.999932 -0.999988 -7.488000e-05 0.999692 1.999842 -2.000047 -1.812700e-04 0.999871

7 0.999978 -0.999996 -2.305000e-05 0.999905 1.999951 -2.000014 -5.618000e-05 0.999960

8 0.999993 -0.999999 -7.160000e-06 0.999970 1.999985 -2.000004 -1.741000e-05 0.999988

9 0.999998 -1.000000 -2.220000e-06 0.999991 1.999995 -2.000001 -5.400000e-06 0.999996

10 0.999999 -1.000000 -6.900000e-07 0.999997 1.999999 -2.000000 -1.680000e-06 0.999999

11 1.000000 -1.000000 -2.200000e-07 0.999999 2.000000 -2.000000 -5.300000e-07 1.000000

12 1.000000 -1.000000 -7.000000e-08 1.000000 2.000000 -2.000000 -1.700000e-07 1.000000

MATRIZ DEL ERROR ABSOLUTO DEL METODO GAUSS-SEIDEL

In [22]: error_seidel=matriz_error([1, -1, 0, 1, 2, -2, 0, 1],solucion_seidel,iteracion)

TABLA DEL ERROR ABSOLUTO VS NUMERO DE ITERACIONES

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 2/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [133]: import pandas

iteracion=12
nombr=['Error x_1','Error x_2','Error x_3','Error x_4','Error x_5','Error x_6','Error x_7','Error x_8']
pandas.DataFrame(error_seidel,range(iteracion+1),nombr)

Out[133]:
Error x_1 Error x_2 Error x_3 Error x_4 Error x_5 Error x_6 Error x_7 Error x_8

0 0.250000 0.125000 0.775000 0.550000 0.054166 0.165833 0.387500 0.198333

1 0.162499 0.148611 0.052055 0.068555 0.063444 0.002277 0.066722 0.039744

2 0.050166 0.009842 0.014201 0.037919 0.015690 0.005978 0.019415 0.014605

3 0.006011 0.000027 0.001936 0.009931 0.005408 0.001469 0.006134 0.004294

4 0.000477 0.000187 0.000825 0.003242 0.001638 0.000492 0.001884 0.001353

5 0.000253 0.000034 0.000236 0.000988 0.000511 0.000149 0.000585 0.000417

6 0.000067 0.000012 0.000074 0.000307 0.000158 0.000046 0.000181 0.000129

7 0.000021 0.000003 0.000023 0.000095 0.000049 0.000014 0.000056 0.000040

8 0.000006 0.000001 0.000007 0.000029 0.000015 0.000004 0.000017 0.000012

9 0.000002 0.000000 0.000002 0.000009 0.000004 0.000001 0.000005 0.000003

10 0.000000 0.000000 0.000000 0.000002 0.000001 0.000000 0.000001 0.000001

11 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

12 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

METODO JACOBI

4𝑥1 + 𝑥2 − 𝑥3 = 3
𝑥1 + 6𝑥2 − 2𝑥3 + 𝑥4 − 𝑥5 = −6
𝑥2 + 5𝑥3 − 𝑥5 + 𝑥6 = −5
2𝑥2 + 5𝑥4 − 𝑥5 − 𝑥7 − 𝑥8 = 0
−𝑥3 − 𝑥4 + 6𝑥5 − 𝑥6 − 𝑥8 = 12
−𝑥3 − 𝑥5 + 5𝑥6 = −12
−𝑥4 + 4𝑥7 − 𝑥8 = −2
−𝑥4 − 𝑥5 − 𝑥7 + 5𝑥8 = 2
Si la diagonal de la matriz no es cero, podemos despejar el sistema de ecuaciones de la siguiente forma:

𝑥1 = (3 − 𝑥42 + 𝑥3 )
𝑥2 = (−6 − 𝑥1 + 2𝑥63 + −𝑥4 + 𝑋5 )
𝑥3 = (−5 − 𝑥2 +5 𝑥5 − 𝑥6 )
𝑥4 = (−𝑥2 + 𝑥5 5+ 𝑥7 + 𝑋8 )
𝑥5 = (12 + 𝑋3 + 𝑥64 + 𝑥6 + 𝑥8 )
𝑥6 = (−12 + 5𝑥3 + 𝑥5 )
𝑥7 = (−2 + 𝑥44 + 𝑥8 )
𝑥8 = (2 + 𝑋4 +5𝑋5 + 𝑥7 )
los valores desconocidos inician en cero y para la siguiente iteracion se utilizan los datos de la iteracion anterior:

𝑥1 = (3 − 04 + 0) = 0.750000
𝑥2 = (−6 − 0 + 206 + −0 + 0) = −1.000000
𝑥3 = (−5 − 05+ 0 − 0) = −1.000000
𝑥4 = (−0 + 05+ 0 + 0) = 0
𝑥5 = (12 + 0 +60 + 0 + 0) = 2.000000
𝑥6 = (−12 +5 0 + 0) = −2.400000
𝑥7 = (−2 +40 + 0) = −0.500000
𝑥8 = (2 + 𝑋4 5+ 0 + 0) = 0.400000
segunda iteracion:

𝑥1 = (3 − (−1.000000) − 1.000000) = 0.750000

4 + 0 + 2.00000)
𝑥2 = (−6 − 0.750000 + 2−1.000000 = −1.125000
6
𝑥3 = (−5 − (−1.000000) + 2.000000 − (−2.400000)) = 0.105000
5 − 0.500000 + 𝑋 )
𝑥4 = (−(−1.000000) + 2.000000 8 = 0.830000
(12 − 1.000000 + 0 − 52.400000 + 0.400000)
𝑥5 = 6 = 1.822500
𝑥6 = (−12 − 1.000000 + 2.000000) = −2.014500
50.400000)
𝑥7 = (−2 + 0 + = −0.109250
4
𝑥8 = (2 + 0 + 2.000000
5
− 0.500000) = 0.892000
FUNCION DEL METODO JACOBI

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 3/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [28]: def jacobi(A, x ,b,iteracion=1,trunca=8):

import math
import numpy as np

matriz = np.zeros((iteracion+1,7+1))
temp=np.zeros(8)

n = len(a)

# convergencia
for j in range(n):
dominio = 0.0
for i in range(j+1, n):
if j != i:
dominio += math.fabs(a[i][j])
if A[i][i] < dominio:
exit('No converge la matriz ')

for k in range(iteracion+1):
for j in range(n):
# se guarda la b[j] en una variable temporal
temporal = truncar(b[j],trunca)
for i in range(trunca):
if(j != i):
temporal-=A[j][i] * x[i]
temporal=truncar(temporal, trunca)
temp[j] =truncar( temporal / A[j][j],trunca)
x=temp
matriz[:][k]=x
return matriz

TABLA DE SOLUCIONES VS ITERACIONES DEL METODO JACOBI

In [39]: import pandas

iteracion=12
inicio = [0, 0, 0, 0, 0, 0, 0, 0]
solucion_jacobi = jacobi(a, inicio, b,iteracion,8)
nombres=['x1','x2','x3','x4','x5','x6','x7','x8']
pandas.DataFrame(solucion_jacobi,range(iteracion+1),nombres)

Out[39]:
x1 x2 x3 x4 x5 x6 x7 x8

0 0.750000 -1.000000 -1.000000e+00 0.000000 2.000000 -2.400000 -5.000000e-01 0.400000

1 0.750000 -1.125000 1.050000e-01 0.830000 1.822500 -2.014500 -1.925000e-01 0.892000

2 1.057500 -0.975833 -3.743334e-02 0.894733 1.955800 -2.016327 -5.331668e-02 0.959443

3 0.984600 -0.999733 -5.628000e-03 0.972279 1.984961 -2.004133 -1.706951e-02 0.988034

4 0.998526 -0.999517 -2.277760e-03 0.990992 1.995436 -2.001368 -5.243540e-03 0.996237

5 0.999310 -0.999904 -6.584600e-04 0.997247 1.998576 -2.000416 -1.629000e-03 0.998839

6 0.999811 -0.999967 -2.081700e-04 0.999144 1.999560 -2.000130 -5.043300e-04 0.999640

7 0.999940 -0.999990 -6.413000e-05 0.999735 1.999864 -2.000040 -1.562900e-04 0.999888

8 0.999981 -0.999997 -1.990000e-05 0.999918 1.999958 -2.000012 -4.842000e-05 0.999965

9 0.999994 -0.999999 -6.170000e-06 0.999975 1.999987 -2.000004 -1.501000e-05 0.999989

10 0.999998 -1.000000 -1.910000e-06 0.999992 1.999996 -2.000001 -4.660000e-06 0.999997

11 0.999999 -1.000000 -6.000000e-07 0.999998 1.999999 -2.000000 -1.450000e-06 0.999999

12 1.000000 -1.000000 -1.900000e-07 0.999999 2.000000 -2.000000 -4.600000e-07 1.000000

MATRIZ ERROR DEL METODO JACOBI

In [40]: error_jacobi=matriz_error([1, -1, 0, 1, 2, -2, 0, 1],solucion_jacobi,iteracion)

TABLA DEL ERROR ABSOLUTO VS ITERACIONES

In [41]: import pandas

iteracion=12
nombres=['Error x1','Error x2','Error x3','Error x4','Error x5','Error x6','Error x7','Error x8']
pandas.DataFrame(error_jacobi,range(iteracion+1),nombres)

Out[41]:
Error x1 Error x2 Error x3 Error x4 Error x5 Error x6 Error x7 Error x8

0 0.250000 0.000000 1.000000 1.000000 0.000000 0.399999 0.500000 0.600000

1 0.250000 0.125000 0.104999 0.170000 0.177500 0.014500 0.192500 0.108000

2 0.057499 0.024166 0.037433 0.105266 0.044200 0.016326 0.053316 0.040556

3 0.015400 0.000266 0.005628 0.027721 0.015038 0.004133 0.017069 0.011965

4 0.001473 0.000483 0.002277 0.009008 0.004564 0.001368 0.005243 0.003763

5 0.000690 0.000096 0.000658 0.002752 0.001423 0.000416 0.001629 0.001161

6 0.000188 0.000033 0.000208 0.000856 0.000440 0.000129 0.000504 0.000360

7 0.000060 0.000009 0.000064 0.000264 0.000136 0.000040 0.000156 0.000111

8 0.000018 0.000003 0.000019 0.000082 0.000042 0.000012 0.000048 0.000034

9 0.000005 0.000000 0.000006 0.000025 0.000013 0.000003 0.000015 0.000010

10 0.000001 0.000000 0.000001 0.000007 0.000004 0.000001 0.000004 0.000003

11 0.000000 0.000000 0.000000 0.000002 0.000001 0.000000 0.000001 0.000001

12 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

FUNCION NORMA INFINITA

METODO S.O.R

𝑤 𝑖−1 𝑛
𝑋𝑖 (𝑘) = 𝐴𝑖𝑖 [𝑏𝑖 − ∑ 𝐴𝑖𝑗 𝑥𝑗 (𝑘) − ∑ 𝐴𝑖𝑗 𝑥𝑗 (𝑘−1) ] + (1 − 𝑤)𝑥𝑖 (𝑘−1)
𝑗=1 𝑗=𝑖+1
Donde:

𝑥(𝑘) es el valor de x momentaneo.

𝑤(𝑘−1)
es el parametro de relajacion 0 < 𝑤 < 2 .
𝑥 es el valor de x para la k anterior.
localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 4/12
23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

FUNCION DEL METODO (S.O.R)

Calcula la solucion de un sistema de ecuaciones usando un parametro de relajacion w, que varia de [0,2].

In [79]: def sor(A, b, iteracion=1, w=1,trunca=8):

import numpy as np
import math
matriz = np.zeros((iteracion+1,8))

n = len(A)
anterior = [0.0]*n

# convergencia
for j in range(n):
dominio = 0.0
for i in range(j+1, n):
if j != i:
dominio += math.fabs(a[i][j])
if A[i][i] < dominio:
exit('No converge la matriz ')

# Para garantizar que los elementos de la diagonal principal sean distintos de cero
for i in range(n):
if A[i][i] == 0:
exit('A[i][i] deben ser distinto de cero')

siguiente = [truncar(b[i]/float(A[i][i]),trunca) for i in range(n)]

print('siguiente=',siguiente)
for k in range(iteracion+1):
anterior[:] = siguiente[:]
for i in range(n):
for j in range(n):
sum_1 = truncar(sum(A[i][j]*siguiente[j] for j in range(i)),8)
sum_2 = truncar(sum(A[i][j]*anterior[j] for j in range(i+1, n)),8)
siguiente[i] = truncar((float(w)/A[i][i])*(b[i] - sum_1 - sum_2) + (1-w)*anterior[i],trunca)
matriz[:][k]=siguiente
return matriz

TABLA DE SOLUCIONES VS EL NUMERO DE ITERACIONES DE CADA VARIABLE 'X' DEL METODO 𝑆.𝑂.𝑅
In [80]: import pandas
iteracion=12
solucion_sor = sor(a, b, iteracion, w=1)
nombres=['x1','x2','x3','x4','x5','x6','x7','x8']
pandas.DataFrame(solucion_sor,range(iteracion+1),nombres)

siguiente= [0.75, -1.0, -1.0, 0.0, 2.0, -2.4, -0.5, 0.4]

Out[80]:
x1 x2 x3 x4 x5 x6 x7 x8

0 0.750000 -1.125000 1.050000e-01 0.830000 1.822500 -2.014500 -1.925000e-01 0.892000

1 1.057500 -0.975833 -3.743334e-02 0.894733 1.955800 -2.016327 -5.331667e-02 0.959443

2 0.984600 -0.999733 -5.628000e-03 0.972279 1.984961 -2.004133 -1.706951e-02 0.988034

3 0.998526 -0.999517 -2.277760e-03 0.990992 1.995436 -2.001368 -5.243540e-03 0.996237

4 0.999310 -0.999904 -6.584600e-04 0.997247 1.998576 -2.000416 -1.629000e-03 0.998839

5 0.999811 -0.999967 -2.081700e-04 0.999144 1.999560 -2.000130 -5.043300e-04 0.999640

6 0.999940 -0.999990 -6.412000e-05 0.999735 1.999864 -2.000040 -1.562900e-04 0.999888

7 0.999981 -0.999997 -1.990000e-05 0.999918 1.999958 -2.000012 -4.842000e-05 0.999965

8 0.999994 -0.999999 -6.170000e-06 0.999975 1.999987 -2.000004 -1.501000e-05 0.999989

9 0.999998 -1.000000 -1.910000e-06 0.999992 1.999996 -2.000001 -4.660000e-06 0.999997

10 0.999999 -1.000000 -6.000000e-07 0.999998 1.999999 -2.000000 -1.450000e-06 0.999999

11 1.000000 -1.000000 -1.900000e-07 0.999999 2.000000 -2.000000 -4.600000e-07 1.000000

12 1.000000 -1.000000 -6.000000e-08 1.000000 2.000000 -2.000000 -1.500000e-07 1.000000

MATRIZ ERROR DEL METODO S.O.R

In [85]: error_sor=matriz_error([1, -1, 0, 1, 2, -2, 0, 1],solucion_sor,iteracion)

TABLA DEL ERROR VS ITERACIONES

In [132]: import pandas

iteracion=12
nombres=['Error x_1','Error x_2','Error x_3','Error x_4','Error x_5','Error x_6','Error x_7','Error x_8']
pandas.DataFrame(error_sor,range(iteracion+1),nombres)

Out[132]:
Error x_1 Error x_2 Error x_3 Error x_4 Error x_5 Error x_6 Error x_7 Error x_8

0 0.250000 0.125000 0.105000 0.170000 0.177500 0.014499 0.192500 0.107999

1 0.057500 0.024166 0.037433 0.105266 0.044200 0.016326 0.053316 0.040556

2 0.015399 0.000266 0.005628 0.027721 0.015038 0.004133 0.017069 0.011965

3 0.001473 0.000483 0.002277 0.009008 0.004564 0.001368 0.005243 0.003763

4 0.000690 0.000096 0.000658 0.002752 0.001423 0.000416 0.001629 0.001161

5 0.000188 0.000033 0.000208 0.000856 0.000440 0.000129 0.000504 0.000360

6 0.000060 0.000009 0.000064 0.000264 0.000136 0.000040 0.000156 0.000111

7 0.000018 0.000003 0.000019 0.000082 0.000042 0.000012 0.000048 0.000034

8 0.000005 0.000000 0.000006 0.000025 0.000013 0.000003 0.000015 0.000010

9 0.000001 0.000000 0.000001 0.000007 0.000004 0.000001 0.000004 0.000003

10 0.000000 0.000000 0.000000 0.000002 0.000001 0.000000 0.000001 0.000001

11 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

12 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

SEPARACION DE LA MATRIZ DE ERRORES EN VECTORES PARA SU COMPARACIÓN

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 5/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [87]: iteracion=12
import numpy as ss
import math
vector_x1_seidel=ss.zeros((iteracion+1))
vector_x2_seidel=ss.zeros((iteracion+1))
vector_x3_seidel=ss.zeros((iteracion+1))
vector_x4_seidel=ss.zeros((iteracion+1))
vector_x5_seidel=ss.zeros((iteracion+1))
vector_x6_seidel=ss.zeros((iteracion+1))
vector_x7_seidel=ss.zeros((iteracion+1))
vector_x8_seidel=ss.zeros((iteracion+1))

vector_x1_jacobi=ss.zeros((iteracion+1))
vector_x2_jacobi=ss.zeros((iteracion+1))
vector_x3_jacobi=ss.zeros((iteracion+1))
vector_x4_jacobi=ss.zeros((iteracion+1))
vector_x5_jacobi=ss.zeros((iteracion+1))
vector_x6_jacobi=ss.zeros((iteracion+1))
vector_x7_jacobi=ss.zeros((iteracion+1))
vector_x8_jacobi=ss.zeros((iteracion+1))

vector_x1_sor=ss.zeros((iteracion+1))
vector_x2_sor=ss.zeros((iteracion+1))
vector_x3_sor=ss.zeros((iteracion+1))
vector_x4_sor=ss.zeros((iteracion+1))
vector_x5_sor=ss.zeros((iteracion+1))
vector_x6_sor=ss.zeros((iteracion+1))
vector_x7_sor=ss.zeros((iteracion+1))
vector_x8_sor=ss.zeros((iteracion+1))

for j in range(iteracion+1):
vector_x1_seidel[j]=error_seidel[j][0]
vector_x2_seidel[j]=error_seidel[j][1]
vector_x3_seidel[j]=error_seidel[j][2]
vector_x4_seidel[j]=error_seidel[j][3]
vector_x5_seidel[j]=error_seidel[j][4]
vector_x6_seidel[j]=error_seidel[j][5]
vector_x7_seidel[j]=error_seidel[j][6]
vector_x8_seidel[j]=error_seidel[j][7]

for j in range(iteracion+1):
vector_x1_jacobi[j]=error_jacobi[j][0]
vector_x2_jacobi[j]=error_jacobi[j][1]
vector_x3_jacobi[j]=error_jacobi[j][2]
vector_x4_jacobi[j]=error_jacobi[j][3]
vector_x5_jacobi[j]=error_jacobi[j][4]
vector_x6_jacobi[j]=error_jacobi[j][5]
vector_x7_jacobi[j]=error_jacobi[j][6]
vector_x8_jacobi[j]=error_jacobi[j][7]

for j in range(0, iteracion+1):

vector_x1_sor[j]=error_sor[j][0]
vector_x2_sor[j]=error_sor[j][1]
vector_x3_sor[j]=error_sor[j][2]
vector_x4_sor[j]=error_sor[j][3]
vector_x5_sor[j]=error_sor[j][4]
vector_x6_sor[j]=error_sor[j][5]
vector_x7_sor[j]=error_sor[j][6]
vector_x8_sor[j]=error_sor[j][7]

GRAFICA COMPARATIVAS DE LOS METODOS VS ITERACIONES

In [114]:
graficar_individual(vector_x1_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X1') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x1_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X1') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x1_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X1') #se grafica el error para cada 'n' distinto

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 6/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [113]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X1']

graficar_tres(vector_x1_seidel,vector_x1_jacobi,vector_x1_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

In [115]:
graficar_individual(vector_x2_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X2') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x2_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X2') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x2_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X2') #se grafica el error para cada 'n' distinto

In [117]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X2']

graficar_tres(vector_x2_seidel,vector_x2_jacobi,vector_x2_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 7/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [118]:
graficar_individual(vector_x3_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X3') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x3_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X3') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x3_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X3') #se grafica el error para cada 'n' distinto

In [119]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X3']

graficar_tres(vector_x3_seidel,vector_x3_jacobi,vector_x3_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

In [122]:
graficar_individual(vector_x4_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X4') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x4_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X4') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x4_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X4') #se grafica el error para cada 'n' distinto

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 8/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [121]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X4']

graficar_tres(vector_x4_seidel,vector_x4_jacobi,vector_x4_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

In [123]:
graficar_individual(vector_x5_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X5') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x5_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X5') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x5_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X5') #se grafica el error para cada 'n' distinto

In [124]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X5']

graficar_tres(vector_x5_seidel,vector_x5_jacobi,vector_x5_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 9/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [125]:
graficar_individual(vector_x6_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X6') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x6_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X6') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x6_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X6') #se grafica el error para cada 'n' distinto

In [126]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X6']

graficar_tres(vector_x6_seidel,vector_x6_jacobi,vector_x6_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

In [127]:
graficar_individual(vector_x7_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x7_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x7_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 10/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

In [128]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X7']

graficar_tres(vector_x7_seidel,vector_x7_jacobi,vector_x7_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

In [129]:
graficar_individual(vector_x8_seidel,'b','error_SEIDEL','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x8_jacobi,'y','error_JACOBI','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto
graficar_individual(vector_x8_sor,'g','error_S.O.R','ERROR ABSOLUTO PARA X7') #se grafica el error para cada 'n' distinto

In [130]: name=['COMPPARACION DE ERRORES PARA EL PUNTO X8']

graficar_tres(vector_x8_seidel,vector_x8_jacobi,vector_x8_sor,'error_SEIDEL','error_JACOBI','error_S.O.R',name)

Concluciones y observaciones:

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 11/12

23/10/2020 G##_nombreEstudiante_Ej1A - Jupyter Notebook

Del comportamiento de las graficas en las 12 iteraciones se concluye que el metodo Seidel se acerca un poco mejor que el Jacobi, el meotodo S.O.R. se acercó mejor que
los metodos anteriores, en cuanto al metodo Gauss-Geidel y Jacobi a pesar de tener pequeños cambios presenta diferencias en la presicion de sus valores, convergen a
cero a medida que aumentamos el numero de iteraciones, las diferencias de los metodos son notables en la comparacion de las ultimas incognitas del sitemas de
ecuaciones, la exactitud del metodo S.O.R. depende del valor del parametro de relajacion 'w'.

Referencia bibliografica:

Canale, R. P. y P. Canale, R. (2007). Métodos numéricos para ingenieros (5a. ed.). México D.F, México: McGraw-Hill Interamericana. (pp. 451 – 477).

In [ ]:

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej1A.ipynb 12/12

23/10/2020 G##_nombreEstudiante_Ej2A - Jupyter Notebook

Ejercicio 2: Regresión Lineal

La regresión lineal se enfrasca la relación estadística entre dos variables continuas llamadas variables de predicción y respuesta.

𝑋
𝑌
La variable predictora se puede encontrar como o como variable independiente.
La variable de respuesta se puede encontrar como o variable dependiente.

Ecuacion

𝑦(𝑥) = 𝑎1 𝑥 + 𝑎0 + 𝑒
Donde:
𝑎𝑎0 eses ella punto de intercepcion con el eje Y.
1
𝑒 es el error (aleatorio).
pendiente.

Mediante los datos se va calcular los coficientes tanto como el error estandar.

x 1 2 3 4 5 6 7 8 9

y 1 1.5 2 3 4 5 8 10 13

FUNCIÓN TRUNCAR

In [46]: def truncar(f, n):

import math
return math.floor(f * 10 ** n) / 10 ** n

PARA REALIZAR LA REGRESIÓN LINEAL ES NECESARIO HALLAR LAS SIGUIENTES SUMATORIAS DE LOS DATOS:

∑𝑥𝑖 ∑𝑦𝑖 ∑(𝑥𝑖𝑦𝑖 ) ∑ 𝑥𝑖2

TABLA DEL PROCEDIMIENTO DE REGRESIÓN LINEAL

El siguiente codigo realiza las anteriores sumatorias pero de una manera en que se pueda apreciar el procedimiento mediante la tabulación de cada dato.

In [60]: import pandas

name=[]
import numpy as np
import math

x=[1, 2, 3, 4, 5, 6, 7, 8, 9]
y=[1, 1.5, 2, 3, 4, 5, 8, 10, 13]

n = len(x)

# valores iniciales
matriz_1 = np.zeros((n+1,4))
sum_x=0
sum_y=0
sum_xy=0
sum_xx=0

for j in range(0,n):
matriz_1[j][0]=x[j]
matriz_1[j][1]=y[j]
matriz_1[j][2]=x[j]*y[j]
matriz_1[j][3]=x[j]**2
sum_x+=x[j]
sum_y+=y[j]
sum_xy+=x[j]*y[j]
sum_xx+=x[j]**2
matriz_1[n][0]=sum_x
matriz_1[n][1]=sum_y
matriz_1[n][2]=sum_xy
matriz_1[n][3]=sum_xx

# para tabular
name=[0,1,2,3,4,5,6,7,8,'suma'] #name igual tamaño que los vectores 'x' y 'y'
nombres=['x[ i ]','y[ i ]','x[ i ]*y[ i ]','x[ i ]**2']
pandas.DataFrame(matriz_1,name,nombres)

Out[60]:
x[ i ] y[ i ] x[ i ]*y[ i ] x[ i ]**2

0 1.0 1.0 1.0 1.0

1 2.0 1.5 3.0 4.0

2 3.0 2.0 6.0 9.0

3 4.0 3.0 12.0 16.0

4 5.0 4.0 20.0 25.0

5 6.0 5.0 30.0 36.0

6 7.0 8.0 56.0 49.0

7 8.0 10.0 80.0 64.0

8 9.0 13.0 117.0 81.0

suma 45.0 47.5 325.0 285.0

De la tabla se obtienen los valores de la sumatoria para despues halla los coeficientes:

x[ i ] y[ i ] x[ i ]*y[ i ] x[ i ]^2

0 1.0 1.0 1.0 1.0

1 2.0 1.5 3.0 4.0

2 3.0 2.0 6.0 9.0

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej2A.ipynb#Ecuacion-lineal-resultante: 1/4

23/10/2020 G##_nombreEstudiante_Ej2A - Jupyter Notebook

x[ i ] y[ i ] x[ i ]*y[ i ] x[ i ]^2

3 4.0 3.0 12.0 16.0

4 5.0 4.0 20.0 25.0

5 6.0 5.0 30.0 36.0

6 7.0 8.0 56.0 49.0

7 8.0 10.0 80.0 64.0

8 9.0 13.0 117.0 81.0

suma 45.0 47.5 325.0 285.0

∑ 𝑥𝑖 = 45
∑ 𝑦𝑖 = 47.5
∑(𝑥𝑖𝑦𝑖 ) = 325
∑ 𝑥𝑖2 = 285
Ahora se reemplazan los valores anteriores de la sumatoria dentro de las siguientes ecuaciones para los coeficientes.

CALCULOS DE LOS COEFICIENTES

𝑛∑(𝑥 𝑦 ) − ∑ 𝑥 ∑ 𝑦
𝑎1 = 𝑛∑ 𝑥𝑖 2 − (∑ 𝑥𝑖 )2 𝑖
𝑖 𝑖 𝑖

∑𝑦 𝑎
𝑎0 = 𝑛 − 𝑛 𝑖
𝑖 1 ∑ 𝑥

𝑎1 = 9(325)−(45)(47.5)
9(285)−(45)2 = (2925)−(2137.5) = 1.145833
(2565)−(2025)
𝑎0 = 47.59 − 1.145833( 459 ) = −2.013887

CODIGO PARA CALCULOS DE LOS COEFICIENTES PARA LA ECUACION

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej2A.ipynb#Ecuacion-lineal-resultante: 2/4

23/10/2020 G##_nombreEstudiante_Ej2A - Jupyter Notebook

In [59]: import pandas

import numpy as np
import sympy as sp
import math
xx = sp.Symbol('xx') #variable simbolica
x=[1, 2, 3, 4, 5, 6, 7, 8, 9]
y=[1, 1.5, 2, 3, 4, 5, 8, 10, 13]

n = len(x) # dimension del vector

# Estado inicial
matriz_2 = np.zeros((n+1,4))
sumx=0
sumy=0
sumxy=0
sumxx=0

for i in range(0,n):
matriz_2[i][0]=x[i]
matriz_2[i][1]=y[i]
matriz_2[i][2]=x[i]*y[i]
matriz_2[i][3]=x[i]**2
sumx+=x[i]
sumy+=y[i]
sumxy+=x[i]*y[i]
sumxx+=x[i]**2
matriz_2[n][0]=sumx
matriz_2[n][1]=sumy
matriz_2[n][2]=sumxy
matriz_2[n][3]=sumxx

promedio_y=truncar(sumy/n,6) #promedio de Y
promedio_x=truncar(sumx/n,6) #promedio de x
a1=truncar((n*sumxy-sumx*sumy)/(n*sumxx-sumx**2),6) #coeficiente a1
a0=truncar(promedio_y-a1*promedio_x,6) #coeficiente a2

coeficiente=[]

ecua=a1*xx+a0
ecua_print=np.str(ecua)
print(ecua_print)

coeficiente=[a1,a0]
pandas.DataFrame([coeficiente],[ecua_print],['a1','a0'])

1.458333*xx - 2.013888

Out[59]:
a1 a0

1.458333*xx - 2.013888 1.458333 -2.013888

Y(x)=1.458333*x - 2.013888

GRAFICA DEL AJUSTE LINEAL

In [42]: import matplotlib.pyplot as plt

import numpy as np
import math

l= np.zeros(n) # puntos para la funcion lineal

for j in range(0, n):
l[j]=ecua.subs(xx,x[j]) # reemplazar valores de X en la ecuacion y

plt.figure(figsize=(15,8)) # Tamaño de la grafica

plt.title('GRAFICA DE AJUSTE LINEAL POR MÍNIMOS CUADRADOS') # Titulo superior
plt.ylabel('Y')
plt.xlabel('X')

nomb=np.str(ecua) #CONVERTIR LA FUNCION A CARACTER

plt.plot(x,np.zeros(len(x)),'r--') # eje de x
plt.plot(x, l,'r', label =nomb ) # mostrar funcion
plt.legend() #Identificar grafica
plt.plot(x,y,'go') # Graficar

Out[42]: [<matplotlib.lines.Line2D at 0x1914e456ee0>]

Estimación de errores en el ajuste lineal por mínimos cuadrados

El error del ajuste lineal se calcula por medio de las siguientes dos ecuaciones.

𝑆𝑟 = ∑(𝑦𝑖 − 𝑎0 − 𝑎1 𝑥𝑖 )2
localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej2A.ipynb#Ecuacion-lineal-resultante: 3/4
23/10/2020

⎯⎯⎯⎯⎯⎯⎯⎯⎯
𝑆 ⎯
G##_nombreEstudiante_Ej2A - Jupyter Notebook

𝑠 𝑦𝑥 = √ 𝑛 −𝑟 2
Mediante una tabla se aprecia el error aletorior de cada punto.

In [50]: import pandas

matriz_error=[] #matriz para el proceso de error
e=y-l # hallamos el error restando los vectores de la funcion resultante
e_2=e**2
matriz_error=[y,t,e,e_2]
pandas.DataFrame(matriz_error,['y[ i ]','𝑎0−𝑎1*𝑥[ 𝑖 ]','e[ i ]','sr[ i ]'],x)

Out[50]:
1 2 3 4 5 6 7 8 9

y[ i ] 1.000000 1.500000 2.000000 3.000000 4.000000 5.000000 8.000000 10.000000 13.000000

𝑎 0−𝑎 1*𝑥[ 𝑖 ] -0.555555 0.902778 2.361111 3.819444 5.277777 6.736110 8.194443 9.652776 11.111109

e[ i ] 1.555555 0.597222 -0.361111 -0.819444 -1.277777 -1.736110 -0.194443 0.347224 1.888891

sr[ i ] 2.419751 0.356674 0.130401 0.671488 1.632714 3.014078 0.037808 0.120565 3.567909

0 1 2 3 4 5 6 7 8 9

sr[ i ] 2.419751 0.356674 0.130401 0.671488 1.632714 3.014078 0.037808 0.120565 3.567909

se suma los valores de cada 𝑆𝑟 [𝑖]

𝑆𝑟 = 2.419751 + 0.356674 + 0.130401 + 0.671488 + 1.632714 + 3.014078 + 0.037808 + 0.120565 + 3.567909 = 11.951388
In [58]: sr=0
sr=float(truncar(sum((y[j]-f.subs(xx,x[j]))**2 for j in range(n)),6))
sr_1=truncar((sr/(n-2))**(0.5),6) #error
print('sr=',sr)
print('s y/x=',sr_1)
pandas.DataFrame([[sr,sr_1]],['error'],['sr','s y/x'])

sr= 11.951388
s y/x= 1.306652

Out[58]:
sr s y/x

error 11.951388 1.306652

⎯(11.951388)
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
𝑠 𝑦𝑥 = √ (9 − 2) = 1.306652
CONCLUSIONES:

La dispersión de los datos fue evidente al agraficar los puntos y la ecuacion por esta razon el error presentó valores relativamente alto, la funcion resultante se ajusto de exelente manera a los puntos dispersos.

La regresión lineal es un exelente metodo para ajustar linealmente los datos de un conjunto de puntos dispersos. pero se debe saber con anticipacion que es lineal, no puede utilizar si al inspeccionar los datos de forma
visual encontramos una ubicacion de los puntos aparentemente aleatoria.

BIBLIOGRAFIA REFERENTE :

Canale, R. P. y P. Canale, R. (2007). Regresíon lineal, Métodos numéricos para ingenieros (5a. ed.). México D.F, México: McGraw-Hill Interamericana. (pp. 465 –
476).

In [ ]:

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej2A.ipynb#Ecuacion-lineal-resultante: 4/4

24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

Ejercicio 3: Interpolación

𝑥 1 2 3 4 5 6 8 9 10 11
𝑦 1.36788 0.63534 0.38312 0.26832 0.20674 1.36788 0.38312 0.26832 0.20674 0.09093
Econtrar el juste a un polinomio de interpolación con los datos dados, empleando cada uno de los siguientes métodos:

Newton
Lagrange
Trazadores cúbicos

Determine el valor en 𝑥 = 7 con el polinomio encontrado.

FUNCIÓN PARA TRUNCAR

In [1]: def truncar(f, n):

import math
return math.floor(f * 10 ** n) / 10 ** n

Polinomios de Interpolación de Newton con Diferencias Divididas

In [ ]: x=[1, 2, 3, 4, 5, 6, 8, 9, 10, 11]

y=[1.36788, 0.63534, 0.38312, 0.26832, 0.20674, 1.36788, 0.38312, 0.26832, 0.20674, 0.09093]

𝑥 1 2 3 4 5 6 8 9 10 11
𝑦 1.36788 0.63534 0.38312 0.26832 0.20674 1.36788 0.38312 0.26832 0.20674 0.09093
PASO 1:

Mediante esta tabla se aprecia de clara manera como funcionan las diferencias divididas que son necesarias para el metodo de interpolación de Newton. Esta diagonal que desciende son los valores que se necesitan para
resolver el siguiente paso:

𝑋𝑖 𝑌𝑖 𝑃𝑟𝑖𝑚𝑒𝑟𝑎 − 𝑑𝑖𝑓 𝑆𝑒𝑔𝑢𝑛𝑑𝑎 − 𝑑𝑖𝑓 𝑡𝑒𝑟𝑐𝑒𝑟𝑎 − 𝑑𝑖𝑓 𝐶𝑢𝑎𝑟𝑡𝑎 − 𝑑𝑖𝑓 (𝑁 − 1) − 𝑑𝑖𝑓

𝑋0 𝑌0 𝐷0,0 = (𝑦0 )
𝑋1 𝑌1 𝐷0,1 = ((𝑦𝑥11−−𝑦𝑥00)) 𝐷1,1 = (𝐷(𝑥011−−𝐷𝑥00,0) )
𝑋2 𝑌2 𝐷0,2 = ((𝑦𝑥22−−𝑦𝑥11)) 𝐷1,2 = (𝐷(0,2𝑥2−−𝐷𝑥10,1) ) 𝑏2,2 = (𝑏(𝑥1,22−−𝑥𝑏1,11) )
𝑋3 𝑌3 𝐷0,3 = ((𝑦𝑥33−−𝑦𝑥22)) 𝐷1,3 = (𝐷(0,3𝑥3−−𝐷𝑥20,2) ) 𝐷2,3 = (𝐷(1,3𝑥3−−𝐷𝑥21,2) ) 𝐷3,3 = (𝐷(2,3𝑥3−−𝐷𝑥22,2) )
. . . . . . . . .
. . . . . . . . .
. . . . . . . . .
𝑋𝑛−1 𝑌𝑛−1 𝐷0,𝑛−1 = ((𝑥𝑦𝑛−1𝑛−1−−𝑥𝑦𝑛−2𝑛−2)) 𝐷1,𝑛−1 = (𝐷(𝑥0,𝑛−1𝑛−1−−𝑥𝐷𝑛−20,𝑛−2) ) 𝐷2,𝑛−1 = (𝐷(1,𝑛−1 −𝐷1,𝑛−2)
𝑥𝑛−1−𝑥𝑛−2 ) 𝐷3,𝑛−1 = (𝐷(𝑥2,𝑛−1𝑛−1−−𝑥𝐷𝑛−22,𝑛−2) ) . . . . . 𝐷𝑛−1,𝑛−1 = (𝐷𝑛−1,𝑛−1 −𝐷𝑛−1,𝑛−2))
(𝑥𝑛−1−𝑥𝑛−2)

Cada nueva columna utiliza los dos valores anteriores mas cercanos para hallar la pendiente entre puntos, mientras mas puntos mayor será la cantidad de terminos de la ecuacion general del metodo.

PASO 2:

Se guarda la diagona del matriz en un nuevo vector que será utilizado en la ecuacion general:

𝐹[𝑥0 ] = 𝑏0 = 𝐷0,0
𝐹[𝑥0 , 𝑥1 ] = 𝑏1 = 𝐷1,1
𝐹[𝑥0 , 𝑥1 , 𝑥2 ] = 𝑏2 = 𝐷2,2
𝐹[𝑥0 , 𝑥1 , 𝑥2 , 𝑥3 ] = 𝑏3 = 𝐷3,3
.
.
.
𝐹[𝑥0 , 𝑥1 , 𝑥2 , 𝑥3 ...., 𝑥𝑛 ] = 𝑏𝑛−1 = 𝐷𝑛−1,𝑛−1
TERCER PASO:

Reemplazar los datos del veto 𝑏𝑖 en la siguiente ecuación general:

𝑓(𝑥) = 𝑏0 + 𝑏1 (𝑥 − 𝑥1 ) + 𝑏2 (𝑥 − 𝑥2 )(𝑥 − 𝑥1 ).......+𝑏𝑛−1 (𝑥 − 𝑥3 )(𝑥 − 𝑥2 )....(𝑥 − 𝑥𝑛−1 )
Ejemplo:

Tomando los puntos (𝑥0 , 𝑦0 )(𝑥1 , 𝑦1 )(𝑥2 , 𝑦2 )(𝑥3 , 𝑦3 ), se obtienen 4 terminos en fucion de la variable [x] comprendida entre los puntos 𝑥0 y 𝑥3 :
𝑓(7) = 𝑏00 + 𝑏1 (7 − 𝑥1 ) + 𝑏2 (7 − 𝑥2 )(7 − 𝑥1 ) + 𝑏3 (7 − 𝑥3 )(7 − 𝑥2 )(7 − 𝑥1 )

Tabla del procedimiento de diferencias dividas

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 1/6

24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

In [279]: import pandas

import numpy as np
import math
x=[1, 2, 3, 4, 5, 6, 8, 9, 10, 11]
y=[1.36788, 0.63534, 0.38312, 0.26832, 0.20674, 1.36788, 0.38312, 0.26832, 0.20674, 0.09093]

n = len(x)

vector = np.zeros((n))
matriz = [0.0] * n
for i in range(n):
matriz[i] = [0.0] * n

for i in range(n):
vector[i]=x[i]
matriz[i][0]=y[i]

for i in range(1,n):
for j in range(i,n):
matriz[j][i] = truncar(( (matriz[j][i-1]-matriz[j-1][i-1]) / (vector[j]-vector[j-i])),8)

rango=range(len(x))

name=['f(xi)','Primera dif','Segunda dif','Tercera dif','Cuarta dif','Quinta dif','Sexta dif','Septima dif',

'Octava dif','Novena dif']
pandas.DataFrame(matriz,rango,name)

Out[279]:
f(xi) Primera dif Segunda dif Tercera dif Cuarta dif Quinta dif Sexta dif Septima dif Octava dif Novena dif

0 1.36788 0.00000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

1 0.63534 -0.73254 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

2 0.38312 -0.25222 0.240160 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

3 0.26832 -0.11480 0.068710 -0.057150 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

4 0.20674 -0.06158 0.026610 -0.014033 0.010779 0.000000 0.000000 0.000000 0.000000 0.000000

5 1.36788 1.16114 0.611360 0.194917 0.052237 0.008292 0.000000 0.000000 0.000000 0.000000

6 0.38312 -0.49238 -0.551173 -0.290633 -0.097110 -0.024891 -0.004740 0.000000 0.000000 0.000000

7 0.26832 -0.11480 0.125860 0.169258 0.091978 0.031515 0.008058 0.001600 0.000000 0.000000

8 0.20674 -0.06158 0.026610 -0.024813 -0.038814 -0.021799 -0.007616 -0.001959 -0.000395 0.000000

9 0.09093 -0.11581 -0.027115 -0.017908 0.001381 0.006699 0.004071 0.001461 0.000380 0.000078

La siguiente funcion resuleve la ecuacion general mediante la diagonal de la matriz y reemplaza el punto dentro de la funcion polinomial.

In [282]:
def interpol_lineal(matriz,x,evaluar):
n = len(x)
aproximar = 0
multipli = 1.0
for i in range(n):
multipli = matriz[i][i]
for j in range(1,i+1):
multipli *=evaluar - x[j-1]
aproximar += multipli
aproximar=truncar(aproximar,6)
print('f(',evaluar,')=',aproximar)
return aproximar

Llamamos la funcion y se le asignan los valores previamente hallados evaluados en el punto x=7.

In [284]: x=[1, 2, 3, 4, 5, 6, 8, 9, 10, 11]

y=[1.36788, 0.63534, 0.38312, 0.26832, 0.20674, 1.36788, 0.38312, 0.26832, 0.20674, 0.09093]
interpol_lineal(matriz,x,7)

f( 7 )= 1.700541

Out[284]: 1.700541

f( 7 )= 1.700541

POLINOMIOS DE INTERPOLACIÓN DE LAGRANGE

Consiste en encontrar un polinomio de grado n cuya función pase por cada uno de los puntos dados.

𝑥 1 2 3 4 5 6 8 9 10 11
𝑦 1.36788 0.63534 0.38312 0.26832 0.20674 1.36788 0.38312 0.26832 0.20674 0.09093

𝑛
∑ 𝑓(𝑥𝑛 )𝐿(𝑥,𝑛,𝑖)
𝐢=0
Dónde:

𝐹(𝑥𝑛 ): es una variable dependiente o tambien '𝑦𝑖 '.

𝑥𝑛 : variable independiente.
𝑖 : variable controlada por la sumatoria.
𝐿(𝑥,𝑛,𝑖) : polinomio de lagrange.
POLINOMIO DE LAGRANGE

𝐿(𝑋,𝑛,𝑖) = ∏ ((𝑋𝑥𝑖 −− 𝑥𝑥𝑘𝑘))

𝑛
𝑘=0
Dónde:

X: es una variable y se deja expresada.

𝑥𝑘 : variable controlada por la productoria.
𝑥𝑖 : variable controlada por la sumatoria.
n: grado del polinomio.
𝑥𝑖 ≠ 𝑥𝑘
localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 2/6
24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

Funcion completa del polinomio:

𝐹 (𝑥) = ∑ [(𝑦𝑖 ) ∙ ∏ ((𝑋𝑥𝑖 −− 𝑥𝑥𝑘𝑘)) ]

𝑛 𝑛
𝑖=0 𝑘=0
Para entender el desarrollo del metodo tomamos los siguientes puntos como ejemplo:
(0,2)(1,4)(2,6)
2 (𝑥 − 𝑥𝑘 ) = (𝑥 − 𝑥1 ) ∙ (𝑥 − 𝑥2 )
∏
𝑘=0 (𝑥0 − 𝑥𝑘 ) (𝑥0 − 𝑥1 ) (𝑥0 − 𝑥2  ) 
2(𝑥 − 𝑥𝑘 ) = (𝑥 − 1) ∙ (𝑥 − 2) = 𝑥2 − 3𝑥 + 2
∏
𝑘=0 (0 − 𝑥𝑘 ) (0 − 1) (0 − 2 )  2
2 (𝑥 − 𝑥𝑘 ) = (𝑥 − 𝑥0 ) ∙ (𝑥 − 𝑥2 )
∏
𝑘=0 (𝑥1 − 𝑥𝑘 ) (𝑥1 − 𝑥0 ) (𝑥1 − 𝑥2 )
2 (𝑥 − 𝑥𝑘 ) = (𝑥 − 0) ∙ (𝑥 − 2) = 𝑥2 − 2𝑥
∏
𝑘=0 (1 − 𝑥𝑘 ) (1 − 0) (1 − 2) −1
2 (𝑥 − 𝑥𝑘 ) = (𝑥 − 𝑥0 ) ∙ (𝑥 − 𝑥1 )
∏
𝑘=0 (𝑥2 − 𝑥𝑘 ) (𝑥2 − 𝑥0 ) (𝑥2 − 𝑥1 )
2 (𝑥 − 𝑥𝑘 ) = (𝑥 − 0) ∙ (𝑥 − 1) = 𝑥2 − 𝑥
∏
𝑘=0 (2 − 𝑥𝑘 ) (2 − 0) (2 − 1) 2
𝐹 (𝑥) = ∑ [(𝑦𝑛 ) ∙ ∏ ((𝑋𝑥𝑛 −− 𝑥𝑥𝑘𝑘)) ] =(𝑦0 ) ((𝑥𝑥0 −− 𝑥𝑥11)) ∙ ((𝑥𝑥0 −− 𝑥𝑥22)) + (𝑦1 ) ((𝑥𝑥1 −− 𝑥𝑥00)) ∙ ((𝑥𝑥1 −− 𝑥𝑥22)) +  (𝑦2 ) ((𝑥𝑥2 −− 𝑥𝑥10)) ∙ ((𝑥𝑥2 −− 𝑥𝑥11))
𝑛 𝑛
𝐢=0 𝐤=0

𝐹 (𝑥) = ∑ [(𝑦𝑛 ) ∙ ∏ ((𝑋𝑥𝑛 −− 𝑥𝑥𝑘𝑘)) ] =(2) 𝑥 − 3𝑥2 + 2 + (4) (−𝑥 1+ 2𝑥) + (6) 𝑥 2− 𝑥 = 2(𝑥 + 1)
𝑛 𝑛 2 2 2
𝐢=0 𝐤=0
FUNCION POLINOMIO DE LAGRANGE

La siguiente función calcula la expresión polinomica demas de evaluar un punto dentro del la expresion polinomica.

In [323]: def pol_lagrange(x,y,T=None):

import sympy as sp
import numpy as np
import math
n=len(x)
xx=sp.Symbol('xx')
pol=0
suma=0
for i in range(n):
L=1
for k in range(n):
if k!=i:
L=L*(xx-x[k])/(x[i]-x[k])
pol=pol+y[i]*L
pol=sp.expand(pol)
if T==None:
return pol
elif T!=None:
suma=suma+truncar(pol.subs(xx,T),6)
return suma
else:
return truncar(pol.subs(xx,T),6)

Expresión del polinomio de interpolacion de Lagrange

In [325]: x=[1, 2, 3, 4, 5, 6, 8, 9, 10, 11]

y=[1.36788, 0.63534, 0.38312, 0.26832, 0.20674, 1.36788, 0.38312, 0.26832, 0.20674, 0.09093]
pol_lagrange(x,y)

Out[325]: 7.75474537037037 ⋅ 10−5𝑥𝑥9 − 0.00411773082010582𝑥𝑥8 + 0.0929337116402116𝑥𝑥7 − 1.16332772387566𝑥𝑥6 + 8.84314659606481𝑥𝑥5

− 42.0262941921296𝑥𝑥4 + 123.835735597222𝑥𝑥3 − 215.879794996032𝑥𝑥2 + 198.811024047619𝑥𝑥 − 71.1415028571429
Resultado de evaluar t=7 en la expresion anterior.

In [324]: print('f(',7,')=',float(pol_lagrange(x,y,7)))

f( 7 )= 1.700525

f( 7 )= 1.700525

TRAZADORES CUBICOS

Los trazadores cúbicos tienen como objetivo es econtrar un polinomio de tercer grado para cada intervalo entre nodos:

𝑓𝑖(𝑥) = 𝑎𝑖 𝑥3 + 𝑏𝑖 𝑥2 + 𝑐𝑖 𝑥 + 𝑑𝑖
Así, para n + 1 datos (i = 0, 1, 2,..., n), existen n intervalos y, en consecuencia, 4n incógnitas a evaluar. Como con los trazadores cuadráticos, se requieren 4n condiciones para evaluar las incógnitas. Éstas son:

1. Los valores de la función deben ser iguales en los nodos interiores (2n – 2 condiciones).
2. La primera y última función deben pasar a través de los puntos extremos (2 condiciones).
3. Las primeras derivadas en los nodos interiores deben ser iguales (n – 1 condiciones).
4. Las segundas derivadas en los nodos interiores deben ser iguales (n – 1 condiciones).
5. Las segundas derivadas en los nodos extremos son cero (2 condiciones).

(P. Canale,2007,p.532)

𝑥 1 2 3 4 5 6 8 9 10 11
localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 3/6
24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

𝑥 1 2 3 4 5 6 8 9 10 11
𝑦 1.36788 0.63534 0.38312 0.26832 0.20674 1.36788 0.38312 0.26832 0.20674 0.09093
PASO 1:

Tenemos el siguiente sistema de ecuacion que depende de las posiciones de los vectores de y 𝑌 𝑋
... Para entender mejor el proceso debemos cambiar las incognitas que en este caso seria la segunda derivada de la
ecuacion del tramo 𝑓 "𝑖 (𝑥𝑖−1 ) 𝑓 "𝑖 (𝑥𝑖 ) 𝑓 "𝑖 (𝑥𝑖+1 )
, , cambiarlas a valores de , , 𝑘𝑖−1 𝑘𝑖 𝑘𝑖+1
e igualar el resultado al termino independiente . 𝑏𝑗
(𝑥𝑖 − 𝑥𝑖−1 )𝑓 " (𝑥𝑖−1 ) + (𝑥𝑖+1 − 𝑥𝑖−1 )𝑓 " (𝑥𝑖 ) + (𝑥𝑖+1 − 𝑥𝑖 )𝑓 " (𝑥𝑖+1 ) = 𝑥𝑖+16− 𝑥𝑖 [𝑦𝑖+1 − 𝑦𝑖 ] + 𝑥𝑖 −6𝑥𝑖−1 [𝑦𝑖−1 − 𝑦𝑖 ]
(𝑥𝑖 − 𝑥𝑖−1 )𝑘𝑖−1 + (𝑥𝑖+1 − 𝑥𝑖−1 )𝑘𝑖 + (𝑥𝑖+1 − 𝑥𝑖 )𝑘𝑖+1 = 𝑏𝑗
PASO 2:

Guardar el sistema de ecuaciones en una matriz 𝐴𝑗𝑖 y los terminos independientes en el vector 𝑏𝑗 .
𝐴𝑗𝑖 = (𝑥𝑖 − 𝑥𝑖−1 )𝑘𝑖−1 + (𝑥𝑖+1 − 𝑥𝑖−1 )𝑘𝑖 + (𝑥𝑖+1 − 𝑥𝑖 )𝑘𝑖+1
𝑏𝑗 = 𝑥𝑖+16− 𝑥𝑖 [𝑦𝑖+1 − 𝑦𝑖 ] + 𝑥𝑖 −6𝑥𝑖−1 [𝑦𝑖−1 − 𝑦𝑖 ]
PASO 3:

Se resuelve el sitemas de ecuaciones por medio de Gauss-Jordan o cualquier otro metodo, dando como resultadoles los valores de 𝑘𝑖 .
A: es una matriz cuadrada de dimeción (n-2)

𝐴∗𝑘=𝑏
PASO 4:

Una vez resuelto el sistema de ecuaciones, seran utilizados en las siguientes formulas que daran como resultado la función polinomica de tercer grado entre los puntos.

𝑐1 = 6(𝑓𝑥𝑖 "(𝑖 −𝑥𝑥𝑖−1𝑖−1) ) = 6(𝑥𝑘𝑖 −𝑖−1𝑥𝑖−1 )

𝑐2 = 6(𝑓𝑥𝑖𝑖"(−𝑥𝑥𝑖−1𝑖 ) ) = 6(𝑥𝑖 −𝑘𝑖𝑥𝑖−1 )
𝑐3 = [ 𝑥𝑖 𝑦−𝑖−1𝑥𝑖−1 − 𝑘(𝑖−1) 𝑥𝑖 −6𝑥𝑖−1 ]
𝑐4 = [ 𝑥𝑖 −𝑦𝑥𝑖𝑖−1 − 𝑘(𝑖) 𝑥𝑖 −6𝑥𝑖−1 ]
Los valores de los anteriores coeficientes se reemplazan en la siguiente formula dependiente de la variable X.

𝑓𝑖(𝑥) = 𝑐1 (𝑥𝑖 − 𝑥) + 𝑐2 (𝑥 − 𝑥𝑖−1) + 𝑐3 (𝑥𝑖 − 𝑥) + 𝑐4 (𝑥 − 𝑥𝑖−1)

Para tener en cuenta:

las segundas revidas de los extremos son cero y no entran en el sitema de ecuaciones.

𝑓 " (𝑥0 ) = 𝑘0 = 0
𝑓 " (𝑥𝑛−1 ) = 𝑘𝑛−1 = 0
CODIGO DEL METODO DE TRASADORES CUBICOS

Se halla la matriz 𝑓𝑖𝑗 y el vector 𝑏𝑗 que almacenan todo el sistema de ecuaciones, una vez resuelto se hallan las distintas funciones polinomicas para cada tramo guardandola en 𝑓𝑢𝑛𝑖 .

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 4/6

24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

In [183]: import pandas

import numpy as np
import sympy as sp
import math
proceso=[]
n=len(x)
xx = sp.Symbol('xx')
f=np.zeros((n-2,n-2))
b=np.zeros((n-2))
fun=[]

x=[1, 2, 3, 4, 5, 6, 8, 9, 10, 11]

y=[1.36788, 0.63534, 0.38312, 0.26832, 0.20674, 1.36788, 0.38312, 0.26832, 0.20674, 0.09093]

#condiciones iniciales del metodo

f[0][0]=2*(x[2]-x[0])
f[0][1]=x[2]-x[1]
b[0]=6*(y[2]-y[1])/(x[2]-x[1])+6*(y[0]-y[1])/(x[1]-x[0])

#metodo
for i in range(2,n-1):
f[i-1][i-1-1]=x[i]-x[i-1]
f[i-1][i-1]=2*(x[i+1]-x[i-1])
if i!=n-2:
f[i-1][i]=x[i+1]-x[i]
b[i-1]=6*(y[i+1]-y[i])/(x[i+1]-x[i])+6*(y[i-1]-y[i])/(x[i]-x[i-1])

#resuelve la matriz del sistemas de ecuaciones

sol=np.linalg.solve(f,b)

for i in range(1,n-1):
#condicion final
if i!=1:
condition=sol[i-1-1]
if i==1:
condition=0

#coeficientes para crear el polinomio de grado 3 del tramo

aa=truncar(condition/(6*(x[i]-x[i-1])),6)
bb=truncar(sol[i-1]/(6*(x[i]-x[i-1])),6)
cc=truncar(y[i-1]/(x[i]-x[i-1])-condition*(x[i]-x[i-1])/6,6)
dd=truncar(y[i]/(x[i]-x[i-1])-sol[i-1]*(x[i]-x[i-1])/6,6)

#almacena todos las expresiones de los polinomios para cada tramo

fun=fun+[sp.expand(aa*(x[i]-xx)**3+bb*(xx-x[i-1])**3+cc*(x[i]-xx)+dd*(xx-x[i-1]))]
#almacena los parametros para motrarlos despues
proceso=proceso+[[aa,bb,cc,dd]]

TABLA DE TODOS LOS LOS VALORES DE LAS DERIVADAS

In [186]: import pandas

name=['f"(x1)','f"(x2)','f"(x3)','f"(x4)','f"(x5)','f"(x6)','f"(x7)','f"(x8)']
pandas.DataFrame(f,range(len(f)),name) #imprimimos la matriz en froma de cuadro

Out[186]:
f"(x1) f"(x2) f"(x3) f"(x4) f"(x5) f"(x6) f"(x7) f"(x8)

0 4.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0

1 1.0 4.0 1.0 0.0 0.0 0.0 0.0 0.0

2 0.0 1.0 4.0 1.0 0.0 0.0 0.0 0.0

3 0.0 0.0 1.0 4.0 1.0 0.0 0.0 0.0

4 0.0 0.0 0.0 1.0 6.0 2.0 0.0 0.0

5 0.0 0.0 0.0 0.0 2.0 6.0 1.0 0.0

6 0.0 0.0 0.0 0.0 0.0 1.0 4.0 1.0

7 0.0 0.0 0.0 0.0 0.0 0.0 1.0 4.0

TABLA DE LA MATRIZ CONTENEDORA DE ECUACIONES

In [194]: print(b)

[ 2.88192 0.82452 0.31932 7.33632 -9.92112 2.26548 0.31932 -0.32538]

COEFICIENTES PARA CADA FUNCION POLINOMICA.

In [187]: import pandas

name=['C_1','C_2','C_3','C_4']
pandas.DataFrame(proceso,range(len(proceso)),name) #imprimimos la matriz en froma de cuadro

Out[187]:
C_1 C_2 C_3 C_4

0 0.000000 0.112004 1.367880 0.523335

1 0.112004 0.032300 0.523335 0.350819

2 0.032300 -0.103787 0.350819 0.372106

3 -0.103787 0.436066 0.372106 -0.229327

4 0.436066 -0.417758 -0.229327 1.785637

5 -0.208879 0.104240 1.519455 -0.225402

6 0.208480 -0.037788 0.174639 0.306107

7 -0.037788 -0.004111 0.306107 0.210850

SOLUCION DEL SISTEMA DE ECUACIONES

In [197]: print(sol)

[ 0.67202934 0.19380263 -0.62271985 2.61639676 -2.5065472 1.25088321

-0.22672486 -0.02466379]

TODAS LAS FUNCIONES DE LOS TRAMOS ENTRE PUNTOS.

In [196]: fun

Out[196]: [0.112004*xx**3 - 0.336012*xx**2 - 0.508533*xx + 2.100421,

-0.079704*xx**3 + 0.814236*xx**2 - 2.809024*xx + 3.634075,
-0.136087*xx**3 + 1.321683*xx**2 - 4.331362*xx + 5.156407,
0.539853*xx**3 - 6.789597*xx**2 + 28.11376*xx - 38.103761,
-0.853824*xx**3 + 14.115558*xx**2 - 76.412014*xx + 136.105859,
0.313119*xx**3 - 6.889416*xx**2 + 49.617831*xx - 115.953836,
-0.246268*xx**3 + 6.535872*xx**2 - 57.784468*xx + 170.452271,
0.033677*xx**3 - 1.022643*xx**2 + 10.24217*xx - 33.627661]

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 5/6

24/10/2020 G##_nombreEstudiante_Ej3A - Jupyter Notebook

EVALUAR PUNTOS DENTRO DEL CONJUNTO DE ECUACIONES

Mediante la ecuacion anterior se pude hallar cualquier punto dentro de los limites del vector "x" y tambien se muestra la funcion que corresponde al tramo del punto.

In [228]: from sympy import*

def evaluar_sistm_ecuaciones(x,ecuaciones,num):
for j in range(0,len(x)):
if x[j]>=num:
break
print('j=',j)
print(ecuaciones[j-1] )
return float(truncar(ecuaciones[j].subs(xx,num),6))

In [327]: print('f(',7,')=',evaluar_sistm_ecuaciones(x,fun,7))

j= 6
0.313119*xx**3 - 6.889416*xx**2 + 49.617831*xx - 115.953836
f( 7 )= 1.748799

f( 7 )= 1.748799

TABLA COMPARATIVA

METODO NEWTON LAGRANGE TRAZADOR CUBICO

F(7) 1.700541 1.700525 1.748799

OBSERVACIONES Y CONCLUCIONES:

El metodo de polinomios de Lagrange es el más sencillo de programar y ofrece valores muy similares al metodo de interpolacion de newton, la mejora es que este metodo no requiere del cálculo ni del almacenamiento
que newton maneja.
La interpolación de Newton en diferencias divididas funciona de forma excelente en lo casos donde se sabe el grado de dicho polinomio.
El metodo de trazadores cubicos utiliza polinomios de tercer grado en cada tramo, ese ajuste suaviza el valor de sus puntos entre la unión. Este metodo es menos propenso a oscilaciones devido a que esta limitados por
polinomios de tercer grado, considero este metodo el más acertado de los tres pero utiliza mas recursos que los anteriores metodos.

REFERENTE BIBLIOGRAFICO:

•Canale, R. P. y P. Canale, R. (2007). Métodos numéricos para ingenieros (5a. ed.). México D.F, México: McGraw-Hill Interamericana. (pp. 502 – 537).

In [ ]:

localhost:8888/notebooks/Documents/D_segundo trabajo jupyter - copia/G%23%23_nombreEstudiante_Ej3A.ipynb 6/6

 Bibliografía

Canale, R. P. y P. Canale, R. (2007). Métodos numéricos para ingenieros (5a. ed.). México D.F,
Mexico: McGraw-Hill Interamericana. Recuperado de
https://elibronet.bibliotecavirtual.unad.edu.co/es/lc/unad/titulos/73710