0% encontró este documento útil (0 votos)
158 vistas16 páginas

G-48 Tarea 1

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1/ 16

METODOS NUMERICOS

Tarea 2 - Fundamentos de programación, Teoría de Errores y Solución de Ecuaciones No


Lineales

Presentado a:
Edgar Andres Villabon
Tutor

Entregado por:
Marisol Oviedo Jaimes
Código: 1096957972
Alvaro Celis Bedoya

Grupo: 100401_48

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA - UNAD


ESCUELA DE CIENCIAS BÁSICAS, INGENIERÍAS Y TECNOLOGÍAS
MÁLAGA
Octubre.
2020
INTRODUCCION

Este trabajo tiene como aplicar los fundamentos básicos de un lenguaje de programación con la

identificación clara de los conceptos de la teoría de error correctamente en la resolución de

ecuaciones no lineales, a través de ejercicios de temáticas tales como: Fundamentos de

Programación, Teoría de Errores y la Solución de ecuaciones no lineales. Para ello se realizo un

video explicando uno de los ejercicios, los cuales son realizados en el programa jupyter notebook

y presentados en extensión phyton, por lo cual es importante conocer más a profundidad el

mismo.
OBJETIVOS

Objetivo General

Aplicar los fundamentos básicos de un lenguaje de programación con la identificación clara de


los conceptos de la teoría de error correctamente en la resolución de ecuaciones no lineales.

Objetivos Específicos

 Dar solución a los ejercicios en el programa phyton.


 Conocer mas a profundidad las temáticas planteadas para la actividad.
 Identificar la importancia de utilizar phyton en la solución de ecuaciones, programación y
teoría de error.
EJERCICIOS DESARROLLADOS
Ejercicio B: Marisol Oviedo Jaimes
Ejercicio 1. Fundamentos de Programación. 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:
A=1/2 | ∑(i=1)^n▒〖x_i (y(i+1)-y_(i-1))〗|, En donde A es el área del polígono, n es el número de
lados del polígono, (x_i,y_i) las coordenadas del vértice i-ésimo Y por tratarse de un polígono
cíclico, x_(n+1)=x_1 x_n=x_0 Al igual que y_(n+1)=y_1 y_n=y_0 Gráficamente los resultados

representan: 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. • 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. • Defina
un módulo llamado salida.py que contenga una función llamada “pares” que muestre por pantalla
los pares ordenados de las coordenadas de los puntos del polígono, y otra función llamada
areaPoligono que muestre el valor del área calculada, con un mensaje adecuado y sin
ambigüedad. • 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.

# module entrada.py
def entrada():
n=int(input("Por favor digite el número de lados del polígono "))
print("Usted digitó: {0}".format(n))
return n

# module calculos.py
from math import *
def areaPoligono(n):
xlist = []
ylist = []
for k in range(1, n+1):
x = int(input("x_{0} = ".format(k)))
xlist.append(x)
y = int(input("y_{0} = ".format(k)))
ylist.append(y)
sum = 0
for i in range(len(xlist)):
indexf = i+1
if indexf >= n:
indexf %= n
indexb = i-1
if indexb < 0:
indexb += n
#print("{0}, {1}, {2}".format(i, indexf, indexb))
sum += xlist[i] * (ylist[indexf]-ylist[indexb])

sum = abs(sum)/2.0
return sum

def calculos(n):
print("El área del polígono es {0}: ".format(areaPoligono(n)))
# module main.py
n = entrada()
print(n)
calculos(n)

Por favor digite el número de lados del polígono 3


Usted digitó: 3
3
x_1 = 2
y_1 = 2
x_2 = -2
y_2 = 2
x_3 = 0
y_3 = -2
El área del polígono es 8.0:

Link video:
https://www.youtube.com/watch?v=8O2gGGmsY5U

Ejercicio D: Alvaro Celis

Ejercicio 1. Con la siguiente secuencia de números decimales y sus respectivos valores en


números romanos, se puede construir cualquier secuencia de números romanos: M = 1000; CM =
900; D = 500; CD = 400; C = 100; XC = 90; L = 50; XL = 40; X = 10; IX = 9; V = 5; IV = 4; I =
1

• Genere un módulo en Python llamado convertir y que contenga las funciones indicadas más
abajo.

Construya una función en Python llamada dec2floatList que reciba como argumento un número
escrito en forma decimal y devuelva su representación en número flotante, empleando listas.

• Construya una función en Python llamada dec2floatDic que reciba como argumento un número
escrito en forma decimal y devuelva su representación en número flotante, empleando
diccionarios.

• Construya un programa en Python que llame las funciones indicadas arriba y escriba los
resultados de las funciones anteriores en un archivo de texto, con el siguiente mensaje: El número
dec en decimales corresponde a rom en números romanos.
En donde dec y rom son los valores de los números en decimales y en romanos, respectivamente,
por Ejemplo, en el archivo de texto debe aparecer:

