def test_unfix_all(self):
# Test with leaf nodes
adder = Adder(n=3,
x0=[1, 2, 3],
dof_names=['x', 'y', 'z'],
dof_fixed=[True, False, False])
iden = Identity(x=10, dof_fixed=True)
adder_x = adder.x
iden_x = iden.x
self.assertEqual(len(adder_x), 2)
self.assertEqual(adder.dof_size, 2)
self.assertAlmostEqual(adder_x[0], 2)
self.assertAlmostEqual(adder_x[1], 3)
self.assertEqual(len(iden_x), 0)
with self.assertRaises(ValueError):
iden.x = [10]
with self.assertRaises(ValueError):
adder.x = [4, 5, 6]
iden.unfix_all()
adder.unfix_all()
iden.x = [10]
adder.x = [4, 5, 6]
self.assertEqual(iden.dof_size, 1)
self.assertEqual(adder.dof_size, 3)
self.assertAlmostEqual(adder._dofs.loc['x', '_x'], 4)
self.assertAlmostEqual(adder._dofs.loc['y', '_x'], 5)
self.assertAlmostEqual(adder._dofs.loc['z', '_x'], 6)
self.assertAlmostEqual(iden._dofs.loc['x0', '_x'], 10)
# Check with Optimizable objects containing parents
adder = Adder(n=3,
x0=[1, 2, 3],
dof_names=['x', 'y', 'z'],
dof_fixed=[True, False, False])
iden = Identity(x=10, dof_fixed=True)
test_obj = OptClassWithParents(10, opts_in=[iden, adder])
with self.assertRaises(ValueError):
test_obj.x = np.array([20, 4, 5, 6, 25])
adder.unfix_all()
test_obj.x = np.array([4, 5, 6, 25])
self.assertAlmostEqual(test_obj._dofs.loc['val', '_x'], 25)
self.assertAlmostEqual(adder._dofs.loc['x', '_x'], 4)
self.assertAlmostEqual(adder._dofs.loc['y', '_x'], 5)
self.assertAlmostEqual(adder._dofs.loc['z', '_x'], 6)
iden.unfix_all()
test_obj.x = np.array([1, 1, 2, 3, 10])
self.assertAlmostEqual(iden._dofs.loc['x0', '_x'], 1)
self.assertAlmostEqual(adder._dofs.loc['x', '_x'], 1)
self.assertAlmostEqual(adder._dofs.loc['y', '_x'], 2)
self.assertAlmostEqual(adder._dofs.loc['z', '_x'], 3)
self.assertAlmostEqual(test_obj._dofs.loc['val', '_x'], 10)
def test_parent_dof_transitive_behavior(self):
iden1 = Identity()
iden2 = Identity()
lsp = LeastSquaresProblem.from_sigma([3, -4], [2, 5], opts_in=[iden1, iden2])
iden1.x = [10]
self.assertAlmostEqual(np.abs(lsp.residuals()[0]), 3.5)
self.assertAlmostEqual(np.abs(lsp.residuals()[1]), 0.8)
def test_least_squares_combination(self):
iden1 = Identity()
iden2 = Identity()
term1 = LeastSquaresProblem.from_sigma(3, 2, opts_in=[iden1])
term2 = LeastSquaresProblem.from_sigma(-4, 5, opts_in=[iden2])
lsp = term1 + term2
iden1.x = [10]
self.assertAlmostEqual(np.abs(lsp.residuals()[0]), 3.5)
self.assertAlmostEqual(np.abs(lsp.residuals()[1]), 0.8)
def test_single_value_opt_in(self):
iden = Identity()
lst = LeastSquaresProblem.from_sigma(3, 0.1, opts_in=iden)
iden.x = [17]
correct_value = ((17 - 3) / 0.1) # ** 2
self.assertAlmostEqual(np.abs(lst.residuals()[0]),
correct_value,
places=11)
iden.x = [0]
term1 = LeastSquaresProblem.from_sigma(3, 2, opts_in=iden)
self.assertAlmostEqual(np.abs(term1.residuals()[0]), 1.5)
term1.x = [10]
self.assertAlmostEqual(np.abs(term1.residuals()[0]), 3.5)
self.assertAlmostEqual(np.abs(term1.residuals(x=[0])), 1.5)
self.assertAlmostEqual(np.abs(term1.residuals(x=[5])), 1)
def test_x(self):
# Check with leaf type Optimizable objects
adder = Adder(n=3, x0=[1, 2, 3], dof_names=['x', 'y', 'z'])
iden = Identity(x=10, dof_fixed=True)
adder_dofs = adder.x
iden_dofs = iden.x
self.assertAlmostEqual(adder_dofs[0], 1)
self.assertAlmostEqual(adder_dofs[1], 2)
self.assertAlmostEqual(adder_dofs[2], 3)
self.assertEqual(len(iden_dofs), 0)
adder.x = [4, 5, 6]
self.assertAlmostEqual(adder._dofs.loc['x', '_x'], 4)
self.assertAlmostEqual(adder._dofs.loc['y', '_x'], 5)
self.assertAlmostEqual(adder._dofs.loc['z', '_x'], 6)
with self.assertRaises(ValueError):
iden.x = np.array([
11,
], dtype=float)
self.assertAlmostEqual(iden.full_x[0], 10)
# Check with Optimizable objects containing parents
adder2 = Adder(3)
iden2 = Identity(x=10)
test_obj1 = OptClassWithParents(10, opts_in=[iden2, adder2])
with self.assertRaises(ValueError):
test_obj1.x = np.array([20])
test_obj1.x = np.array([20, 4, 5, 6, 25])
self.assertAlmostEqual(test_obj1._dofs.loc['val', '_x'], 25)
self.assertAlmostEqual(iden2._dofs.loc['x0', '_x'], 20)
self.assertAlmostEqual(adder2._dofs.loc['x0', '_x'], 4)
self.assertAlmostEqual(adder2._dofs.loc['x1', '_x'], 5)
self.assertAlmostEqual(adder2._dofs.loc['x2', '_x'], 6)
adder3 = Adder(3)
test_obj2 = OptClassWithParents(10, opts_in=[iden, adder3])
with self.assertRaises(ValueError):
test_obj2.x = np.array([20, 4, 5, 6, 25])
test_obj2.x = np.array([4, 5, 6, 25])
self.assertAlmostEqual(iden._dofs.loc['x0', '_x'], 10)
self.assertAlmostEqual(adder3._dofs.loc['x0', '_x'], 4)
self.assertAlmostEqual(adder3._dofs.loc['x1', '_x'], 5)
self.assertAlmostEqual(adder3._dofs.loc['x2', '_x'], 6)
self.assertAlmostEqual(test_obj2._dofs.loc['val', '_x'], 25)
def test_call(self):
# Test for leaf nodes
adder = Adder(n=3,
x0=[1, 2, 3],
dof_names=['x', 'y', 'z'],
dof_fixed=[True, False, False])
self.assertAlmostEqual(adder(), 6.0)
adder.fix('y')
self.assertAlmostEqual(adder(), 6.0)
iden = Identity(x=10, dof_fixed=True)
self.assertAlmostEqual(iden(), 10.0)
# Set dofs and call
adder.x = [6]
self.assertAlmostEqual(adder(), 9.0)
adder.unfix_all()
adder.x = [4, 5, 6]
self.assertAlmostEqual(adder(), 15.0)
iden.unfix_all()
iden.x = [20]
self.assertAlmostEqual(iden(), 20.0)
# Call with arguments
self.assertAlmostEqual(adder(x=[10, 11, 12]), 33)
self.assertAlmostEqual(iden(x=[20]), 20)
# Now call without arguments to make sure the previous value is returned
self.assertAlmostEqual(adder(), 33)
self.assertAlmostEqual(iden(), 20)
# Fix dofs and now call
adder.fix('x')
self.assertAlmostEqual(adder([1, 2]), 13)
adder.fix_all()
self.assertAlmostEqual(adder(), 13)
iden.fix_all()
self.assertAlmostEqual(iden(), 20)
# Check with Optimizable objects containing parents
adder = Adder(n=3,
x0=[1, 2, 3],
dof_names=['x', 'y', 'z'],
dof_fixed=[True, False, False])
iden = Identity(x=10, dof_fixed=True)
test_obj1 = OptClassWithParents(20, opts_in=[iden, adder])
# Value returned by test_obj1 is (val + 2*iden())/(10.0 + adder())
self.assertAlmostEqual(test_obj1(), 2.5)
# Set the parents nodes' x and call
adder.x = [4, 5]
self.assertAlmostEqual(test_obj1(), 2.0)
# Set the dofs and call
test_obj1.x = np.array([14, 15, 30])
self.assertAlmostEqual(test_obj1(), 1.25)
# Set only the node local dofs and call
test_obj1.local_x = [20]
self.assertAlmostEqual(test_obj1(), 1.0)
# Call with arguments
self.assertAlmostEqual(test_obj1([2, 3, 20]), 2.5)
# Followed by Call with no arguments
self.assertAlmostEqual(test_obj1(), 2.5)
