Andrés Mora Zúñiga B14463 Laboratorio 9 Parte Uno La primera

Nota: 100
Andrés Mora Zúñiga
B14463
Laboratorio 9
Parte Uno
La primera parte del laboratorio consistía en utilizar el método de Newton para el calculo de las raíces
reales de un polinomio de grado n. La solución a esta parte del laboratorio me quedó así:
#! /usr/bin/python
# -*- coding: utf-8 -*import sys
#Primero se asegura que el numero de argumentos sea el minimo correcto.
if len(sys.argv) < 4 :
print 'Numero insfuciente de argumentos'
print 'Debe introducir minimo un polinomio de grado 1 para calcular la solucion real cerca del punto
establecido'
print 'Los datos deben ir: coeficientes-del-polinomio punto-referente'
sys.exit(1)
# Se declaran las variables con las cuales se va a trabajar.
variables = len(sys.argv) - 2
coeficientes = []
derivados = []
punto = int(sys.argv[len(sys.argv)-1])
valorfx = 0
valordfx = 0
#Define los coeficientes de la funcion original en un vector utilizando la linea de entrada de comandos
def coef():
for i in range (0, variables):
coeficientes.append(int(sys.argv[i+1]))
# Define los coeficientes de la derivada con base a los coeficientes de la original.
def coefderiv():
for n in range (0, variables-1):
derivados.append(int(coeficientes[n]) * (variables - (n+1)))
derivados.append(0)
# Evalua la funcion en un punto enviado como parametro.
def funcionevaluada(x):
a=0
for i in range (0, variables):
a += coeficientes[i]*(x**(variables-i-1))
return a
# Evalua la derivada de la funcion en un punto enviado como parametro.
def derivadaevaluada(x):
b=0
for i in range (0, variables):
b += derivados[i]*(x**(variables-i-2))
return b
# Utiliza el metodo de Newton para calcular la aproximacion.
def aproximacion():
x = punto
for i in range (0, 20):
valorfx = funcionevaluada(x)
valordfx = derivadaevaluada(x)
x = x - (valorfx/valordfx)
return x
# Orden logico de la ejecucion de comandos para que el programa funciones adecuadamente
coef()
coefderiv()
print aproximacion()
El método coef() me define mediante un algoritmo simple, un vector que contiene los coeficientes de la
función original.
El método coefderiv() realiza algo similar pero con los coeficientes de la derivada de la función.
Los métodos funcionevaluada() y derivadaevaluada(), me hacen exactamente eso, evaluar las funciones
en un punto variante que se ingresa como un parámetro.
Finalmente el método aproximación es el que implimenta todos los métodos anteriores con el fin de
llevar a cabo el algoritmo de Newton para hallar las raíces reales del polinomio de grado n.
Este método toma un punto x definido por el usuario y le aplica el algoritmo, aumentando o
disminuyendo el el valor de este punto y luego volviendo a evaluar todo hasta que se estabilice. El
programa realiza las iteraciones 20 veces para que la aproximación sea buena.
Parte Dos
Esta parte tenía como finalidad utilizar el método de Euler para encontrar la tensión como una función
variante en el tiempo debido a las variantes de la carga por este mismo. El programa debía de calcular
las tensiones variantes en el tiempo varias veces, e imprimir en un archivo todos los valores de la
tensión referentes a un tiempo específico hasta llegar al tiempo final. Los pasos también eran definidos
por el usuario. El programa me quedó así:
#! /usr/bin/python
# -*- coding: utf-8 -*import sys
#Primero se asegura que el numero de argumentos sea el correcto.
if not len(sys.argv) == 6:
print 'Ingreso un numero incorrecto de argumentos\nDebe de ingresar R C V paso tiempo-final'
sys.exit(1)
# De ser correcto, procede a asignar los valores con los que se va a trabajar, R resitencia, C
capacitancia, V tension, paso, tf Tiempo Final, y se establencen los valores qt carga variante en el
tiempo y ti tiempo inicial en 0 como valores iniciales.
R = float(sys.argv[1])
C = float(sys.argv[2])
V = float(sys.argv[3])
paso = float(sys.argv[4])
tf = float(sys.argv[5])
qt = 0
ti = 0
# Este metodo es el utilizado para evaluar la derivada, recibe los argumentos dados por el usuario y un
q variante.
def evaluar(q, R, C, V):
dq = (C*V-q)/(C*R)
return dq
# Se crea el archivo CSV para escritura de resultados.
CSV = open('Valores de tiempo y tension', 'w')
# A partir de aqui el programa implementa el metodo de euler para encontrar la tension e imprime los
resultados en el archivo establecido.
while ti < tf:
devaluada = evaluar(qt, R, C, V)
ti += paso
qt = qt + paso * devaluada
tension = qt * C
resultado = '%.3f , %f' %(ti, tension)
print >> CSV, resultado
El orden lógico del programa es el siguiente:
1. Se verifica que la cantidad de argumentos ingresados sea el correcto para poder llegar a la
solución correcta del problema, de lo contrario el programa no se ejecuta.
2. Luego de verificar que la cantidad es correcta, procede al almacenar en variables las entradas
del vector de línea de comandos para una manipulación mas sencilla.
3. Se define el método que deja calcular las variaciones de la carga con respecto al tiempo y se
nombra evaluar().
4. Se crea el archivo CSV sobre el cual se van a imprimir los datos de tensiones y tiempo.
5. Y se implementa el método de Euler para calcular la tensión.
En el método de Euler se evalua la derivada, se aumenta el paso en uno, y se le agrega al valor original
de la carga la derivada evaluada por la longitud del paso para ir aumentando poco a poco la carga y
obteniendo valores bastante aproximados para la tensión en un tiempo que avanza desde el inicial = 0 ,
hasta el final en pasos definidos por el usuario.
El archivo de valores de tiempo contra tensión se obtuvo al ingresar los valores:
R = 100
C=1
V = 10
paso = 0.01
tiempo final = 10
Nota: el archivo se adjunta como parte de la solución del laboratorio.