def test_addition_operator():
"""Addition operator."""
my_coordinate = Coordinate2d(3.0, 4.0)
my_other_coordinate = Coordinate2d(5.0, 7.0)
sum_coordinate = my_coordinate + my_other_coordinate
assert (sum_coordinate.get_x() == 8.0)
assert (sum_coordinate.get_y() == 11.0)
def test_subtraction_operator():
"""Subtraction operator."""
my_coordinate = Coordinate2d(3.0, 4.0)
my_other_coordinate = Coordinate2d(5.0, 7.0)
difference = my_coordinate - my_other_coordinate
assert (difference.get_x() == -2.0)
assert (difference.get_y() == -3.0)
def test_update_step():
"""Verify update step."""
initial_position = Coordinate2d(0, 0)
initial_speed = Coordinate2d(3, 4)
sample_time = 0.1
base_model = TrueModel(initial_position, initial_speed, sample_time)
acceleration = Coordinate2d(0, 0)
base_model.update_state(acceleration)
new_state = base_model.get_state()
assert abs(new_state[0] - 0.3) < 1e-8
assert (new_state[1] == 3)
assert abs(new_state[2] - 0.4) < 1e-8
assert (new_state[3] == 4)
def test_set_state():
"""Verify we set the state correctly."""
input_data = create_input_data()
base_model = TrueModel(input_data['position'], input_data['speed'],
input_data['sample_time'])
state = [0, 1, 2, 3]
base_model.set_state(state)
new_state = base_model.get_state()
for idx in range(len(state)):
assert (state[idx] == new_state[idx])
assert (base_model.get_position() == Coordinate2d(0, 2))
assert (base_model.get_speed() == Coordinate2d(1, 3))
def update_state(self, acceleration):
"""Update state of the system."""
new_data = []
for idx in (0, 1):
new_data.append(
self.__update_single_coordinate(
self.get_position().get_idx(idx),
self.get_speed().get_idx(idx), acceleration.get_idx(idx)))
new_position_x = new_data[0][0]
new_speed_x = new_data[0][1]
new_position_y = new_data[1][0]
new_speed_y = new_data[1][1]
self.__position = Coordinate2d(new_position_x, new_position_y)
self.__speed = Coordinate2d(new_speed_x, new_speed_y)
def test_base():
"""Base test."""
my_coordinate = Coordinate2d(3.0, 4.0)
assert (my_coordinate.get_x() == 3.0)
assert (my_coordinate.get_y() == 4.0)
assert (my_coordinate.get_idx(0) == 3.0)
assert (my_coordinate.get_idx(1) == 4.0)
def test_update_step_acceleration():
"""Verify update step with non zero acceleration."""
initial_position = Coordinate2d(0, 0)
initial_speed = Coordinate2d(0, 0)
sample_time = 0.1
base_model = TrueModel(initial_position, initial_speed, sample_time)
for iteration in range(5):
acceleration = Coordinate2d(1 * iteration, 2 * iteration)
current_position = base_model.get_position()
current_speed = base_model.get_speed()
base_model.update_state(acceleration)
new_state = base_model.get_state()
expected_state = compute_new_state(current_position, current_speed,
acceleration, sample_time)
assert all([abs(new_state[i] - expected_state[i]) < 1e-8]
for i in range(len(new_state)))
def create_input_data():
"""Utility function for creating input data."""
position = Coordinate2d(3.0, 4.0)
speed = Coordinate2d(2.0, 5.0)
sample_time = 0.1
return {'position': position, 'speed': speed, 'sample_time': sample_time}
def test_equality():
"""Equal and not equal operators."""
my_coordinate = Coordinate2d(3.0, 4.0)
assert (my_coordinate == Coordinate2d(3.0, 4.0))
assert (my_coordinate != Coordinate2d(3.0, 3.0))
assert (my_coordinate != Coordinate2d(4.0, 4.0))
def test_negative_operator():
"""Negative operator."""
my_coordinate = Coordinate2d(3.0, 4.0)
negative_coordinate = -my_coordinate
assert (negative_coordinate.get_x() == -3.0)
assert (negative_coordinate.get_y() == -4.0)
def set_state(self, state):
"""Set internal state of the system."""
self.__position = \
Coordinate2d(state[0], state[2])
self.__speed = \
Coordinate2d(state[1], state[3])