def test_simplify_detect_negative_alias(self):
# Create model, cache it, and load the cache
compiler_options = \
{'detect_aliases': True}
casadi_model = transfer_model(TEST_DIR, 'NegativeAlias',
compiler_options)
ref_model = Model()
x = ca.MX.sym('x')
der_x = ca.MX.sym('der(x)')
ref_model.states = list(map(Variable, [x]))
ref_model.states[0].min = 1
ref_model.states[0].max = 2
ref_model.states[0].nominal = 10
ref_model.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, []))
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.equations = [der_x - x]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
self.assertEquals(casadi_model.states[0].aliases, ['-alias'])
def test_if_else(self):
with open(os.path.join(TEST_DIR, 'IfElse.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'IfElse')
ref_model = Model()
x = ca.MX.sym("x")
y1 = ca.MX.sym("y1")
y2 = ca.MX.sym("y2")
y3 = ca.MX.sym("y3")
y_max = ca.MX.sym("y_max")
ref_model.inputs = list(map(Variable, [x]))
ref_model.outputs = list(map(Variable, [y1, y2, y3]))
ref_model.alg_states = list(map(Variable, [y1, y2, y3]))
ref_model.parameters = list(map(Variable, [y_max]))
ref_model.parameters[0].value = 10
ref_model.equations = [
y1 - ca.if_else(x > 0, 1, 0) * y_max,
ca.if_else(
x > 1, ca.vertcat(y3 - 100, y2 - y_max),
ca.if_else(x > 2, ca.vertcat(y3 - 1000, y2 - y_max - 1),
ca.vertcat(y3 - 10000, y2)))
]
self.assert_model_equivalent_numeric(ref_model, casadi_model)
def test_simplify_all(self):
# Create model, cache it, and load the cache
compiler_options = \
{'expand_vectors': True,
'replace_constant_values': True,
'replace_constant_expressions': True,
'replace_parameter_values': True,
'replace_parameter_expressions': True,
'eliminate_constant_assignments': True,
'detect_aliases': True,
'eliminable_variable_expression': r'_\w+',
'reduce_affine_expression': True}
casadi_model = transfer_model(TEST_DIR, 'Simplify', compiler_options)
ref_model = Model()
p3 = ca.MX.sym('p3')
x = ca.MX.sym('x')
der_x = ca.MX.sym('der(x)')
y = ca.MX.sym('y')
ref_model.states = list(map(Variable, [x]))
ref_model.states[0].min = 1
ref_model.states[0].max = 2
ref_model.states[0].nominal = 10
ref_model.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, [y]))
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.constants = list(map(Variable, []))
constant_values = []
for _cst, v in zip(ref_model.constants, constant_values):
_cst.value = v
ref_model.parameters = list(map(Variable, [p3]))
parameter_values = [np.nan]
for par, v in zip(ref_model.parameters, parameter_values):
par.value = v
A = ca.MX(2, 3)
A[0, 0] = -1.0
A[0, 1] = 1.0
A[1, 0] = -1.1
A[1, 2] = 1.0
b = ca.MX(2, 1)
b[0] = -6 - 3 * p3
b[1] = -7
x = ca.vertcat(x, der_x, y)
ref_model.equations = [ca.mtimes(A, x) + b]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
def test_attributes(self):
with open(os.path.join(TEST_DIR, 'Attributes.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'Attributes')
print(casadi_model)
ref_model = Model()
nested_p1 = ca.MX.sym('nested.p1')
nested_p = ca.MX.sym('nested.p')
nested_s = ca.MX.sym('nested.s')
i = ca.MX.sym("int")
b = ca.MX.sym("bool")
r = ca.MX.sym("real")
der_r = ca.MX.sym("der(real)")
test_state = ca.MX.sym("test_state")
i1 = ca.MX.sym("i1")
i2 = ca.MX.sym("i2")
i3 = ca.MX.sym("i3")
i4 = ca.MX.sym("i4")
cst = ca.MX.sym("cst")
prm = ca.MX.sym("prm")
protected_variable = ca.MX.sym("protected_variable")
ref_model.states = list(map(Variable, [r]))
ref_model.states[0].start = 20
ref_model.der_states = list(map(Variable, [der_r]))
ref_model.alg_states = list(
map(Variable,
[nested_s, i, b, i4, test_state, protected_variable]))
ref_model.alg_states[1].min = -5
ref_model.alg_states[1].max = 10
ref_model.inputs = list(map(Variable, [i1, i2, i3]))
ref_model.inputs[0].fixed = True
ref_model.outputs = list(map(Variable, [i4, protected_variable]))
ref_model.constants = list(map(Variable, [cst]))
constant_values = [1]
for c, v in zip(ref_model.constants, constant_values):
c.value = v
ref_model.parameters = list(map(Variable, [nested_p1, nested_p, prm]))
parameter_values = [1, 2 * nested_p1, 2]
for c, v in zip(ref_model.parameters, parameter_values):
c.value = v
ref_model.equations = [
i4 - ((i1 + i2) + i3),
der_r - (i1 + ca.if_else(b, 1, 0, True) * i),
protected_variable - (i1 + i2), nested_s - 3 * nested_p,
test_state - r
]
self.assert_model_equivalent_numeric(ref_model, casadi_model)
def test_simplify_eliminate_constant_assignments(self):
# Create model, cache it, and load the cache
compiler_options = \
{'eliminate_constant_assignments': True}
casadi_model = transfer_model(TEST_DIR, 'Simplify', compiler_options)
ref_model = Model()
c = ca.MX.sym('c')
p1 = ca.MX.sym('p1')
p2 = ca.MX.sym('p2')
p3 = ca.MX.sym('p3')
p4 = ca.MX.sym('p4')
x = ca.MX.sym('x')
der_x = ca.MX.sym('der(x)')
alias = ca.MX.sym('alias')
y = ca.MX.sym('y')
_tmp = ca.MX.sym('_tmp')
cst = ca.MX.sym('cst')
ref_model.states = list(map(Variable, [x]))
ref_model.states[0].min = 0
ref_model.states[0].max = 3
ref_model.states[0].nominal = 10
ref_model.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, [alias, y, _tmp]))
ref_model.alg_states[0].min = 1
ref_model.alg_states[0].max = 2
ref_model.alg_states[0].nominal = 1
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.constants = list(map(Variable, [c, cst]))
constant_values = [3, 4]
for _cst, v in zip(ref_model.constants, constant_values):
_cst.value = v
ref_model.parameters = list(map(Variable, [p1, p2, p3, p4]))
parameter_values = [2.0, 2 * p1, np.nan, 2 * p3]
for par, v in zip(ref_model.parameters, parameter_values):
par.value = v
ref_model.equations = [
der_x - x - p1 - p2 - p3 - p4, alias - x, y - x - c - _tmp - cst,
_tmp - 0.1 * x
]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
def test_simplify_replace_parameter_values_and_expressions(self):
# Create model, cache it, and load the cache
compiler_options = \
{'replace_parameter_values': True,
'replace_parameter_expressions': True}
casadi_model = transfer_model(TEST_DIR, 'Simplify', compiler_options)
ref_model = Model()
c = ca.MX.sym('c')
p3 = ca.MX.sym('p3')
x = ca.MX.sym('x')
der_x = ca.MX.sym('der(x)')
alias = ca.MX.sym('alias')
y = ca.MX.sym('y')
_tmp = ca.MX.sym('_tmp')
cst = ca.MX.sym('cst')
ref_model.states = list(map(Variable, [x]))
ref_model.states[0].min = 0
ref_model.states[0].max = 3
ref_model.states[0].nominal = 10
ref_model.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, [alias, y, _tmp, cst]))
ref_model.alg_states[0].min = 1
ref_model.alg_states[0].max = 2
ref_model.alg_states[0].nominal = 1
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.constants = list(map(Variable, [c]))
constant_values = [3]
for _cst, v in zip(ref_model.constants, constant_values):
_cst.value = v
ref_model.parameters = list(map(Variable, [p3]))
parameter_values = [np.nan]
for par, v in zip(ref_model.parameters, parameter_values):
par.value = v
ref_model.equations = [
der_x - x - 6 - 3 * p3, alias - x, y - x - c - _tmp - cst,
_tmp - 0.1 * x, cst - 4
]
print(casadi_model)
print(ref_model)
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
def test_builtin(self):
with open(os.path.join(TEST_DIR, 'BuiltinFunctions.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'BuiltinFunctions')
print("BuiltinFunctions", casadi_model)
ref_model = Model()
x = ca.MX.sym("x")
y = ca.MX.sym("y")
z = ca.MX.sym("z")
w = ca.MX.sym("w")
u = ca.MX.sym("u")
ref_model.inputs = list(map(Variable, [x]))
ref_model.outputs = list(map(Variable, [y, z, w, u]))
ref_model.alg_states = list(map(Variable, [y, z, w, u]))
ref_model.equations = [y - ca.sin(ref_model.time), z - ca.cos(x), w - ca.fmin(y, z), u - ca.fabs(w)]
self.assert_model_equivalent_numeric(ref_model, casadi_model)
def test_simplify_reduce_affine_expression_loop(self):
# Create model, cache it, and load the cache
compiler_options = \
{'expand_vectors': True,
'detect_aliases': True,
'reduce_affine_expression': True,
'replace_constant_expressions': True,
'replace_constant_values': True,
'replace_parameter_expressions': True,
'replace_parameter_values': True}
casadi_model = transfer_model(TEST_DIR, 'SimplifyLoop',
compiler_options)
ref_model = Model()
x = ca.MX.sym('x')
y0 = ca.MX.sym('y[0]')
y1 = ca.MX.sym('y[1]')
A = ca.MX(2, 3)
A[0, 0] = -1
A[0, 1] = 1
A[0, 2] = 0
A[1, 0] = -2
A[1, 1] = 0
A[1, 2] = 1
b = ca.MX(2, 1)
b[0, 0] = 0
b[1, 0] = 0
ref_model.states = list(map(Variable, []))
ref_model.der_states = list(map(Variable, []))
ref_model.alg_states = list(map(Variable, [x, y0, y1]))
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
x = ca.vertcat(x, y0, y1)
ref_model.equations = [ca.mtimes(A, x) + b]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
def test_simplify_expand_vectors(self):
# Create model, cache it, and load the cache
compiler_options = \
{'expand_vectors': True}
casadi_model = transfer_model(TEST_DIR, 'SimplifyVector', compiler_options)
ref_model = Model()
x0 = ca.MX.sym('x[0]')
x1 = ca.MX.sym('x[1]')
der_x0 = ca.MX.sym('der(x)[0]')
der_x1 = ca.MX.sym('der(x)[1]')
ref_model.states = list(map(Variable, [x0, x1]))
ref_model.der_states = list(map(Variable, [der_x0, der_x1]))
ref_model.alg_states = list(map(Variable, []))
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.equations = [der_x0 - x0, der_x1 - x1]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)
def test_simplify_reduce_affine_expression(self):
# Create model, cache it, and load the cache
compiler_options = \
{'reduce_affine_expression': True}
casadi_model = transfer_model(TEST_DIR, 'Simplify', compiler_options)
ref_model = Model()
c = ca.MX.sym('c')
p1 = ca.MX.sym('p1')
p2 = ca.MX.sym('p2')
p3 = ca.MX.sym('p3')
p4 = ca.MX.sym('p4')
x = ca.MX.sym('x')
der_x = ca.MX.sym('der(x)')
alias = ca.MX.sym('alias')
y = ca.MX.sym('y')
_tmp = ca.MX.sym('_tmp')
cst = ca.MX.sym('cst')
ref_model.states = list(map(Variable, [x]))
ref_model.states[0].min = 0
ref_model.states[0].max = 3
ref_model.states[0].nominal = 10
ref_model.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, [alias, y, _tmp, cst]))
ref_model.alg_states[0].min = 1
ref_model.alg_states[0].max = 2
ref_model.alg_states[0].nominal = 1
ref_model.inputs = list(map(Variable, []))
ref_model.outputs = list(map(Variable, []))
ref_model.constants = list(map(Variable, [c]))
constant_values = [3]
for _cst, v in zip(ref_model.constants, constant_values):
_cst.value = v
ref_model.parameters = list(map(Variable, [p1, p2, p3, p4]))
parameter_values = [2.0, 2 * p1, np.nan, 2 * p3]
for par, v in zip(ref_model.parameters, parameter_values):
par.value = v
A = ca.MX(5, 6)
A[0, 0] = -1.0
A[0, 1] = 1.0
A[1, 2] = 1.0
A[1, 0] = -1.0
A[2, 0] = -1.0
A[2, 3] = 1.0
A[2, 4] = -1.0
A[2, 5] = -1.0
A[3, 0] = -0.1
A[3, 4] = 1.0
A[4, 5] = 1.0
b = ca.MX(5, 1)
b[0] = -p1 - p2 - p3 - p4
b[2] = -c
b[4] = -4
x = ca.vertcat(x, der_x, alias, y, _tmp, cst)
ref_model.equations = [ca.mtimes(A, x) + b]
# Compare
self.assert_model_equivalent_numeric(casadi_model, ref_model)