def check_evaluate(id_dp, dp): """ Test for PrimitiveDP:evaluate() """ print('Testing %s: %s' % (id_dp, dp)) F = dp.get_fun_space() R = dp.get_res_space() UR = UpperSets(R) LF = LowerSets(F) M = dp.get_imp_space() # We get a random m m0 = M.witness() try: lf, ur = dp.evaluate(m0) except NotSolvableNeedsApprox: return UR.belongs(ur) LF.belongs(lf) if not lf.maximals or not ur.minimals: msg = 'The point m0 gave empty lf, ur.' raise_desc(Exception, msg, lf=lf, ur=ur, m0=M.format(m0), M=M, dp=dp.repr_long()) # take one possible feasible pair _f = list(lf.maximals)[0] _r = list(ur.minimals)[0]
def solve_meat_solve_rtof(trace, ndp, dp, r, intervals, max_steps, exp_advanced): F = dp.get_fun_space() LF = LowerSets(F) res = dp.solve_r(r) fnames = ndp.get_fnames() x = ", ".join(fnames) # todo: add better formatting trace.log('Maximal functionality possible: %s = %s' % (x, LF.format(res))) return res, trace
def eval_constant_lowersetfromcollection(op, context): x = eval_constant(op.value, context) v = x.value u = x.unit S = u.S maximals = poset_minima(v.elements, S.leq) value = LowerSet(maximals, S) unit = LowerSets(S) if do_extra_checks(): unit.belongs(value) vu = ValueWithUnits(value, unit) return vu
def check_solve_r_chain(id_dp, dp): with primitive_dp_test(id_dp, dp): from mcdp_posets.utils import poset_check_chain R = dp.get_res_space() F = dp.get_fun_space() LF = LowerSets(F) r_chain = R.get_test_chain(n=8) poset_check_chain(R, r_chain) try: lfchain = map(dp.solve_r, r_chain) except NotSolvableNeedsApprox: return try_with_approximations(id_dp, dp, check_solve_r_chain) try: # now, notice that we need to reverse this lfchain_reversed = list(reversed(lfchain)) poset_check_chain(LF, lfchain_reversed) except ValueError as e: msg = 'The map solve_r() for %r is not monotone.' % id_dp raise_wrapped(Exception, e, msg, r_chain=r_chain, lfchain=lfchain, lfchain_reversed=lfchain_reversed, compact=True)
def eval_solve_r(op, context): check_isinstance(op, CDP.SolveRModel) from .eval_ndp_imp import eval_ndp ndp = eval_ndp(op.model, context) dp = ndp.get_dp() r0 = eval_constant(op.r, context) F = dp.get_fun_space() R = dp.get_res_space() tu = get_types_universe() try: tu.check_leq(r0.unit, R) except NotLeq as e: msg = 'Input not correct.' raise_wrapped(DPSemanticError, e, msg, compact=True) r = r0.cast_value(R) res = dp.solve_r(r) try: LF = LowerSets(F) return ValueWithUnits(res, LF) except NotBelongs as e: msg = 'Invalid result of solve_r().' raise_desc(DPInternalError, msg, res=res, dp=dp.repr_long())
def solve_r(self, r): l2 = self.dp2.solve_r(r) if do_extra_checks(): F2 = self.dp2.get_fun_space() LF2 = LowerSets(F2) LF2.belongs(l2) maxs = set([]) # todo: express as operation on antichains for l in l2.maximals: v = self.dp1.solve_r(l) maxs.update(v.maximals) F = self.get_fun_space() maximals = poset_maxima(maxs, F.leq) lf = LowerSet(maximals, F) return lf
def check_lang84(): # TODO: rename to LF # In LF, F = parse_poset('m') LF = LowerSets(F) lf0 = F.Ls(set([])) lf1 = F.L(0.0) lf2 = F.L(5.0) lf3 = F.L(F.get_top()) # the bottom is lf3 LF.check_leq(lf3, lf2) LF.check_leq(lf3, lf1) LF.check_leq(lf3, lf0) LF.check_leq(lf2, lf1) LF.check_leq(lf2, lf0) LF.check_leq(lf1, lf0) pass
def dual01_chain(id_dp, dp): try: with primitive_dp_test(id_dp, dp): print('Starting testing with %r' % id_dp) # get a chain of resources F = dp.get_fun_space() R = dp.get_res_space() # try to solve try: dp.solve(F.witness()) dp.solve_r(R.witness()) except NotSolvableNeedsApprox: print('NotSolvableNeedsApprox - doing lower bound ') n = 5 dpL, dpU = get_dp_bounds(dp, nl=n, nu=n) dual01_chain(id_dp+'_L%s'%n, dpL) dual01_chain(id_dp+'_U%s'%n, dpU) return LF = LowerSets(F) UR = UpperSets(R) rchain = R.get_test_chain(n=8) poset_check_chain(R, rchain) try: lfchain = list(map(dp.solve_r, rchain)) for lf in lfchain: LF.belongs(lf) except NotSolvableNeedsApprox as e: print('skipping because %s' % e) return try: poset_check_chain(LF, list(reversed(lfchain))) except ValueError as e: msg = 'The results of solve_r() are not a chain.' raise_wrapped(Exception, e, msg, chain=rchain, lfchain=lfchain) # now, for each functionality f, # we know that the corresponding resource should be feasible for lf, r in zip(lfchain, rchain): print('') print('r: %s' % R.format(r)) print('lf = h*(r) = %s' % LF.format(lf)) for f in lf.maximals: print(' f = %s' % F.format(f)) f_ur = dp.solve(f) print(' f_ur = h(f) = %s' % UR.format(f_ur)) try: f_ur.belongs(r) except NotBelongs as e: try: Rcomp.tolerate_numerical_errors = True f_ur.belongs(r) logger.info('In this case, there was a numerical error') logger.info('Rcomp.tolerate_numerical_errors = True solved the problem') except: msg = '' raise_wrapped(AssertionError, e, msg, lf=lf, r=r, f_ur=f_ur, r_repr=r.__repr__(), f_ur_minimals=f_ur.minimals.__repr__()) finally: Rcomp.tolerate_numerical_errors = False
def repr_h_map(self): LF = LowerSets(self.F) return 'f ⟼ {⟨⟩} if f ∈ %s, else ø' % LF.format(self.limit)
def process_rtof(self, e, string, do_approximations, nl, nu): mcdp_library = library_from_env(e) parsed = mcdp_library.parse_constant(string) space = parsed.unit value = parsed.value ndp, dp = self.get_ndp_dp_e(e) R = dp.get_res_space() LF = LowerSets(dp.get_fun_space()) try: r = parsed.cast_value(R) except NotLeq: msg = 'Space %s cannot be converted to %s' % (parsed.unit, R) raise DPSemanticError(msg) logger.info('query rtof: %s ...' % R.format(r)) tracer = Tracer(logger=logger) max_steps = 10000 intervals = False res = {} if do_approximations: dpl, dpu = get_dp_bounds(dp, nl, nu) result_l, _trace = solve_meat_solve_rtof(tracer, ndp, dpl, r, intervals, max_steps, False) result_u, trace = solve_meat_solve_rtof(tracer, ndp, dpu, r, intervals, max_steps, False) data = dict(result_l=result_l, result_u=result_u, dpl=dpl, dpu=dpu) res['output_result'] = 'Lower: %s\nUpper: %s' % ( LF.format(result_l), LF.format(result_u)) else: try: result, trace = solve_meat_solve_rtof(tracer, ndp, dp, r, intervals, max_steps, False) except NotSolvableNeedsApprox: msg = 'The design problem has infinite antichains. Please use approximations.' raise NeedsApprox(msg) data = dict(result=result, dp=dp) res['output_result'] = LF.format(result) e = cgi.escape res['output_space'] = e(space.__repr__() + '\n' + str(type(space))) res['output_raw'] = e(value.__repr__() + '\n' + str(type(value))) res['output_formatted'] = e(space.format(value)) res['output_trace'] = str(trace) return data, res
def eval_space_makelowersets(r, context): P = eval_space(r.space, context) return LowerSets(P)