def InvMult2L1(): F = parse_poset('m') R1 = parse_poset('s') R2 = parse_poset('m/s') R = (R1, R2) n = 8 return InvMult2L(F, R, n)
def ProductNDP_3(): F1 = parse_poset('J') F2 = parse_poset('m') F3 = parse_poset('s') Fs = (F1, F2, F3) R = parse_poset('J*m*s') return ProductNDP(Fs, R)
def DPLoop2_1(): F1 = parse_poset('N') R1 = parse_poset('J') F2 = parse_poset('m') R2 = F2 F = PosetProduct((F1, F2)) R = PosetProduct((R1, R2)) dp = Template(F, R) return DPLoop2(dp)
def CatalogueDP1(): m1 = 'A' m2 = 'B' m3 = 'C' M = FiniteCollectionAsSpace([m1, m2, m3]) F = parse_poset('V') R = parse_poset('J') entries = [ (m1, 1.0, 2.0), (m2, 2.0, 4.0), (m3, 3.0, 6.0), ] return CatalogueDP(F, R, M, entries)
def adv_embed_1(): """ PosetProduct does not take into account permutations. """ P1 = parse_poset("m x J") P2 = parse_poset("J x m") tu = get_types_universe() try: tu.check_leq(P1, P2) except NotLeq: pass else: assert False try: tu.check_leq(P2, P1) except NotLeq: pass else: assert False
def Mux5(): """ One with a 1: <a, *> -> a """ N = parse_poset('Nat') One = PosetProduct(()) P = PosetProduct((N, One)) coords = 0 return Mux(P, coords)
def check_lang_namedtuple6(): s = """namedproduct( tag: s )""" print('1') parse_wrap(Syntax.space_product_with_labels, s) print('2') parse_wrap(Syntax.space_operand, s) print('2b') parse_poset(s) s = """namedproduct( tag: S(DuckiebotIntersectionSignal) )""" print('3') parse_poset(s) print('4')
def check_mult_mixed2(): tu = get_types_universe() dimensionless = parse_poset('dimensionless') Nat = parse_poset('Nat') # m * s ndp = parse_ndp(""" mcdp { provides a [m] provides b [s] requires x = provided a * provided b } """) M = ndp.get_rtype('x') tu.check_equal(M, parse_poset('m*s')) # Nat * Nat ndp = parse_ndp(""" mcdp { provides a [Nat] provides b [Nat] requires x = provided a * provided b } """) M = ndp.get_rtype('x') tu.check_equal(M, Nat) # Nat * [] ndp = parse_ndp(""" mcdp { provides a [Nat] provides b [dimensionless] requires x = provided a * provided b } """) M = ndp.get_rtype('x') tu.check_equal(M, dimensionless)
def _compute_connection_options(self): unconnected_fun, unconnected_res = get_missing_connections(self.context) n = 0 usd = parse_poset('USD') for (dp, s) in unconnected_res: r = CResource(dp, s) R = self.context.get_rtype(r) foptions = get_compatible_unconnected_functions(R, self.context, unconnected_fun) ok = [] for f in foptions: if R == usd and would_introduce_cycle(self.context, r=r, f=f): print('skipping %r - %r because it adds a cycle' % (r, f)) continue ok.append(f) unconnected_fun.remove((f.dp, f.s)) if ok: n += 1 return n
def MinF1DP_1(): F = parse_poset('Nat') f = 4 return MinF1DP(F, f)
def InvMultValueDP2nonzero(): F = parse_poset('m*s') U = parse_poset('s') R = parse_poset('m') v = 10.0 return InvMultValueDP(F=F, R=R, unit=U, value=v)
def InvPlus2L_1(): F = parse_poset('m') Rs = (F, F) n = 9 return InvPlus2L(F, Rs, n)
def LimitMaximals_1(): F = parse_poset('Nat x Nat') values = [(5, 1), (1, 5)] return LimitMaximals(F, values)
def MinusValueDP2(): F = parse_poset('J') U = parse_poset('mJ') v = U.get_top() return MinusValueDP(F=F, c_value=v, c_space=U)
def Mux1(): """ a -> a """ F = parse_poset('Nat') coords = () return Mux(F, coords)
def InvPlus2Nat1(): F = parse_poset('Nat') Rs = (F, F) return InvPlus2Nat(F, Rs)
def ProductNDP_1(): F1 = parse_poset('J') F2 = parse_poset('m') Fs = (F1, F2) R = parse_poset('J*m') return ProductNDP(Fs, R)
def InvMult2Nat1(): N = parse_poset('Nat') return InvMult2Nat(N, (N, N))
def InvMult21(): F = parse_poset('m') R1 = parse_poset('s') R2 = parse_poset('m/s') R = (R1, R2) return InvMult2(F, R)
def Identity1(): F = parse_poset('V') return Identity(F)
def Mux4(): """ <a, <b, c> > -> < <a, b>, c> """ F = parse_poset('J x (m x Hz)') coords = [[0, (1, 0)], (1, 1)] return Mux(F, coords)
def Mux3(): """ a -> <a> """ F = parse_poset('Nat') coords = [()] return Mux(F, coords)
def Series0_1(): dp1 = Constant1() # R = V V = parse_poset('V') dp2 = MaxR1DP(V, 2.0) return Series0(dp1, dp2)
def InvPlus2_1(): F = parse_poset('m') Rs = (F, F) return InvPlus2(F, Rs)
def JoinNDP_1(): n = 3 F = parse_poset('Nat') return JoinNDP(n, F)
def InvPlus2U_1(): F = parse_poset('m') Rs = (F, F) n = 4 return InvPlus2U(F, Rs, n)
def Conversion_a(): A = parse_poset('kg') B = parse_poset('g') return get_conversion(A, B)
def Product2DP_L_1(): F1 = parse_poset('J') F2 = parse_poset('m') Fs = (F1, F2) R = parse_poset('J*m') return Product2DP_L(Fs, R, 5)
def check_lang_namedtuple1(): parse_wrap(Syntax.PRODUCTWITHLABELS, 'product') parse_wrap(Syntax.space_product_with_labels, 'product(weight: g, energy: J)') P = parse_poset('product(weight: g, energy: J)') print P print P.format((2.0, 1.0))
def Limit_1(): F = parse_poset('m') value = 5.0 return Limit(F, value)
def MaxR1DP_1(): F = parse_poset('Nat') f = 4 return MaxR1DP(F, f)
def Template_1(): P = parse_poset('m') F = P R = PosetProduct((P,P)) return Template(F, R)
def Product2DP_U_1(): F1 = parse_poset('J') F2 = parse_poset('m') Fs = (F1, F2) R = parse_poset('J*m') return Product2DP_U(Fs, R, 5) #
def SumNLDP_1(): m = parse_poset('m') Fs = (m, m) R = m nl = 5 return SumNLDP(Fs=Fs,R=R,n=nl)
def JoinNDualDP_1(): n = 3 F0 = parse_poset('Nat') return JoinNDualDP(n, F0)
def FuncNotMoreThan_1(): F = parse_poset('m') limit = 2.0 return FuncNotMoreThan(F, limit)
def MeetNDP_1(): n = 3 P = parse_poset('Nat') return MeetNDP(n, P)
def Mux2(): """ <a> -> a """ P0 = parse_poset('Nat') F = PosetProduct((P0, )) coords = 0 return Mux(F, coords)
def SumNUDP_1(): m = parse_poset('m') Fs = (m, m) R = m nu = 5 return SumNUDP(Fs=Fs,R=R,n=nu)
def Constant1(): R = parse_poset('V') value = 1.0 return Constant(R, value)
def RcompUnitsPowerDP_1(): F = parse_poset('m') num = 2 den = 3 return RcompUnitsPowerDP(F, num, den)
def MultValueDP3top(): F = parse_poset('m') U = parse_poset('s') v = U.get_top() R = parse_poset('m*s') return MultValueDP(F=F, R=R, unit=U, value=v)
def PlusValueDP1(): F = parse_poset('J') U = parse_poset('mJ') v = 1000.0 return PlusValueDP(F, c_value=v, c_space=U)
def MultValueDP2zero(): F = parse_poset('m') U = parse_poset('s') v = 0.0 R = parse_poset('m*s') return MultValueDP(F=F, R=R, unit=U, value=v)
def report_plane2(data): matplotlib_settings() cs = CommonStats(data) r = Report() what_to_plot_res = dict(total_mass="kg", total_cost="USD") what_to_plot_fun = dict(endurance="Wh", extra_payload="g") plot_all_directions(r, queries=data['queries'], results=data['results'], what_to_plot_res=what_to_plot_res, what_to_plot_fun=what_to_plot_fun) fig1 = dict(figsize=(3, 3)) fig2 = dict(figsize=(4, 4)) fnames = ('endurance', 'extra_payload') rnames = ('total_cost', 'total_mass') axis = (108, 145, 0.05, 0.8) axis2 = (105, 111.5, 0.05, 0.27) fs, rs = cs.iterate(fnames, rnames) colors = get_colors(len(fs)) f = r.figure() with f.plot('resources1', **fig1) as pylab: ieee_spines_zoom3(pylab) for i, ((f1, f2), resources) in enumerate(zip(fs, rs)): color = colors[i] if resources: marker = 'k.' else: marker = 'x' pylab.plot(f1, f2, marker, markerfacecolor=color, clip_on=False) pylab.xlabel('endurance [min]') pylab.ylabel('extra_payload [g]') # pylab.xticks([0, 30, 60, 90, 120]) set_axis_colors(pylab, color_functions, color_functions) params0 = dict(color_shadow=[1.0, 0.8, 0.8], markers='k.', markers_params={}) color_shadow = params0['color_shadow'] markers = params0['markers'] P = parse_poset('dimensionless x dimensionless') with f.plot('resources2', **fig2) as pylab: ieee_spines_zoom3(pylab) for i, resources in enumerate(rs): v = P.Us(resources) color = colors[i] plot_upset_R2(pylab, v, axis, extra_space_shadow=0, color_shadow=color, markers=markers, marker_params=dict(markerfacecolor=color)) pylab.ylabel('total mass [kg]') pylab.xlabel('total cost [USD]') pylab.xticks([110, 120, 130, 140, 150]) # pylab.yticks([0.2, 0.25, 0.3, 0.35]) set_axis_colors(pylab, color_resources, color_resources) pylab.axis(axis) rs_subset = rs[:3] with f.plot('resources3', **fig2) as pylab: ieee_spines_zoom3(pylab) for i, resources in enumerate(rs_subset): v = P.Us(resources) color = colors[i] plot_upset_R2(pylab, v, axis2, extra_space_shadow=0, color_shadow=color, markers=markers, marker_params=dict(markerfacecolor=color)) pylab.ylabel('total mass [kg]') pylab.xlabel('total cost [USD]') pylab.xticks([ 110, 110.5, 111, 111.5, ]) set_axis_colors(pylab, color_resources, color_resources) return r
def ConstantMinimals1(): R = parse_poset('V x V') values = [(1.0, 0.0), (0.5, 0.5)] return ConstantMinimals(R, values)