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