Fundamentos de programación Teoría de Errores y solución de ecuaciones no

lineales

Nombre:

Materia

Carrera

Profesor

Año
Introducción:
Para resolver ejercicios de forma automatizada y que cumplan los requerimientos
que se piden en cada actividad, los cuales tomaría mucho tiempo hacerlos a
manos, se utilizara el programa Python, un lenguaje de programación que sirve
para crear programas funcionales.
Para este taller en específico se utilizará Python para realizar sumatorias, y para
crear formular que permitan crear funciones matemáticas simples creadas a partir
de métodos como polinomios de Taylor o newton raphson que emularan de forma
aproximada, funciones más complejas.
Ejercicio 1
B: La Fórmula del área de Gauss, es un algoritmo matemático usado para calcular el área de un
polígono simple cuyos vértices están descritos como pares de coordenadas en el plano. La fórmula
puede representarse mediante la expresión:

n
A=
1
2 |∑i=1
|
x i ( y i +1− y i−1 )

Donde
𝐴 es el área del polígono
𝑛 es el número de lados del polígono
(𝑥𝑖, 𝑦𝑖), 𝑖 = 1,2,3, … , 𝑛 son las coordenadas de los vértices del polígono

Y por tratarse de un polígono cíclico 𝑥𝑛+1 = 𝑥1 y 𝑥𝑛 = 𝑥0, al igual que

𝑦𝑛+1 = 𝑦1 y 𝑦𝑛 = 𝑦0

Gráficamente los cálculos representan:

Figura 3. Tomado de wikipedia

Haga un programa en Python que

 Defina un módulo llamado entrada.py que contenga una

función llamada entrada empleada para el ingreso de los datos
por teclado del número de lados del polígono 𝑛 y cada uno de los
valores del par ordenado (𝑥𝑖, 𝑦𝑖), 𝑖 = 1,2,3, … , 𝑛 (en orden contrario
a las manecillas del reloj) y los vaya almacenando en dos listas,
inicialmente vacías, una para los valores de las coordenadas en
𝑥 y otra para los valores de las coordenadas en 𝑦. Debe tener en
cuenta que a ambas listas se les debe adicionar el primer
elemento y debe devolver las listas con los pares de
coordenadas ingresados y adicionados el primer elemento de
cada lista, por ser un polígono cíclico.
Código Python

def entrada(n):
xi=[]
yi=[]

for i in range(n):
x=input("ingrese un valor x: ")
print(x)
y=input("ingrese un valor y: ")
print(y)

xi.extend(x)
yi.extend(y)

xi.extend(xi[0])
yi.extend(yi[0])
xi.reverse()
yi.reverse()
xi.extend(xi[1])
yi.extend(yi[1])
xi.reverse()
yi.reverse()

return n,xi,yi

Defina un módulo llamado calculos.py que contenga una función llamada

areaPoligono que calcule el área del polígono empleando la fórmula mostrada
arriba. Debe determinar los argumentos que la función recibirá para poder ser ejecutada
adecuadamente y devolver como resultado el área del polígono.
Codigo Python
def areapoligono (n,xi,yi):
S=0
for i in range (n):
x1=int(xi[i+1])
y2=int(yi[i+2])
y0=int(yi[i])
S=abs(((1/2)*x1*(y2-y0))+S)
 print("Area de un polígono con " + str(n) + " lados es: " + str(S))
Defina un módulo llamado calculos.py que contenga una función
llamada areaPoligono que calcule el área del polígono empleando la
fórmula mostrada arriba. Debe determinar los argumentos que la
función recibirá para poder ser ejecutada adecuadamente y devolver
como resultado el área del polígono.

Codigo Python

def pares (n,xi,yi):

for i in range (n):

x=int(xi[i+1])

y=int(yi[i+1])

print(x,y)

El archivo main.py deberá contener únicamente el llamado a cada

una de las funciones solicitadas arriba y una breve descripción de lo
que hace el programa, definiendo cada uno de los datos de entrada y
salida empleando docstring.

Codigo Python

n=int(input("ingrese el numero de lados del poligono: "))

print(n)

import entrada

r=entrada.entrada(n)

xi=r[1]

yi=r[2]

import calculos

import salida
calculos.areapoligono(n,xi,yi)

salida.pares(n,xi,yi)

Ejercicio 2: Teoría de Errores

Para el desarrollo de este ejercicio, es necesario que revise en el

Entorno de Aprendizaje (Unidad 1 - Contenidos y referentes
bibliográficos), las siguientes referencias:
B: 𝑓(𝑥) = 𝑒𝑥2 , centrado en 𝑥 = 0
Para cada uno de los ejercicios seleccionados realice un programa en
Python empleando el Jupyter Notebook que:
 Determine los polinomios de Taylor desde el grado cero (0)
hasta el grado cinco (5)
 Realice una gráfica comparativa con la evaluación de los
