def error (n,m, umbral): s=0 for i in range(m): apr1 = modulo.aproximacion(n) apr2 =modulo.aproximacion(n) if abs(modulo.aproximacion(n))-(modulo.aproximacion(n))> umbral: s+=1 porcentaje=float((float(s)/float(n))*100) return porcentaje
def error (n,m,umbral): s=0 for i in range(m): apr1 = modulo.aproximacion(n) apr2 =modulo.aproximacion(n) if abs(modulo.aproximacion(n))-(modulo.aproximacion(n))> umbral: s+=1 porcentaje=float((float(s)/float(n))*100) return porcentaje
def error(numero_intervalo, numero_test, umbral): errores=0.0 for i in range (numero_test): aprox1= modulo.aproximacion(numero_intervalo) aprox2= modulo.aproximacion(numero_test) resultado= aprox1 - aprox2 if abs(resultado)>= umbral: errores+=1 return (errores/numero_test)*100
def error(nro_intervalos, nro_test, umbral): recuento=0 for i in (0,nro_test): valor=modulo.aproximacion(nro_intervalos) if(abs(valor-modulo.PI)>umbral): recuento=recuento+1 porcentaje=(recuento/float(nro_test))*100 return porcentaje
def error(nro_intervalos,nro_test, umbral): contador=0 for i in range(nro_test): apri=modulo.aproximacion(nro_intervalos) error=abs(Pi-apri) if error>umbral: numero=numero+1 fallo=(nro_test/numero)*100 return fallo
def error (intervalo, n_test, umbral): fallos = 0 for i in range(n_test): apr = modulo.aproximacion (intervalo) diferencia = abs(modulo.PI - apr) if (diferencia > umbral): fallos += 1 porcentaje = (float(fallos)/float(n_test))*100 return porcentaje
def error(intervalo, n_test, umbral): fallos = 0 for i in range(n_test): apr = modulo.aproximacion(intervalo) diferencia = abs(modulo.PI - apr) if (diferencia > umbral): fallos += 1 porcentaje = (float(fallos) / float(n_test)) * 100 return porcentaje
def error (interv, test, umbral): # definimos la funcion fallo = 0 # inicializamos fallo for i in range ( 1, test+1): # recorremos la cantidad de la variable test aprox = modulo.aproximacion (interv) error = abs (aprox - PI) if error > umbral: # Suma la cantidad de errores que tiene fallo = fallo + 1 porcent = (fallo/ float (test))* 100 # inicializamos el porcentaje return porcent # devolvemos el porcentaje del error
#!/src/bin/python import modulo t_upla=(1e1,1e2,1e3,1e4,1e5,1e6,1e7) lista = [] def mostrar(lista): for l in range(0, m): dif = modulo.PI-l print ' PI35DT: %.35f lista: %f PI35DT-lista: %f ' % (modulo.PI,l,dif) for i in t_upla: y = modulo.aproximacion(i) lista = lista + [y] mostrar(lista) #El numero maximo de elementos de la t_upla es 7. #Al introducir el elemento 100000000 se producen errores de memoria. #Los elementos de la t_upla no se pueden definir en notación cientifica. #La expresion .pyc es el acronimo de "Copiled Python script file".
#! /usr/bin/python import modulo import sys if __name__ == '__main__': lista=[] t_upla=[10,100,1000,10000,100000] for i in range (0,len(t_upla)): a= modulo.aproximacion(t_upla[i]) lista=lista +[a]
#!/usr/bin/python #!encoding:UTF-8 import modulo valores = (10**1, 10**2, 10**3, 10**4, 10**5, 10**6, 10**7, 10**8) l = [] for valor in valores: j = modulo.aproximacion (valor) l = l + [j] print l # Cuando introduzco el número 200000000 ya muestra un error de memoria, con lo cual,podemos afirmar que es el número máximo de valores que podemos introducir. # Los elementos de la t-upla no los podemos definir en notación científica, porque los recibe como un número real, y nosotros en modulo habíamos declaro n de tipo entero. Al modificar en módulo n = int(nn), transforma el número introducido a tipo entero, con lo que sí recibe números reales. # La extensión .pyc permite llamar al documento de una forma más rápida que con .py, pero no ahorra nada de tiempo en relación a la interpretación. # Para poder calcular el tiempo necesitamos de una función.
#!ecoding: UTF-8 import modulo import time nro_test=10 intervalos=[10, 50, 100, 150, 500, 550, 1000, 10000, 100000] umbral=[1e-3, 1e-4, 1e-5, 1e-6, 1e-7] nombre = "prac12.txt" #Abrimos el archivo y escribimos, como cabecera, el orden en el que almacenaremos los datos. f=open(nombre, 'w') f.write ('Intervalos, Valor aproximado, Porcetaje de fallos, Tiempo CPU \n ') f.write('============================ \n') # Vamos a for n in intervalos: p=[] p=p+[n] a=modulo.aproximacion(n) p=p+[a] ci=time.clock() for e in umbral: e=modulo.error(n, nro_test, e) p=p+[e] cf=time.clock() tp=cf-ci p=p+[tp] f.write(str(p)) f.write("\n") f.close()
def error (interv, test, umbral): fallo = 0 for i in range ( 1, test+1): aprox = modulo.aproximacion (interv)
import modulo t_uplas=(10,100,1000,10000,100000,1000000) l=[] for i in range(len(t_uplas)): m=modulo.aproximacion(t_uplas[i]) l=l+[m] print l #El numero maximo de la t_upla es 6 y se producen errores a partir de 8. Los elemenotos de la t_upla sí se pueden definir en notación científica. .pyc permite a python ejecutar archivos de otros formatos.
#!/src/bin/python import modulo import time nro_test = 10 intervalos = [10, 50, 100, 150, 500, 550, 1000] umbral = [1e-3, 1e-4, 1e-5, 1e-6, 1e-7] nombre = "prct12_b.txt" f = open(nombre, 'w') f.write('Intervalos, Valor aproximado, Porcetaje de fallos, Tiempo CPU \n ') f.write('============================ \n') for n in intervalos: p = [] p = p + [n] a = modulo.aproximacion(n) p = p + [a] ci = time.clock() for e in umbral: e = modulo.error(n, nro_test, e) p = p + [e] cf = time.clock() tp = cf - ci p = p + [tp] f.write(str(p)) f.write("\n") f.close()
import modulo t_upla=(10,100,1000,10000,100000,1000000,10000000,100000000) for i in range(0, len(t_upla[i])): print modulo.aproximacion(t_upla[i]) # El numero maximo de elmentos de la t_upla es de 8 # se producen para 9 o mas elementos # No