def check_uncertainty2():
ndp = parse_ndp("""
mcdp {
provides f1 [N]
f1 <= Uncertain(1 N, 2 N)
}
""")
dp = ndp.get_dp()
dpl, dpu = get_dp_bounds(dp, 1, 1)
R = dp.get_res_space()
UR = UpperSets(R)
f0 = 0.0 # N
sl = dpl.solve(f0)
su = dpu.solve(f0)
UR.check_leq(sl, su)
print sl
print su
f0 = 1.5 # N
sl = dpl.solve(f0)
su = dpu.solve(f0)
UR.check_leq(sl, su)
print sl
print su
feasible = UpperSet(set([()]), R)
infeasible = UpperSet(set([]), R)
sl_expected = feasible
su_expected = infeasible
print sl_expected
print su_expected
UR.check_equal(sl, sl_expected)
UR.check_equal(su, su_expected)
def check_lang_connections2():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
requires b [s]
b >= 10 s
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
F = dp.get_fun_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("F: %s" % F)
print("R: %s" % R)
print("I: %s" % I)
print("M: %s" % M)
UR = UpperSets(R)
ur = dp.solve(())
print('ur: %s' % ur)
UR.check_equal(ur, R.U(10.0))
def check_lang_connections2():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
requires b [s]
b >= 10 s
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
F = dp.get_fun_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("F: %s" % F)
print("R: %s" % R)
print("I: %s" % I)
print("M: %s" % M)
UR = UpperSets(R)
ur = dp.solve(())
print('ur: %s' % ur)
UR.check_equal(ur, R.U(10.0))
def check_lang_connections1():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
provides a [g]
a <= 10 g
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("I: %s" % I)
print("M: %s" % M)
print("R: %s" % R)
UR = UpperSets(R)
empty = R.Us(set())
ur1 = dp.solve(5.0)
ur2 = dp.solve(14.0)
print('ur1: %s' % ur1)
print('ur2: %s' % ur2)
UR.check_equal(empty, ur2)
def check_uncertainty2():
ndp = parse_ndp("""
mcdp {
provides f1 [N]
f1 <= Uncertain(1 N, 2 N)
}
""")
dp = ndp.get_dp()
dpl, dpu = get_dp_bounds(dp, 1, 1)
R = dp.get_res_space()
UR = UpperSets(R)
f0 = 0.0 # N
sl = dpl.solve(f0)
su = dpu.solve(f0)
UR.check_leq(sl, su)
print sl
print su
f0 = 1.5 # N
sl = dpl.solve(f0)
su = dpu.solve(f0)
UR.check_leq(sl, su)
print sl
print su
feasible = UpperSet(set([()]), R)
infeasible = UpperSet(set([]), R)
sl_expected = feasible
su_expected = infeasible
print sl_expected
print su_expected
UR.check_equal(sl, sl_expected)
UR.check_equal(su, su_expected)
def check_lang_connections1():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
provides a [g]
a <= 10 g
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("I: %s" % I)
print("M: %s" % M)
print("R: %s" % R)
UR = UpperSets(R)
empty = R.Us(set())
ur1 = dp.solve(5.0)
ur2 = dp.solve(14.0)
print('ur1: %s' % ur1)
print('ur2: %s' % ur2)
UR.check_equal(empty, ur2)
def check_approximation4():
ndp = parse_ndp("""
approx(mass,0%,0g,Top kg) mcdp {
provides in [g]
requires mass [g]
mass >= in
}""")
dp = ndp.get_dp()
R = dp.get_res_space()
UR = UpperSets(R)
UR.check_equal(dp.solve(55.0), R.U(55.0))
UR.check_equal(dp.solve(55.01), R.U(55.01))
def check_anyof1():
ndp = parse_ndp("""
mcdp {
requires x [g x g]
x >= any-of({<0g,1g>, <1g, 0g>})
}
""")
dp = ndp.get_dp()
R = dp.get_res_space()
UR = UpperSets(R)
res = dp.solve(())
UR.check_equal(res, UpperSet([(0.0, 1.0), (1.0, 0.0)], R))
def check_anyof1():
ndp = parse_ndp("""
mcdp {
requires x [g x g]
x >= any-of({<0g,1g>, <1g, 0g>})
}
""")
dp = ndp.get_dp()
R = dp.get_res_space()
UR = UpperSets(R)
res = dp.solve(())
UR.check_equal(res, UpperSet([(0.0,1.0),(1.0,0.0)], R))
def check_approximation5():
ndp = parse_ndp("""
approx(mass,0%,0g,Top kg) mcdp {
provides in [g]
requires mass [g]
mass >= in
}""")
dp = ndp.get_dp()
R = dp.get_res_space()
F = dp.get_fun_space()
UR = UpperSets(R)
res = dp.solve(F.get_top())
UR.check_equal(res, R.U(R.get_top()))
def new_uncertainty01use():
s = """mcdp {
requires r1 = 10 kg ± 50 g
}
"""
ndp = parse_ndp(s)
dp = ndp.get_dp()
dpl, dpu = get_dp_bounds(dp, 1, 1)
rl = dpl.solve(())
ru = dpu.solve(())
R = dp.get_res_space()
UR = UpperSets(R)
UR.check_equal(rl, UpperSet([9.95], R))
UR.check_equal(ru, UpperSet([10.05], R))
def check_approximation1():
ndp = parse_ndp("""
approx(mass,0%,0g,55 g) mcdp {
provides in [g]
requires mass [g]
mass >= in
}""")
dp = ndp.get_dp()
R = dp.get_res_space()
UR = UpperSets(R)
res = dp.solve(55.0)
print(res)
UR.check_equal(res, R.U(55.0))
res = dp.solve(55.1)
print(res)
UR.check_equal(res, R.Us(set()))
def check_lang_connections3():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
provides f1 [g]
provides f2 [s]
requires r1 [s]
f1 <= 1 g
f2 <= 2 s
r1 >= 2 s
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
F = dp.get_fun_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("F: %s" % F)
print("R: %s" % R)
print("I: %s" % I)
print("M: %s" % M)
UR = UpperSets(R)
ur = dp.solve((0.5, 0.4))
print('ur: %s' % ur)
UR.check_equal(ur, R.U(2.0))
f_infeasible = (1.1, 1.0)
ur = dp.solve(f_infeasible)
print('ur: %s' % ur)
empty = R.Us(set())
UR.check_equal(ur, empty)
imps = dp.get_implementations_f_r(f=(0.4, 0.4), r=2.0)
print('imps: %s' % imps)
def check_lang_connections3():
""" This is considered connected. """
ndp = assert_parsable_to_connected_ndp("""
mcdp {
provides f1 [g]
provides f2 [s]
requires r1 [s]
f1 <= 1 g
f2 <= 2 s
r1 >= 2 s
}""")
dp = ndp.get_dp()
I = dp.get_imp_space()
F = dp.get_fun_space()
R = dp.get_res_space()
M = dp.get_imp_space()
print("F: %s" % F)
print("R: %s" % R)
print("I: %s" % I)
print("M: %s" % M)
UR = UpperSets(R)
ur = dp.solve((0.5, 0.4))
print('ur: %s' % ur)
UR.check_equal(ur, R.U(2.0))
f_infeasible = (1.1, 1.0)
ur = dp.solve(f_infeasible)
print('ur: %s' % ur)
empty = R.Us(set())
UR.check_equal(ur, empty)
imps = dp.get_implementations_f_r(f=(0.4, 0.4), r=2.0)
print('imps: %s' % imps)
def check_join_not_existence():
""" A test for finite posets where the join might not exist. """
from mcdp_library.library import MCDPLibrary
l = MCDPLibrary()
add_def_poset(
l, 'P', """
finite_poset {
a <= b <= c
A <= B <= C
}
""")
# parse_wrap(Syntax.LOAD, '`')
# parse_wrap(Syntax.posetname, 'P')
# print Syntax.load_poset
# parse_wrap(Syntax.load_poset, '`P')
# parse_wrap(Syntax.space_operand, '`P')
# parse_wrap(Syntax.fun_statement, "provides x [`P]")
ndp = l.parse_ndp("""
mcdp {
provides x [`P]
provides y [`P]
requires z [`P]
z >= x
z >= y
}
""",
context=Context())
dp = ndp.get_dp()
res1 = dp.solve(('a', 'b'))
P = l.load_poset('P')
UR = UpperSets(P)
UR.check_equal(res1, UpperSet(['b'], P))
res2 = dp.solve(('a', 'A'))
UR.check_equal(res2, UpperSet([], P))
def check_join_not_existence():
""" A test for finite posets where the join might not exist. """
from mcdp_library.library import MCDPLibrary
l = MCDPLibrary()
add_def_poset(l, 'P', """
finite_poset {
a <= b <= c
A <= B <= C
}
""")
# parse_wrap(Syntax.LOAD, '`')
# parse_wrap(Syntax.posetname, 'P')
# print Syntax.load_poset
# parse_wrap(Syntax.load_poset, '`P')
# parse_wrap(Syntax.space_operand, '`P')
# parse_wrap(Syntax.fun_statement, "provides x [`P]")
ndp = l.parse_ndp("""
mcdp {
provides x [`P]
provides y [`P]
requires z [`P]
z >= x
z >= y
}
""", context=Context())
dp = ndp.get_dp()
res1 = dp.solve(('a', 'b'))
P = l.load_poset('P')
UR = UpperSets(P)
UR.check_equal(res1, UpperSet(['b'], P))
res2 = dp.solve(('a', 'A'))
UR.check_equal(res2, UpperSet([], P))
def check_anyof2():
ndp = parse_ndp("""
mcdp {
provides x [g x g]
x <= any-of({<0g,1g>, <1g, 0g>})
}
""")
dp = ndp.get_dp()
R = dp.get_res_space()
F = dp.get_fun_space()
UR = UpperSets(R)
res = dp.solve((0.5, 0.5))
l = LowerSet(P=F, maximals=[(0.0, 1.0), (1.0, 0.0)])
l.belongs((0.0, 0.5))
l.belongs((0.5, 0.0))
UR.check_equal(res, UpperSet([], R))
res = dp.solve((0.0, 0.5))
UR.check_equal(res, UpperSet([()], R))
res = dp.solve((0.5, 0.0))
UR.check_equal(res, UpperSet([()], R))
def check_anyof2():
ndp = parse_ndp("""
mcdp {
provides x [g x g]
x <= any-of({<0g,1g>, <1g, 0g>})
}
""")
dp = ndp.get_dp()
R = dp.get_res_space()
F = dp.get_fun_space()
UR = UpperSets(R)
res = dp.solve((0.5, 0.5))
l = LowerSet(P=F, maximals=[(0.0, 1.0), (1.0, 0.0)])
l.belongs((0.0, 0.5))
l.belongs((0.5, 0.0))
UR.check_equal(res, UpperSet([], R))
res = dp.solve((0.0, 0.5))
UR.check_equal(res, UpperSet([()], R))
res = dp.solve((0.5, 0.0))
UR.check_equal(res, UpperSet([()], R))
def check_loop_result3():
parse_wrap(Syntax.primitivedp_expr,
'code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)')[0]
parse_wrap(Syntax.ndpt_simple_dp_model,
"""
dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)
}
""")[0]
assert_semantic_error("""
mcdp {
s = instance dp {
requires x [Nat]
provides c [Nat]
# semantic error: does not exist
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)
}
}"""
)
assert_semantic_error("""
mcdp {
s = instance dp {
requires x [Nat]
provides c [Nat]
# semantic error: not a DP
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap(n=3)
}
}"""
)
ndp = parse_ndp("""
mcdp {
adp1 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3)
}
s = instance adp1
s.c >= s.x
}"""
)
# UNat = UpperSets(Nat())
dp = ndp.get_dp()
print dp
res = dp.solve(())
print res.__repr__()
One = PosetProduct(())
U1 = UpperSets(One)
U1.check_equal(res, One.U(()))
ndp = parse_ndp("""
mcdp {
adp1 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3)
}
adp2 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=2)
}
s = instance choose(a: adp1, b: adp2)
s.c >= s.x
requires x for s
}"""
)
N = Nat()
UNat = UpperSets(N)
dp = ndp.get_dp()
print dp
res = dp.solve(())
print res
UNat.check_equal(res, N.U(2))
def check_loop_result3():
parse_wrap(Syntax.primitivedp_expr,
'code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)')[0]
parse_wrap(Syntax.ndpt_simple_dp_model,
"""
dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)
}
""")[0]
assert_semantic_error("""
mcdp {
s = instance dp {
requires x [Nat]
provides c [Nat]
# semantic error: does not exist
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap___(n=3)
}
}"""
)
assert_semantic_error("""
mcdp {
s = instance dp {
requires x [Nat]
provides c [Nat]
# semantic error: not a DP
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterMap(n=3)
}
}"""
)
ndp = parse_ndp("""
mcdp {
adp1 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3)
}
s = instance adp1
s.c >= s.x
}"""
)
# UNat = UpperSets(Nat())
dp = ndp.get_dp()
print dp
res = dp.solve(())
print res.__repr__()
One = PosetProduct(())
U1 = UpperSets(One)
U1.check_equal(res, One.U(()))
ndp = parse_ndp("""
mcdp {
adp1 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=3)
}
adp2 = dp {
requires x [Nat]
provides c [Nat]
implemented-by code mcdp_dp_tests.inv_mult_plots.CounterDP(n=2)
}
s = instance choose(a: adp1, b: adp2)
s.c >= s.x
requires x for s
}"""
)
N = Nat()
UNat = UpperSets(N)
dp = ndp.get_dp()
print dp
res = dp.solve(())
print res
UNat.check_equal(res, N.U(2))
