def get_approx_dp(S, name, approx_perc, approx_abs, approx_abs_S, max_value,
max_value_S):
from mcdp_posets.types_universe import express_value_in_isomorphic_space
approx_abs_ = express_value_in_isomorphic_space(S1=approx_abs_S,
s1=approx_abs,
S2=S)
max_value_ = express_value_in_isomorphic_space(S1=max_value_S,
s1=max_value,
S2=S)
if approx_perc > 0: # pragma: no cover
raise_desc(DPNotImplementedError, 'Approx_perc not implemented')
dps = []
if max_value > 0:
dp_max = FuncNotMoreThan(S, max_value_)
dps.append(dp_max)
if approx_abs_ > 0:
dps.append(makeLinearCeilDP(S, approx_abs_))
dp = wrap_series(S, dps)
ndp = dpwrap(dp, name, name)
return ndp
def get_samples(request, ndp):
xaxis = str(request.params['xaxis'])
# yaxis = str(request.params['yaxis'])
xmin = request.params['xmin'].encode('utf-8')
xmax = request.params['xmax'].encode('utf-8')
nsamples = int(request.params['nsamples'])
fnames = ndp.get_fnames()
rnames = ndp.get_rnames()
# must pass the other functions as parameters
f = {}
for fn in fnames:
if fn == xaxis: continue
if not fn in request.params:
msg = 'You have to pass the value of function %r.' % fn
raise_desc(ValueError, msg, rnames=rnames)
s = request.params[fn]
try:
val = parse_constant(s)
except DPSyntaxError as e:
msg = 'Cannot parse value for %r.' % fn
raise_wrapped(ValueError, e, msg, compact=True)
F = ndp.get_ftype(fn)
f[fn] = express_value_in_isomorphic_space(val.unit, val.value, F)
F = ndp.get_ftype(xaxis)
try:
xmin = parse_constant(xmin)
xmax = parse_constant(xmax)
except DPSyntaxError as e:
msg = 'Cannot parse value for xmax/xmin.'
raise_wrapped(ValueError, e, msg, compact=True)
xmin = express_value_in_isomorphic_space(xmin.unit, xmin.value, F)
xmax = express_value_in_isomorphic_space(xmax.unit, xmax.value, F)
import numpy as np
xsamples = np.linspace(xmin, xmax, nsamples)
samples = []
for xsample in xsamples:
t = []
for fn in fnames:
if fn == xaxis:
t.append(xsample)
else:
t.append(f[fn])
sample = tuple(t)
if len(fnames) == 1:
sample = sample[0]
samples.append(sample)
return samples
def get(matches, used, Ps, get_P, Pa, ua):
others = list(set(used) - set(matches))
extra = PosetProduct(tuple(map(get_P, others)))
print('extra for Pa: %s' % extra)
Pa_comp = PosetProduct(Pa.subs + extra.subs)
print('Pa_comp: %s' % Pa_comp)
extra_minimals = extra.get_minimal_elements()
m_matches = matches + others
s = set()
R = set()
for m1, m2 in itertools.product(ua.minimals, extra_minimals):
m = m1 + m2
s.add(m)
r = [None] * len(used)
for i, a in enumerate(used):
S1 = Pa_comp.subs[m_matches.index(a)]
s1 = m[m_matches.index(a)]
S2 = get_P(a)
r[i] = express_value_in_isomorphic_space(S1, s1, S2)
r = tuple(r)
R.add(r)
Pa_comp_lb = Pa_comp.Us(s)
print('Pa_comp_lb: %s' % Pa_comp_lb)
Ps_a = Ps.Us(R)
return Ps_a
def get(matches, used, Ps, get_P, Pa, ua):
others = list(set(used) - set(matches))
extra = PosetProduct(tuple(map(get_P, others)))
print('extra for Pa: %s' % extra)
Pa_comp = PosetProduct(Pa.subs + extra.subs)
print('Pa_comp: %s' % Pa_comp)
extra_minimals = extra.get_minimal_elements()
m_matches = matches + others
s = set()
R = set()
for m1, m2 in itertools.product(ua.minimals, extra_minimals):
m = m1 + m2
s.add(m)
r = [None] * len(used)
for i, a in enumerate(used):
S1 = Pa_comp.subs[m_matches.index(a)]
s1 = m[m_matches.index(a)]
S2 = get_P(a)
r[i] = express_value_in_isomorphic_space(S1, s1, S2)
r = tuple(r)
R.add(r)
Pa_comp_lb = Pa_comp.Us(s)
print('Pa_comp_lb: %s' % Pa_comp_lb)
Ps_a = Ps.Us(R)
return Ps_a
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 get_approx_dp(S, name, approx_perc, approx_abs, approx_abs_S, max_value,
max_value_S):
from mcdp_posets.types_universe import express_value_in_isomorphic_space
approx_abs_ = express_value_in_isomorphic_space(S1=approx_abs_S, s1=approx_abs, S2=S)
max_value_ = express_value_in_isomorphic_space(S1=max_value_S, s1=max_value, S2=S)
if approx_perc > 0:
raise_desc(DPNotImplementedError, 'Approx_perc not implemented')
dps = []
if max_value > 0:
dp_max = FuncNotMoreThan(S, max_value_)
dps.append(dp_max)
if approx_abs_ > 0:
dps.append(makeLinearCeilDP(S, approx_abs_))
dp = wrap_series(S, dps)
ndp = dpwrap(dp, name, name)
return ndp
def opt_basic_7():
libnames = ['actuation']
library = get_test_library2(libnames)
# outdir = 'out/opt_basic_7'
# cache_dir = os.path.join(outdir, 'cache')
library.use_tmp_cache()
ndp = library.load_ndp('duckiebot_sol00')
min_functions = {
'motion': '< `RigidBodyID: rb1, 0.1 m/s, 10 minutes >',
}
_flabels, F0s, f0s = _parse_dict(min_functions, library)
names = [name for name, _ndp in cndp_get_name_ndp_notfunres(ndp)]
print('names: %s' % names)
to_remove = list(names)
to_remove.remove('dagu_chassis')
# to_remove.remove('battery_ravpower')
# to_remove.remove('USBMicroCharging')
from mcdp_opt_tests.ndp_utils import cndp_remove_one_child
for n in to_remove:
ndp = cndp_remove_one_child(ndp, n)
print ndp
if len(F0s) > 1:
F = PosetProduct(F0s)
f0 = f0s
else:
F = F0s[0]
f0 = f0s[0]
dp = ndp.get_dp()
F1 = dp.get_fun_space()
f1 = express_value_in_isomorphic_space(F, f0, F1)
_res = dp.solve(f1)
def express_vu_in_isomorphic_space(vb, va):
""" Returns vb in va's units """
from mcdp_posets.types_universe import express_value_in_isomorphic_space
value = express_value_in_isomorphic_space(vb.unit, vb.value, va.unit)
return ValueWithUnits(value=value, unit=va.unit)
def express_vu_in_isomorphic_space(vb, va):
""" Returns vb in va's units """
from mcdp_posets.types_universe import express_value_in_isomorphic_space
value = express_value_in_isomorphic_space(vb.unit, vb.value, va.unit)
return ValueWithUnits(value=value, unit=va.unit)
def cast_value(self, P):
""" Returns the value cast in the space P (larger than
the current space). """
return express_value_in_isomorphic_space(self.unit, self.value, P)
