def test_function_call(self):
with open(os.path.join(TEST_DIR, 'FunctionCall.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'FunctionCall')
print("FunctionCall", casadi_model)
ref_model = Model()
radius = ca.MX.sym('radius')
diameter = radius * 2
circle_properties = ca.Function('circle_properties', [radius], [
3.14159 * diameter, 3.14159 * radius**2,
ca.if_else(3.14159 * radius**2 > 10, 1, 2),
ca.if_else(3.14159 * radius**2 > 10, 10, 3.14159 * radius**2), 8,
3, 12
])
c = ca.MX.sym("c")
a = ca.MX.sym("a")
d = ca.MX.sym("d")
e = ca.MX.sym("e")
S1 = ca.MX.sym("S1")
S2 = ca.MX.sym("S2")
r = ca.MX.sym("r")
ref_model.alg_states = list(map(Variable, [c, a, d, e, S1, S2, r]))
ref_model.outputs = list(map(Variable, [c, a, d, e, S1, S2]))
ref_model.equations = [
ca.vertcat(c, a, d, e, S1, S2) -
ca.vertcat(*circle_properties.call([r])[0:-1])
]
self.assert_model_equivalent_numeric(ref_model, casadi_model)
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_arrayexpressions(self):
with open(os.path.join(TEST_DIR, 'ArrayExpressions.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'ArrayExpressions')
print(casadi_model)
ref_model = Model()
a = ca.MX.sym("a", 3)
b = ca.MX.sym("b", 4)
c = ca.MX.sym("c", 3)
d = ca.MX.sym("d", 3)
e = ca.MX.sym("e", 3)
g = ca.MX.sym("g", 1)
h = ca.MX.sym("h", 1)
i = ca.MX.sym('i', 2, 3)
B = ca.MX.sym("B", 3)
C = ca.MX.sym("C", 2)
D = ca.MX.sym("D", 3)
E = ca.MX.sym("E", 2)
arx = ca.MX.sym("ar.x", 3)
arcy = ca.MX.sym("arc.y", 2)
arcw = ca.MX.sym("arc.w", 2)
nested1z = ca.MX.sym('nested1.z', 3)
nested2z = ca.MX.sym('nested2.z', 2, 3)
nested1n = ca.MX.sym('nested1.n', 1)
nested2n = ca.MX.sym('nested2.n', 2)
scalar_f = ca.MX.sym("scalar_f")
c_dim = ca.MX.sym("c_dim")
d_dim = ca.MX.sym("d_dim")
ref_model.alg_states = list(map(Variable, [arx, arcy, arcw, nested1z, nested2z, a, c, d, e, scalar_f, g, h, i]))
ref_model.alg_states[6].min = [0, 0, 0]
ref_model.parameters = list(map(Variable, [nested2n, nested1n, d_dim]))
parameter_values = [np.array([3, 3]), 3, 3]
for const, val in zip(ref_model.parameters, parameter_values):
const.value = val
ref_model.outputs = list(map(Variable, [h]))
ref_model.constants = list(map(Variable, [b, c_dim, B, C, D, E]))
constant_values = [np.array([2.7, 3.7, 4.7, 5.7]), 2, ca.linspace(1., 2., 3), 1.7 * ca.DM.ones(2),
ca.DM.zeros(3), ca.DM.ones(2)]
for const, val in zip(ref_model.constants, constant_values):
const.value = val
ref_model.equations = [c - (a + b[0:3] * e), d - (ca.sin(a / b[1:4])), e - (d + scalar_f), g - ca.sum1(c),
h - B[1], arx[1] - scalar_f, nested1z - ca.DM.ones(3), nested2z[0, :].T - np.array([4, 5, 6]),
nested2z[1, 0] - 3, nested2z[1, 1] - 2, nested2z[1, 2] - 1, i[0, :] - ca.transpose(ca.DM.ones(3)), i[1, :] - ca.transpose(ca.DM.ones(3)), arcy[0] - arcy[1],
arcw[0] + arcw[1], a - np.array([1, 2, 3]), scalar_f - 1.3]
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_estimator(self):
with open(os.path.join(TEST_DIR, 'Estimator.mo'), 'r') as f:
txt = f.read()
ast_tree = parser.parse(txt)
casadi_model = gen_casadi.generate(ast_tree, 'Estimator')
ref_model = Model()
print(casadi_model)
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.der_states = list(map(Variable, [der_x]))
ref_model.alg_states = list(map(Variable, [y]))
ref_model.outputs = list(map(Variable, [y]))
ref_model.equations = [der_x + x, y - x]
self.assert_model_equivalent_numeric(ref_model, casadi_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)