def test_evolve_shape():
''' Validate that the shape of evolve method return value
'''
a = Attractor()
assert a.evolve().shape == (
a.points,
4), "\n the array that was obtained does not have a proper shape \n"
class Runga_Kutta(unittest.TestCase):
"""This is set of basic test for Euler method"""
def setUp(self):
self.a = Attractor()
self.a.points = 10000
self.a.start = 0
self.a.end = 100
def test_dataframe(self):
"""Make sure the data frame is created with right number of rows"""
df = self.a.evolve(order=4)
print "This is length of dataframe", len(df)
assert len(df) - 1 == 10000 # subrtact 1 for the title row
def test_filesave(self):
"""Test ot make sure we are able to save the file"""
file_save_status = self.a.save()
print "The status of file save is ", file_save_status
assert file_save_status == True
def test_diff_start_points(self):
"""Make sure the data frame is created when using non default values"""
df = self.a.evolve(r0=[1.0, 1.5, 2.0], order=4)
print " The first row of dataframe is ", df.iloc[2,]
print "This starting values of X variable is ", df.iloc[0, 1]
def test_rhs_shape():
''' Validate that the shape of the rhs method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.rhs(xyz).shape == (
3, ), "\n the shape of the array that was returned is not 3 \n"
def test_euler():
""" This test case is to ensure proper size of the value returned by our euler method.
If this test fails it will indicate that there aren't the correct number of items being passed
to the method."""
a = Attractor()
xyz = np.array([0.0,0.0,0.0])
assert a.euler(xyz).shape == (3, ), "\n The array given to the euler method did not contain 3 items!\n"
class TestCases:
def setup(self):
self.s=s
self.p=p
self.b=b
start=0
self.start=start
self.end=end
self.points=points
self.a=Attractor(s,p,b,start,end,points)
def test_euler(self):
"To Test Euler Method"
assert self.myObj.euler(np.array([0.1,0.,0.]))[0]==-1.
assert int(self.myObj.euler(np.array([0.1,0.,0.]))[1])==int(2.8)
assert self.myObj.euler(np.array([0.1,0.,0.]))[2]==0.
def test_rk2(self):
"To Order 2nd Order Runga-Kutta"
obj = Attractor()
obj.evolve([10,10,10],2)
assert attr.solution['x'].count() > 0
assert attr.solution['y'].count() > 0
assert attr.solution['z'].count() > 0
def test_solve(self):
"To Test saving to .csv function"
self.a.save()
data=open('save_solution.csv','r')
d=data.read()
def test(self):
"To test attractor result"
obj = Attractor()
expected_result = [9.6 , 5.6 , 19.97333333]
res = obj.euler([10,5,20])
assert (expected_result == res).all
print "Passed"
class Gravity(Sketchy):
def setup(self):
width, height = [600, 400]
self.a = Attractor(width, height)
self.balls = []
for i in range(0, 10):
self.balls.append(Ball(width,height))
self.size(width, height)
def update(self):
for i in range(len(self.balls)):
for j in range(len(self.balls)):
if i != j:
self.force = self.balls[j].attract(self.balls[i])
applyForce(self.balls[i], self.force)
self.force = self.a.attract(self.balls[i])
applyForce(self.balls[i], self.force)
self.balls[i].update(600, 400)
def draw(self, g):
g.background(1, 1, 1)
for i in range(len(self.balls)):
self.balls[i].draw(g)
self.a.draw(g)
def test_rk2(self):
"To Order 2nd Order Runga-Kutta"
obj = Attractor()
obj.evolve([10,10,10],2)
assert attr.solution['x'].count() > 0
assert attr.solution['y'].count() > 0
assert attr.solution['z'].count() > 0
def test_rk4_shape():
''' Validate that the shape of rk4 method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.rk4(xyz).shape == (
3,
), "\n the shape of the array that was obtained from rk4 is not 3 \n"
def test_euler_shape():
''' Validate that the shape of the euler method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.euler(xyz).shape == (
3,
), "\n the shape of the array that was obtained from euler is not 3 \n"
def euler_test(self):
"""Tests Euler's method in Attractor and ensures the arrays are being filled to the correct and same sizes"""
a = Attractor()
a.evolve([1, 2, 3], 1)
assert len(a.solution['x']) > 0, "\nError in Euler's solution for x"
assert len(a.solution['y']) > 0, "\nError in Euler's solution for y"
assert len(a.solution['z']) > 0, "\nError in Euler's solution for z"
assert len(a.solution['x']) == len(a.solution['y']), "\nError in assigning values to arrays for solution x and/or y"
assert len(a.solution['y']) == len(a.solution['z']), "\nError in assigning values to arrays for solution y and/or z"
def rk4_test(self):
"""Tests the fourth order Runge Kutta method and ensures the arrays are being filled correctly and similarily"""
a = Attractor()
a.evolve([1, 2, 3], 4)
assert len(a.solution['x']) > 0, "\nError in RK4 solution for x"
assert len(a.solution['y']) > 0, "\nError in RK4 solution for y"
assert len(a.solution['z']) > 0, "\nError in RK4 solution for z"
assert len(a.solution['x']) == len(a.solution['y']), "\nError in assigning values to arrays for solution x and/or y"
assert len(a.solution['y']) == len(a.solution['z']), "\nError in assigning values to arrays for solution y and/or z"
def setup(self):
self.s=s
self.p=p
self.b=b
start=0
self.start=start
self.end=end
self.points=points
self.a=Attractor(s,p,b,start,end,points)
def test_save_csv():
''' Ensure that the csv file is created
'''
filename = 'filename.csv'
a = Attractor()
os.remove(filename)
a.evolve()
a.save(filename)
assert os.path.exists(filename), "\n no output file found \n"
print(" test_save_csv method is working as expected ")
def test_rk4():
"""Testing the Runge-Kutta method of order 4.
This is being tested because it has the most amount steps to calculate the result. This is the most likely place for errors.
"""
rk4_true = [0.08425138, 0.19172248, -0.04604073]
print("Expected rk4:", r4_true)
a = Attractor()
print("Actual rk4:", a.rk4([1,2,3]))
assert a.rk4([1,2,3]) == rk4_true
def test_rk2():
"""Testing the Runge-Kutta method of order 2.
This is being tested because it uses a new increment which increases the chance of error.
"""
rk2_true = [0.08416, 0.19146368, -0.04608256]
print("Expected rk2:", rk2_true)
a = Attractor()
print("Actual rk2:", a.rk2([1,2,3]))
assert a.rk2([1,2,3]) == rk2_true
def test_euler():
"""Testing the euler method.
This is being tested because this is a main method in this class.
"""
euler_true = [0.08, 0.184, -0.048]
print("Expected euler:", euler_true)
a = Attractor()
print("Actual euler:", a.euler([1,2,3]))
assert a.euler([1,2,3]) == euler_true
def test_deriv():
"""Testing the derivative calculated.
This is an important test because the euler, rk2, and rk4 estimates use this method. If this method does not calculate the correct values, then everything else will be incorrect.
"""
deriv_true = [10.0, 23.0, -6.0]
print("Expected deriv:", deriv_true)
a = Attractor()
print("Actual deriv:", a.deriv([1,2,3]))
assert a.deriv([1,2,3]) == deriv_true
class TestRandomValues:
"""Define an Attractor with random values for s, p and b, test interface"""
def setup(self):
"""Setup fixture is run before every test method separately"""
s = random.uniform(1, 20)
p = random.uniform(1, 10)
b = random.uniform(1, 15)
self.s = s
self.p = p
self.b = b
start = 0
end = random.uniform(10, 50)
points = random.randint(50, 200)
self.start = start
self.end = end
self.points = points
self.a = Attractor(s, p, b, start, end, points)
def test_defintions(self):
"""Test the first definitions of the class"""
assert (
self.a.params[0] == self.s
), "\n we want to test that value of s save correctly,it gives us error if s!=params[0] \n"
assert (
self.a.params[1] == self.p
), "\n we want to test that value of p save correctly,it gives us error if p!=params[1] \n"
assert (
self.a.params[2] == self.b
), "\n we want to test that value of b save correctly,it gives us error if b!=params[2] \n"
assert (
self.a.dt == (self.end - self.start) / self.points
), "\n we want to test the value of s save correctly,it gives us error if dt!=(end-start)/points \n"
def test_solve(self):
"""Test if solve is printing in the CSV file"""
os.remove("save_solution.csv")
self.a.save()
data = open("save_solution.csv", "r")
d = data.read()
assert len(d) > 0
def test_euler(self):
"""Test if the methods euler is generating the correct answer and we can do this for rk2 and rk4"""
self.a = Attractor(5, 1, 3, 0, 80, 100)
assert (
self.a.euler(0, 1, 0)[0] == 5
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[0]!=5 \n"
assert (
self.a.euler(0, 1, 0)[1] == -1
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[1]!=-1 \n"
assert (
self.a.euler(0, 1, 0)[2] == 0
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[2]!=0 \n"
def test_rk4(self):
"""Test fourth-order RK method yields results. I chose this test to verify that the 4th order RK method yields results and, if not, is the error associated with the calculation of the x-value, y-value, or z-value."""
attr = Attractor()
attr.evolve([10,10,10],4)
print "Test for error in solution for x using rk4 method, Order=4"
assert attr.solution['x'].count() > 0
print " PASSED!!!!"
print "Test for error in solution for y using rk4 method, Order=4"
assert attr.solution['y'].count() > 0
print " PASSED!!!!"
print "Test for error in solution for z using rk4 method, Order=4"
assert attr.solution['z'].count() > 0
print " PASSED!!!!"
def test_euler(self):
"""Test Euler method yields results. I chose this test to verify that the Euler Method yields results. If there is an error is it associated with the calculation of the x-value, y-value, or z-value."""
attr = Attractor()
attr.evolve([10,10,10],1)
print "Assert output for Euler method, x parameter."
assert attr.solution['x'].count() > 0
print " PASSED!!!!"
print "Assert output for Euler method, y parameter."
assert attr.solution['y'].count() > 0
print " PASSED!!!!"
print "Assert output for Euler method z parameter."
assert attr.solution['z'].count() > 0
print " PASSED!!!!"
def euler_test(self):
"""Tests Euler's method in Attractor and ensures the arrays are being filled to the correct and same sizes"""
a = Attractor()
a.evolve([1, 2, 3], 1)
assert len(a.solution['x']) > 0, "\nError in Euler's solution for x"
assert len(a.solution['y']) > 0, "\nError in Euler's solution for y"
assert len(a.solution['z']) > 0, "\nError in Euler's solution for z"
assert len(a.solution['x']) == len(
a.solution['y']
), "\nError in assigning values to arrays for solution x and/or y"
assert len(a.solution['y']) == len(
a.solution['z']
), "\nError in assigning values to arrays for solution y and/or z"
def rk4_test(self):
"""Tests the fourth order Runge Kutta method and ensures the arrays are being filled correctly and similarily"""
a = Attractor()
a.evolve([1, 2, 3], 4)
assert len(a.solution['x']) > 0, "\nError in RK4 solution for x"
assert len(a.solution['y']) > 0, "\nError in RK4 solution for y"
assert len(a.solution['z']) > 0, "\nError in RK4 solution for z"
assert len(a.solution['x']) == len(
a.solution['y']
), "\nError in assigning values to arrays for solution x and/or y"
assert len(a.solution['y']) == len(
a.solution['z']
), "\nError in assigning values to arrays for solution y and/or z"
def test_euler():
"""Tests if dx from euler method is implemented properly
Uses set x, y, and z to be 0.1, 0.0, 0.0"""
a = Attractor()
#say x, y, z = [0.1, 0.0, 0.0]
dx = (10 * (0.0 - 0.1)) * (80.0 - 0.0) / 10000
dy = (0.1 * (28 - 0.0) - 0.0) * (80.0 - 0.0) / 10000
dz = ((0.1 * 0.0) - (8 / 3 * 0.0)) * (80.0 - 0.0) / 10000
ex_euler = np.array([dx, dy, dz])
print("Actual increments: ", a.euler([0.1, 0.0, 0.0]))
print("Expected increments: ", ex_euler)
assert a.euler([0.1, 0.0, 0.0])[0] == ex_euler[0]
def test_modify_attr(self):
#inputs
old_states = ['11','00']
new_states = ['11','10', '00', '01', '11']
f_type = "lambda_bool"
node_names = ['a','b']
old_sol = [[0,0], [1,1]]
new_sol = [[0,0], [0,1], [1,1], [1,0]]
#declare attr
attr = Attractor(old_states, f_type, node_names)
self.assertEqual( old_sol, attr.states)
#modify states
attr.states = new_states
self.assertEqual( new_sol, attr.states)
class TestRandomValues:
"""Define an Attractor with random values for s, p and b, test interface"""
def setup(self):
"""Setup fixture is run before every test method separately"""
s = random.uniform(15, 20)
p = random.uniform(1, 5)
b = random.uniform(10, 15)
self.s = s
self.p = p
self.b = b
start = 0
end = random.uniform(5, 30)
points = random.randint(5, 100)
self.start = start
self.end = end
self.points = points
self.a = Attractor(s, p, b, start, end, points)
def test_defintions(self):
"""Test the first definitions of the class"""
assert (
self.a.params[0] == self.s
), "\n Error in the definition of self.params. The first argument should coincide with the value of s, the first input of the class.\n"
assert (
self.a.params[1] == self.p
), "\n Error in the definition of self.params. The second argument should coincide with the value of p, the second input of the class.\n"
assert (
self.a.params[2] == self.b
), "\n Error in the definition of self.params. The third argument should coincide with the value of b, the third input of the class.\n"
assert self.a.dt == (self.end - self.start) / self.points, "\n Error in the definition of self.dt.\n"
def test_ks(self):
"""Test if the methods euler, rk2 and rk4 are generating the correct answer"""
# The outputs based on specific inputs were calculated by hand and here are compared with the values generated by the Attractor class.
self.a = Attractor(1.0, 1.0, 1.0, 0.0, 80.0, 100)
c = np.array([2, 3, 4])
assert self.a.euler(c)[0] == 1.0, "\n Error in the first element of the np.array output of euler method.\n"
assert self.a.euler(c)[1] == -9.0, "\n Error in the second element of the np.array output of euler method.\n"
assert self.a.euler(c)[2] == 2.0, "\n Error in the third element of the np.array output of euler method.\n"
assert self.a.rk2(c)[0] == -3.0, "\n Error in the first element of the np.array output of rk2 method.\n"
assert self.a.rk2(c)[1] == -8.52, "\n Error in the second element of the np.array output of rk2 method.\n"
assert self.a.rk2(c)[2] == -6.24, "\n Error in the third element of the np.array output of rk2 method.\n"
assert self.a.rk4(c)[0] == 1.97024, "\n Error in the first element of the np.array output of rk4 method.\n"
assert int(self.a.rk4(c)[1]) == -4, "\n Error in the second element of the np.array output of rk4 method.\n"
assert int(self.a.rk4(c)[2]) == 0, "\n Error in the third element of the np.array output of rk4 method.\n"
def test_solve(self):
"""Test if solve is printing in the CSV file"""
# The method deletes the current csv file (if there is one) and creates another one by calling the method 'save'. After that, it analyses if there is somemething written inside the new file.
os.remove("save_solution.csv")
self.a.save()
data = open("save_solution.csv", "r")
d = data.read()
assert (
len(d) > 0
), "\nError in the save method. It is not creating the save_solution.csv file or saving the information of self.solution in it.\n"
def test_dt():
"""Tests step Value"""
a = Attractor()
dt_true = (80.0 - 0.0) / 10000
print("Actual dt value: ", a.dt)
print("Expected dt value: ", dt_true)
assert a.dt == dt_true
def setup(self):
"""Test that initial conditions are setup correctly for default values (start, end, points) and default over-ride (s, p, q). I chose this test so that the initial conditions can be verified and if there is an error identify which parameter the problem is associated with."""
s = randint(1,10)
p = randint(1,10)
b = randint(1,10)
attr = Attractor(s, p, b)
attr.s_t = s
attr.p_t = p
attr.b_t = b
attr = Attractor(attr.s_t, attr.p_t, attr.b_t)
print "Assert value for s parameter over-ride"
assert attr.params[0] == s
print " PASSED!!!!"
print "Assert value for p parameter over-ride"
assert attr.params[1] == p
print " PASSED!!!!"
print "Assert value for b parameter over-ride"
assert attr.params[2] == b
print " PASSED!!!!"
print "Assert default value for start parameter"
assert attr.start == 0
print " PASSED!!!!"
print "Assert default value for end parameter"
assert attr.end == 80
print " PASSED!!!!"
print "Assert default value for points parameter"
assert attr.points == 10000
print " PASSED!!!!"
def setup(self):
width, height = [600, 400]
self.a = Attractor(width, height)
self.balls = []
for i in range(0, 10):
self.balls.append(Ball(width,height))
self.size(width, height)
def test_y_generate():
"""Tests if evolve method is implemented properly
Uses set x, y, and z to be 0.1, 0.0, 0.0"""
a = Attractor()
#say x, y, z = [0.1, 0.0, 0.0]
dx = (10.0 * (0.0 - 0.1)) * (80.0 - 0.0) / 10000 + 0.1
dy = (0.1 * (28 - 0.0) - 0.0) * (80.0 - 0.0) / 10000 + 0.0
dz = ((0.1 * 0.0) - (8 / 3 * 0.0)) * (80.0 - 0.0) / 10000 + 0.0
ex_1 = np.array([dx, dy, dz])
dx2 = (10.0 * (dy - dx)) * (80.0 - 0.0) / 10000.0 + dx
dy2 = (dx * (28.0 - dz) - dy) * (80.0 - 0.0) / 10000.0 + dy
dz2 = ((dx * dy) - (8 / 3 * dz)) * (80.0 - 0.0) / 10000.0 + dz
ex_2 = np.array([dx2, dy2, dz2])
dx3 = (10.0 * (dy2 - dx2)) * (80.0 - 0.0) / 10000.0 + dx2
dy3 = (dx2 * (28.0 - dz2) - dy2) * (80.0 - 0.0) / 10000.0 + dy2
dz3 = ((dx2 * dy2) - (8 / 3 * dz2)) * (80.0 - 0.0) / 10000.0 + dz2
ex_3 = np.array([dx3, dy3, dz3])
dx4 = (10.0 * (dy3 - dx3)) * (80.0 - 0.0) / 10000.0 + dx3
dy4 = (dx3 * (28 - dz3) - dy3) * (80.0 - 0.0) / 10000.0 + dy3
dz4 = ((dx3 * dy3) - (8 / 3 * dz3)) * (80.0 - 0.0) / 10000.0 + dz3
ex_4 = np.array([dx4, dy4, dz4])
dx5 = (10.0 * (dy4 - dx4)) * (80.0 - 0.0) / 10000.0 + dx4
dy5 = (dx4 * (28 - dz4) - dy4) * (80.0 - 0.0) / 10000.0 + dy4
dz5 = ((dx4 * dy4) - (8 / 3 * dz4)) * (80.0 - 0.0) / 10000.0 + dz4
ex_5 = np.array([dx5, dy5, dz5])
a.evolve(order=4)
y_list = a.solution['y'].tolist()
for i in y_list[:6]:
yy = round(i, 2)
for j in [0.0, dy, dy2, dy3, dy4, dy5]:
yyy = round(j, 2)
print("Actual increments: ", yy) #str(a.solution()['x']).strip('[]'))
print("Expected increments: ", yyy)
assert yy == yyy
def init_test(self):
"""Tests the initial setup for the problem to ensure the initial values are set correctly, the increment exists, and there are empty arrays for our variables to be filled later"""
a = Attractor()
assert a.params[0] == 10.0, "\nError in assigning initial parameter s"
assert a.params[1] == 28.0, "\nError in assigning initial parameter p"
assert a.params[
2] == 8.0 / 3.0, "\nError in assigning initial parameter b"
assert len(
a.params
) > 0, "\nError in assigning initial parameters to params array"
assert a.dt > 0, "\nError in setting up dt"
class TestEuler(unittest.TestCase):
"""This is set of basic test for Euler method"""
def setUp(self):
self.a = Attractor()
self.a.points = 10000
self.a.start = 0
self.a.end = 100
def test_dataframe(self):
"""Make sure the data frame is created with right number of rows"""
df = self.a.evolve(order=1)
print "This is length of dataframe", len(df)
assert len(df) - 1 == 10000 # subrtact 1 for the title row
def test_filesave(self):
"""Test ot make sure we are able to save the file"""
file_save_status = self.a.save()
print "The status of file save is ", file_save_status
assert file_save_status == True
def test_euler(self):
"""Test if the methods euler is generating the correct answer and we can do this for rk2 and rk4"""
self.a = Attractor(5, 1, 3, 0, 80, 100)
assert (
self.a.euler(0, 1, 0)[0] == 5
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[0]!=5 \n"
assert (
self.a.euler(0, 1, 0)[1] == -1
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[1]!=-1 \n"
assert (
self.a.euler(0, 1, 0)[2] == 0
), "\n we want to test that value of euler[0] save correctly,it gives us error if euler[2]!=0 \n"
def ball_control():
att = Attractor(pygame.math.Vector2(mouse_X, mouse_Y))
att.draw(win)
print(mouse_X, mouse_Y)
if len(balls) < NUMBER_OF_BALLS:
posInit = pygame.math.Vector2(random.randint(0, W),
random.randint(0, H))
sz = random.randint(2, MAX_SIZE)
ball = Ball(posInit, sz**2, sz, sz)
balls.append(ball)
flag = False
for ball in balls:
attForce = att.attract(ball)
ball.add_force(attForce)
ball.add_force(gForce)
if flag:
ball.add_force(wForce)
flag = False
else:
ball.add_force(-wForce)
flag = True
# friction = - ball.vel
# if friction.length() != 0:
# friction.normalize()
# friction *= 0.01
# ball.add_force(friction)
ball.update()
ball.check_edges()
ball.draw(win)
for i in range(len(balls)):
if i < len(balls) - 1:
balls[i].draw_line(balls[i + 1], win)
else:
balls[0].draw_line(balls[i], win)
def test_ks(self):
"""Test if the methods euler, rk2 and rk4 are generating the correct answer"""
# The outputs based on specific inputs were calculated by hand and here are compared with the values generated by the Attractor class.
self.a = Attractor(1.0, 1.0, 1.0, 0.0, 80.0, 100)
c = np.array([2, 3, 4])
assert self.a.euler(c)[0] == 1.0, "\n Error in the first element of the np.array output of euler method.\n"
assert self.a.euler(c)[1] == -9.0, "\n Error in the second element of the np.array output of euler method.\n"
assert self.a.euler(c)[2] == 2.0, "\n Error in the third element of the np.array output of euler method.\n"
assert self.a.rk2(c)[0] == -3.0, "\n Error in the first element of the np.array output of rk2 method.\n"
assert self.a.rk2(c)[1] == -8.52, "\n Error in the second element of the np.array output of rk2 method.\n"
assert self.a.rk2(c)[2] == -6.24, "\n Error in the third element of the np.array output of rk2 method.\n"
assert self.a.rk4(c)[0] == 1.97024, "\n Error in the first element of the np.array output of rk4 method.\n"
assert int(self.a.rk4(c)[1]) == -4, "\n Error in the second element of the np.array output of rk4 method.\n"
assert int(self.a.rk4(c)[2]) == 0, "\n Error in the third element of the np.array output of rk4 method.\n"
def setup(self):
"""Setup fixture is run before every test method separately"""
s = random.uniform(1, 20)
p = random.uniform(1, 10)
b = random.uniform(1, 15)
self.s = s
self.p = p
self.b = b
start = 0
end = random.uniform(10, 50)
points = random.randint(50, 200)
self.start = start
self.end = end
self.points = points
self.a = Attractor(s, p, b, start, end, points)
def test_save_csv():
''' Ensure that the csv file is created
'''
filename = 'filename.csv'
a = Attractor()
os.remove(filename)
a.evolve()
a.save(filename)
assert os.path.exists(filename), "\n no output file found \n"
print(" test_save_csv method is working as expected ")
def __init__(self, game):
self.game = game
self.canvas = game.canvas
self.background = pygame.image.load(
os.path.join('images', self.name.lower(), 'background.png'))
self.console_image = pygame.image.load(
os.path.join('images', self.name.lower(), 'console.png'))
self.attractors = []
self.flock = None
self.flock = Flock(self)
self.has_visited = False
self._level_complete = False
if self.exit_gate_position:
self.attractors.append(
Attractor(self.exit_gate_position, 500,
Settings.gate_radius * 2))
# 'Attractors': AttractorsRule(self, 1, [Attractor((300, 300), 50)]),
self.flowers = []
self.init_level()
def setUp(self):
self.a = Attractor()
self.a.points = 10000
self.a.start = 0
self.a.end = 100
from attractor import Attractor
if __name__ == "__main__":
AL = Attractor()
AL.animation("RK4", True)
def save_test(self):
"""Tests to see if a save file was created by creating another save file"""
a = Attractor()
a.evolve()
a.save()
def test_dt_value():
''' Ensure that dt is calculated as it is supposed to be
'''
a = Attractor()
assert a.end == a.dt * a.points, "\n time step is not properly evaluated \n"
def setup(self):
"""Setup fixture is run before every test method separately"""
self.at = Attractor(self.c, self.n)
methods = Attractor.methods
res = {}
log_scale = True
for method in methods:
for inv in range(1, 6):
# calcs.append((method,inv))
# res_h.append([])
#
# continue
print("=============================")
print(f'{method}@{inv}')
AL1 = Attractor(step=0.0001,
num_steps=10000) # TODO Шаг выставляется тут!
AL1.set_invariant_params(inv)
AL1.call_method(method)
calls = AL1.get_counter()
print("calls_f: ", calls)
# Get inv func
I, err = AL1.get_invariant_err(inv)
# Cut thirds
l = int(I.shape[1] * (1.0 / 3.0))
I = I[:, l:-l]
err = err[:, l:-l]
txt = f'{method}@{inv}#{calls}'
# fig.savefig
M = np.mean(I[0])
D = np.std(I[0] - M)
from attractor import Attractor
if __name__ == "__main__":
# Euler
AL1 = Attractor()
AL1.call_method("EUL1")
AL1.show("img/Euler", "Euler's method", False, True)
print("Вызовов EUL1 f: ", AL1.get_counter())
# Midpoint
AL2 = Attractor()
AL2.call_method("MIDP2")
AL2.show("img/Midpoint", "Midpoint method", False, True)
print("Вызовов MIDP2 f: ", AL2.get_counter())
# RK4
AL3 = Attractor()
AL3.call_method("RK4")
AL3.show("img/RK4", "RK4 method", False, True)
print("Вызовов RK4 f: ", AL3.get_counter())
# Adams Bashforts
AL4 = Attractor()
AL4.call_method("AB4")
AL4.show("img/Adams_Bashforts_", "Adams Bashfort method", False, True)
print("Вызовов AB4 f: ", AL4.get_counter())
# Adams Moulton 5
AL5 = Attractor()
AL5.call_method("ABM5")
AL5.show("img/Adams_Bashforts_Moulton", "Adams-Bashfort-Moulton", False, True)
def test_rhs_shape():
''' Validate that the shape of the rhs method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.rhs(xyz).shape == (3, ), "\n the shape of the array that was returned is not 3 \n"
def test_evolve_shape():
''' Validate that the shape of evolve method return value
'''
a = Attractor()
assert a.evolve().shape == (a.points, 4), "\n the array that was obtained does not have a proper shape \n"
def test_rk4_shape():
''' Validate that the shape of rk4 method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.rk4(xyz).shape == (3, ), "\n the shape of the array that was obtained from rk4 is not 3 \n"
def test_euler_shape():
''' Validate that the shape of the euler method return value
'''
a = Attractor()
xyz = np.array([0.0, 0.0, 0.0])
assert a.euler(xyz).shape == (3, ), "\n the shape of the array that was obtained from euler is not 3 \n"
