def test_right_angle_deviation_cost_nonzero():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(right_angle_weight=1)
x = np.array([
[0, 0],
[3, 4],
[7, 6],
[10, 10]
]).reshape((-1, 1))
expected_cost = 128 # 2 nodes * ((6-4)(7-3))^2 per node
common = 2 * 2 * (7 - 3) * (6 - 4) # 2 nodes * 2(x2-x1)(y2-y1) per node
expected_grad = np.array([
[0, 0],
[-2*common, -4*common],
[2*common, 4*common],
[0, 0]
]).flatten()
ct = top.RightAngleDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_neighboring_distance_cost_nonzero():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(nominal_dist_neighbors=10,
neighbors_weight=1)
x = np.array([
[0, 0],
[3, 4],
[13, 14],
[16, 18]
]).reshape((-1, 1))
expected_cost = 100 # 4 nodes * (D - sqrt( (x2-x1)^2 + (y2-y1)^2 ))^2 per node
common = 2 * -2 * (10 - 5) / 5 # 2 nodes * (-2 * (D - norm) / norm) per node
expected_grad = np.array([
[common * -3, common * -4],
[common * 3, common * 4],
[common * -3, common * -4],
[common * 3, common * 4]
]).flatten()
ct = top.NeighboringDistance(g, node_indices, neighbors, settings, internal=False)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_interior_node_xy():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[10, 10],
[16, 24],
[30, 30],
[40, 40]
]).reshape((-1, 1))
expected_cost_x = 20 # (20-16)^2 = 16 for [16, 24] + (30-28)^2 = 4 for [30, 30]
expected_cost_y = 20 # (20-24)^2 = 16 for [16, 24] + (30-32)^2 = 4 for [30, 30]
expected_cost = expected_cost_x + expected_cost_y
common_x_1 = 16 - (30 + 10) / 2 # x - mean(x_neighbors)
common_x_2 = 30 - (40 + 16) / 2 # x - mean(x_neighbors)
common_y_1 = 24 - (30 + 10) / 2 # y - mean(y_neighbors)
common_y_2 = 30 - (40 + 24) / 2 # y - mean(y_neighbors)
expected_grad = np.array([
[-common_x_1, -common_y_1],
[2*common_x_1 - common_x_2, 2*common_y_1 - common_y_2],
[2*common_x_2 - common_x_1, 2*common_y_2 - common_y_1],
[-common_x_2, -common_y_2]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_interior_node_x():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[40, 0],
[30, 0],
[16, 0],
[10, 0]
]).reshape((-1, 1))
expected_cost = 20 # (28-30)^2 = 4 for [30, 0] + (20-16)^2 = 16 for [16, 0]
common_1 = 30 - (40 + 16) / 2 # y - mean(y_neighbors)
common_2 = 16 - (30 + 10) / 2 # y - mean(y_neighbors)
expected_grad = np.array([
[-common_1, 0],
[2*common_1 - common_2, 0],
[2*common_2 - common_1, 0],
[-common_2, 0]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_interior_node_y():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[0, 0],
[0, 6],
[0, 20],
[0, 30]
]).reshape((-1, 1))
expected_cost = 20 # (10-6)^2 = 16 for [0, 6] + (18-20)^2 = 4 for [0, 20]
common_1 = 6 - (20 + 0) / 2 # y - mean(y_neighbors)
common_2 = 20 - (30 + 6) / 2 # y - mean(y_neighbors)
expected_grad = np.array([
[0, -common_1],
[0, 2*common_1 - common_2],
[0, 2*common_2 - common_1],
[0, -common_2]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_end_node_y():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[0, 16],
[0, 10],
[0, 8],
[0, 6]
]).reshape((-1, 1))
expected_cost = 4 # Only node [0, 10] will incur cost (deviation of -2 in y)
common = 10 - (16 + 8) / 2 # y - mean(y_neighbors)
expected_grad = np.array([
[0, -common],
[0, 2*common],
[0, -common],
[0, 0]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_end_node_xy():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[6, 14],
[16, 16],
[22, 22],
[28, 28]
]).reshape((-1, 1))
expected_cost = 8 # Only node [16, 16] will incur cost (deviation of 2 in x, -2 in y)
common_x = 16 - (22 + 6) / 2 # x - mean(x_neighbors)
common_y = 16 - (22 + 14) / 2 # y - mean(y_neighbors)
expected_grad = np.array([
[-common_x, -common_y],
[2*common_x, 2*common_y],
[-common_x, -common_y],
[0, 0]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_nonzero_end_node_x():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[4, 0],
[10, 0],
[12, 0],
[14, 0]
]).reshape((-1, 1))
expected_cost = 4 # Only node [10, 0] will incur cost (deviation of 2 in x)
common = 10 - (4 + 12) / 2 # x - mean(x_neighbors)
expected_grad = np.array([
[-common, 0],
[2*common, 0],
[-common, 0],
[0, 0]
]).flatten()
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_nonneighboring_distance_cost_close():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(minimum_dist_others=10,
others_weight=1)
x = np.array([
[0, 0],
[0, 100],
[100, 100],
[3, 4]
]).reshape((-1, 1))
expected_cost = 50 # 2 nodes * (D - sqrt( (x2-x1)^2 + (y2-y1)^2 ))^2 per node
common = 2 * -2 * (10 - 5) / 5 # 2 nodes * (-2 * (D - norm) / norm) per node
expected_grad = np.array([
[common * -3, common * -4],
[0, 0],
[0, 0],
[common * 3, common * 4]
]).flatten()
ct = top.NonNeighboringDistance(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_centroid_deviation_cost_term_zero():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(centroid_deviation_weight=1)
x = np.array([
[0, 0],
[1, 0],
[2, 0],
[3, 0]
]).reshape((-1, 1))
expected_cost = 0
expected_grad = np.zeros(8)
ct = top.CentroidDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_neighboring_distance_cost_zero():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(nominal_dist_neighbors=10,
neighbors_weight=1)
x = np.array([
[0, 0],
[10, 0],
[10, 5],
[20, 5]
]).reshape((-1, 1))
expected_cost = 0
expected_grad = np.zeros(8)
ct = top.NeighboringDistance(g, node_indices, neighbors, settings, internal=False)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_nonneighboring_distance_cost_far():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(minimum_dist_others=10,
others_weight=1)
x = np.array([
[0, 0],
[0, 100],
[100, 100],
[100, 200]
]).reshape((-1, 1))
expected_cost = 0
expected_grad = np.zeros(8)
ct = top.NonNeighboringDistance(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_nonneighboring_distance_cost_multiple_nodes_close():
g, node_indices, neighbors = make_two_component_engine_data()
settings = top.OptimizerSettings(minimum_dist_others=20,
others_weight=1)
x = np.array([
[0, 0], # 1
[100, 0], # c1.1
[103, 4], # c2.1
[106, 1], # c1.2
[109, 5], # c2.2
[200, 0] # 2
]).reshape((-1, 1))
cost_11_21 = 2 * (20 - 5) ** 2
cost_11_22 = 2 * (20 - np.sqrt(106)) ** 2
cost_12_21 = 2 * (20 - np.sqrt(18)) ** 2
cost_12_22 = 2 * (20 - 5) ** 2
expected_cost = cost_11_21 + cost_11_22 + cost_12_21 + cost_12_22
# 2 nodes * (-2 * (D - norm) / norm) per node
common_11_21 = 2 * -2 * (20 - 5) / 5
common_11_22 = 2 * -2 * (20 - np.sqrt(106)) / np.sqrt(106)
common_12_21 = 2 * -2 * (20 - np.sqrt(18)) / np.sqrt(18)
common_12_22 = 2 * -2 * (20 - 5) / 5
expected_grad = np.array([
[0, 0],
[common_11_21 * -3 + common_11_22 * -9, common_11_21 * -4 + common_11_22 * -5],
[common_11_21 * 3 + common_12_21 * -3, common_11_21 * 4 + common_12_21 * 3],
[common_12_21 * 3 + common_12_22 * -3, common_12_21 * -3 + common_12_22 * -4],
[common_11_22 * 9 + common_12_22 * 3, common_11_22 * 5 + common_12_22 * 4],
[0, 0]
]).flatten()
ct = top.NonNeighboringDistance(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_horizontal_deviation_cost_nonzero():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(horizontal_weight=1)
x = np.array([
[0, 0],
[5, 3],
[6, 5],
[10, 10]
]).reshape((-1, 1))
expected_cost = 8 # 2 nodes * (5 - 3)^2 per node
expected_grad = np.array([
[0, 0],
[0, -8],
[0, 8],
[0, 0]
]).flatten()
ct = top.HorizontalDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)
def test_right_angle_deviation_cost_zero_vertical():
g, node_indices, neighbors = make_one_component_engine_data()
settings = top.OptimizerSettings(right_angle_weight=1)
x = np.array([
[0, 0],
[5, 3],
[5, 4],
[10, 10]
]).reshape((-1, 1))
expected_cost = 0
expected_grad = np.array([
[0, 0],
[0, 0],
[0, 0],
[0, 0]
]).flatten()
ct = top.RightAngleDeviation(g, node_indices, neighbors, settings)
cost, grad = ct.evaluate(top.make_costargs(x))
assert cost == expected_cost
np.testing.assert_equal(expected_grad, grad)