El número 12 en decimales corresponde a XII en números romanos

def dec2floatList(numeroEntero):

numerosRomanos = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']

numerosNaturales = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]

numeroSalida = ''

i=0

while numeroEntero > 0 :

for _ in range(numeroEntero // numerosNaturales[i]) :

numeroSalida += numerosRomanos[i]

numeroEntero -= numerosNaturales[i]

i += 1

return numeroSalida

def dec2floatDic(numero):

miDiccionario = {1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC',

50:'L', 40:'XC', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}

numerosNaturales = miDiccionario.keys()

numeroSalida = ''

for numeroNatural in numerosNaturales:


while numeroNatural <= numero:

numeroSalida += miDiccionario[numeroNatural]

numero -= numeroNatural

return numeroSalida

print (dec2floatList(456))

print (dec2floatDic(456))

CDLVI
CDLVI

EJERCICIO 2
Ejercicio B: Marisol Oviedo Jaimes
Ejercicio 2. Teoría de Errores. 𝑓(𝑥)=𝑒𝑥2 , centrado en 𝑥=0 . 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.
Desde la teoría expansiones de funciones en series de potencias, usamos la fórmula de Taylor
𝑓(𝑥)=∑∞𝑛=01𝑛!𝑓(𝑛)(𝑎)(𝑥−𝑎)𝑛
Sabemos del curso de cálculo que la función 𝑒𝑥 expandida alrededor de 0 es
𝑒𝑥=1+𝑥+12!𝑥2+13!𝑥3+…
si reemplazamos 𝑥 por 𝑥2, nos queda
𝑒𝑥2=1+𝑥2+12!𝑥4+13!𝑥6+…
manteniendo a orden 5 nos queda
𝑒𝑥2=1+𝑥2+12𝑥4

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
from math import *
def f(x):
exp(pow(x,2))

# Data for plotting


xp = np.arange(-1.2, 1.2, 0.01)
fp = np.exp(xp*xp)
gp = 1 + xp*xp + 0.5 * xp*xp*xp*xp
error = fp - gp
print(type(xp))
print(type(fp))

fig, ax = plt.subplots()
ax.plot(xp, fp)
ax.plot(xp, gp)
ax.plot(xp, error)

ax.set(xlabel='x', ylabel='f(x)',
title='About as simple as it gets, folks')
ax.grid()
#ax.legend()

fig.savefig("test.png")
plt.show()
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>

Vemos en azul a la función original, en naranja a la aproximación dada por la teoría, y en


verde el plot del error.

Ejericio d: Alvaro Celis Bedoya

Ejercicio 2. 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.

import numpy as np

import matplotlib.pyplot as plt

from sympy import init_session

init_session(quiet=True)
print('{:^52} {:^15} {:^23}'.format('Polinomio', 'Resultado', 'Error de Truncamiento'))

print('{:-^52} {:-^14} {:-^24}'.format( '-', '-', '-', '-', '-', '-'),)

fmto = '{!s:>52} | {:14.10f} | {:17.10f}'

f = 1/(2-x)

valor = f.subs(x,0.5)

poly = []

for i in range(1,7):

coef = f.series(x0=0, n=i).removeO()

poly.append(coef)

respuesta = coef.subs(x,0.5).evalf()

eT = valor - respuesta

print(fmto.format(coef, respuesta, eT))

Polinomio Resultado Error de Truncamiento


---------------------------------------------------- --------------
------------------------
1/2 | 0.5000000000 |
0.1666666667
x/4 + 1/2 | 0.6250000000 |
0.0416666667
x**2/8 + x/4 + 1/2 | 0.6562500000 |
0.0104166667
x**3/16 + x**2/8 + x/4 + 1/2 | 0.6640625000 |
0.0026041667
x**4/32 + x**3/16 + x**2/8 + x/4 + 1/2 | 0.6660156250 |
0.0006510417
x**5/64 + x**4/32 + x**3/16 + x**2/8 + x/4 + 1/2 | 0.6665039062 |
0.0001627604

x = np.linspace(0, 1, 100)

grafica = plt.figure()
grafica.set_figwidth(grafica.get_figwidth() * 4.0)

graf = []

graf.append(grafica.add_subplot(1, 2, 1))

poly_0 = 1/2

poly_1 = x/4 + 1/2

poly_2 = x**2/8 + x/4 + 1/2

poly_3 = x**3/16 + x**2/8 + x/4 + 1/2

poly_4 = x**4/32 + x**3/16 + x**2/8 + x/4 + 1/2

poly_5 = x**5/64 + x**4/32 + x**3/16 + x**2/8 + x/4 + 1/2

graf[0].plot(x, poly_1, 'b')

graf[0].plot(x, poly_2, 'g')

graf[0].plot(x, poly_3, 'm')

graf[0].plot(x, poly_4, 'y')

graf[0].plot(x, poly_5, 'k')

graf[0].plot(x, 1/(2-x), 'r')

graf[0].plot(0, 1, 'o', markersize=11)

graf[0].grid(True)

graf[0].set_title("La funcion $f(x) = 1/({2-x})$")

graf[0].set_xlabel("x")

graf[0].set_ylabel("$f(x)$, $P_1(x)$, $P_2(x)$, $P_3(x)$, $P_4(x)$, $P_5(x)$")

graf[0].legend(["$Polinomio_0(x) = 1/2 $",

"$Polinomio_1(x) = 1 / 2 + x / 4$",

"$Polinomio_2(x) = 1 / 2 + x / 4 + \frac{x^{2}/8}$",
"$Polinomio_3(x) = 1 / 2 + x / 4 + \frac{x^{2}/8}$",

"$Polinomio_4(x) =1 / 2 + x / 4 + \frac{x^{2}/8}$",

"$f(x) = 1/({2-x}) $"], loc = 2)

Grafica

EJERCICIO 3

Ejercicio B: Marisol Oviedo

Ejericio d: Álvaro Celis Bedoya

Ejercicio 3. Energía Eólica – Molino de viento: Cada vez es más común utilizar turbinas eólicas
para generar energía eléctrica. La producción de energía de la potencia generada por un molino
de viento depende del diámetro de la pala y la velocidad del viento. La siguiente fórmula
proporciona una buena estimación de la producción de energía:

𝐸𝑂=0.01328𝐷2𝑉3

Donde 𝐸𝑂 es la energía generada, 𝐷 es el diámetro de una pala del molino (m), 𝑉 es la velocidad
del viento (m/s). Determine cuál debería ser el diámetro de la pala del molino, en metros, si se
desea generar 500 𝑤𝑎𝑡𝑡𝑠 de potencia eléctrica cuando la velocidad del viento es 10 𝑚𝑝ℎ (millas
por hora).
#librerias

import math

#Convertir millas a metros por segundos

def convertirvelocidad(V):

#convertimos mps a m/s

mph = 0.44704

resultado = V * mph

return resultado

#Determinar el diametro de la ecuacion

def ecuacion():

#Variables, Energia Genedar, Diametro de la pala de un molino, Velocidad

Eo= 500

V = convertirvelocidad(10) **3

calculo = math.sqrt(Eo / V * 0.01328)

resultado= round(calculo, 4)

return 'El Diametro De La Pala Del Molino Es: ' + str(resultado) + ' Metros'

#Salida

print(ecuacion())

El Diametro De La Pala Del Molino Es: 0.2726 Metros

Link del video subido a YouTube

https://www.youtube.com/watch?v=hd-cC8Rg6Zk&feature=youtu.be
Conclusiones
 Se logra entregar los ejercicios matemáticos en el programa sugerido por la Guía la cual
es Python.
 Dar solución a problemas y ecuaciones en la herramienta Python es una buena alternativa
ya que es un lenguaje de programación, muy sencillo y fácil, su sintaxis es fácil de
entender puesto que es cercana al lenguaje natural, y los programas hechos en Python
parecen pseudocódigos, lo cual brinda una gran ayuda en su mantenimiento.

 El desarrollo de los ejercicios en este lenguaje de programación evita realizar demasiadas


operaciones y hace el ejercicio mas corto, llegando a una solución mas fácilmente.
Bibliografía

 Algar Díaz, M. J. y Fernández de Sevilla Vellón, M. (2019). Introducción práctica


a la programación con Python. Servicio de Publicaciones. Universidad de Alcalá.
https://elibro-net.bibliotecavirtual.unad.edu.co/es/ereader/unad/124259

 Toomey, D. (2016). Learning Jupyter. Packt Publishing (pp. 7 – 57). Recuperado


de https://bibliotecavirtual.unad.edu.co/login?
url=http://search.ebscohost.com/login.aspx?
direct=true&db=nlebk&AN=1430766&lang=es&site=eds-live&scope=site

 Canale, R. P. y P. Canale, R. (2007). Métodos numéricos para ingenieros (5a. ed.).


México D.F, Mexico: McGraw-Hill Interamericana. (pp. 78–90). Recuperado de
https://elibro-net.bibliotecavirtual.unad.edu.co/es/lc/unad/titulos/73710

 Canale, R. P. y P. Canale, R. (2007). Métodos numéricos para ingenieros (5a. ed.).


México D.F, Mexico: McGraw-Hill Interamericana. (pp. 113–116, 120–159).
Recuperado de https://elibro-
net.bibliotecavirtual.unad.edu.co/es/lc/unad/titulos/73710

También podría gustarte