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 InvPlus2L_1():
F = parse_poset('m')
Rs = (F, F)
n = 9
return InvPlus2L(F, Rs, n)
def InvPlus2U_1():
F = parse_poset('m')
Rs = (F, F)
n = 4
return InvPlus2U(F, Rs, n)
def Limit_1():
F = parse_poset('m')
value = 5.0
return Limit(F, value)
def Limit_1():
F = parse_poset('m')
value = 5.0
return Limit(F, value)
def LimitMaximals_1():
F = parse_poset('Nat x Nat')
values = [(5, 1), (1, 5)]
return LimitMaximals(F, values)
def MaxR1DP_1():
F = parse_poset('Nat')
f = 4
return MaxR1DP(F, f)
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 MinF1DP_1():
F = parse_poset('Nat')
f = 4
return MinF1DP(F, f)
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 PlusValueDP1():
F = parse_poset('J')
U = parse_poset('mJ')
v = 1000.0
return PlusValueDP(F, c_value=v, c_space=U)
def InvPlus2_1():
F = parse_poset('m')
Rs = (F, F)
return InvPlus2(F, Rs)
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)
