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_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_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_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))