def test_integral_of_constant_function():
# test integrate
assert abs(integrate(f1,0,1,1)-2)<= 1E-15
#print ("lol",abs(integrate(f1,0,1,10000)-float(2)))
assert abs(integrate(f1,0,1,10)-2)<= 1E-12
assert abs(integrate(f1,0,1,100)-2)<= 1E-12
assert abs(integrate(f1,0,1,1000)-2)<= 1E-12
assert abs(integrate(f1,0,1,10000)-2)<= 1E-12
# test numpy integrate
assert abs(numpy_integrate(f1,0,1,1)-2)<= 1E-15
#print ("lol",numpy_integrate(f1,0,1,10),abs(numpy_integrate(f1,0,1,10)-float(2)))
assert abs(numpy_integrate(f1,0,1,10)-2)<= 1E-12
assert abs(numpy_integrate(f1,0,1,100)-2)<= 1E-12
assert abs(numpy_integrate(f1,0,1,1000)-2)<= 1E-12
assert abs(numpy_integrate(f1,0,1,10000)-2)<= 1E-12
# test Cython
assert abs(cython_integrate(f1,0,1,1)-2)<= 1E-15
#print ("lol",numpy_integrate(f1,0,1,10),abs(numpy_integrate(f1,0,1,10)-float(2)))
assert abs(cython_integrate(f1,0,1,10)-2)<= 1E-12
assert abs(cython_integrate(f1,0,1,100)-2)<= 1E-12
assert abs(cython_integrate(f1,0,1,1000)-2)<= 1E-12
assert abs(cython_integrate(f1,0,1,10000)-2)<= 1E-12
def test_integral_of_linear_function():
# test integrate
N1=10
#print ("here",abs(1-integrate(f2,0,1,N1)-(float(1)/float(N1))))
assert abs(1-integrate(f2,0,1,N1)-(float(1)/float(N1))) <= 1E-15
N2=100
assert abs(1-integrate(f2,0,1,N2)-(float(1)/float(N2))) <= 1E-15
N3=1000
assert abs(1-integrate(f2,0,1,N3)-(float(1)/float(N3))) <= 1E-15
N4=10000
assert abs(1-integrate(f2,0,1,N4)-(float(1)/float(N4))) <= 1E-15
# test numpy integrate
N1=10
assert abs(1-numpy_integrate(f2,0,1,N1)-(float(1)/float(N1))) <= 1E-15
N2=100
assert abs(1-numpy_integrate(f2,0,1,N2)-(float(1)/float(N2))) <= 1E-15
N3=1000
assert abs(1-numpy_integrate(f2,0,1,N3)-(float(1)/float(N3))) <= 1E-15
N4=10000
assert abs(1-numpy_integrate(f2,0,1,N4)-(float(1)/float(N4))) <= 1E-15
# test Cython
N1=10
assert abs(1-cython_integrate(f2,0,1,N1)-(float(1)/float(N1))) <= 1E-15
N2=100
assert abs(1-cython_integrate(f2,0,1,N2)-(float(1)/float(N2))) <= 1E-15
N3=1000
assert abs(1-cython_integrate(f2,0,1,N3)-(float(1)/float(N3))) <= 1E-15
N4=10000
assert abs(1-cython_integrate(f2,0,1,N4)-(float(1)/float(N4))) <= 1E-15
def integrate(f, a, b, n, method="default", implementation="default"):
sum_of_integral = 0
if implementation == "default":
if method == "default":
sum_of_integral = integrate_default(f, a, b, n)
elif method == "midpoint":
sum_of_integral = midpoint_integrate(f, a, b, n)
if implementation == "numpy":
if method == "default":
sum_of_integral = numpy_integrator.numpy_integrate(f, a, b, n)
elif method == "midpoint":
sum_of_integral = numpy_integrator.numpy_midpoint_integrate(
f, a, b, n)
if implementation == "numba":
if method == "default":
sum_of_integral = numba_integrator.numba_integrate(f, a, b, n)
elif method == "midpoint":
sum_of_integral = numba_integrator.numba_midpoint_integrate(
f, a, b, n)
if implementation == "cython":
if method == "default":
sum_of_integral = cython_integrator.cython_integrate(f, a, b, n)
elif method == "midpoint":
sum_of_integral = cython_integrator.cython_midpoint_integrate(
f, a, b, n)
return sum_of_integral
def test_integral_of_linear_function():
expected_answer = 1
f = lambda x: 2*x; a = 0; b = 1; N = 1000000
computed_answer = numpy_integrate(f, a, b, N)
#assert abs(computed_answer - expected_answer) < 1E-20, "Computational error to large!"
if abs(computed_answer - expected_answer) < (1./N):
print ("Computation ok")
else:
print ("Computational error to large, error = %f" % (1./N))
def test_integral_of_constant_function():
#abs(computed_answer - expected_answer) < 1E-20
expected_answer = 2
f = lambda x: 2; a = 0; b = 1; N = 1000000
#vetorize f to avoid function turning to constant
f = np.vectorize(f)
computed_answer = numpy_integrate(f, a, b, N)
print (computed_answer)
#assert abs(computed_answer - expected_answer) < 1E-20, "Computational error to large!"
if abs(computed_answer - expected_answer) < 1E-10:
print ("Computation ok")
else:
print ("Computational error to large!")
def timings():
N = int(1e7)
def a(x):
return x**2
start_time = time.time()
C = numba_integrate(a, 0, 1, N)
E = time.time() - start_time
print("Python with numba time: %f seconds. With N=%.0e" % (E, N))
start_time_ = time.time()
A = integrate(a, 0, 1, N)
E = time.time() - start_time
print("Normal Python code time: %.5f. With N=%.0e" % (E, N))
start_time = time.time()
B = numpy_integrate(a, 0, 1, N)
E = time.time() - start_time
print("Numpy code time: %f seconds. With N=%.0e" % (E, N))
def test_integral_with_numpy_contest():
computed_answer1 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 3)) / (x / 3)) * (np.sin((x / 5)) / (x / 5))), 0, 50, 10000)
print("første: ", computed_answer1)
computed_answer2 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 3)) / (x / 3)) * (np.sin((x / 5)) / (x / 5)) * (np.sin(
(x / 7)) / (x / 7))), 0, 50, 10000)
print("andre: ", computed_answer2)
computed_answer3 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 3)) / (x / 3)) * (np.sin((x / 5)) / (x / 5)) * (np.sin(
(x / 7)) / (x / 7)) * (np.sin((x / 9)) / (x / 9)) * (np.sin(
(x / 11)) / (x / 11))), 0, 50, 10000)
print("tredje: ", computed_answer3)
computed_answer4 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 3)) / (x / 3)) * (np.sin((x / 5)) / (x / 5)) * (np.sin(
(x / 7)) / (x / 7)) * (np.sin((x / 9)) / (x / 9)) * (np.sin(
(x / 11)) / (x / 11)) * (np.sin((x / 13)) / (x / 13))), 0,
50, 10000)
print("fjerde: ", computed_answer4)
computed_answer5 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 3)) / (x / 3)) * (np.sin((x / 5)) / (x / 5)) * (np.sin(
(x / 7)) / (x / 7)) * (np.sin((x / 9)) / (x / 9)) * (np.sin(
(x / 11)) / (x / 11)) * (np.sin((x / 13)) / (x / 13)) *
(np.sin((x / 15)) / (x / 15))), 0, 50, 10000)
print("femte: ", computed_answer5)
computed_answer6 = numpy_integrate(
lambda x: ((1 / np.pi) * (np.sin(x) / x) * (np.sin(
(x / 4)) / (x / 4)) * (np.sin((x / 4)) / (x / 4)) * (np.sin(
(x / 7)) / (x / 7)) * (np.sin((x / 7)) / (x / 7)) * (np.sin(
(x / 9)) / (x / 9)) * (np.sin((x / 9)) / (x / 9))), 0, 50,
10000)
print("sjette: ", computed_answer6)
def test_numpy_integral_of_linear_function():
def f(x):
return 2 * x
for i in range(1, 4):
assert numpy_integrate(f, 0, 1, 10**i) - 2 < 1E20
def test_numpy_integral_of_constant_function():
def f(x):
return 2
for i in range(1, 4):
assert numpy_integrate(f, 0, 1, 10**i) - 2 < 1E20
approx = 0
i = 1
while abs(approx - float(2.0)) > 10e-10:
#for i in range(1,10):
#print ("here",i,integrate(f5,0, math.pi,i*1000))
approx = integrate(f5, 0, math.pi, i * 1000)
i = i + 1
print("iterations required with integrate", i)
approx = 0
i = 1
while abs(approx - float(2.0)) > 10e-10:
#for i in range(1,3):
#print ("here",i,numpy_integrate(f5,0, math.pi,i*1000))
approx = numpy_integrate(f5, 0, math.pi, i * 1000)
i = i + 1
print("iterations required with numpy_integrate", i)
approx = 0
i = 1
while abs(approx - float(2.0)) > 10e-10:
#for i in range(1,10):
#print ("here",i,integrate(f5,0, math.pi,i*1000))
approx = numba_integrate(f5, 0, math.pi, i * 1000)
i = i + 1
print("iterations required with numba_integrate", i)
approx = 0
i = 1
while abs(approx - float(2.0)) > 10e-10:
from integrator import integrate
from numpy_integrator import numpy_integrate
def f(x):
return x**2
print(integrate(f, 0, 1, 10000))
print(numpy_integrate(f, 0, 1, 10000))
def test_numpy_integrate_linear_function():
computed_ans = numpy_integrate(f2, 0, 1, 10) #N = 10
assert abs(1.0 - computed_ans) < (1.0 / 10 + 1E-10)
computed_ans = numpy_integrate(f2, 0, 1, 1000000) #N = 1000000
assert abs(1.0 - computed_ans) < (1.0 / 1000000 + 1E-10)
def test_numpy_integrate_constant_function():
f1 = vectorize(f)
computed_ans = numpy_integrate(f1, 0, 1, 10) #N = 10
assert abs(2.0 - computed_ans) < 1E-10
computed_ans = numpy_integrate(f1, 0, 1, 10000) #N = 10000
assert abs(2.0 - computed_ans) < 1E-10
#!/usr/bin/python """Import integrate function from integrator.py""" from math import pi, sin from integrator import integrate, midpoint_integrate from numpy_integrator import numpy_integrate, midpoint_numpy_integrate from numba_integrator import numba_integrate, midpoint_numba_integrate import cython_integrator #def comparison(f, a, b, N): a = 0 b = pi f = lambda x: sin(x) N = 100000 exact_answer = 2.0 integrate(f, a, b, N) midpoint_integrate(f, a, b, N) numpy_integrate(f, a, b, N) midpoint_numpy_integrate(f, a, b, N) numba_integrate(f, a, b, N) midpoint_numba_integrate(f, a, b, N) cython_integrator.cython_integrate(a, b, N) cython_integrator.midpoint_cython_integrate(a, b, N)
def test_numpy_integral_of_constant_function(N): f = lambda x: 2 #Test function computed_answer = numpy_integrate(f,0,1,N) expected_answer = 2 assert abs(computed_answer-expected_answer) < 1**(-20)
def test_numpy_integrals_of_linear_function(N,c=1): #c scales error (order of 1/N) f = lambda x: 2*x computed_answer = numpy_integrate(f,0,1,N) expected_answer = float(1) error = float(c)/N assert abs(computed_answer-expected_answer) < error
#FOR MIDPOINT INTEGRATE
for n in range(100, N, jump):
I = midpoint_integrate(f, 0, pi, n)
if abs(I - 2.0) < 10**(-10):
print(
"N needs to be %d or higher to have an error less than 10^(-10) \nwhen integrating with midpoint_integrate"
% (n))
break
else:
if n >= N - jump:
print("Didn't find a large enough N")
#FOR NUMPY INTEGRATE
for n in range(100, N, jump):
I = numpy_integrate(f, 0, pi, n)
if abs(I - 2.0) < 10**(-10):
print(
"N needs to be %d or higher to have an error less than 10^(-10) \nwhen integrating with numpy_integrate"
% (n))
#print("I = %f" % (I))
break
else:
if n >= N - 1:
print("Didn't find a large enough N")
#FOR NUMPY MIDPOINT INTEGRATE
for n in range(100, N, jump):
I = numpy_midpoint_integrate(f, 0, pi, n)
if abs(I - 2.0) < 10**(-10):
print(
