sm/smbinterp
1
0
Fork 0
Code Issues Pull Requests Activity

Major: made scripts pass pep8 and pyflakes

Browse Source
This commit is contained in:
Stephen M. McQuay
2011-09-17 15:38:49 -06:00
parent 1bc797a14d
commit 837a72b246
17 changed files with 835 additions and 866 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/all.py
+10 -10
View File
@@ -11,14 +11,14 @@ import quadratic2d
if __name__ == '__main__':
tests = [
unittest.TestLoader().loadTestsFromTestCase(baker2dorder.Test),
unittest.TestLoader().loadTestsFromTestCase(baker2d.Test),
unittest.TestLoader().loadTestsFromTestCase(baker3d.Test),
unittest.TestLoader().loadTestsFromTestCase(cubic2d.Test),
unittest.TestLoader().loadTestsFromTestCase(pattern.Test),
unittest.TestLoader().loadTestsFromTestCase(quadratic2d.Test),
]
tests = [
unittest.TestLoader().loadTestsFromTestCase(baker2dorder.Test),
unittest.TestLoader().loadTestsFromTestCase(baker2d.Test),
unittest.TestLoader().loadTestsFromTestCase(baker3d.Test),
unittest.TestLoader().loadTestsFromTestCase(cubic2d.Test),
unittest.TestLoader().loadTestsFromTestCase(pattern.Test),
unittest.TestLoader().loadTestsFromTestCase(quadratic2d.Test),
]
for test in tests:
unittest.TextTestRunner(verbosity=3).run(test)
for test in tests:
unittest.TextTestRunner(verbosity=3).run(test)
test/baker2d.py
+108 -108
View File
@@ -2,154 +2,154 @@
import unittest
from interp import baker
from interp import grid
from interp import baker
import numpy as np
import scipy.spatial
class Test(unittest.TestCase):
def setUp(self):
self.l = [[-1, 1], [-1, 0], [-1, 1], [0, -1], [0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]
self.all_points = [
[ 0, 0], # 0
[ 1, 0], # 1
[ 1, 1], # 2
[ 0, 1], # 3
[ 1,-1], # 4
[ 0,-1], # 5
[-1, 1], # 6
[-1, 0], # 7
[-1,-1], # 8
]
self.q = [1, 0, 0, 0, 0, 0, 0, 0, 0]
self.X = [0.5, 0.25]
self.accuracy = 8
def setUp(self):
self.l = [[-1, 1], [-1, 0], [-1, 1], [0, -1],
[0, 0], [0, 1], [1, -1], [1, 0], [1, 1]]
self.all_points = [
[0, 0], # 0
[1, 0], # 1
[1, 1], # 2
[0, 1], # 3
[1, -1], # 4
[0, -1], # 5
[-1, 1], # 6
[-1, 0], # 7
[-1, -1], # 8
]
self.q = [1, 0, 0, 0, 0, 0, 0, 0, 0]
self.X = [0.5, 0.25]
self.accuracy = 8
def testImports(self):
import numpy
import scipy
import interp.grid
import interp.baker
def testImports(self):
import numpy
import scipy
import interp.grid as gv
import interp.baker as bv
def testGetPhis(self):
numpy.__version__
scipy.__version__
X = [0,0]
r = [[-1, -1], [0, 2], [1, -1]]
gv, bv
result = baker.get_phis(X, r)
def testGetPhis(self):
X = [0, 0]
r = [[-1, -1], [0, 2], [1, -1]]
right_answer = [1/3.0, 1/3.0, 1/3.0]
result = baker.get_phis(X, r)
for a,b in zip(result, right_answer):
self.assertAlmostEqual(a,b)
right_answer = [1 / 3.0, 1 / 3.0, 1 / 3.0]
def testGetPhis2(self):
for a, b in zip(result, right_answer):
self.assertAlmostEqual(a, b)
X = [0.5,0.25]
r = [[0, 0], [1, 0], [1, 1]]
def testGetPhis2(self):
X = [0.5, 0.25]
r = [[0, 0], [1, 0], [1, 1]]
result = baker.get_phis(X, r)
result = baker.get_phis(X, r)
right_answer = [0.5, 0.25, 0.25]
right_answer = [0.5, 0.25, 0.25]
for a,b in zip(result, right_answer):
self.assertEqual(a,b)
for a, b in zip(result, right_answer):
self.assertEqual(a, b)
def testQlinear(self):
X = [0.5, 0.25]
r = [[0, 0], [1, 0], [1, 1]]
q = [1, 0, 0]
def testQlinear(self):
X = [0.5, 0.25]
r = [[0, 0], [1, 0], [1, 1]]
q = [1, 0, 0]
phi, result = baker.qlinear(X, grid.grid(r,q))
phi, result = baker.qlinear(X, r, q)
right_answer = 0.5
right_answer = 0.5
self.assertAlmostEqual(result, right_answer)
self.assertAlmostEqual(result, right_answer)
def testRunBaker_1(self):
size_of_simplex = 3
extra_points = 3
def testRunBaker_1(self):
size_of_simplex = 3
extra_points = 3
R = grid.grid(self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
R, R_q = (self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
+ extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, R_q, S, S_q)
answer = baker.run_baker(self.X, R, S)
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
self.assertEqual(sorted((a, b, c)), sorted((0, 0.0, 1 / 3.)))
self.assertEqual(sorted((a,b,c)), sorted((0,0.0,1/3.)))
def testRunBaker_2(self):
size_of_simplex = 3
extra_points = 4
def testRunBaker_2(self):
size_of_simplex = 3
extra_points = 4
R, R_q = (self.all_points[:size_of_simplex], self.q[:size_of_simplex])
R = grid.grid(self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
+ extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, R_q, S, S_q)
answer = baker.run_baker(self.X, R, S)
a, b, c = sorted(answer['abc'])
aa, bb, cc = sorted((2 / 3.0, 2 / 3.0, 1 / 3.0))
a, b, c = sorted(answer['abc'])
aa,bb,cc = sorted((2/3.0, 2/3.0, 1/3.0))
self.assertAlmostEqual(a, aa)
self.assertAlmostEqual(b, bb)
self.assertAlmostEqual(c, cc)
self.assertAlmostEqual(a,aa)
self.assertAlmostEqual(b,bb)
self.assertAlmostEqual(c,cc)
def testRunBaker_3(self):
size_of_simplex = 3
extra_points = 5
def testRunBaker_3(self):
size_of_simplex = 3
extra_points = 5
R, R_q = (self.all_points[:size_of_simplex], self.q[:size_of_simplex])
R = grid.grid(self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
+ extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, R_q, S, S_q)
S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
answer = baker.run_baker(self.X, R, S)
a, b, c = sorted((a, b, c))
aa, bb, cc = sorted((13 / 14., 2 / 7., 15 / 14.))
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
self.assertAlmostEqual(a, aa)
self.assertAlmostEqual(b, bb)
self.assertAlmostEqual(c, cc)
a,b,c = sorted((a,b,c))
aa, bb, cc = sorted((13/14., 2/7., 15/14.))
def testRunBaker_4(self):
size_of_simplex = 3
extra_points = 6
self.assertAlmostEqual(a,aa)
self.assertAlmostEqual(b,bb)
self.assertAlmostEqual(c,cc)
R, R_q = (self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
S, S_q = (self.all_points[size_of_simplex:size_of_simplex \
+ extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, R_q, S, S_q)
def testRunBaker_4(self):
size_of_simplex = 3
extra_points = 6
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
R = grid.grid(self.all_points[:size_of_simplex],
self.q[:size_of_simplex])
a, b, c = sorted((a, b, c))
aa, bb, cc = sorted((48 / 53.0, 15 / 53.0, 54 / 53.0))
S = grid.grid(self.all_points[size_of_simplex:size_of_simplex + extra_points],
self.q[size_of_simplex:size_of_simplex + extra_points])
answer = baker.run_baker(self.X, R, S)
a = answer['abc'][0]
b = answer['abc'][1]
c = answer['abc'][2]
a,b,c = sorted((a,b,c))
aa,bb,cc = sorted((48/53.0, 15/53.0, 54/53.0))
self.assertAlmostEqual(a, aa)
self.assertAlmostEqual(b, bb)
self.assertAlmostEqual(c, cc)
self.assertAlmostEqual(a, aa)
self.assertAlmostEqual(b, bb)
self.assertAlmostEqual(c, cc)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
test/baker2dorder.py
+73 -68
View File
@@ -8,97 +8,102 @@ import numpy as np
from interp.grid import contains
def exact_func(point):
x = point[0]
y = point[1]
return 0.5 + x*x + y
def calculate_error_term(self, a,b,c,d,e,f):
def exact_func(point):
x = point[0]
y = point[1]
return 0.5 + x * x + y
def calculate_error_term(self, a, b, c, d, e, f):
B = np.array([
self.p1[a] * self.p1[b], self.p1[c] * self.p1[d], self.p1[e] * self.p1[f],
self.p2[a] * self.p2[b], self.p2[c] * self.p2[d], self.p2[e] * self.p2[f],
self.p3[a] * self.p3[b], self.p3[c] * self.p3[d], self.p3[e] * self.p3[f],
self.p4[a] * self.p4[b], self.p4[c] * self.p4[d], self.p4[e] * self.p4[f],
])
B.shape = (4,3)
self.p1[a] * self.p1[b], self.p1[c] * self.p1[d], self.p1[e] * self.p1[f],
self.p2[a] * self.p2[b], self.p2[c] * self.p2[d], self.p2[e] * self.p2[f],
self.p3[a] * self.p3[b], self.p3[c] * self.p3[d], self.p3[e] * self.p3[f],
self.p4[a] * self.p4[b], self.p4[c] * self.p4[d], self.p4[e] * self.p4[f],
])
B.shape = (4, 3)
A = np.dot(B.T, B)
rhs = np.dot(B.T, self.w)
abc = np.linalg.solve(A,rhs)
abc = np.linalg.solve(A, rhs)
err = \
abc[0] * self.phis[a] * self.phis[b] + \
abc[1] * self.phis[c] * self.phis[d] + \
abc[2] * self.phis[e] * self.phis[f]
abc[0] * self.phis[a] * self.phis[b] + \
abc[1] * self.phis[c] * self.phis[d] + \
abc[2] * self.phis[e] * self.phis[f]
return err
class Test(unittest.TestCase):
def setUp(self):
self.verts = [
[ 2, 3], # 0
[ 7, 4], # 1
[ 4, 8], # 2
[ 0, 7], # 3, 1
[ 5, 0], # 4, 2
[10, 5], # 5, 3
[ 8, 9], # 6, 4
]
def setUp(self):
self.verts = [
[2, 3], # 0
[7, 4], # 1
[4, 8], # 2
[0, 7], # 3, 1
[5, 0], # 4, 2
[0, 5], # 5, 3
[8, 9], # 6, 4
]
self.q = [exact_func(v) for v in self.verts]
self.q = [exact_func(v) for v in self.verts]
self.g = grid(self.verts, self.q)
self.R, self.R_q = (self.verts[:3], self.q[:3])
self.S, self.S_q = (self.verts[3:], self.q[3:])
self.g = grid(self.verts, self.q)
self.R = grid(self.verts[:3], self.q[:3])
self.S = grid(self.verts[3:], self.q[3:])
self.p1, self.ql1 = baker.qlinear(self.verts[3], self.R, self.q)
self.p2, self.ql2 = baker.qlinear(self.verts[4], self.R, self.q)
self.p3, self.ql3 = baker.qlinear(self.verts[5], self.R, self.q)
self.p4, self.ql4 = baker.qlinear(self.verts[6], self.R, self.q)
self.p1, self.ql1 = baker.qlinear(self.verts[3], self.R)
self.p2, self.ql2 = baker.qlinear(self.verts[4], self.R)
self.p3, self.ql3 = baker.qlinear(self.verts[5], self.R)
self.p4, self.ql4 = baker.qlinear(self.verts[6], self.R)
self.q1 = exact_func(self.verts[3])
self.q2 = exact_func(self.verts[4])
self.q3 = exact_func(self.verts[5])
self.q4 = exact_func(self.verts[6])
self.q1 = exact_func(self.verts[3])
self.q2 = exact_func(self.verts[4])
self.q3 = exact_func(self.verts[5])
self.q4 = exact_func(self.verts[6])
self.w = np.array([
self.q1 - self.ql1,
self.q2 - self.ql2,
self.q3 - self.ql3,
self.q4 - self.ql4,
])
self.X = [4, 5]
self.w = np.array([
self.q1 - self.ql1,
self.q2 - self.ql2,
self.q3 - self.ql3,
self.q4 - self.ql4,
])
self.g = grid(self.verts, self.q)
self.X = [4,5]
self.phis, self.qlin = baker.qlinear(self.X, self.R, self.q)
self.exact = exact_func(self.X)
self.answer = baker.run_baker(self.X, self.R,
self.R_q, self.S, self.S_q)
self.g = grid(self.verts, self.q)
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R))
self.phis, self.qlin = baker.qlinear(self.X, self.R)
self.exact = exact_func(self.X)
self.answer = baker.run_baker(self.X,self.R,self.S)
def test_1(self):
a, b, c, d, e, f = (0, 1, 1, 2, 2, 0)
err = calculate_error_term(self, a, b, c, d, e, f)
self.assertAlmostEqual(err, self.answer['error'])
def test_swap_first_elements(self):
a, b, c, d, e, f = (1, 0, 1, 2, 2, 0)
err = calculate_error_term(self, a, b, c, d, e, f)
self.assertAlmostEqual(err, self.answer['error'])
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R.verts))
def test_swap_two_pairs(self):
a, b, c, d, e, f = (1, 2, 0, 1, 2, 0)
err = calculate_error_term(self, a, b, c, d, e, f)
self.assertAlmostEqual(err, self.answer['error'])
def test_1(self):
a,b,c,d,e,f = (0,1, 1,2, 2,0)
err = calculate_error_term(self, a,b,c,d,e,f)
self.assertAlmostEqual(err, self.answer['error'])
def test_swap_first_elements(self):
a,b,c,d,e,f = (1,0, 1,2, 2,0)
err = calculate_error_term(self, a,b,c,d,e,f)
self.assertAlmostEqual(err, self.answer['error'])
def test_swap_two_pairs(self):
a,b,c,d,e,f = (1,2, 0,1, 2,0)
err = calculate_error_term(self, a,b,c,d,e,f)
self.assertAlmostEqual(err, self.answer['error'])
def test_swap_all_pairs(self):
a,b,c,d,e,f = (0,2, 0,1, 2,1)
err = calculate_error_term(self, a,b,c,d,e,f)
self.assertAlmostEqual(err, self.answer['error'])
def test_swap_all_pairs(self):
a, b, c, d, e, f = (0, 2, 0, 1, 2, 1)
err = calculate_error_term(self, a, b, c, d, e, f)
self.assertAlmostEqual(err, self.answer['error'])
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
test/baker3d.py
+21 -26
View File
@@ -2,38 +2,33 @@
import unittest
from interp.baker import get_phis, qlinear
from interp.grid import grid
import numpy as np
import scipy.spatial
class Test(unittest.TestCase):
def setUp(self):
self.X = [0.0, 0.0, 0.0]
self.r = [
[0.0, 0.0, 1.0],
[0.94280904333606508, 0.0, -0.3333333283722672],
[-0.47140452166803232, 0.81649658244673617, -0.3333333283722672],
[-0.47140452166803298, -0.81649658244673584, -0.3333333283722672],
]
self.q = [0.0, 0.0, 0.0, 4]
def setUp(self):
self.X = [0.0, 0.0, 0.0]
self.r = [
[0.0, 0.0, 1.0],
[0.94280904333606508, 0.0, -0.3333333283722672],
[-0.47140452166803232, 0.81649658244673617, -0.3333333283722672],
[-0.47140452166803298, -0.81649658244673584, -0.3333333283722672],
]
self.q = [0.0, 0.0, 0.0, 4]
def testGetPhis(self):
result = get_phis(self.X, self.r)
right_answer = [0.25, 0.25, 0.25, 0.25]
def testGetPhis(self):
result = get_phis(self.X, self.r)
right_answer = [0.25, 0.25, 0.25, 0.25]
for a, b in zip(result, right_answer):
self.assertAlmostEqual(a, b)
for a,b in zip(result, right_answer):
self.assertAlmostEqual(a,b)
def testQlinear(self):
phi, result = qlinear(self.X, grid(self.r, self.q))
result = result
right_answer = 1.0
self.assertAlmostEqual(result, right_answer)
def testQlinear(self):
phi, result = qlinear(self.X, self.r, self.q)
result = result
right_answer = 1.0
self.assertAlmostEqual(result, right_answer)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=2).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=2).run(suite)
test/cubic2d.py
+61 -56
View File
@@ -4,71 +4,76 @@ import unittest
from interp.baker import run_baker
from interp.grid import grid
from interp.grid import contains
from interp.grid import contains
def exact_func(X):
x = X[0]
y = X[0]
return 1 + x + y
x = X[0]
y = X[0]
return 1 + x + y
class Test(unittest.TestCase):
def setUp(self):
self.verts = [
[ 0.25, 0.40], # 0
[ 0.60, 0.80], # 1
[ 0.65, 0.28], # 2
[ 0.28, 0.65], # 3
[ 1.00, 0.75], # 4
[ 0.30, 0.95], # 5
[ 0.80, 0.50], # 6
[ 0.35, 0.15], # 7
]
self.q = [exact_func(p) for p in self.verts]
def setUp(self):
self.g = [[0.25, 0.40], # 0
[0.60, 0.80], # 1
[0.65, 0.28], # 2
[0.28, 0.65], # 3
[1.00, 0.75], # 4
[0.30, 0.95], # 5
[0.80, 0.50], # 6
[0.35, 0.15], # 7
]
self.q = [exact_func(p) for p in self.g]
self.X = [0.55, 0.45]
self.R = self.g[0:3]
self.R_q = self.q[0:3]
self.exact = exact_func(self.X)
self.X = [0.55, 0.45]
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R))
self.g = grid(self.verts, self.q)
# self.g.construct_connectivity()
self.R = self.g.create_mesh(range(3))
def test_RunBaker_1_extra_point(self, extra=1):
S = self.g[3:3 + extra]
S_q = self.q[3:3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
# expected failure ...
self.assertTrue(lin_err >= final_err)
self.exact = exact_func(self.X)
def test_RunBaker_2_extra_point(self, extra=2):
S = self.g[3: 3 + extra]
S_q = self.q[3:3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_3_extra_point(self, extra=3):
S = self.g[3: 3 + extra]
S_q = self.q[3:3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R.verts))
def test_RunBaker_4_extra_point(self, extra=4):
S = self.g[3: 3 + extra]
S_q = self.q[3:3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_1_extra_point(self, extra=1):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_2_extra_point(self, extra=2):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_3_extra_point(self, extra=3):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_4_extra_point(self, extra=4):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_5_extra_point(self, extra=5):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_5_extra_point(self, extra=5):
S = self.g[3: 3 + extra]
S_q = self.q[3:3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q, order=3)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
test/pattern.py
+33 -35
View File
@@ -4,49 +4,47 @@ import unittest
from interp.baker import pattern
class Test(unittest.TestCase):
def setUp(self):
pass
def setUp(self):
pass
def testImports(self):
from interp.baker import pattern
def testImports(self):
from interp.baker import pattern as ppp
ppp
def test_baker_eq_8(self):
b = sorted([tuple(sorted(i)) for i in ((0,1),(1,2),(2,0))])
p = sorted(pattern(3,2))
self.assertEqual(b,p)
def test_baker_eq_8(self):
b = sorted([tuple(sorted(i)) for i in ((0, 1), (1, 2), (2, 0))])
p = sorted(pattern(3, 2))
self.assertEqual(b, p)
def test_baker_eq_17(self):
b = sorted([tuple(sorted(i)) for i in ((0,1,1), (0,2,2), (1,0,0), (1,2,2), (2,0,0), (2,1,1), (0,1,2))])
p = sorted(pattern(3,3))
self.assertEqual(b,p)
def test_baker_eq_17(self):
b = sorted([tuple(sorted(i)) for i in ((0, 1, 1), (0, 2, 2), (1, 0, 0),
(1, 2, 2), (2, 0, 0), (2, 1, 1), (0, 1, 2))])
p = sorted(pattern(3, 3))
self.assertEqual(b, p)
def test_baker_eq_15(self):
b = sorted([tuple(sorted(i)) for i in (
(0,1), (0,2), (0,3),
(1,2), (1,3), (2,3))])
def test_baker_eq_15(self):
b = sorted([tuple(sorted(i)) for i in (
(0, 1), (0, 2), (0, 3),
(1, 2), (1, 3), (2, 3))])
p = sorted(pattern(4,2))
self.assertEqual(b,p)
def test_smcquay_(self):
b = sorted([tuple(sorted(i)) for i in (
(0,1,2), (1,2,3), (0,1,3), (0,2,3),
(0,0,1), (0,1,1),
(1,2,2), (1,1,2),
(0,2,2), (0,0,2),
(1,3,3), (1,1,3),
(2,2,3), (2,3,3),
(0,3,3), (0,0,3))])
p = sorted(pattern(4,3))
self.assertEqual(b,p)
p = sorted(pattern(4, 2))
self.assertEqual(b, p)
def test_smcquay_(self):
b = sorted([tuple(sorted(i)) for i in (
(0, 1, 2), (1, 2, 3), (0, 1, 3), (0, 2, 3),
(0, 0, 1), (0, 1, 1),
(1, 2, 2), (1, 1, 2),
(0, 2, 2), (0, 0, 2),
(1, 3, 3), (1, 1, 3),
(2, 2, 3), (2, 3, 3),
(0, 3, 3), (0, 0, 3))])
p = sorted(pattern(4, 3))
self.assertEqual(b, p)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
test/quadratic2d.py
+63 -57
View File
@@ -4,76 +4,82 @@ import unittest
from interp.baker import run_baker
from interp.grid import grid
from interp.grid import contains
from interp.grid import grid
from interp.grid import contains
def exact_func(X):
x = X[0]
y = X[0]
return 1 - x*x + y*y
x = X[0]
y = X[0]
return 1 - x * x + y * y
class Test(unittest.TestCase):
def setUp(self):
self.points = [
[ 0.25, 0.40], # 0
[ 0.60, 0.80], # 1
[ 0.65, 0.28], # 2
[ 0.28, 0.65], # 3
[ 1.00, 0.75], # 4
[ 0.30, 0.95], # 5
[ 0.80, 0.50], # 6
[ 0.35, 0.15], # 7
def setUp(self):
self.g = [
[0.25, 0.40], # 0
[0.60, 0.80], # 1
[0.65, 0.28], # 2
[0.28, 0.65], # 3
[1.00, 0.75], # 4
[0.30, 0.95], # 5
[0.80, 0.50], # 6
[0.35, 0.15], # 7
]
self.q = [exact_func(p) for p in self.points]
self.q = [exact_func(p) for p in self.g]
self.X = [0.25, 0.4001]
self.X = [0.55, 0.45]
self.X = [0.25, 0.4001]
self.X = [0.55, 0.45]
self.g = grid(self.points, self.q)
self.R = self.g.create_mesh(range(3))
self.R = self.g[0:3]
self.R_q = self.q[0:3]
self.exact = exact_func(self.X)
self.exact = exact_func(self.X)
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R))
def test_RunBaker_1_extra_point(self, extra=1):
S = self.g[3: 3 + extra]
S_q = self.q[3: 3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.accuracy = 8
#XXX: not sure about this one:
self.assertEqual(lin_err, final_err)
def test_R_contains_X(self):
self.assertTrue(contains(self.X, self.R.verts))
def test_RunBaker_2_extra_point(self, extra=2):
S = self.g[3: 3 + extra]
S_q = self.q[3: 3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_1_extra_point(self, extra=1):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
def test_RunBaker_3_extra_point(self, extra=3):
S = self.g[3: 3 + extra]
S_q = self.q[3: 3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
# I expect this one to be bad:
# self.assertTrue(lin_err >= final_err)
def test_RunBaker_4_extra_point(self, extra=4):
S = self.g[3: 3 + extra]
S_q = self.q[3: 3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_2_extra_point(self, extra=2):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_3_extra_point(self, extra=3):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_4_extra_point(self, extra=4):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_5_extra_point(self, extra=5):
S = self.g.create_mesh(range(3, 3 + extra))
answer = run_baker(self.X, self.R, S)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
def test_RunBaker_5_extra_point(self, extra=5):
S = self.g[3: 3 + extra]
S_q = self.q[3: 3 + extra]
answer = run_baker(self.X, self.R, self.R_q, S, S_q)
lin_err = abs(self.exact - answer['qlin'])
final_err = abs(self.exact - answer['final'])
self.assertTrue(lin_err >= final_err)
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)
suite = unittest.TestLoader().loadTestsFromTestCase(Test)
unittest.TextTestRunner(verbosity=3).run(suite)