def test_variable(self):
"""Test special single-argument substitution for Variable"""
x = Variable('x')
y = Variable('y')
m = x * y**2
self.assertEqual(x.sub(3), 3)
# make sure x was not mutated
self.assertEqual(x, Variable('x'))
self.assertNotEqual(x.sub(3), Variable('x'))
# also make sure the old way works
self.assertEqual(x.sub({x: 3}), 3)
# and for vectors
xvec = VectorVariable(3, 'x')
self.assertEqual(xvec[1].sub(3), 3)
def test_string_mutation(self):
x = Variable("x", "m")
descr_before = list(x.exp)[0].descr
y = x.sub({"x": "y"})
descr_after = list(x.exp)[0].descr
self.assertEqual(descr_before, descr_after)
x_changed_descr = dict(descr_before)
x_changed_descr["name"] = "y"
y_descr = list(y.exp)[0].descr
self.assertEqual(x_changed_descr["name"], y_descr["name"])
if not isinstance(descr_before["units"], str):
self.assertAlmostEqual(x_changed_descr["units"] / y_descr["units"],
1.0)
self.assertEqual(x.sub({"x": x}), x)
def test_string_mutation(self):
x = Variable("x", "m")
descr_before = list(x.exp)[0].descr
y = x.sub("x", "y")
descr_after = list(x.exp)[0].descr
self.assertEqual(descr_before, descr_after)
x_changed_descr = dict(descr_before)
x_changed_descr["name"] = "y"
y_descr = list(y.exp)[0].descr
self.assertEqual(x_changed_descr["name"], y_descr["name"])
if not isinstance(descr_before["units"], str):
self.assertAlmostEqual(x_changed_descr["units"]/y_descr["units"],
1.0)
self.assertEqual(x.sub("x", x), x)
def test_basic(self):
"""Basic substitution, symbolic"""
x = Variable('x')
y = Variable('y')
p = 1 + x**2
q = p.sub({x: y**2})
self.assertEqual(q, 1 + y**4)
self.assertEqual(x.sub({x: y}), y)
def test_variable(self):
"""Test special single-argument substitution for Variable"""
x = Variable('x')
y = Variable('y')
m = x*y**2
self.assertEqual(x.sub(3), 3)
self.assertEqual(x.sub(y), y)
self.assertEqual(x.sub(m), m)
# make sure x was not mutated
self.assertEqual(x, Variable('x'))
self.assertNotEqual(x.sub(3), Variable('x'))
# also make sure the old way works
self.assertEqual(x.sub({x: 3}), 3)
self.assertEqual(x.sub({x: y}), y)
# and for vectors
x = VectorVariable(3, 'x')
self.assertEqual(x[1].sub(3), 3)
def test_basic(self):
"""Basic substitution, symbolic"""
x = Variable('x')
y = Variable('y')
p = 1 + x**2
q = p.sub({x: y**2})
self.assertEqual(q, 1 + y**4)
self.assertEqual(x.sub({x: y}), y)
def test_quantity_sub(self):
if gpkit.units:
x = Variable("x", 1, "cm")
y = Variable("y", 1)
self.assertEqual(x.sub({x: 1 * gpkit.units.m}).c.magnitude, 100)
# NOTE: uncomment the below if requiring Quantity substitutions
# self.assertRaises(ValueError, x.sub, x, 1)
self.assertRaises(ValueError, x.sub, {x: 1 * gpkit.units.N})
self.assertRaises(ValueError, y.sub, {y: 1 * gpkit.units.N})
v = gpkit.VectorVariable(3, "v", "cm")
subbed = v.sub({v: [1, 2, 3] * gpkit.units.m})
self.assertEqual([z.c.magnitude for z in subbed], [100, 200, 300])
def test_quantity_sub(self):
if gpkit.units:
x = Variable("x", 1, "cm")
y = Variable("y", 1)
self.assertEqual(x.sub({x: 1*gpkit.units.m}).c.magnitude, 100)
# NOTE: uncomment the below if requiring Quantity substitutions
# self.assertRaises(ValueError, x.sub, x, 1)
self.assertRaises(ValueError, x.sub, {x: 1*gpkit.units.N})
self.assertRaises(ValueError, y.sub, {y: 1*gpkit.units.N})
v = gpkit.VectorVariable(3, "v", "cm")
subbed = v.sub({v: [1, 2, 3]*gpkit.units.m})
self.assertEqual([z.c.magnitude for z in subbed], [100, 200, 300])
def test_signomial(self):
"""Test Signomial substitution"""
D = Variable('D', units="N")
x = Variable('x', units="N")
y = Variable('y', units="N")
a = Variable('a')
with SignomialsEnabled():
sc = (a * x + (1 - a) * y - D)
subbed = sc.sub({a: 0.1})
self.assertEqual(subbed, 0.1 * x + 0.9 * y - D)
self.assertTrue(isinstance(subbed, Signomial))
subbed = sc.sub({a: 2.0})
self.assertTrue(isinstance(subbed, Signomial))
self.assertEqual(subbed, 2 * x - y - D)
_ = a.sub({a: -1}).value # fix monomial assumptions
def test_signomial(self):
"""Test Signomial substitution"""
D = Variable('D', units="N")
x = Variable('x', units="N")
y = Variable('y', units="N")
a = Variable('a')
with SignomialsEnabled():
sc = (a*x + (1 - a)*y - D)
subbed = sc.sub({a: 0.1})
self.assertEqual(subbed, 0.1*x + 0.9*y - D)
self.assertTrue(isinstance(subbed, Signomial))
subbed = sc.sub({a: 2.0})
self.assertTrue(isinstance(subbed, Signomial))
self.assertEqual(subbed, 2*x - y - D)
_ = a.sub({a: -1}).value # fix monomial assumptions
def test_scalar_units(self):
x = Variable("x", "m")
xvk = x.key
y = Variable("y", "km")
yvk = y.key
units_exist = bool(x.units)
for x_ in ["x", xvk, x]:
for y_ in ["y", yvk, y]:
if not isinstance(y_, str) and units_exist:
expected = 1000.0
else:
expected = 1.0
self.assertAlmostEqual(expected, mag(x.sub({x_: y_}).c))
if units_exist:
z = Variable("z", "s")
self.assertRaises(ValueError, y.sub, {y: z})
def test_scalar_units(self):
x = Variable("x", "m")
xvk = x.key
y = Variable("y", "km")
yvk = y.key
units_exist = bool(x.units)
for x_ in ["x", xvk, x]:
for y_ in ["y", yvk, y]:
if not isinstance(y_, str) and units_exist:
expected = 0.001
else:
expected = 1.0
self.assertAlmostEqual(expected, mag(x.sub(x_, y_).c))
if units_exist:
z = Variable("z", "s")
self.assertRaises(ValueError, y.sub, y, z)
def test_quantity_sub(self):
if gpkit.units:
x = Variable("x", 1, "cm")
y = Variable("y", 1)
self.assertEqual(x.sub({x: 1 * gpkit.units.m}).c.magnitude, 100)
# NOTE: uncomment the below if requiring Quantity substitutions
# self.assertRaises(ValueError, x.sub, x, 1)
self.assertRaises(ValueError, x.sub, {x: 1 * gpkit.ureg.N})
self.assertRaises(ValueError, y.sub, {y: 1 * gpkit.ureg.N})
v = gpkit.VectorVariable(3, "v", "cm")
subbed = v.sub({v: [1, 2, 3] * gpkit.ureg.m})
self.assertEqual([z.c.magnitude for z in subbed], [100, 200, 300])
v = VectorVariable(1, "v", "km")
v_min = VectorVariable(1, "v_min", "km")
m = Model(v.prod(), [v >= v_min],
{v_min: [2 * gpkit.units("nmi")]})
cost = m.solve(verbosity=0)["cost"]
self.assertAlmostEqual(cost / (3.704 * gpkit.ureg("km")), 1.0)
m = Model(v.prod(), [v >= v_min],
{v_min: np.array([2]) * gpkit.units("nmi")})
cost = m.solve(verbosity=0)["cost"]
self.assertAlmostEqual(cost / (3.704 * gpkit.ureg("km")), 1.0)
def test_quantity_sub(self):
if gpkit.units:
x = Variable("x", 1, "cm")
y = Variable("y", 1)
self.assertEqual(x.sub({x: 1*gpkit.units.m}).c.magnitude, 100)
# NOTE: uncomment the below if requiring Quantity substitutions
# self.assertRaises(ValueError, x.sub, x, 1)
self.assertRaises(ValueError, x.sub, {x: 1*gpkit.ureg.N})
self.assertRaises(ValueError, y.sub, {y: 1*gpkit.ureg.N})
v = gpkit.VectorVariable(3, "v", "cm")
subbed = v.sub({v: [1, 2, 3]*gpkit.ureg.m})
self.assertEqual([z.c.magnitude for z in subbed], [100, 200, 300])
v = VectorVariable(1, "v", "km")
v_min = VectorVariable(1, "v_min", "km")
m = Model(v.prod(), [v >= v_min],
{v_min: [2*gpkit.units("nmi")]})
cost = m.solve(verbosity=0)["cost"]
self.assertAlmostEqual(cost/(3.704*gpkit.ureg("km")), 1.0)
m = Model(v.prod(), [v >= v_min],
{v_min: np.array([2])*gpkit.units("nmi")})
cost = m.solve(verbosity=0)["cost"]
self.assertAlmostEqual(cost/(3.704*gpkit.ureg("km")), 1.0)
def test_unitless_monomial_sub(self):
"Tests that dimensionless and undimensioned subs can interact."
x = Variable("x", "-")
y = Variable("y")
self.assertEqual(x.sub({x: y}), y)
def test_unitless_monomial_sub(self):
"Tests that dimensionless and undimensioned subs can interact."
x = Variable("x", "-")
y = Variable("y")
self.assertEqual(x.sub({x: y}), y)
