def test_matrix_sq():
""" Matrix Form of Minimize(square(v0)) """
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(v0)
con = []
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True)
assert(c.c == [0, 0, 1])
assert(c.A is None)
assert(c.b is None)
assert_G = {
'row':[0, 1, 2],
'col':[2, 2, 0],
'val':[Constant(-1.0), Constant(-1.0), Constant(2.0)]
}
assert_h = [Constant(1.0), Constant(-1.0), Constant(0.0)]
assert_G = COO_to_CS(assert_G, (len(assert_h), len(c.c)), 'col')
assert(c.G == assert_G)
assert(all([c.h[n].value == t.value for n, t in enumerate(assert_h)]))
assert(c.dims == {'q': [3], 'l': 0})
reset_symbols()
def test_relax_sq2norm_constr():
""" Relaxed Form of Minimize(square(norm(v0))) with v0 >= p0"""
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(norm(v0))
con = [v0 >= p0] # should become -v0 + p0 <= 0
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True, only='relax')
assert( type(c.constraints[-1]) is le)
assert( type(c.constraints[-1].expr) is sums.sum)
assert( type(c.constraints[-1].expr.args[0]) is muls.smul)
assert( type(c.constraints[-1].expr.args[1]) is muls.smul)
assert( c.objective is not obj )
assert( 'sym0' == c.objective.name )
string_equals = [
"""((-1.0 * sym1) + (1.0 * norm2(v0))) <= 0""",
"""((-1.0 * sym0) + (1.0 * square(sym1))) <= 0""",
"""((-1.0 * v0) + (p0 * 1.0)) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n],'==',string,'?')
assert(str(c.constraints[n]) == string)
print('SUCCESS!')
reset_symbols()
def test_relax_sq():
""" Relaxed Form of Minimize(square(v0)) """
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(v0)
con = []
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True, only='relax')
assert( len(c.constraints) == 1 )
assert( c.objective is not obj )
assert( 'sym0' == c.objective.name )
assert(type(c.constraints[0]) is le)
assert(c.constraints[0].expr.args[0].curvature == 0)
assert(c.constraints[0].expr.args[1].curvature == +1)
assert(c.constraints[0].expr.args[1].symbol_groups()[0][0].value == 1.0)
assert(c.constraints[0].expr.args[1].symbol_groups()[2][0].name == 'square')
reset_symbols()
def test_smith_sq():
""" Smith Form of Minimize(square(v0)) """
v0 = Variable(name='v0')
v1 = Variable(name='v1')
p0 = Parameter(name='p0')
p1 = Parameter(name='p1')
obj = square(v0)
con = []
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True, only='smith')
assert (len(c.constraints) == 1)
assert (c.objective is not obj)
assert ('sym0' == c.objective.name)
assert (hasattr(c.constraints[0].expr.args[0], 'name'))
assert (c.constraints[0].expr.args[0].name == 'sym0')
assert (hasattr(c.constraints[0].expr.args[1], 'args'))
assert (hasattr(c.constraints[0].expr.args[1].args[0], 'value'))
assert (c.constraints[0].expr.args[1].args[0].value == -1.0)
assert (hasattr(c.constraints[0].expr.args[1].args[1], 'name'))
assert (c.constraints[0].expr.args[1].args[1].name == 'square')
reset_symbols()
def test_relax_sq2norm():
""" Relaxed Form of Minimize(square(norm(v0))) """
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(norm(v0))
con = []
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True, only='relax')
assert( c.objective is not obj )
assert( 'sym0' == c.objective.name )
# Let up on the testing rigor a bit, now that we checked core fundamentals
string_equals = [
"""((-1.0 * sym1) + (1.0 * norm2(v0))) <= 0""",
"""((-1.0 * sym0) + (1.0 * square(sym1))) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n],'==',string,'?')
assert(str(c.constraints[n]) == string)
print('SUCCESS!')
reset_symbols()
def test_matrix_sq2norm_sqcon():
""" Relaxed Form : Minimize(square(norm(v0))) with v0 >= square(v1) """
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(norm(v0 + v1))
con = [v0 >= square(v1)] # should become -v0 + square(v1) <= 0
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True)
sym3 = [v for vn, v in c.vars.items() if vn == 'sym3'][0]
assert_A = {'row': [0, 0, 0],
'col': [0, 1, 4],
'val': [Constant(-1.0), Constant(-1.0), Constant(1.0)]}
assert_b = [Constant(0.0)]
#assert_G = {'row': [0, 0, 1, 2, 3, 4, 5, 6, 7, 8],
# 'col': [0, 5, 3, 4, 2, 2, 3, 5, 5, 1],
# 'val': [Constant(-1.0), Constant(0.0), Constant(-1.0), Constant(1.0),
# Constant(-1.0), Constant(-1.0), Constant(2.0), Constant(-1.0),
# Constant(-1.0), Constant(2.0)]}
assert_G = {'row': [0, 0, 1, 2, 3, 4, 5, 6, 7, 8],
'col': [0, 5, 3, 4, 2, 2, 3, 5, 5, 1],
'val': [Constant(-1.0), Constant(1.0), Constant(-1.0), Constant(1.0),
Constant(-1.0), Constant(-1.0), Constant(2.0), Constant(-1.0),
Constant(-1.0), Constant(2.0)]}
assert_h = [ (-1.0 * sym3), Constant(0.0), Constant(0.0), Constant(1.0),
Constant(-1.0), Constant(0.0), Constant(1.0),
Constant(-1.0), Constant(0.0)]
assert_h = [Constant(0.0), Constant(0.0), Constant(0.0), Constant(1.0),
Constant(-1.0), Constant(0.0), Constant(1.0), Constant(-1.0),
Constant(0.0)]
assert_dims = {'q': [2, 3, 3], 'l': 1}
assert_A = COO_to_CS(assert_A, (len(assert_b), len(c.c)), 'col')
assert_G = COO_to_CS(assert_G, (len(assert_h), len(c.c)), 'col')
assert_c = [0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
assert(c.c == assert_c)
assert(c.A == assert_A)
assert(c.b == assert_b)
assert(c.G == assert_G)
assert(all([c.h[n].value == t.value for n, t in enumerate(assert_h)]))
assert(c.dims == assert_dims)
reset_symbols()
def test_constraints():
v0 = Variable(name='v0')
v1 = Variable(name='v1')
p0 = Parameter(name='p0')
p1 = Parameter(name='p1')
c = (v0 == 0)
print(c)
assert (type(c) == eq)
assert (c.expr.args[0] is v0)
c = (v0 <= 0)
print(c)
assert (type(c) == le)
assert (c.expr.args[0] is v0)
c = (v0 >= 0)
print(c)
assert (type(c) == le)
assert (c.expr.args[0].args[0].value == -1)
assert (c.expr.args[0].args[1] is v0)
c = (v0 >= p0)
print(c)
assert (type(c) == le)
assert (c.expr.args[0].args[0].value == -1)
assert (c.expr.args[0].args[1] is v0)
assert (c.expr.args[1].args[0] is p0)
# TODO: ADD TESTS FOR ATOMS AND FUNCTIONS IN CONSTRAINTS!
# ATOMS in Constraints
c = (v1 + v0 == p0)
print(c)
assert (type(c) == eq)
assert (str(c) == '(p0 + (-1.0 * v1) + (-1.0 * v0)) == 0')
# FUNCTIONS in Constraints
c = (norm(v1) <= v0)
print(c)
assert (type(c) == le)
assert (c.expr.nterms == 2)
assert (c.expr.args[1].args[1] is v0)
reset_symbols()
def test_square_graph():
v0 = Variable(name='v0')
s0 = Symbol(name='s0')
expr = square(v0)
constr = (expr <= s0) # effectively in relaxed smith form
print('Graph form of', end='')
print(constr)
constr = constr.graph_form()
print('-->', constr)
print()
n = max(v0.shape[0], v0.shape[1])
assert (constr.dims == n + 2)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
c = constr # keeps below names same as other tests
string_equals = [
"""(-1.0 + (-1.0 * s0)) <= 0""", """(1.0 + (-1.0 * s0)) <= 0""",
"""((2.0 * v0)) <= 0"""
]
for n, string in enumerate(string_equals):
print(c.constraints[n], '==', string, '?')
assert (str(c.constraints[n]) == str(string))
print('SUCCESS!')
reset_symbols()
def test_relax_least_squares_constr():
""" Relaxed Form : Minimize(square(norm(F*x - g))) with x >= p0 """
x = Variable ((3,1),name='x')
F = Parameter((3,3),name='F')
g = Parameter((3,1),name='g')
objective = square(norm( F*x - g ))
objective = Minimize(objective)
problem = Problem(objective, [x >= 0])
c = Canonicalize(problem, verbose=True, only='relax')
string_equals = [
"""(sym2 + (-1.0 * matmul(F, x))) == 0""",
"""(sym3 + (-1.0 * sym2) + (g * 1.0)) == 0""",
"""((-1.0 * sym1) + (1.0 * norm2(sym3))) <= 0""",
"""((-1.0 * sym0) + (1.0 * square(sym1))) <= 0""",
"""((-1.0 * x)) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n],' ???? ',string, end=' ')
assert(str(c.constraints[n]) == string)
print('... SUCCESS!')
reset_symbols()
def test_elementwisesymbol_into_function():
""" Test a shaped symbol input to a scalar function and
the elementwise output """
x = Variable((3, 1), name='x')
expr = square(x)
print(expr)
constr = (expr <= 0)
print(constr)
expand = constr.expand()
print(expand)
assert (type(constr.expr) is sums.sum)
assert (type(constr.expr.args[0]) is Vector)
assert (len(constr.expr.args[0].args) == 3)
assert (len(expand) == 3)
assert (all([type(a) is le for a in expand]))
reset_symbols()
def test_norm_inf():
x = Variable((3, 1), name='x')
objective = norm(x, kind='inf') # returns max(abs(x))
objective = Minimize(objective)
problem = Problem(objective, [])
c = Canonicalize(problem, verbose=True, only='smith')
assert (len(c.constraints) == 4)
string_equals = [
"""(sym1[0][0] + (-1.0 * abs(x[0][0]))) == 0""",
"""(sym1[1][0] + (-1.0 * abs(x[1][0]))) == 0""",
"""(sym1[2][0] + (-1.0 * abs(x[2][0]))) == 0""",
"""(sym0 + (-1.0 * max(sym1))) == 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n], ' ???? ', string, end=' ')
assert (str(c.constraints[n]) == string)
print('... SUCCESS!')
reset_symbols()
def test_matvec():
""" Test Matrix * Vector product """
a = Parameter((3, 3), name='a')
x = Variable((3, 1), name='x')
m = a * x
print(m, 'with shapes', a.shape, 'x', x.shape)
expanded = m.expand()
print_matrix(expanded)
assert (list_shape(expanded) == m.shape)
# Holds all the indices we assert must be in each ELEMENT of each atom
ind = [[
[[(0, 0), (0, 0)], [(0, 1), (1, 0)], [(0, 2), (2, 0)]],
], [
[[(1, 0), (0, 0)], [(1, 1), (1, 0)], [(1, 2), (2, 0)]],
], [
[[(2, 0), (0, 0)], [(2, 1), (1, 0)], [(2, 2), (2, 0)]],
]]
for n, row in enumerate(ind):
for m, col in enumerate(row):
for s, sumarg in enumerate(col):
for a, mularg_shape in enumerate(sumarg):
assert (
expanded[n][m].args[s].args[a].index == mularg_shape)
reset_symbols()
def test_sqrt_graph():
v0 = Variable(name='v0')
s0 = Symbol(name='s0')
expr = sqrt(v0) # concave
constr = (expr >= s0) # effectively in relaxed smith form
print('Graph form of', end=' ')
print(constr)
constr = constr.graph_form()
print('-->', constr)
assert (constr.dims == 3)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
c = constr
string_equals = [
"""(-1.0 + (-1.0 * v0)) <= 0""",
"""(1.0 + (-1.0 * v0)) <= 0""",
"""((2.0 * s0)) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n], '==', string, '?')
assert (str(c.constraints[n]) == str(string))
print('SUCCESS!')
reset_symbols()
def test_quad_over_lin_x1_graph():
v0 = Variable(name='v0')
s0 = Symbol(name='s0')
x = v0
expr = quad_over_lin([1], x)
constr = (expr <= s0) # effectively in relaxed smith form
print('Graph form of', end='')
print(constr)
constr = constr.graph_form()
print('-->', constr)
print()
assert (constr.dims == 3)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
c = constr # keeps below names same as other tests
string_equals = [
"""((-1.0 * v0) + (-1.0 * s0)) <= 0""",
"""((1.0 * v0) + (-1.0 * s0)) <= 0""",
"""(2.0) <= 0""" # although this constraint is weird, it is required
]
for n, string in enumerate(string_equals):
print(c.constraints[n], '==', string, '?')
assert (str(c.constraints[n]) == str(string))
print('SUCCESS!')
reset_symbols()
def test_symbol_curvature():
v = Variable(name='v')
assert (v.curvature == 0)
p = Parameter(name='p')
assert (p.curvature == 0)
reset_symbols()
def test_matrix_sq2norm_constr():
""" Matrix Form of Minimize(square(norm(v0))) with v0 >= p0"""
v0 = Variable(name = 'v0')
v1 = Variable(name = 'v1')
p0 = Parameter(name = 'p0')
p1 = Parameter(name = 'p1')
obj = square(norm(v0))
con = [v0 >= p0] # should become -v0 + p0 <= 0
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True)
assert_c = [0.0, 0.0, 1.0, 0.0]
assert_A = COO_to_CS({'row':[],'col':[],'val':[]}, (0,4), 'col')
assert_G = {'row': [0, 1, 2, 3, 4, 5], 'col': [0, 3, 0, 2, 2, 3],
'val': [Constant(-1.0), Constant(-1.0), Constant(1.0),
Constant(-1.0), Constant(-1.0), Constant(2.0)]}
assert_h = [(-1.0 * p0), Constant(0.0), Constant(0.0),
Constant(1.0), Constant(-1.0), Constant(0.0)]
assert_G = COO_to_CS(assert_G, (len(assert_h), len(c.c)), 'col')
assert(c.c == assert_c)
assert(c.A is None)
assert(c.b is None)
assert(c.G == assert_G)
assert(all([c.h[n].value == t.value for n, t in enumerate(assert_h)]))
assert(c.dims == {'q': [2, 3], 'l': 1})
reset_symbols()
def test_mul_redirect():
""" Test that mul redirects properly to matmul """
a = Parameter((10, 1), name='a')
b = Variable((1, 10), name='b')
m = a * b
assert (type(m) is matmul)
assert (m.args[0] is a)
assert (m.args[1] is b)
reset_symbols()
def test_live_symbols():
v = Variable((10, ), name='v')
assert (v.shape == (10, 1))
assert (v.name == 'v')
assert ('v' in symbols.keys())
reset_symbols()
assert ('v' not in symbols.keys())
v = Variable((10, ))
assert (v.shape == (10, 1))
assert (v.name == 'sym0')
assert ('sym0' in symbols.keys())
reset_symbols()
assert ('sym0' not in symbols.keys())
def test_quad_over_lin_comp_graph():
v0 = Variable(name='v0')
v1 = Variable(name='v1')
s0 = Symbol(name='s0')
x = [(3 - v0), (1 + v1)]
expr = quad_over_lin(x, 1)
constr = (expr <= s0) # effectively in relaxed smith form
print('Graph form of', end='')
print(constr)
constr = constr.graph_form()
print('-->', constr)
print()
n = len(x)
assert (constr.dims == n + 2)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
c = constr # keeps below names same as other tests
string_equals = [
"""(-1.0 + (-1.0 * s0)) <= 0""",
"""(1.0 + (-1.0 * s0)) <= 0""",
"""(6.0 + (-2.0 * v0)) <= 0""",
"""(2.0 + (2.0 * v1)) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n], '==', string, '?')
assert (str(c.constraints[n]) == str(string))
print('SUCCESS!')
reset_symbols()
def test_smith_sq2norm_sqcon():
""" Smith Form : Minimize(square(norm(v0))) with v0 >= square(v1) """
v0 = Variable(name='v0')
v1 = Variable(name='v1')
p0 = Parameter(name='p0')
p1 = Parameter(name='p1')
obj = square(norm(v0 + v1))
con = [v0 >= square(v1)] # should become -v0 + square(v1) <= 0
p = Problem(Minimize(obj), con)
c = Canonicalize(p, verbose=True, only='smith')
assert (type(c.constraints[-1]) is le)
assert (type(c.constraints[-1].expr) is sums.sum)
assert (type(c.constraints[-1].expr.args[0]) is muls.smul)
assert (type(c.constraints[-1].expr.args[1]) is muls.smul)
assert (c.objective is not obj)
assert ('sym0' == c.objective.name)
string_equals = [
"""(sym2 + (-1.0 * v0) + (-1.0 * v1)) == 0""",
"""(sym1 + (-1.0 * norm2(sym2))) == 0""",
"""(sym0 + (-1.0 * square(sym1))) == 0""",
"""(sym3 + (-1.0 * square(v1))) == 0""",
"""((-1.0 * v0) + (1.0 * sym3)) <= 0""",
]
for n, string in enumerate(string_equals):
print(c.constraints[n], ' ???? ', string, end=' ')
assert (str(c.constraints[n]) == string)
print('... SUCCESS!')
reset_symbols()
def test_matrix_least_squares_constr():
""" Minimize(square(norm(F*x - g))) with x >= p0 """
x = Variable ((3,1),name='x')
F = Parameter((3,3),name='F')
g = Parameter((3,1),name='g')
objective = square(norm( F*x - g ))
objective = Minimize(objective)
problem = Problem(objective, [x >= 1])
c = Canonicalize(problem, verbose=True)
# Test for errors, not asserts, and for solution outcome (via ecos_solution)
reset_symbols()
def check_curvy_function(function, asserted_curvature):
print('Testing Curvature of', function.name)
v = Variable(name='v')
e = function(v)
if asserted_curvature > 0:
assert (e.curvature > 0)
else:
assert (e.curvature < 0)
e = -1 * function(v)
if asserted_curvature > 0:
assert (e.curvature < 0)
else:
assert (e.curvature > 0)
reset_symbols()
def test_matmul_constraint():
""" Test that constraints with matmul are expanded elementwise in canon """
p = Parameter((3, 1), name='p')
a = Parameter((3, 3), name='a')
x = Variable((3, 1), name='x')
expr = a * x
print('expr', expr)
constr = (expr <= p)
print('constr', constr)
constr = constr.expand()
print('-->', constr)
print()
assert (len(constr) == 3)
assert (all([type(a) is le for a in constr]))
reset_symbols()
def test_norm_graph():
v0 = Variable(name='v0')
s0 = Symbol(name='s0')
expr = norm(v0)
constr = (expr <= s0) # effectively in relaxed smith form
print('Graph form of', end='')
print(constr)
constr = constr.graph_form()
print('-->', constr)
print()
n = max(v0.shape[0], v0.shape[1])
assert (constr.dims == n + 1)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
assert (constr.constraints[1].expr.args[0] is v0)
assert (constr.constraints[0].expr.args[0].args[1] is s0)
reset_symbols()
def test_min_graph():
v0 = Variable((3, 1), name='v0')
s0 = Symbol(name='s0')
expr = minimum(v0) # concave
constr = (expr >= s0) # effectively in relaxed smith form
print('Graph form of', end=' ')
print(constr)
constr = constr.graph_form()
print('-->', constr)
print()
print('Expanded:')
constrs = constr.expand()
for con in constrs:
print('-->', con)
print()
assert (constr.dims == 1)
assert (type(constr) is SecondOrderConeConstraint)
assert (all([type(c) is le for c in constr.constraints]))
string_equals = [
["""((1.0 * v0[0][0]) + (-1.0 * s0)) <= 0"""],
["""((1.0 * v0[1][0]) + (-1.0 * s0)) <= 0"""],
["""((1.0 * v0[2][0]) + (-1.0 * s0)) <= 0"""],
]
for i, c in enumerate(constrs):
for n, string in enumerate(string_equals[i]):
print(c.constraints[n], '==', string, '?')
assert (str(c.constraints[n]) == str(string))
print('SUCCESS!')
reset_symbols()
def test_elementwiselist_into_function():
""" Test a list input to a scalar function and the elementwise output """
x = Variable(name='x')
y = Variable(name='y')
z = Variable(name='z')
a = Variable(name='a')
b = Variable(name='b')
c = Variable(name='c')
expr = square([x, y, z, a, b, c])
print(expr)
constr = (expr <= 0)
print(constr)
assert (type(constr.expr) is sums.sum)
assert (type(constr.expr.args[0]) is Vector)
assert (len(constr.expr.args[0].args) == 6)
reset_symbols()
def test_shape():
v = Variable(name='v')
assert (v.shape == (1, 1))
assert (v.name == 'v')
v.clean()
v = Variable((10, ), name='v')
assert (v.shape == (10, 1))
assert (v.name == 'v')
v.clean()
v = Variable((10, 10), name='v')
assert (v.shape == (10, 10))
assert (v.name == 'v')
v.clean()
def test_summation():
v0 = Variable(name='v0')
v1 = Variable(name='v1')
p0 = Parameter(name='p0')
p1 = Parameter(name='p1')
s = v0
print(s)
assert (type(s) is Variable)
assert (s is v0)
s = v0 + 0
print(s)
assert (type(s) is sums.sum)
assert (s.args[0] is v0)
assert (s.nterms == 1)
s = v0 + v1
print(s)
assert (s.nterms == 2)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1])
assert (s.coeffs['v0'].value == +1)
assert (s.coeffs['v1'].value == +1)
s = v0 + v1 + 1
print(s)
assert (s.nterms == 3)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1, None])
assert (s.coeffs['v0'].value == +1)
assert (s.coeffs['v1'].value == +1)
assert (s.offset[0].value == 1)
s = v0 + (-v1 + (1 + p1))
print(s)
assert (s.nterms == 4)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1, None, None])
assert (s.coeffs['v0'].value == +1)
assert (s.coeffs['v1'].value == -1)
assert ((s.offset[0]).value == 1)
assert ((s.offset[1]) == p1)
s = 3 * v0 + 2 * v1 + 4
print(s)
assert (s.nterms == 3)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1, None])
assert (s.coeffs['v0'].value == 3)
assert (s.coeffs['v1'].value == 2)
assert (s.offset[0].value == 4)
s = 3 * (v0 + 2 * v1 + 4)
print(s)
assert (s.nterms == 3)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1, None])
assert (s.coeffs['v0'].value == 3)
assert (s.coeffs['v1'].value == 6)
assert (s.offset[0].value == 12)
s = p0 * (v0 + p1 * v1 + 4)
print(s)
assert (s.nterms == 3)
assert (type(s) is sums.sum)
assert (s.vars == [v0, v1, None])
assert (s.coeffs['v0'] == p0)
assert (s.coeffs['v1'].args[0] == p0)
assert (s.coeffs['v1'].args[1] == p1)
assert ((s.offset[0]).args[0].value == 4.0)
assert ((s.offset[0]).args[1] == p0)
reset_symbols()
def test_scalarmul():
s0 = Symbol(name='s0')
v0 = Variable(name='v0')
v1 = Variable(name='v1')
p0 = Parameter(name='p0')
p1 = Parameter(name='p1')
m = 1 * v0
if debug:
print(m)
assert (m == v0)
m = 2 * v0
if debug:
print(m)
assert (m.coefficient_of(v0).value == 2)
m = 3 * (2 * v0)
if debug:
print(m)
assert (m.coefficient_of(v0).value == 6)
m = p0 * (2 * v0)
if debug:
print(m)
assert (type(m.coefficient_of(v0)) == muls.smul)
assert (p0 in m.coefficient_of(v0).args)
assert (2.0 in [
arg.value for arg in m.coefficient_of(v0).args
if hasattr(arg, 'value')
])
m = (-1 * s0)
if debug:
print(m)
assert (hasattr(m.args[0], 'value'))
assert (m.args[0].value == -1)
assert (m.args[1] is s0)
m = 3 * (2 * (4 * v0))
if debug:
print(m)
assert (m.coefficient_of(v0).value == 24)
m = 3 * (2 * (4 * v0 + 1 * v1))
if debug:
print(m)
assert (m.coefficient_of(v0).value == 24)
assert (m.coefficient_of(v1).value == 6)
m = 2 * (3 * (p0 + p1 * v1) + 3 * (2 * p0 + 3 * v0))
v0_coeff = m.coefficient_of(v0)
v1_coeff = m.coefficient_of(v1)
if debug:
print(m)
assert (m.nterms == 4)
assert (type(v0_coeff) == Constant)
assert (type(v1_coeff) == muls.smul)
assert (v0_coeff.value == 18)
assert (p1 in v1_coeff.args)
assert (6.0
in [arg.value for arg in v1_coeff.args if hasattr(arg, 'value')])
# Test factorization of terms
m = 2 * (3 * (p0 + p1 * v1) + 3 * (2 * p0 + 3 * v0)) + v1
v0_coeff = m.coefficient_of(v0)
v1_coeff = m.coefficient_of(v1)
if debug:
print(m)
assert (m.nterms == 5)
assert (type(v0_coeff) == Constant)
assert (type(v1_coeff) == sums.sum)
assert (v0_coeff.value == 18)
assert (v1_coeff.args[0].args[0].value == 6.0)
assert (v1_coeff.args[0].args[1] == p1)
assert (v1_coeff.args[1].value == 1.0)
reset_symbols()