def check_comments16():
parse_wrap_check('1 g', Syntax.definitely_constant_value)
parse_wrap_check("'Number of constants'", Syntax.comment_con)
parse_wrap_check("axx = 1.2 g", Syntax.setname_rvalue)
parse_wrap_check("axx", Syntax.constant_name)
expr=Syntax.constant_name + Syntax.EQ + Syntax.definitely_constant_value
parse_wrap_check("axx = 1.2 g", expr)
def parse(t):
return CDPLanguage.SetNameConstant(t[0], t[1], t[2])
expr2 = sp(expr, parse)
parse_wrap_check("axx = 1.2 g", expr2)
parse_wrap_check("axx = 1.2 g", Syntax.setname_constant)
parse_wrap_check("a = 1 g", Syntax.setname_constant)
parse_wrap_check("a = 1 g 'Number of constants'", Syntax.setname_constant)
parse_wrap_check("constant a = 1 g 'Number of constants'", Syntax.setname_constant)
parse_wrap_check(
"constant gravity = (9.8 m/s^2) / 6 dimensionless 'Gravity on Earth'",
Syntax.setname_constant)
s = """
mcdp {
' One example of documentation for the entire MCDP.'
requires mass [kg] 'The mass that must be transported.'
provides capacity [kWh] 'The capacity of the battery.'
constant a = 1 g 'Number of constants'
constant gravity = (9.8 m/s^2) / 6 dimensionless 'Gravity on Earth'
variable x, y [Nat] 'constant '
}"""
parse_ndp(s)
def check_lang99(): # TODO: rename
s = """
mcdp {
requires r [Nat]
f = Nat: 2 + required r
provides f
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
requires r [Nat]
f = Nat: 2 + r
provides f
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
provides f [Nat]
r = Nat: 2 + f
requires r
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_approx_res4(): # check_error line
s = ("""
mcdp {
provides f [m]
requires r [m]
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f f
""")
try:
parse_ndp(s) # , Syntax.ndpt_dp_rvalue)
except DPSyntaxError as e:
s = str(e)
assert 'line 18' in s
return
else:
raise Exception()
def constant_inverse_constant():
s = """
mcdp {
constant x = 1 / 2 m
}
"""
parse_ndp(s)
def check_comments03b():
""" Double comments """
s = """ mcdp { '''Doc''' } """
parse_ndp(s)
s = ''' mcdp { """Doc""" } '''
parse_ndp(s)
def imlements1():
s = """
mcdp {
implements mcdp { }
}
"""
parse_ndp(s)
def check_comments16():
parse_wrap_check('1 g', Syntax.definitely_constant_value)
parse_wrap_check("'Number of constants'", Syntax.comment_con)
parse_wrap_check("axx = 1.2 g", Syntax.setname_rvalue)
parse_wrap_check("axx", Syntax.constant_name)
# expr = Syntax.constant_name + Syntax.EQ + Syntax.definitely_constant_value
# parse_wrap_check("axx = 1.2 g", expr)
# def parse(t):
# return CDPLanguage.SetNameConstant(t[0], t[1], t[2], t[3])
# expr2 = sp(expr, parse)
# parse_wrap_check("axx = 1.2 g", expr2)
parse_wrap_check("axx = 1.2 g", Syntax.setname_constant)
parse_wrap_check("a = 1 g", Syntax.setname_constant)
parse_wrap_check("a = 1 g 'Number of constants'", Syntax.setname_constant)
parse_wrap_check("constant a = 1 g 'Number of constants'", Syntax.setname_constant)
parse_wrap_check(
"constant gravity = (9.8 m/s^2) / 6 dimensionless 'Gravity on Earth'",
Syntax.setname_constant)
s = """
mcdp {
' One example of documentation for the entire MCDP.'
requires mass [kg] 'The mass that must be transported.'
provides capacity [kWh] 'The capacity of the battery.'
constant a = 1 g 'Number of constants'
constant gravity = (9.8 m/s^2) / 6 dimensionless 'Gravity on Earth'
variable x, y [Nat] 'constant '
}"""
parse_ndp(s)
def check_approx_res4(): # check_error line
s = ("""
mcdp {
provides f [m]
requires r [m]
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f
r >= f f
""")
try:
parse_ndp(s) # , Syntax.ndpt_dp_rvalue)
except DPSyntaxError as e:
s = str(e)
assert 'line 18' in s
return
else:
raise Exception()
def check_comments03b():
""" Double comments """
s = """ mcdp { '''Doc''' } """
parse_ndp(s)
s = ''' mcdp { """Doc""" } '''
parse_ndp(s)
def constant_inverse3():
s = """
mcdp {
provides precision [1/mm]
provided precision <= 1 / 2 m
}
"""
parse_ndp(s)
def check_lang107(): # TODO: rename
""" sum of nat constants """
s = """
mcdp {
requires x [Nat]
required x >= Nat:2 + Nat:1
}
"""
parse_ndp(s)
def check_lang107(): # TODO: rename
""" sum of nat constants """
s = """
mcdp {
requires x [Nat]
required x >= Nat:2 + Nat:1
}
"""
parse_ndp(s)
def check_lang106(): # TODO: rename
""" Refininement when variables have the same name. """
s = """
mcdp {
requires power [Nat]
provides power [Nat]
power >= power + Nat:1
}
"""
parse_ndp(s)
def check_lang106(): # TODO: rename
""" Refininement when variables have the same name. """
s = """
mcdp {
requires power [Nat]
provides power [Nat]
power >= power + Nat:1
}
"""
parse_ndp(s)
def missing_power_resources():
parse_ndp("""
mcdp {
provides f [dimensionless]
requires r [dimensionless]
provided f <= (required r)²
}
""")
def check_lang89b(): # TODO: rename
s = """
mcdp {
provides f [Nat]
requires r [Nat]
r >= max(f, f, f)
}
"""
parse_ndp(s).get_dp()
def check_lang89b(): # TODO: rename
s = """
mcdp {
provides f [Nat]
requires r [Nat]
r >= max(f, f, f)
}
"""
parse_ndp(s).get_dp()
def special_letters1():
s = """
mcdp {
provides lift [N]
requires power [W]
requires budget [USD]
required budget ≥ 1000 USD
requires mass = 1 kg
l = provided lift
#01234
p₀ = 1 W
p₁ = 1 W / N
p₂ = 1 W / N²
α₁ = 10
# xₘₐₓ
required power ≥ p₀ + p₁·l + p₂·l²
}
"""
parse_ndp(s)
# should be able to use a_1 and a₁ as synonyms
s = """
mcdp {
a_1 = 42
b = a₁
}
"""
parse_ndp(s)
s = """
mcdp {
a₁ = 42
b = a_1
}
"""
parse_ndp(s)
s = """
mcdp {
η = 42
b = eta
}
"""
parse_ndp(s)
s = """
mcdp {
eta = 42
b = η
}
"""
parse_ndp(s)
def check_variables02():
s = """
mcdp {
provides f [Nat]
requires r [Nat]
variable x [Nat]
provided f <= x
x <= required r
}
"""
parse_ndp(s)
def check_variables12():
s = """
mcdp {
provides z [Nat]
variable x, y [Nat]
x + y >= ceil(sqrt(x)) + ceil(sqrt(y)) + provided z
requires x, y
}
"""
parse_ndp(s)
def check_lang118(): # TODO: rename
""" Warnings """
s = """
mcdp {
provides f [Nat]
f <= Nat: 2
}
"""
context = ModelBuildingContext()
parse_ndp(s, context)
w = context.warnings
assert_equal(len(w), 1)
assert_equal(w[0].which, MCDPWarnings.LANGUAGE_REFERENCE_OK_BUT_IMPRECISE)
def check_lang118(): # TODO: rename
""" Warnings """
s = """
mcdp {
provides f [Nat]
f <= Nat: 2
}
"""
context = ModelBuildingContext()
parse_ndp(s, context)
w = context.warnings
assert_equal(len(w), 1)
assert_equal(w[0].which, MCDPWarnings.LANGUAGE_REFERENCE_OK_BUT_IMPRECISE)
def check_lang_invplus():
assert_parsable_to_connected_ndp("""
mcdp {
provides a [s]
requires x [s]
requires y [s]
x + y >= a
}""")
s = """
mcdp {
provides a [s]
requires x [s]
requires y [s]
requires z [s]
x + y * z >= a
}"""
try:
parse_ndp(s)
except DPSemanticError as e:
if 'Inconsistent units' in str(e):
pass
else:
msg = 'Expected inconsistent unit error.'
raise_desc(Exception, msg)
else:
msg = 'Expected exception'
raise_desc(Exception, msg)
s = """
mcdp {
provides a [s]
requires x [s]
requires y [hour]
x + y >= a
}"""
try:
parse_ndp(s)
except DPNotImplementedError as e:
pass
else:
msg = 'Expected DPNotImplementedError'
raise_desc(Exception, msg)
def check_lang_invplus():
assert_parsable_to_connected_ndp("""
mcdp {
provides a [s]
requires x [s]
requires y [s]
x + y >= a
}""")
s = """
mcdp {
provides a [s]
requires x [s]
requires y [s]
requires z [s]
x + y * z >= a
}"""
try:
parse_ndp(s)
except DPSemanticError as e:
if 'Inconsistent units' in str(e):
pass
else:
msg = 'Expected inconsistent unit error.'
raise_desc(Exception, msg)
else:
msg = 'Expected exception'
raise_desc(Exception, msg)
s = """
mcdp {
provides a [s]
requires x [s]
requires y [hour]
x + y >= a
}"""
try:
parse_ndp(s)
except DPNotImplementedError as e:
pass
else:
msg = 'Expected DPNotImplementedError'
raise_desc(Exception, msg)
def assert_parse_ndp_semantic_error(string, contains=None):
"""
Asserts that parsing this string as an NDP will raise
a DPSemanticError. If contains is not None, it is
a substring that must be contained in the error.
Returns the exception.
"""
try:
res = parse_ndp(string)
except DPSemanticError as e:
if contains is not None:
s = str(e)
if not contains in s:
msg = 'Expected a DPSemanticError with substring %r.' % contains
raise_wrapped(TestFailed, e, msg, string=string)
return e
else:
return e
except BaseException as e:
msg = 'Expected DPSemanticError, but obtained %s.' % type(e)
raise_wrapped(TestFailed, e, msg, string=string)
msg = 'Expected DPSemanticError, but no exception was thrown.'
raise_desc(TestFailed, msg, string=string, result=res)
assert False
def check_comments_show_up():
s = """
# comment1
mcdp {
requires x [Nat]
# comment2
requires x [Nat]
}
"""
try:
parse_ndp(s)
except DPSemanticError as e:
st = str(e)
if not 'comment2' in st:
msg = 'Comments are not preserved'
raise_wrapped(Exception, e, msg)
def check_comments_show_up():
s = """
# comment1
mcdp {
requires x [Nat]
# comment2
requires x [Nat]
}
"""
try:
parse_ndp(s)
except DPSemanticError as e:
st = str(e)
if not 'comment2' in st:
msg = 'Comments are not preserved'
raise_wrapped(Exception, e, msg)
def check_lang89d(): # TODO: rename
# All of these should be equivalent to Min1(Nat, 2)
min3s = [ """
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(f, Nat:2)
} ""","""
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(f, Nat:2, Nat:3)
} ""","""
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(Nat:2, f, Nat:3)
}"""]
for s in min3s:
# print '-' * 10
# print s
dp = parse_ndp(s).get_dp()
# print dp.repr_long()
check_isinstance(dp, MinF1DP)
assert dp.value == 2
def assert_parse_ndp_semantic_error(string, contains=None):
"""
Asserts that parsing this string as an NDP will raise
a DPSemanticError. If contains is not None, it is
a substring that must be contained in the error.
Returns the exception.
"""
try:
res = parse_ndp(string)
except DPSemanticError as e:
if contains is not None:
s = str(e)
if not contains in s:
msg = 'Expected a DPSemanticError with substring %r.' % contains
raise_wrapped(TestFailed, e, msg, string=string)
return e
else:
return e
except BaseException as e:
msg = 'Expected DPSemanticError, but obtained %s.' % type(e)
raise_wrapped(TestFailed, e, msg, string=string)
msg = 'Expected DPSemanticError, but no exception was thrown.'
raise_desc(TestFailed, msg, string=string, result=res)
assert False
def check_lang89d(): # TODO: rename
# All of these should be equivalent to Min1(Nat, 2)
min3s = [
"""
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(f, Nat:2)
} """, """
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(f, Nat:2, Nat:3)
} """, """
mcdp {
provides f [Nat]
requires r [Nat]
r >= min(Nat:2, f, Nat:3)
}"""
]
for s in min3s:
# print '-' * 10
# print s
dp = parse_ndp(s).get_dp()
# print dp.repr_long()
check_isinstance(dp, MinF1DP)
assert dp.value == 2
def check_approx_res3():
s = """
mcdp {
requires y [m]
provides x [m]
y >= approx(x, 1 J)
}
"""
try:
parse_ndp(s)
except DPSemanticError as e:
s = str(e)
assert 'The step is specified in a unit' in s
else:
raise Exception()
def sum01():
s = """
mcdp {
a = instance mcdp {
requires mass = 10 g
}
b = instance mcdp {
requires mass = 10 g
}
requires mass = sum mass required by *
}
"""
parse_ndp(s)
def assert_parsable_to_connected_ndp(s , desc=None): # @UnusedVariable
""" This asserts that s can be compiled to a *connected* ndp. """
res = parse_ndp(s)
if isinstance(res, SimpleWrap):
return res
ndp = res.abstract()
#print(ndp.repr_long())
return ndp
def check_approx_res3():
s = """
mcdp {
requires y [m]
provides x [m]
y >= approx(x, 1 J)
}
"""
try:
parse_ndp(s)
except DPSemanticError as e:
s = str(e)
assert 'The step is specified in a unit' in s
else:
raise Exception()
def assert_parsable_to_connected_ndp(s, desc=None): # @UnusedVariable
""" This asserts that s can be compiled to a *connected* ndp. """
res = parse_ndp(s)
if isinstance(res, SimpleWrap):
return res
ndp = res.abstract()
#print(ndp.repr_long())
return ndp
def sum02():
s = """
mcdp {
a = instance mcdp {
provides capacity = 10 g
}
b = instance mcdp {
provides capacity = 10 g
}
provides capacity = sum capacity provided by *
}
"""
parse_ndp(s)
def check_shortcut5_context():
s = """
mcdp {
provides f1,f2 [Nat]
requires r1,r2 [Nat]
}
"""
ndp = parse_ndp(s)
assert_equal(['r1', 'r2'], ndp.get_rnames())
assert_equal(['f1', 'f2'], ndp.get_fnames())
def check_lang113(): # TODO: rename
s = """
mcdp {
provides x = Nat:1 * 10 g
}
"""
ndp = parse_ndp(s)
dp = ndp.get_dp()
print dp.repr_long()
def check_addmake1():
parse_wrap_check(""" addmake(root: code mcdp_lang_tests.syntax_misc.f) mcdp {} """,
Syntax.ndpt_addmake)
ndp = parse_ndp(""" addmake(root: code mcdp_lang_tests.syntax_misc.f) mcdp {} """)
assert len(ndp.make) == 1
assert ndp.make[0][0] == 'root'
from mcdp_lang.eval_ndp_imp import ImportedFunction
assert isinstance(ndp.make[0][1], ImportedFunction)
def check_lang96(): # TODO: rename
s = """
mcdp {
requires rb [J]
provides f2 [J]
f2 <= rb + 2 J
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_shortcut5_context():
s = """
mcdp {
provides f1,f2 [Nat]
requires r1,r2 [Nat]
}
"""
ndp = parse_ndp(s)
assert_equal(['r1','r2'], ndp.get_rnames())
assert_equal(['f1','f2'], ndp.get_fnames())
def check_lang96(): # TODO: rename
s = """
mcdp {
requires rb [J]
provides f2 [J]
f2 <= rb + 2 J
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang113(): # TODO: rename
s="""
mcdp {
provides x = Nat:1 * 10 g
}
"""
ndp = parse_ndp(s)
dp = ndp.get_dp()
print dp.repr_long()
def check_lang92(): # TODO: rename
s = """
mcdp {
provides f [m]
requires r [m]
max(provided f, 5 m) <= required r
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang94(): # TODO: rename
s = """
mcdp {
provides f [m]
requires r [m]
provided f <= min(required r, 5m)
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang97(): # TODO: rename
""" Requires shortcut with constant """
s = """
mcdp {
x = Nat: 2
requires x
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
x = Nat: 2
y = Nat: 3
requires x, y
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang111(): # TODO: rename
""" constant ref for functions """
s = """
mcdp {
c = Nat: 2
provides f = c
}
"""
ndp = parse_ndp(s)
dp = ndp.get_dp()
print dp.repr_long()
def check_lang94(): # TODO: rename
s = """
mcdp {
provides f [m]
requires r [m]
provided f <= min(required r, 5m)
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang111(): # TODO: rename
""" constant ref for functions """
s = """
mcdp {
c = Nat: 2
provides f = c
}
"""
ndp = parse_ndp(s)
dp = ndp.get_dp()
print dp.repr_long()
def check_lang97(): # TODO: rename
""" Requires shortcut with constant """
s = """
mcdp {
x = Nat: 2
requires x
}
"""
parse_ndp(s).get_dp()
# print dp.repr_long()
s = """
mcdp {
x = Nat: 2
y = Nat: 3
requires x, y
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang92(): # TODO: rename
s = """
mcdp {
provides f [m]
requires r [m]
max(provided f, 5 m) <= required r
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang95b(): # TODO: rename
# Nat and rcomp
s = """
mcdp {
requires r [Nat]
provides f [Nat]
provided f + Rcomp:2.3 <= required r
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
requires r [Nat]
provides f [Nat]
f <= required r + Rcomp:2.3
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
requires r [Nat]
provides f [Nat]
f <= required r + Top Rcomp
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
s = """
mcdp {
requires r [Nat]
provides f [Nat]
provided f + Top Rcomp <= required r
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_comments07(): # rename check_addition_nat_rcomp
s = """
mcdp {
variable a, c [dimensionless]
c >= square(a) + Nat:1
a >= square(c)
} """
parse_ndp(s)
s = """
mcdp {
variable a, c [Rcomp]
c >= square(a) + Nat:1
a >= square(c)
} """
parse_ndp(s)
def check_lang89e(): # TODO: rename
s = """
mcdp {
provides f [Nat]
requires r [Nat]
r >= ceil(f)
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang88b(): # TODO: rename
s = """
mcdp {
provides f [dimensionless]
requires r >= ceil(provided f)
}
"""
dp = parse_ndp(s).get_dp()
print(s)
print(dp.repr_long())
R = dp.get_res_space()
assert R == R_dimensionless, R
def check_lang89f(): # TODO: rename
s = """
mcdp {
provides f [Rcomp]
requires r [Rcomp]
required r >= ceil(provided f)
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_lang89i(): # TODO: rename
s = """
mcdp {
provides f [m]
requires r [Nat]
required r >= ceil(provided f) / 5 m
}
"""
dp = parse_ndp(s).get_dp()
print dp.repr_long()
def check_minmax2(): # TODO: rename
ndp = parse_ndp("""
mcdp {
provides f1 [Nat]
provides f2 [Nat]
requires r [Nat]
min(provided f1, provided f2) <= required r
}
""")
dp = ndp.get_dp()
check_isinstance(dp, MeetNDP)
def figint01():
ndp = parse_ndp("""
mcdp {
}
""")
mf = MakeFiguresNDP(ndp=ndp, library=None, yourname=None)
for name in mf.available():
formats = mf.available_formats(name)
res = mf.get_figure(name, formats)
print('%s -> %s %s ' % (name, formats, map(len, [res[f] for f in formats])))
def check_comments07(): # rename check_addition_nat_rcomp
s = """
mcdp {
variable a, c [dimensionless]
c >= square(a) + Nat:1
a >= square(c)
} """
parse_ndp(s)
s = """
mcdp {
variable a, c [Rcomp]
c >= square(a) + Nat:1
a >= square(c)
} """
parse_ndp(s)
