def setup(self, goods=None, bads=None, taylor_order=6):
goods = goods if goods else {}
goods.update({1 / k: 1 / v for k, v in bads.items()})
N = check_values_length(goods)
exp_S = VectorVariable(N, "e^{S}")
VectorVariable(N, "S")
self.cost = 1
constraints = [[exp_S >= 1, exp_S.prod() == np.e]]
for monomial, options in goods.items():
m_nd = Variable("|%s|" %
monomial.latex(excluded=["models", "units"]))
exp_m = Variable("e^{%s}" % m_nd.latex(excluded=["models"]))
self.cost /= monomial
if hasattr(options, "units"):
monomial = monomial / (1 * options.units)
options = options.magnitude
options_scale = options.mean()
options /= options_scale
constraints.append([
m_nd == monomial / options_scale,
(exp_S**options).prod() == exp_m,
exp_m >= 1 + te_exp_minus1(m_nd, taylor_order),
])
return constraints
def test_check_result(self):
"""issue 361"""
N = 5
L = 5.
dx = L / (N - 1)
EI = Variable("EI", 10)
p = VectorVariable(N, "p")
p = p.sub(p, 100 * np.ones(N))
V = VectorVariable(N, "V")
M = VectorVariable(N, "M")
th = VectorVariable(N, "th")
w = VectorVariable(N, "w")
eps = 1E-6
substitutions = {var: eps for var in [V[-1], M[-1], th[0], w[0]]}
objective = w[-1]
constraints = [
EI * V.left[1:N] >=
EI * V[1:N] + 0.5 * dx * p.left[1:N] + 0.5 * dx * p[1:N],
EI * M.left[1:N] >=
EI * M[1:N] + 0.5 * dx * V.left[1:N] + 0.5 * dx * V[1:N],
EI * th.right[0:N - 1] >= EI * th[0:N - 1] +
0.5 * dx * M.right[0:N - 1] + 0.5 * dx * M[0:N - 1],
EI * w.right[0:N - 1] >= EI * w[0:N - 1] +
0.5 * dx * th.right[0:N - 1] + 0.5 * dx * th[0:N - 1]
]
m = Model(objective, constraints, substitutions)
sol = m.solve(verbosity=0)
def setup(self, N=4):
EI = Variable("EI", 1e4, "N*m^2")
dx = Variable("dx", "m", "Length of an element")
L = Variable("L", 5, "m", "Overall beam length")
q = VectorVariable(N, "q", 100 * np.ones(N), "N/m",
"Distributed load at each point")
V = VectorVariable(N, "V", "N", "Internal shear")
V_tip = Variable("V_{tip}", 0, "N", "Tip loading")
M = VectorVariable(N, "M", "N*m", "Internal moment")
M_tip = Variable("M_{tip}", 0, "N*m", "Tip moment")
th = VectorVariable(N, "\\theta", "-", "Slope")
th_base = Variable("\\theta_{base}", 0, "-", "Base angle")
w = VectorVariable(N, "w", "m", "Displacement")
w_base = Variable("w_{base}", 0, "m", "Base deflection")
# below: trapezoidal integration to form a piecewise-linear
# approximation of loading, shear, and so on
# shear and moment increase from tip to base (left > right)
shear_eq = (V >= V.right + 0.5 * dx * (q + q.right))
shear_eq[-1] = (V[-1] >= V_tip) # tip boundary condition
moment_eq = (M >= M.right + 0.5 * dx * (V + V.right))
moment_eq[-1] = (M[-1] >= M_tip)
# slope and displacement increase from base to tip (right > left)
theta_eq = (th >= th.left + 0.5 * dx * (M + M.left) / EI)
theta_eq[0] = (th[0] >= th_base) # base boundary condition
displ_eq = (w >= w.left + 0.5 * dx * (th + th.left))
displ_eq[0] = (w[0] >= w_base)
# minimize tip displacement (the last w)
self.cost = w[-1]
return [shear_eq, moment_eq, theta_eq, displ_eq, L == (N - 1) * dx]
def test_init(self):
"""Test VectorVariable initialization"""
# test 1
n = 3
v = VectorVariable(n, 'v', label='dummy variable')
self.assertTrue(isinstance(v, NomialArray))
v_mult = 3*v
for i in range(n):
self.assertTrue(isinstance(v[i], PlainVariable))
self.assertTrue(isinstance(v[i], Monomial))
# test that operations on Variable cast to Monomial
self.assertTrue(isinstance(v_mult[i], Monomial))
self.assertFalse(isinstance(v_mult[i], PlainVariable))
# test 2
x = VectorVariable(3, 'x', label='dummy variable')
x_0 = Variable('x', idx=(0,), shape=(3,), label='dummy variable')
x_1 = Variable('x', idx=(1,), shape=(3,), label='dummy variable')
x_2 = Variable('x', idx=(2,), shape=(3,), label='dummy variable')
x2 = NomialArray([x_0, x_1, x_2])
self.assertEqual(x, x2)
# test inspired by issue 137
N = 20
x_arr = np.arange(0, 5, 5/N) + 1e-6
x = VectorVariable(N, 'x', x_arr, 'm', "Beam Location")
def test_exclude_vector(self):
x = VectorVariable(2, "x", [2, 1])
x_ = VectorVariable(2, "x", [1, 2], model="_")
try:
LinkedConstraintSet([x >= 1, x_ >= 1], exclude="x")
except ValueError:
self.fail("linking was an unexpected ValueError (sub conflict?).")
def test_ast(self): # pylint: disable=too-many-statements
if sys.platform[:3] == "win":
return
t = Variable("t")
u = Variable("u")
v = Variable("v")
w = Variable("w")
x = VectorVariable(3, "x")
y = VectorVariable(3, "y")
z = VectorVariable(3, "z")
a = VectorVariable((3, 2), "a")
# print(w >= x) # TODO: this always prints the vector on the left
self.assertEqual(str(3*(x + y)*z), "3·(x[:] + y[:])·z[:]")
nni = 3
ii = np.tile(np.arange(1, nni+1), a.shape[1:]+(1,)).T
self.assertEqual(str(w*NomialArray(ii)/nni)[:4], "w·[[")
self.assertEqual(str(w*NomialArray(ii)/nni)[-4:], "]]/3")
self.assertEqual(str(NomialArray(ii)*w/nni)[:2], "[[")
self.assertEqual(str(NomialArray(ii)*w/nni)[-6:], "]]·w/3")
self.assertEqual(str(w*ii/nni)[:4], "w·[[")
self.assertEqual(str(w*ii/nni)[-4:], "]]/3")
self.assertEqual(str(w*(ii/nni))[:4], "w·[[")
self.assertEqual(str(w*(ii/nni))[-2:], "]]")
self.assertEqual(str(w >= (x[0]*t + x[1]*u)/v),
"w >= (x[0]·t + x[1]·u)/v")
self.assertEqual(str(x), "x[:]")
self.assertEqual(str(x*2), "x[:]·2")
self.assertEqual(str(2*x), "2·x[:]")
self.assertEqual(str(x + 2), "x[:] + 2")
self.assertEqual(str(2 + x), "2 + x[:]")
self.assertEqual(str(x/2), "x[:]/2")
self.assertEqual(str(2/x), "2/x[:]")
self.assertEqual(str(x**3), "x[:]³")
self.assertEqual(str(-x), "-x[:]")
self.assertEqual(str(x/y/z), "x[:]/y[:]/z[:]")
self.assertEqual(str(x/(y/z)), "x[:]/(y[:]/z[:])")
self.assertEqual(str(x >= y), "x[:] >= y[:]")
self.assertEqual(str(x >= y + z), "x[:] >= y[:] + z[:]")
self.assertEqual(str(x[:2]), "x[:2]")
self.assertEqual(str(x[:]), "x[:]")
self.assertEqual(str(x[1:]), "x[1:]")
self.assertEqual(str(y * [1, 2, 3]), "y[:]·[1, 2, 3]")
self.assertEqual(str(x[:2] == (y*[1, 2, 3])[:2]),
"x[:2] = (y[:]·[1, 2, 3])[:2]")
self.assertEqual(str(y + [1, 2, 3]), "y[:] + [1, 2, 3]")
self.assertEqual(str(x == y + [1, 2, 3]), "x[:] = y[:] + [1, 2, 3]")
self.assertEqual(str(x >= y + [1, 2, 3]), "x[:] >= y[:] + [1, 2, 3]")
self.assertEqual(str(a[:, 0]), "a[:,0]")
self.assertEqual(str(a[2, :]), "a[2,:]")
g = 1 + 3*a[2, 0]**2
gstrbefore = str(g)
g.ast = None
gstrafter = str(g)
self.assertEqual(gstrbefore, gstrafter)
def test_ast(self): # pylint: disable=too-many-statements
t = Variable("t")
u = Variable("u")
v = Variable("v")
w = Variable("w")
x = VectorVariable(3, "x")
y = VectorVariable(3, "y")
z = VectorVariable(3, "z")
a = VectorVariable((3, 2), "a")
print(w >= x)
self.assertEqual(str(3 * (x + y) * z), "3*(x[:] + y[:])*z[:]")
nni = 3
ii = np.tile(np.arange(1., nni + 1.), a.shape[1:] + (1, )).T
self.assertEqual(str(w * NomialArray(ii) / nni)[:4], "w*[[")
self.assertEqual(str(w * NomialArray(ii) / nni)[-4:], "]]/3")
self.assertEqual(str(NomialArray(ii) * w / nni)[:2], "[[")
self.assertEqual(str(NomialArray(ii) * w / nni)[-6:], "]]*w/3")
self.assertEqual(str(w * ii / nni)[:4], "w*[[")
self.assertEqual(str(w * ii / nni)[-4:], "]]/3")
self.assertEqual(str(w * (ii / nni))[:4], "w*[[")
self.assertEqual(str(w * (ii / nni))[-2:], "]]")
self.assertEqual(str(w >= (x[0] * t + x[1] * u) / v),
"w >= (x[0]*t + x[1]*u)/v")
self.assertEqual(str(x), "x[:]")
self.assertEqual(str(x * 2), "x[:]*2")
self.assertEqual(str(2 * x), "2*x[:]")
self.assertEqual(str(x + 2), "x[:] + 2")
self.assertEqual(str(2 + x), "2 + x[:]")
self.assertEqual(str(x / 2), "x[:]/2")
self.assertEqual(str(2 / x), "2/x[:]")
if sys.version_info <= (3, 0):
self.assertEqual(str(x**3), "x[:]^3")
self.assertEqual(str(-x), "-x[:]")
self.assertEqual(str(x / y / z), "x[:]/y[:]/z[:]")
self.assertEqual(str(x / (y / z)), "x[:]/(y[:]/z[:])")
self.assertEqual(str(x >= y), "x[:] >= y[:]")
self.assertEqual(str(x >= y + z), "x[:] >= y[:] + z[:]")
self.assertEqual(str(x[:2]), "x[:2]")
self.assertEqual(str(x[:]), "x[:]")
self.assertEqual(str(x[1:]), "x[1:]")
self.assertEqual(str(y * [1, 2, 3]), "y[:]*[1, 2, 3]")
self.assertEqual(str(x[:2] == (y * [1, 2, 3])[:2]),
"x[:2] = (y[:]*[1, 2, 3])[:2]")
self.assertEqual(str(y + [1, 2, 3]), "y[:] + [1, 2, 3]")
self.assertEqual(str(x == y + [1, 2, 3]), "x[:] = y[:] + [1, 2, 3]")
self.assertEqual(str(x >= y + [1, 2, 3]), "x[:] >= y[:] + [1, 2, 3]")
self.assertEqual(str(a[:, 0]), "a[:,0]")
self.assertEqual(str(a[2, :]), "a[2,:]")
g = 1 + 3 * a[2, 0]**2
gstrbefore = str(g)
g.ast = None
gstrafter = str(g)
if sys.version_info <= (3, 0):
self.assertEqual(gstrbefore, gstrafter)
def test_vector_sub(self):
x = VectorVariable(3, "x")
y = VectorVariable(3, "y")
ymax = VectorVariable(3, "ymax")
with SignomialsEnabled():
# issue1077 links to a case that failed for SPs only
m = Model(x.prod(), [x + y >= 1, y <= ymax])
m.substitutions["ymax"] = [0.3, 0.5, 0.8]
m.localsolve(verbosity=0)
def test_trivial_vector_gp(self):
"Create and solve a trivial GP with VectorVariables"
x = VectorVariable(2, "x")
y = VectorVariable(2, "y")
prob = Model(cost=(sum(x) + 2 * sum(y)), constraints=[x * y >= 1])
sol = prob.solve(solver=self.solver, verbosity=0)
self.assertEqual(sol("x").shape, (2, ))
self.assertEqual(sol("y").shape, (2, ))
for x, y in zip(sol("x"), sol("y")):
self.assertAlmostEqual(x, np.sqrt(2.), self.ndig)
self.assertAlmostEqual(y, 1 / np.sqrt(2.), self.ndig)
self.assertAlmostEqual(sol["cost"] / (4 * np.sqrt(2)), 1., self.ndig)
def test_vector(self):
x = Variable("x")
y = Variable("y")
z = VectorVariable(2, "z")
p = x*y*z
self.assertTrue(all(p.sub({x: 1, "y": 2}) == 2*z))
self.assertTrue(all(p.sub({x: 1, y: 2, "z": [1, 2]}) ==
z.sub({z: [2, 4]})))
xvec = VectorVariable(3, "x", "m")
xs = xvec[:2].sum()
for x_ in ["x", xvec]:
self.assertAlmostEqual(mag(xs.sub({x_: [1, 2, 3]}).c), 3.0)
def test_left_right(self):
x = VectorVariable(10, 'x')
xL = x.left
xR = x.right
self.assertEqual(xL[0], 0)
self.assertEqual(xL[1], x[0])
self.assertEqual(xR[-1], 0)
self.assertEqual(xR[0], x[1])
self.assertEqual((xL + xR)[1:-1], x[2:] + x[:-2])
x = VectorVariable((2, 3), 'x')
self.assertRaises(NotImplementedError, lambda: x.left)
self.assertRaises(NotImplementedError, lambda: x.right)
def test_te_secant(self):
"Test Taylor expansion of secant(var)"
x = Variable('x')
self.assertEqual(te_secant(x, 1), 1 + x**2/2.)
self.assertEqual(te_secant(x, 2), 1 + x**2/2. + 5*x**4/24.)
self.assertEqual(te_secant(x, 0), 1)
# make sure x was not modified
self.assertEqual(x, Variable('x'))
# try for VectorVariable too
y = VectorVariable(3, 'y')
self.assertEqual(te_secant(y, 1), 1 + y**2/2.)
self.assertEqual(te_secant(y, 2), 1 + y**2/2. + 5*y**4/24.)
self.assertEqual(te_secant(y, 0), 1)
# make sure y was not modified
self.assertEqual(y, VectorVariable(3, 'y'))
def test_te_tangent(self):
"Test Taylor expansion of tangent(var)"
x = Variable('x')
self.assertEqual(te_tangent(x, 1), x)
self.assertEqual(te_tangent(x, 3), x + x**3/3. + 2*x**5/15.)
self.assertEqual(te_tangent(x, 0), 0)
# make sure x was not modified
self.assertEqual(x, Variable('x'))
# try for VectorVariable too
y = VectorVariable(3, 'y')
self.assertEqual(te_tangent(y, 1), y)
self.assertEqual(te_tangent(y, 3), y + y**3/3. + 2*y**5/15.)
self.assertEqual(te_tangent(y, 0), 0)
# make sure y was not modified
self.assertEqual(y, VectorVariable(3, 'y'))
def test_te_exp_minus1(self):
"""Test Taylor expansion of e^x - 1"""
x = Variable('x')
self.assertEqual(te_exp_minus1(x, 1), x)
self.assertEqual(te_exp_minus1(x, 3), x + x**2/2. + x**3/6.)
self.assertEqual(te_exp_minus1(x, 0), 0)
# make sure x was not modified
self.assertEqual(x, Variable('x'))
# try for VectorVariable too
y = VectorVariable(3, 'y')
self.assertEqual(te_exp_minus1(y, 1), y)
self.assertEqual(te_exp_minus1(y, 3), y + y**2/2. + y**3/6.)
self.assertEqual(te_exp_minus1(y, 0), 0)
# make sure y was not modified
self.assertEqual(y, VectorVariable(3, 'y'))
def test_constraintget(self):
x = Variable("x")
x_ = Variable("x", model="_")
xv = VectorVariable(2, "x")
xv_ = VectorVariable(2, "x", model="_")
self.assertEqual(Model(x, [x >= 1])["x"], x)
with self.assertRaises(ValueError):
_ = Model(x, [x >= 1, x_ >= 1])["x"]
with self.assertRaises(ValueError):
_ = Model(x, [x >= 1, xv >= 1])["x"]
self.assertTrue(all(Model(xv.prod(), [xv >= 1])["x"] == xv))
with self.assertRaises(ValueError):
_ = Model(xv.prod(), [xv >= 1, xv_ >= 1])["x"]
with self.assertRaises(ValueError):
_ = Model(xv.prod(), [xv >= 1, x_ >= 1])["x"]
def test_sum(self):
x = VectorVariable(5, 'x')
p = x.sum()
self.assertTrue(isinstance(p, Posynomial))
self.assertEqual(p, sum(x))
x = VectorVariable((2, 3), 'x')
rowsum = x.sum(axis=1)
colsum = x.sum(axis=0)
self.assertTrue(isinstance(rowsum, NomialArray))
self.assertTrue(isinstance(colsum, NomialArray))
self.assertEqual(rowsum[0], sum(x[0]))
self.assertEqual(colsum[0], sum(x[:, 0]))
self.assertEqual(len(rowsum), 2)
self.assertEqual(len(colsum), 3)
def test_sigeq(self):
x = Variable("x")
y = VectorVariable(1, "y")
c = Variable("c")
# test left vector input to sigeq
with SignomialsEnabled():
m = Model(c, [
c >= (x + 0.25)**2 + (y - 0.5)**2,
SignomialEquality(x**2 + x, y)
])
sol = m.localsolve(solver=self.solver, verbosity=0, mutategp=False)
self.assertAlmostEqual(sol("x"), 0.1639472, self.ndig)
self.assertAlmostEqual(sol("y")[0], 0.1908254, self.ndig)
self.assertAlmostEqual(sol("c"), 0.2669448, self.ndig)
# test right vector input to sigeq
with SignomialsEnabled():
m = Model(c, [
c >= (x + 0.25)**2 + (y - 0.5)**2,
SignomialEquality(y, x**2 + x)
])
sol = m.localsolve(solver=self.solver, verbosity=0)
self.assertAlmostEqual(sol("x"), 0.1639472, self.ndig)
self.assertAlmostEqual(sol("y")[0], 0.1908254, self.ndig)
self.assertAlmostEqual(sol("c"), 0.2669448, self.ndig)
# test scalar input to sigeq
y = Variable("y")
with SignomialsEnabled():
m = Model(c, [
c >= (x + 0.25)**2 + (y - 0.5)**2,
SignomialEquality(x**2 + x, y)
])
sol = m.localsolve(solver=self.solver, verbosity=0)
self.assertAlmostEqual(sol("x"), 0.1639472, self.ndig)
self.assertAlmostEqual(sol("y"), 0.1908254, self.ndig)
self.assertAlmostEqual(sol("c"), 0.2669448, self.ndig)
def test_init(self):
"""Test VarKey initialization"""
# test no-name init
_ = ArrayVariable(1)
# test protected field
with self.assertRaises(ValueError):
_ = ArrayVariable(1, idx=5)
# test type
x = VarKey('x')
self.assertEqual(type(x), VarKey)
# test no args
x = VarKey()
self.assertEqual(type(x), VarKey)
y = VarKey(**x.descr)
self.assertEqual(x, y)
# test special 'name' keyword overwriting behavior
x = VarKey('x', flavour='vanilla')
self.assertEqual(x.name, 'x')
x = VarKey(name='x')
self.assertEqual(x.name, 'x')
# pylint: disable=redundant-keyword-arg
self.assertRaises(TypeError, lambda: VarKey('x', name='y'))
self.assertIsInstance(x.latex(), str)
self.assertIsInstance(x.latex_unitstr(), str)
# test index latex printing
y = VectorVariable(2, "y")
self.assertEqual(y[0].key.latex(), "{\\vec{y}}_{0}")
def test_vector_sweep(self):
"""Test sweep involving VectorVariables"""
x = Variable("x")
x_min = Variable("x_min", 1)
y = VectorVariable(2, "y")
m = Model(x, [x >= y.prod()])
m.substitutions.update({y: ('sweep', [[2, 3], [5, 7], [9, 11]])})
a = m.solve(verbosity=0)["cost"]
b = [6, 15, 27, 14, 35, 63, 22, 55, 99]
self.assertTrue(all(abs(a - b) / (a + b) < 1e-7))
x_min = Variable("x_min", 1) # constant to check array indexing
m = Model(x, [x >= y.prod(), x >= x_min])
m.substitutions.update({y: ('sweep', [[2, 3], [5, 7, 11]])})
sol = m.solve(verbosity=0)
a = sol["cost"]
b = [10, 15, 14, 21, 22, 33]
self.assertTrue(all(abs(a - b) / (a + b) < 1e-7))
self.assertEqual(sol["constants"][x_min], 1)
for i, bi in enumerate(b):
self.assertEqual(sol.atindex(i)["constants"][x_min], 1)
ai = m.solution.atindex(i)["cost"]
self.assertTrue(abs(ai - bi) / (ai + bi) < 1e-7)
m = Model(x, [x >= y.prod()])
m.substitutions.update({y: ('sweep', [[2, 3, 9], [5, 7, 11]])})
self.assertRaises(ValueError, m.solve, verbosity=0)
def test_link_conflict(self):
"Check that substitution conflicts are flagged during linking."
x_fx1 = Variable("x", 1, models=["fixed1"])
x_fx1b = Variable("x", 1, models=["fixed1b"])
x_free = Variable("x", models=["free"])
x_fx2 = Variable("x", 2, models=["fixed2"])
lc = LinkedConstraintSet([x_fx1 >= 1, x_fx1b >= 1])
self.assertEqual(lc.substitutions["x"], 1)
lc = LinkedConstraintSet([x_fx1 >= 1, x_free >= 1])
self.assertEqual(lc.substitutions["x"], 1)
self.assertRaises(ValueError, LinkedConstraintSet,
[x_fx1 >= 1, x_fx2 >= 1])
vecx_free = VectorVariable(3, "x", models=["free"])
vecx_fixed = VectorVariable(3, "x", [1, 2, 3], models=["fixed"])
lc = LinkedConstraintSet([vecx_free >= 1, vecx_fixed >= 1])
self.assertEqual(lc.substitutions["x"].tolist(), [1, 2, 3])
def test_elementwise_mult(self):
m = Variable('m')
x = VectorVariable(3, 'x', label='dummy variable')
x_0 = Variable('x', idx=(0, ), shape=(3, ), label='dummy variable')
x_1 = Variable('x', idx=(1, ), shape=(3, ), label='dummy variable')
x_2 = Variable('x', idx=(2, ), shape=(3, ), label='dummy variable')
# multiplication with numbers
v = NomialArray([2, 2, 3]).T
p = NomialArray([2 * x_0, 2 * x_1, 3 * x_2]).T
self.assertEqual(x * v, p)
# division with numbers
p2 = NomialArray([x_0 / 2, x_1 / 2, x_2 / 3]).T
self.assertEqual(x / v, p2)
# power
p3 = NomialArray([x_0**2, x_1**2, x_2**2]).T
self.assertEqual(x**2, p3)
# multiplication with monomials
p = NomialArray([m * x_0, m * x_1, m * x_2]).T
self.assertEqual(x * m, p)
# division with monomials
p2 = NomialArray([x_0 / m, x_1 / m, x_2 / m]).T
self.assertEqual(x / m, p2)
self.assertIsInstance(v.str_without(), str)
self.assertIsInstance(v.latex(), str)
self.assertIsInstance(p.str_without(), str)
self.assertIsInstance(p.latex(), str)
def test_nonnumeric(self):
x = VectorVariable(2, "x")
kd = KeyDict()
kd[x[1]] = "2"
self.assertTrue(np.isnan(kd[x[0]]))
self.assertEqual(kd[x[1]], "2")
self.assertNotIn(x[0], kd)
self.assertIn(x[1], kd)
def test_constraint_gen(self):
x = VectorVariable(3, 'x', label='dummy variable')
x_0 = Variable('x', idx=(0, ), shape=(3, ), label='dummy variable')
x_1 = Variable('x', idx=(1, ), shape=(3, ), label='dummy variable')
x_2 = Variable('x', idx=(2, ), shape=(3, ), label='dummy variable')
v = NomialArray([1, 2, 3]).T
p = [x_0, x_1 / 2, x_2 / 3]
self.assertEqual(list((x <= v).flathmaps({})), [e.hmap for e in p])
def test_units(self):
# inspired by gpkit issue #106
c = VectorVariable(5, "c", "m", "Local Chord")
if gpkit.units:
constraints = (c == 1 * gpkit.units.m)
else:
constraints = (c == 1)
self.assertEqual(len(constraints), 5)
def test_substition(self):
x = VectorVariable(3, 'x', label='dummy variable')
c = {x: [1, 2, 3]}
self.assertEqual(x.sub(c), [Monomial({}, e) for e in [1, 2, 3]])
p = x**2
self.assertEqual(p.sub(c), [Monomial({}, e) for e in [1, 4, 9]])
d = p.sum()
self.assertEqual(d.sub(c), Monomial({}, 14))
def test_te_tangent(self):
"Test Taylor expansion of tangent(var)"
x = Variable('x')
self.assertEqual(te_tangent(x, 1), x)
self.assertEqual(te_tangent(x, 3), x + x**3 / 3 + 2 * x**5 / 15)
self.assertEqual(te_tangent(x, 0), 0)
# make sure x was not modified
self.assertEqual(x, Variable('x'))
# try for VectorVariable too
y = VectorVariable(3, 'y')
self.assertEqual(te_tangent(y, 1), y)
self.assertEqual(te_tangent(y, 3), y + y**3 / 3 + 2 * y**5 / 15)
self.assertEqual(te_tangent(y, 0), 0)
# make sure y was not modified
self.assertEqual(y, VectorVariable(3, 'y'))
with self.assertRaises(NotImplementedError):
_ = te_tangent(x, 16)
def test_empty(self):
x = VectorVariable(3, 'x')
# have to create this using slicing, to get object dtype
empty_posy_array = x[:0]
self.assertRaises(ValueError, empty_posy_array.sum)
self.assertRaises(ValueError, empty_posy_array.prod)
self.assertEqual(len(empty_posy_array), 0)
self.assertEqual(empty_posy_array.ndim, 1)
def test_vector(self):
v = VectorVariable(3, "v")
kd = KeyDict()
kd[v] = np.array([2, 3, 4])
self.assertTrue(all(kd[v] == kd[v.key]))
self.assertTrue(all(kd["v"] == np.array([2, 3, 4])))
self.assertEqual(v[0].key.idx, (0, ))
self.assertEqual(kd[v][0], kd[v[0]])
self.assertEqual(kd[v][0], 2)
kd[v[0]] = 6
self.assertEqual(kd[v][0], kd[v[0]])
self.assertEqual(kd[v][0], 6)
self.assertTrue(all(kd[v] == np.array([6, 3, 4])))
v = VectorVariable(3, "v", "m")
kd[v] = np.array([2, 3, 4])
if gpkit.units:
kd[v[0]] = gpkit.units("inch")
def test_constraint_gen(self):
x = VectorVariable(3, 'x', label='dummy variable')
x_0 = Monomial('x', idx=(0, ), shape=(3, ), label='dummy variable')
x_1 = Monomial('x', idx=(1, ), shape=(3, ), label='dummy variable')
x_2 = Monomial('x', idx=(2, ), shape=(3, ), label='dummy variable')
v = NomialArray([1, 2, 3]).T
p = [x_0, x_1 / 2, x_2 / 3]
self.assertEqual((x <= v).as_posyslt1(), p)
def setup(self, N):
edgeCost = VectorVariable([N, N], 'edgeCost')
edgeMaxFlow = VectorVariable([N, N], 'edgeMaxFlow')
slackCost = Variable('slackCost', 1000)
connect = VectorVariable([N, N], 'connectivity')
flow = VectorVariable([N, N], 'flow')
source = VectorVariable(N, 'source')
sink = VectorVariable(N, 'sink')
slack = VectorVariable(N, 'slack')
constraints = []
with SignomialsEnabled():
for i in range(0, N):
constraints.extend([
Tight([
sink[i] + sum(flow[i, :]) <= slack[i] *
(source[i] + sum(flow[:, i]))
]),
Tight([slack[i] >= 1])
])
for j in range(0, N):
constraints += [
flow[i, j] <= connect[i, j] * edgeMaxFlow[i, j],
connect[i, j] <= 1., flow[i, j] >= 1e-20
]
for i in range(0, N):
for j in range(i + 1, N):
constraints.extend(
[connect[i, j] * connect[j, i] <= 1e-20])
return constraints
