def __init__(self, ndps, labels=None): from mcdp_posets.types_universe import get_types_universe if not isinstance(ndps, tuple) or not len(ndps) >= 1: raise_desc(ValueError, 'Expected a nonempty tuple.', ndps=ndps) if labels is not None: if not isinstance(labels, tuple) or not len(labels) == len(ndps): raise_desc(ValueError, 'Need labels to be consistent', ndps=ndps, labels=labels) self.labels = labels tu = get_types_universe() first = ndps[0] ftypes = first.get_ftypes(first.get_fnames()) rtypes = first.get_rtypes(first.get_rnames()) for i, ndp in enumerate(ndps): ftypes_i = ndp.get_ftypes(ndp.get_fnames()) rtypes_i = ndp.get_rtypes(ndp.get_rnames()) name = 'model #%d' % i if not self.labels else self.labels[i].__repr__() try: tu.check_equal(ftypes, ftypes_i) except NotEqual as e: msg = 'Cannot create co-product: ftypes of %s do not match the first.' % name raise_wrapped(ValueError, e, msg, ftypes=ftypes, ftypes_i=ftypes_i) try: tu.check_equal(rtypes, rtypes_i) except NotEqual as e: msg = 'Cannot create co-product: rtypes of %s not match the first.' % name raise_wrapped(ValueError, e, msg, rtypes=rtypes, rtypes_i=rtypes_i) self.ndps = ndps
def get_common(ua, ub): Pa = ua.P Pb = ub.P if not isinstance(Pa, PosetProduct) or not isinstance(Pb, PosetProduct): raise NotImplementedError((Pa, Pb)) # first, it might be that they have different spaces # let's find out how to match them tu = get_types_universe() # for each i in Pa, we will match it to the first matches1 = [] for i, P in enumerate(Pa.subs): for j, Q in enumerate(Pb.subs): if ('B', j) in matches1: continue if tu.leq(P, Q): matches1.append(('B', j)) break else: matches1.append(('A', i)) matches2 = [] for j, Q in enumerate(Pb.subs): if ('B', j) in matches1: # used by somebody matches2.append(('B', j)) else: for i, P in enumerate(Pa.subs): if matches1[i] is not None: continue if tu.leq(Q, P): matches2.append(('A', i)) break else: matches2.append(('B', j)) print('matches1: %s' % matches1) print('matches2: %s' % matches2) used = sorted(set(matches1 + matches2)) def get_P(_): (which, index) = _ if which == 'A': return Pa.subs[index] if which == 'B': return Pb.subs[index] assert False Ps = PosetProduct(tuple(map(get_P, used))) print('used: %s' % used) print('Ps: %s' % Ps) # now we need to complete the first Ps_a = get(matches1, used, Ps, get_P, Pa, ua) Ps_b = get(matches2, used, Ps, get_P, Pb, ub) print('Ps_a: %s' % Ps_a) print('Ps_b: %s' % Ps_b) S = UpperSets(Ps) return S, Ps_a, Ps_b
def check_embedding21(): # In general P ~= PosetProduct((P,)) # but we don't do it yet. P = Rcomp() S = PosetProduct((P, )) tu = get_types_universe() _, _ = tu.get_embedding(P, S)
def get_common(ua, ub): Pa = ua.P Pb = ub.P if not isinstance(Pa, PosetProduct) or not isinstance(Pb, PosetProduct): raise NotImplementedError((Pa, Pb)) # first, it might be that they have different spaces # let's find out how to match them tu = get_types_universe() # for each i in Pa, we will match it to the first matches1 = [] for i, P in enumerate(Pa.subs): for j, Q in enumerate(Pb.subs): if ('B', j) in matches1: continue if tu.leq(P, Q): matches1.append(('B', j)) break else: matches1.append(('A', i)) matches2 = [] for j, Q in enumerate(Pb.subs): if ('B', j) in matches1: # used by somebody matches2.append(('B', j)) else: for i, P in enumerate(Pa.subs): if matches1[i] is not None: continue if tu.leq(Q, P): matches2.append(('A', i)) break else: matches2.append(('B', j)) print('matches1: %s' % matches1) print('matches2: %s' % matches2) used = sorted(set(matches1 + matches2)) def get_P(_): (which, index) = _ if which == 'A': return Pa.subs[index] if which == 'B': return Pb.subs[index] assert False Ps = PosetProduct(tuple(map(get_P, used))) print('used: %s' % used) print('Ps: %s' % Ps) # now we need to complete the first Ps_a = get(matches1, used, Ps, get_P, Pa, ua) Ps_b = get(matches2, used, Ps, get_P, Pb, ub) print('Ps_a: %s' % Ps_a) print('Ps_b: %s' % Ps_b) S = UpperSets(Ps) return S, Ps_a, Ps_b
def process(self, request, string, nl, nu): l = self.get_library(request) parsed = l.parse_constant(string) space = parsed.unit value = parsed.value model_name = self.get_model_name(request) library = self.get_current_library_name(request) ndp, dp = self._get_ndp_dp(library, model_name) F = dp.get_fun_space() UR = UpperSets(dp.get_res_space()) tu = get_types_universe() tu.check_leq(parsed.unit, F) f = express_value_in_isomorphic_space(parsed.unit, parsed.value, F) print('query: %s ...' % F.format(f)) from mocdp import logger tracer = Tracer(logger=logger) dpl, dpu = get_dp_bounds(dp, nl, nu) intervals = False max_steps = 10000 result_l, _trace = solve_meat_solve(tracer, ndp, dpl, f, intervals, max_steps, False) result_u, trace = solve_meat_solve(tracer, ndp, dpu, f, intervals, max_steps, False) key = (string, nl, nu) res = dict(result_l=result_l, result_u=result_u, dpl=dpl, dpu=dpu) self.solutions[key] = res res = {} 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_result'] = 'Lower: %s\nUpper: %s' % (UR.format(result_l), UR.format(result_u)) res['output_trace'] = str(trace) encoded = "nl=%s&nu=%s&string=%s" % (nl, nu, string) res['output_image'] = 'display.png?' + encoded res['ok'] = True return res
def check_type_universe1(): tu = get_types_universe() R1 = parse_poset('dimensionless') R2 = parse_poset('dimensionless') assert R1 == R2 tu.check_equal(R1, R2) tu.check_leq(R1, R2) _embed1, _embed2 = tu.get_embedding(R1, R2)
def check_unit_conversions2(): tu = get_types_universe() A = make_rcompunit('mph') B = make_rcompunit('m/s') assert not A == B tu.check_leq(A, B) tu.check_leq(B, A) assert not tu.equal(A, B) B_from_A, A_from_B = tu.get_embedding(A, B) print('B_from_A: %s' % B_from_A) print('A_from_B: %s' % A_from_B) tu.check_equal(B_from_A.dom, A) tu.check_equal(B_from_A.cod, B) tu.check_equal(A_from_B.dom, B) tu.check_equal(A_from_B.cod, A) print('B_from_A: %s a=1.0 B_from_A(1.0) = %s' % (B_from_A, B_from_A(1.0))) assert_allclose(B_from_A(1.0), ONE_MPH_IN_M_S) assert_allclose(A_from_B(ONE_MPH_IN_M_S), 1.0) ndp = parse_ndp(""" mcdp { provides a [m/s] provides b [mph] requires c [m/s] requires d [mph] c >= a + b d >= a + b } """) print ndp.repr_long() dp = ndp.get_dp() print dp.repr_long() cases = ( ((0.0, 1.0), (ONE_MPH_IN_M_S, 1.0)), ((1.0, 0.0), (1.0, 1.0 / ONE_MPH_IN_M_S)), ) for func, expected in cases: print('func: %s F = %s' % (str(func), dp.get_fun_space())) print('expected: %s' % str(expected)) r = dp.solve(func) print('obtained: %s %s' % (str(r), dp.get_res_space())) limit = list(r.minimals)[0] assert_allclose(limit, expected)
def check_type_universe1(): tu = get_types_universe() R1 = parse_poset('dimensionless') R2 = parse_poset('dimensionless') assert R1 == R2 tu.check_equal(R1, R2) tu.check_leq(R1, R2) _embed1, _embed2 = tu.get_embedding(R1, R2)
def check_unit_conversions2(): tu = get_types_universe() A = make_rcompunit('mph') B = make_rcompunit('m/s') assert not A == B tu.check_leq(A, B) tu.check_leq(B, A) assert not tu.equal(A, B) B_from_A, A_from_B = tu.get_embedding(A, B) print('B_from_A: %s' % B_from_A) print('A_from_B: %s' % A_from_B) tu.check_equal(B_from_A.dom, A) tu.check_equal(B_from_A.cod, B) tu.check_equal(A_from_B.dom, B) tu.check_equal(A_from_B.cod, A) print('B_from_A: %s a=1.0 B_from_A(1.0) = %s' % (B_from_A, B_from_A(1.0))) assert_allclose(B_from_A(1.0), ONE_MPH_IN_M_S) assert_allclose(A_from_B(ONE_MPH_IN_M_S), 1.0) ndp = parse_ndp(""" mcdp { provides a [m/s] provides b [mph] requires c [m/s] requires d [mph] c >= a + b d >= a + b } """) print ndp.repr_long() dp = ndp.get_dp() print dp.repr_long() cases = ( ((0.0, 1.0), (ONE_MPH_IN_M_S, 1.0)), ((1.0, 0.0), (1.0, 1.0 / ONE_MPH_IN_M_S)), ) for func, expected in cases: print('func: %s F = %s' % (str(func), dp.get_fun_space())) print('expected: %s' % str(expected)) r = dp.solve(func) print('obtained: %s %s' % (str(r), dp.get_res_space())) limit = list(r.minimals)[0] assert_allclose(limit, expected)
def __init__(self, ndps, labels=None): from mcdp_posets.types_universe import get_types_universe if not isinstance(ndps, tuple) or not len(ndps) >= 1: raise_desc(ValueError, 'Expected a nonempty tuple.', ndps=ndps) if labels is not None: if not isinstance(labels, tuple) or not len(labels) == len(ndps): raise_desc(ValueError, 'Need labels to be consistent', ndps=ndps, labels=labels) self.labels = labels tu = get_types_universe() first = ndps[0] ftypes = first.get_ftypes(first.get_fnames()) rtypes = first.get_rtypes(first.get_rnames()) for i, ndp in enumerate(ndps): ftypes_i = ndp.get_ftypes(ndp.get_fnames()) rtypes_i = ndp.get_rtypes(ndp.get_rnames()) name = 'model #%d' % i if not self.labels else self.labels[ i].__repr__() try: tu.check_equal(ftypes, ftypes_i) except NotEqual as e: msg = 'Cannot create co-product: ftypes of %s do not match the first.' % name raise_wrapped(ValueError, e, msg, ftypes=ftypes, ftypes_i=ftypes_i) try: tu.check_equal(rtypes, rtypes_i) except NotEqual as e: msg = 'Cannot create co-product: rtypes of %s not match the first.' % name raise_wrapped(ValueError, e, msg, rtypes=rtypes, rtypes_i=rtypes_i) self.ndps = ndps
def less_resources2(ua, ub): """ ua must be <= ub """ Pa = ua.P Pb = ub.P if not isinstance(Pa, PosetProduct) or not isinstance(Pb, PosetProduct): raise NotImplementedError((Pa, Pb)) tu = get_types_universe() matches = [] for i, P in enumerate(Pa.subs): for j, Q in enumerate(Pb.subs): if j in matches: continue if tu.leq(P, Q): matches.append(j) break else: # msg = 'Could not find match.' return False # now we have found an embedding # first we create a projection for Pb m1 = MuxMap(F=Pb, coords=matches) ub2 = upperset_project_map(ub, m1) Pb2 = ub2.P UPb2 = UpperSets(Pb2) # now we create the embedding A_to_B, _ = tu.get_embedding(Pa, Pb2) ua2 = upperset_project_map(ua, A_to_B) print('Pa: %s' % Pa) print('Pb2: %s' % Pb2) print('ua2: %s' % ua2) print('ub2: %s' % ub2) return UPb2.leq(ua2, ub2)
def less_resources2(ua, ub): """ ua must be <= ub """ Pa = ua.P Pb = ub.P if not isinstance(Pa, PosetProduct) or not isinstance(Pb, PosetProduct): raise NotImplementedError((Pa, Pb)) tu = get_types_universe() matches = [] for i, P in enumerate(Pa.subs): for j, Q in enumerate(Pb.subs): if j in matches: continue if tu.leq(P, Q): matches.append(j) break else: # msg = 'Could not find match.' return False # now we have found an embedding # first we create a projection for Pb m1 = MuxMap(F=Pb, coords=matches) ub2 = upperset_project_map(ub, m1) Pb2 = ub2.P UPb2 = UpperSets(Pb2) # now we create the embedding A_to_B, _ = tu.get_embedding(Pa, Pb2) ua2 = upperset_project_map(ua, A_to_B) print('Pa: %s' % Pa) print('Pb2: %s' % Pb2) print('ua2: %s' % ua2) print('ub2: %s' % ub2) return UPb2.leq(ua2, ub2)
def __init__(self, maps): """ maps = [f, g, h] === h o g o f They are in order of application. """ self.maps = tuple(maps) from mcdp_posets.types_universe import get_types_universe tu = get_types_universe() for i in range(len(maps) - 1): first = maps[i] second = maps[i + 1] cod1 = first.get_codomain() dom2 = second.get_domain() tu.check_equal(cod1, dom2) mcdp_dev_warning('Check that the composition makes sense') dom = self.maps[0].get_domain() cod = self.maps[-1].get_codomain() Map.__init__(self, dom=dom, cod=cod)
def __init__(self, maps): """ maps = [f, g, h] === h o g o f They are in order of application. """ self.maps = tuple(maps) from mcdp_posets.types_universe import get_types_universe tu = get_types_universe() for i in range(len(maps)-1): first = maps[i] second =maps[i+1] cod1 = first.get_codomain() dom2 = second.get_domain() tu.check_equal(cod1, dom2) mcdp_dev_warning('Check that the composition makes sense') dom = self.maps[0].get_domain() cod = self.maps[-1].get_codomain() Map.__init__(self, dom=dom, cod=cod)
def check_consistent_data(names, fnames, rnames, connections): from mocdp.comp.context import get_name_for_res_node, get_name_for_fun_node from mocdp.comp.context import is_res_node_name from mcdp_posets.types_universe import get_types_universe tu = get_types_universe() for n in names: try: check_good_name(n) except ValueError as e: msg = 'This name is not good.' raise_wrapped(ValueError, e, msg, names=names) isit, x = is_fun_node_name(n) if isit and not x in fnames: msg = 'The name for the node seems to be the one for a function.' raise_desc(ValueError, msg, n=n, fnames=fnames) isit, x = is_res_node_name(n) if isit and not x in rnames: if not n in rnames: msg = 'The name for the node seems to be the one for a resource.' raise_desc(ValueError, msg, n=n, rnames=rnames) for f in fnames: fnode = get_name_for_fun_node(f) if not fnode in names: msg = 'Expecting to see a node with the name of the function.' raise_desc(ValueError, msg, f=f, names=list(names.keys())) fn = names[fnode] if not f in fn.get_fnames(): msg = ('Expecting to see the special function node have function ' 'with function name.') raise_desc(ValueError, msg, f=f, fnode=fnode, fn=fn, fn_fnames=fn.get_fnames()) for r in rnames: rnode = get_name_for_res_node(r) if not rnode in names: msg = 'Expecting to see a node with the name of the resource.' raise_desc(ValueError, msg, r=r, names=list(names.keys())) rn = names[rnode] if not r in rn.get_rnames(): msg = ('Expecting to see the special resource node have resource ' 'with resource name.') raise_desc(ValueError, msg, r=r, rnode=rnode, rn=rn, rn_rnames=rn.get_rnames()) for c in connections: try: if not c.dp1 in names: raise_desc(ValueError, 'First DP %r not found.' % c.dp1, name=c.dp1, available=list(names)) if not c.s1 in names[c.dp1].get_rnames(): raise_desc(ValueError, 'Resource %r of first DP %r not found' % (c.s1, c.dp1), rname=c.s1, available=names[c.dp1].get_rnames()) if not c.dp2 in names: raise_desc(ValueError, 'Second DP %r not found.' % c.dp2, name=c.dp2, available=list(names)) if not c.s2 in names[c.dp2].get_fnames(): raise_desc(ValueError, 'Function %r of second DP %r not found.' % (c.s2, c.dp2), s2=c.s2, available=names[c.dp2].get_fnames()) R = names[c.dp1].get_rtype(c.s1) F = names[c.dp2].get_ftype(c.s2) try: tu.check_equal(R, F) except NotEqual as e: msg = 'Invalid connection %s' % c.__repr__() raise_wrapped(ValueError, e, msg, R=R, F=F) except ValueError as e: msg = 'Invalid connection %s.' % (c.__repr__()) raise_wrapped(ValueError, e, msg, compact=True)
def check_consistent_data(names, fnames, rnames, connections): from mocdp.comp.context import get_name_for_res_node, get_name_for_fun_node from mocdp.comp.context import is_res_node_name from mcdp_posets.types_universe import get_types_universe tu = get_types_universe() for n in names: try: check_good_name(n) except ValueError as e: msg = 'This name is not good.' raise_wrapped(ValueError, e, msg, names=names) isit, x = is_fun_node_name(n) if isit and not x in fnames: msg = 'The name for the node seems to be the one for a function.' raise_desc(ValueError, msg, n=n, fnames=fnames) isit, x = is_res_node_name(n) if isit and not x in rnames: if not n in rnames: msg = 'The name for the node seems to be the one for a resource.' raise_desc(ValueError, msg, n=n, rnames=rnames) for f in fnames: fnode = get_name_for_fun_node(f) if not fnode in names: msg = 'Expecting to see a node with the name of the function.' raise_desc(ValueError, msg, f=f, names=list(names.keys())) fn = names[fnode] if not f in fn.get_fnames(): msg = ('Expecting to see the special function node have function ' 'with function name.') raise_desc(ValueError, msg, f=f, fnode=fnode, fn=fn, fn_fnames=fn.get_fnames()) for r in rnames: rnode = get_name_for_res_node(r) if not rnode in names: msg = 'Expecting to see a node with the name of the resource.' raise_desc(ValueError, msg, r=r, names=list(names.keys())) rn = names[rnode] if not r in rn.get_rnames(): msg = ('Expecting to see the special resource node have resource ' 'with resource name.') raise_desc(ValueError, msg, r=r, rnode=rnode, rn=rn, rn_rnames=rn.get_rnames()) for c in connections: try: if not c.dp1 in names: raise_desc(ValueError, 'First DP %r not found.' % c.dp1, name=c.dp1, available=list(names)) if not c.s1 in names[c.dp1].get_rnames(): raise_desc(ValueError, 'Resource %r of first DP %r not found' %( c.s1, c.dp1), rname=c.s1, available=names[c.dp1].get_rnames()) if not c.dp2 in names: raise_desc(ValueError, 'Second DP %r not found.' % c.dp2, name=c.dp2, available=list(names)) if not c.s2 in names[c.dp2].get_fnames(): raise_desc(ValueError, 'Function %r of second DP %r not found.' % (c.s2, c.dp2), s2=c.s2, available=names[c.dp2].get_fnames()) R = names[c.dp1].get_rtype(c.s1) F = names[c.dp2].get_ftype(c.s2) try: tu.check_equal(R, F) except NotEqual as e: msg = 'Invalid connection %s' % c.__repr__() raise_wrapped(ValueError, e, msg, R=R, F=F) except ValueError as e: msg = 'Invalid connection %s.' % (c.__repr__()) raise_wrapped(ValueError, e, msg, compact=True)