def eval_space_interval(r, context):
from mcdp_lang.eval_constant_imp import eval_constant
va = eval_constant(r.a, context)
vb = eval_constant(r.b, context)
vb2 = express_vu_in_isomorphic_space(vb, va)
P = GenericInterval(va.unit, va.value, vb2.value)
return P
def eval_space_interval(r, context):
from mcdp_lang.eval_constant_imp import eval_constant
va = eval_constant(r.a, context)
vb = eval_constant(r.b, context)
vb2 = express_vu_in_isomorphic_space(vb, va)
P = GenericInterval(va.unit, va.value, vb2.value)
return P
def eval_lfunction_invplus_sort_ops(ops, context, wants_constant):
"""
pos_constants, neg_constants, functions = sort_ops(ops, context)
"""
from .eval_constant_imp import eval_constant
pos_constants = []
neg_constants = []
functions = []
for op in ops:
try:
x = eval_constant(op, context)
check_isinstance(x, ValueWithUnits)
if isinstance(x.unit, (RcompUnits, Rcomp, Nat)):
pos_constants.append(x)
elif isinstance(x.unit, RbicompUnits):
neg_constants.append(x)
else:
msg = 'Invalid addition - needs error'
raise_desc(DPInternalError, msg, x=x)
except NotConstant as e:
if wants_constant:
msg = 'Sum not constant because one op is not constant.'
raise_wrapped(NotConstant, e, msg, op=op, compact=True)
x = eval_lfunction(op, context)
assert isinstance(x, CFunction)
functions.append(x)
return pos_constants, neg_constants, functions
def eval_lfunction_invmult_sort_ops(ops, context, wants_constant):
""" Divides in resources and constants
Returns functions, constants
"""
from .eval_constant_imp import eval_constant
constants = []
functions = []
for op in ops:
try:
x = eval_constant(op, context)
check_isinstance(x, ValueWithUnits)
constants.append(x)
continue
except NotConstant as e:
pass
except DPSemanticError as e:
if 'Variable ref' in str(e):
pass
else:
raise
if wants_constant:
msg = 'Product not constant because one op is not constant.'
raise_wrapped(NotConstant, e, msg, op=op)
x = eval_lfunction(op, context)
assert isinstance(x, CFunction)
functions.append(x)
return functions, constants
def eval_lfunction_invplus_sort_ops(ops, context, wants_constant):
"""
pos_constants, neg_constants, functions = sort_ops(ops, context)
"""
from .eval_constant_imp import eval_constant
pos_constants = []
neg_constants = []
functions = []
for op in ops:
try:
x = eval_constant(op, context)
check_isinstance(x, ValueWithUnits)
if isinstance(x.unit, (RcompUnits, Rcomp, Nat)):
pos_constants.append(x)
elif isinstance(x.unit, RbicompUnits):
neg_constants.append(x)
else:
msg = 'Invalid addition - needs error'
raise_desc(DPInternalError, msg, x=x)
except NotConstant as e:
if wants_constant:
msg = 'Sum not constant because one op is not constant.'
raise_wrapped(NotConstant, e, msg, op=op)
x = eval_lfunction(op, context)
assert isinstance(x, CFunction)
functions.append(x)
return pos_constants, neg_constants, functions
def eval_lfunction_invmult_sort_ops(ops, context, wants_constant):
""" Divides in resources and constants
Returns functions, constants
"""
from .eval_constant_imp import eval_constant
constants = []
functions = []
for op in ops:
try:
x = eval_constant(op, context)
check_isinstance(x, ValueWithUnits)
constants.append(x)
continue
except NotConstant as e:
pass
except DPSemanticError as e:
if 'Variable ref' in str(e):
pass
else:
raise
if wants_constant:
msg = 'Product not constant because one op is not constant.'
raise_wrapped(
NotConstant,
e,
msg, # op=op,
compact=True)
x = eval_lfunction(op, context)
assert isinstance(x, CFunction)
functions.append(x)
return functions, constants
def eval_rvalue_as_constant(s):
""" Parses as an rvalue (resource) and evaluates as a constant value.
Returns ValueWithUnit. """
parsed = parse_wrap(Syntax.rvalue, s)[0]
context = Context()
from mcdp_lang.eval_constant_imp import eval_constant
value = eval_constant(parsed, context)
return value
def eval_rvalue_as_constant(s):
""" Parses as an rvalue (resource) and evaluates as a constant value.
Returns ValueWithUnit. """
parsed = parse_wrap(Syntax.rvalue, s)[0]
context = Context()
from mcdp_lang.eval_constant_imp import eval_constant
value = eval_constant(parsed, context)
return value
def eval_lfunction(lf, context):
check_isinstance(context, ModelBuildingContext)
if isinstance(lf, (CDP.NewFunction, CDP.DerivResourceRef)):
msg = 'The functionality %r cannot be used on this side of the constraint.'
raise_desc(DPSemanticError, msg % lf.name.value)
constants = (CDP.Collection, CDP.SimpleValue, CDP.SpaceCustomValue,
CDP.Top, CDP.Bottom, CDP.Minimals, CDP.Maximals,
CDP.NatConstant, CDP.RcompConstant, CDP.ConstantDivision,
CDP.SpecialConstant)
if isinstance(lf, constants):
from mcdp_lang.eval_constant_imp import eval_constant
res = eval_constant(lf, context)
assert isinstance(res, ValueWithUnits)
return get_valuewithunits_as_function(res, context)
from .eval_lfunction_imp_maketuple import eval_MakeTuple_as_lfunction
from .eval_uncertainty import eval_lfunction_Uncertain
from .eval_lfunction_imp_label_index import eval_lfunction_label_index
from .eval_lfunction_imp_label_index import eval_lfunction_tupleindexfun
from mcdp_lang.eval_uncertainty import eval_lfunction_FValueBetween
from mcdp_lang.eval_uncertainty import eval_lfunction_FValuePlusOrMinus
from mcdp_lang.eval_uncertainty import eval_lfunction_FValuePlusOrMinusPercent
cases = {
CDP.Function: eval_lfunction_Function,
CDP.NewResource: eval_lfunction_newresource,
CDP.MakeTuple: eval_MakeTuple_as_lfunction,
CDP.DisambiguationFun: eval_lfunction_disambiguation,
CDP.FunctionLabelIndex: eval_lfunction_label_index,
CDP.TupleIndexFun: eval_lfunction_tupleindexfun,
CDP.AnyOfFun: eval_lfunction_anyoffun,
CDP.InvMult: eval_lfunction_invmult,
CDP.InvPlus: eval_lfunction_invplus,
CDP.VariableRef: eval_lfunction_variableref,
CDP.ActualVarRef: eval_lfunction_ActualVarRef,
CDP.DerivFunctionRef: eval_lfunction_DerivFunctionRef,
CDP.FValueMinusN: eval_lfunction_FValueMinusN,
CDP.GenericOperationFun: eval_lfunction_genericoperationfun,
CDP.ConstantRef: eval_lfunction_ConstantRef,
CDP.UncertainFun: eval_lfunction_Uncertain,
CDP.FValueBetween: eval_lfunction_FValueBetween,
CDP.FValuePlusOrMinus: eval_lfunction_FValuePlusOrMinus,
CDP.FValuePlusOrMinusPercent: eval_lfunction_FValuePlusOrMinusPercent,
CDP.SumFunctions: eval_fvalue_SumFunctions,
}
for klass, hook in cases.items():
if isinstance(lf, klass):
return hook(lf, context)
if True: # pragma: no cover
r = recursive_print(lf)
msg = 'eval_lfunction(): cannot evaluate this as a function:'
msg += '\n' + indent(r, ' ')
raise_desc(DoesNotEvalToFunction, msg)
def parse_constant_eval(x, context):
from mocdp.comp.context import ValueWithUnits
from mcdp_lang.eval_constant_imp import eval_constant
result = eval_constant(x, context)
assert isinstance(result, ValueWithUnits)
value = result.value
space = result.unit
space.belongs(value)
return result
def parse_constant_eval(x, context):
from mocdp.comp.context import ValueWithUnits
from mcdp_lang.eval_constant_imp import eval_constant
result = eval_constant(x, context)
assert isinstance(result, ValueWithUnits)
value = result.value
space = result.unit
space.belongs(value)
return result
def interpret_params_1string(p, F, context=None):
if context is None:
context = Context()
res = parse_wrap(Syntax.constant_value, p)[0]
vu = eval_constant(res, context)
Fd = vu.unit
fd = vu.value
tu = get_types_universe()
tu.check_leq(Fd, F)
A_to_B, _ = tu.get_embedding(Fd, F)
fg = A_to_B(fd)
return fg
def eval_lfunction(lf, context):
check_isinstance(context, ModelBuildingContext)
constants = (CDP.Collection, CDP.SimpleValue, CDP.SpaceCustomValue,
CDP.Top, CDP.Bottom, CDP.Minimals, CDP.Maximals,
CDP.NatConstant, CDP.RcompConstant)
if isinstance(lf, (CDP.NewFunction, CDP.DerivResourceRef)):
msg = 'The functionality %r cannot be used on this side of the constraint.'
raise_desc(DPSemanticError, msg % lf.name.value)
if isinstance(lf, constants):
from mcdp_lang.eval_constant_imp import eval_constant
res = eval_constant(lf, context)
assert isinstance(res, ValueWithUnits)
return get_valuewithunits_as_function(res, context)
from .eval_lfunction_imp_maketuple import eval_MakeTuple_as_lfunction
from .eval_uncertainty import eval_lfunction_Uncertain
from .eval_lfunction_imp_label_index import eval_lfunction_label_index
from .eval_lfunction_imp_label_index import eval_lfunction_tupleindexfun
cases = {
CDP.Function: eval_lfunction_Function,
CDP.NewResource: eval_lfunction_newresource,
CDP.MakeTuple: eval_MakeTuple_as_lfunction,
CDP.UncertainFun: eval_lfunction_Uncertain,
CDP.DisambiguationFun: eval_lfunction_disambiguation,
CDP.FunctionLabelIndex: eval_lfunction_label_index,
CDP.TupleIndexFun: eval_lfunction_tupleindexfun,
CDP.AnyOfFun: eval_lfunction_anyoffun,
CDP.InvMult: eval_lfunction_invmult,
CDP.InvPlus: eval_lfunction_invplus,
CDP.VariableRef: eval_lfunction_variableref,
CDP.ActualVarRef: eval_lfunction_ActualVarRef,
CDP.DerivFunctionRef: eval_lfunction_DerivFunctionRef,
CDP.FValueMinusN: eval_lfunction_FValueMinusN,
CDP.GenericOperationFun: eval_lfunction_genericoperationfun,
CDP.ConstantRef: eval_lfunction_ConstantRef,
}
for klass, hook in cases.items():
if isinstance(lf, klass):
return hook(lf, context)
if True: # pragma: no cover
r = recursive_print(lf)
msg = 'eval_lfunction(): cannot evaluate this as a function:'
msg += '\n' + indent(r, ' ')
raise_desc(DPInternalError, msg)
def interpret_params_1string(p, F, context=None):
if context is None:
context = Context()
res = parse_wrap(Syntax.constant_value, p)[0]
vu = eval_constant(res, context)
Fd = vu.unit
fd = vu.value
tu = get_types_universe()
tu.check_leq(Fd, F)
A_to_B, _ = tu.get_embedding(Fd, F)
fg = A_to_B(fd)
return fg
def eval_lfunction_FValueMinusN(lf, context):
ops = get_odd_ops(unwrap_list(lf.ops))
# first one should be a functionality
fvalue = eval_lfunction(ops[0], context)
# ops after the first should be constant
must_be_constants = ops[1:]
from .eval_constant_imp import eval_constant
constants = []
for mc in must_be_constants:
try:
c = eval_constant(mc, context)
constants.append(c)
except:
raise
constant = plus_constantsN(constants)
# f - constant <= (x)
# f <= (x) + Constant
F = context.get_ftype(fvalue)
if isinstance(F, Nat) and isinstance(constant.unit, Nat):
dp = PlusValueNatDP(constant.value)
elif isinstance(F, Rcomp):
dp = PlusValueRcompDP(constant.value)
elif isinstance(F, RcompUnits):
dp = PlusValueDP(F=F, c_value=constant.value, c_space=constant.unit)
else:
msg = 'Could not create this operation with %s. ' % F
raise_desc(DPSemanticError, msg, F=F)
return create_operation_lf(context,
dp=dp,
functions=[fvalue],
name_prefix='_minusvalue',
op_prefix='_op',
res_prefix='_result')
def sort_resources_and_constants(ops, mode, context):
"""
Returns a tuple of three arrays:
types, are_they_constant, resources_or_constants
mode is either 'functions' or 'resources'
resources_or_constants contains either CResources or ValueWithUnits
"""
assert mode in ['functions', 'resources']
rtypes = []
are_they_constant = []
resources_or_constants = []
for op in ops:
try:
c = eval_constant(op, context)
resources_or_constants.append(c)
rtypes.append(c.unit)
are_they_constant.append(True)
continue
except NotConstant:
pass
if mode == 'resources':
from .eval_resources_imp import eval_rvalue
ref = eval_rvalue(op, context)
P = context.get_rtype(ref)
elif mode == 'functions':
from .eval_lfunction_imp import eval_lfunction
ref = eval_lfunction(op, context)
P = context.get_ftype(ref)
else:
assert False
resources_or_constants.append(ref)
are_they_constant.append(False)
rtypes.append(P)
return rtypes, are_they_constant, resources_or_constants
def sort_resources_and_constants(ops, mode, context):
"""
Returns a tuple of three arrays:
types, are_they_constant, resources_or_constants
mode is either 'functions' or 'resources'
resources_or_constants contains either CResources or ValueWithUnits
"""
assert mode in ['functions', 'resources']
rtypes = []
are_they_constant = []
resources_or_constants = []
for op in ops:
try:
c = eval_constant(op, context)
resources_or_constants.append(c)
rtypes.append(c.unit)
are_they_constant.append(True)
continue
except NotConstant:
pass
if mode == 'resources':
from .eval_resources_imp import eval_rvalue
ref = eval_rvalue(op, context)
P = context.get_rtype(ref)
elif mode == 'functions':
from .eval_lfunction_imp import eval_lfunction
ref = eval_lfunction(op, context)
P = context.get_ftype(ref)
else:
assert False
resources_or_constants.append(ref)
are_they_constant.append(False)
rtypes.append(P)
return rtypes, are_they_constant, resources_or_constants
def eval_lfunction_anyoffun(lf, context):
from .eval_constant_imp import eval_constant
from mcdp_posets import FiniteCollectionsInclusion
from mcdp_dp import LimitMaximals
from mcdp_posets import FiniteCollection
assert isinstance(lf, CDP.AnyOfFun)
constant = eval_constant(lf.value, context)
if not isinstance(constant.unit, FiniteCollectionsInclusion):
msg = 'I expect that the argument to any-of evaluates to a finite collection.'
raise_desc(DPSemanticError, msg, constant=constant)
assert isinstance(constant.unit, FiniteCollectionsInclusion)
P = constant.unit.S
assert isinstance(constant.value, FiniteCollection)
elements = set(constant.value.elements)
maximals = poset_maxima(elements, P.leq)
if len(elements) != len(maximals):
msg = 'The elements are not maximals.'
raise_desc(DPSemanticError, msg, elements=elements, maximals=maximals)
dp = LimitMaximals(values=maximals, F=P)
return create_operation_lf(context, dp=dp, functions=[])
def eval_lfunction_FValueMinusN(lf, context):
ops = get_odd_ops(unwrap_list(lf.ops))
# first one should be a functionality
fvalue = eval_lfunction(ops[0], context)
# ops after the first should be constant
must_be_constants = ops[1:]
from .eval_constant_imp import eval_constant
constants = []
for mc in must_be_constants:
try:
c = eval_constant(mc, context)
constants.append(c)
except:
raise
constant = plus_constantsN(constants)
# f - constant <= (x)
# f <= (x) + Constant
F = context.get_ftype(fvalue)
if isinstance(F, Nat) and isinstance(constant.unit, Nat):
dp = PlusValueNatDP(constant.value)
elif isinstance(F, Rcomp):
dp = PlusValueRcompDP(constant.value)
elif isinstance(F, RcompUnits):
dp = PlusValueDP(F=F, c_value=constant.value, c_space=constant.unit)
else:
msg = 'Could not create this operation with %s. ' % F
raise_desc(DPSemanticError, msg, F=F)
return create_operation_lf(context, dp=dp, functions=[fvalue],
name_prefix='_minusvalue', op_prefix='_op',
res_prefix='_result')
def eval_lfunction_anyoffun(lf, context):
from .eval_constant_imp import eval_constant
from mcdp_posets import FiniteCollectionsInclusion
from mcdp_dp import LimitMaximals
from mcdp_posets import FiniteCollection
assert isinstance(lf, CDP.AnyOfFun)
constant = eval_constant(lf.value, context)
if not isinstance(constant.unit, FiniteCollectionsInclusion):
msg = 'I expect that the argument to any-of evaluates to a finite collection.'
raise_desc(DPSemanticError, msg, constant=constant)
assert isinstance(constant.unit, FiniteCollectionsInclusion)
P = constant.unit.S
assert isinstance(constant.value, FiniteCollection)
elements = set(constant.value.elements)
maximals = poset_maxima(elements, P.leq)
if len(elements) != len(maximals):
msg = 'The elements are not maximals.'
raise_desc(DPSemanticError, msg, elements=elements, maximals=maximals)
dp = LimitMaximals(values=maximals, F=P)
return create_operation_lf(context, dp=dp, functions=[],
name_prefix='_anyof')