polinomios solicitados en el numeral anterior y determine cuál es
el error de truncamiento resultante en cada uno de los
polinomios hallados. Haga una gráfica del comportamiento del
error para cada polinomio.
 Haga un análisis de resultados basándose en la teoría y en los
resultados obtenidos. Debe incluir referencias a la bibliografía
empleada usando las normas APA. Comentarios sin referencias
no serán tenidos en cuenta.

Codigo Python

import matplotlib.pyplot as plt

import numpy as np

import math

a=0
x = np.arange(0,5,0.1)

fa = np.exp(a**2)

fx = np.exp(x**2)

p0=fa

p1=p0+((fa)*2*a)*(x - a)

p2=p1+(2*((fa)+(2*fa*(a**2)))/math.factorial(2))*((x - a)**2)

p3=p2+(2*((4*fa*(a**3))+(6*fa*a)))/math.factorial(3)*((x - a)**3)

p4=p3+(2*((8*fa*(a**4))+(24*fa*(a**2))
+(6*fa))/math.factorial(4))*((x - a)**4)

p5=p4+((32*(a**5)+(160*(a**3))+120*a)*fa)/math.factorial(5)*((x
- a)**5)

plt.plot(x,fx)

plt.plot(x,p1)

plt.xlabel('x')

plt.ylabel('y')

plt.title('P1')

plt.show()

plt.plot(x,fx)

plt.plot(x,p2)

plt.xlabel('x')
plt.ylabel('y')

plt.title('P2')

plt.show()

plt.plot(x,fx)

plt.plot(x,p3)

plt.xlabel('x')

plt.ylabel('y')

plt.title('P3')

plt.show()

plt.plot(x,fx)

plt.plot(x,p4)

plt.xlabel('x')

plt.ylabel('y')

plt.title('P4')

plt.show()

plt.plot(x,fx)

plt.plot(x,p5)

plt.xlabel('x')

plt.ylabel('y')
plt.title('P5')

plt.show()

y = 0.5

f2 = np.exp(y**2)

pa=p0+((fx)*2*a)*(y - a)

pb=pa+(2*((fx)+(2*fx*(a**2)))/math.factorial(2))*((y - a)**2)

pc=pb+(2*((4*fx*(a**3))+(6*fx*a)))/math.factorial(3)*((y - a)**3)

pd=pc+(2*((8*fx*(a**4))+(24*fx*(a**2))
+(6*fx))/math.factorial(4))*((y - a)**4)

pe=pd+((32*(a**5)+(160*(a**3))+120*a)*fx)/math.factorial(5)*((y
- a)**5)

e11=f2-pa

e21=f2-pb

e31=f2-pc

e41=f2-pd

e51=f2-pe

print(e1)

print(e2)

print(e3)

print(e4)
print(e5)
Ejercicio 3: Solución de ecuaciones no lineales
B: Considere la ecuación del movimiento de Kepler

𝑀 = 𝐸 − 𝑒 × 𝑠𝑒𝑛𝑜(𝐸)

relacionando la anomalía media 𝑀 con la anomalía excéntrica 𝐸 de una

órbita elíptica con excentricidad 𝑒. Para encontrar 𝐸, necesitamos
resolver la ecuación no lineal:
𝑓(𝐸) = 𝑀 + 𝑒 × 𝑠𝑒𝑛𝑜(𝐸) − 𝐸 = 0

Dada 𝑒 = 0.0167, la excentricidad de la tierra, y 𝑀 = 1, calcule el valor

de 𝐸.
Codigo Python

import math

def poli(x):

e=0.0167

M=1

fx=M+(e*math.sin(math.degrees(x)))-x

return (fx)

print("Calvular el valor E por el método de bisección")

xi=float(input('limite inferior: '))

xs=float(input('limite superior: '))

error=float((input('error maximo permitido: ')))

xf=(xi+xs)/2

i=0

signo=""

limite=""

print('{:^10}{:^10}{:^10}{:^10}{:^10}{:^10}
{:^10}'.format('#','L.inf','L.sup','Aprox','signo','cambio','error'))

while abs(poli(xf)) > error:

i=i+1

print('{:^10}{:^10.4f}{:^10.4f}{:^10.4f}{:^10}{:^10}
{:^10.4f}'.format(i,float(xi),float(xs),float(xf),signo,limite,float(poli(xf
))))

xf = (xi+xs)/2.0

if poli(xi)*poli(xf) < 0:

xs=xf

signo='Negativo'

limite='Superior'

else:
 xi=xf

signo='Positivo'

limite='Inferior'

print("El valor de E es de: ",xf)

Conclusiones

 El programa python permite recrear cualquier fórmula

matemática y cambiar sus variables a las necesidades de la
persona para obtener los resultados deseados

 También permite recrear gráficos de funciones y poder

compararlas entre si

 El programa de Python tiene limitaciones para algunos conceptos

matemáticos como lo son las derivadas ya que el programa no
permite calcularlas. Sino que uno mismo debe calcularlas a
mano y luego escribirlas para obtener la funcion deseada