def _print_Piecewise(self, expr):
# Filter out default zeros since they are implicit in a TDB
filtered_args = [(x, cond) for x, cond in zip(*[iter(expr.args)] * 2)
if not ((cond == S.true) and (x == S.Zero))]
exprs = [self._stringify_expr(x) for x, cond in filtered_args]
# Only a small subset of piecewise functions can be represented
# Need to verify that each cond's highlim equals the next cond's lowlim
# to_interval() is used because symengine does not implement as_set()
intervals = [to_interval(cond) for x, cond in filtered_args]
intersected_intervals = UniversalSet()
for i in intervals:
intersected_intervals = intersected_intervals.intersection(i)
if (len(intervals) > 1) and (intersected_intervals != EmptySet):
raise ValueError(
'Overlapping intervals cannot be represented: {}'.format(
intervals))
continuous_interval = Interval(intervals[0].args[0],
intervals[-1].args[1], False, True)
# XXX: Wait, should this be the intersection or the union of continuous_interval?
if Union(*intervals).union(continuous_interval) != continuous_interval:
raise ValueError('Piecewise intervals must be continuous')
if not all([cond.free_symbols == {v.T} for x, cond in filtered_args]):
raise ValueError(
'Only temperature-dependent piecewise conditions are supported'
)
# Sort expressions based on intervals
sortindices = [
i[0]
for i in sorted(enumerate(intervals), key=lambda x: x[1].args[0])
]
exprs = [exprs[idx] for idx in sortindices]
# Infinity is implicit in TDB, so we shouldn't print it; ',' means use default value
as_str = lambda x: ',' if (x == S.Infinity) or (x == S.NegativeInfinity
) else str(x)
if len(exprs) > 1:
result = '{1} {0}; {2} Y'.format(exprs[0],
as_str(intervals[0].args[0]),
as_str(intervals[0].args[1]))
result += 'Y'.join([
' {0}; {1} '.format(expr, as_str(i.args[1]))
for i, expr in zip(intervals[1:], exprs[1:])
])
result += 'N'
else:
result = '{0} {1}; {2} N'.format(as_str(intervals[0].args[0]),
exprs[0],
as_str(intervals[0].args[1]))
return result
def to_interval(relational):
if isinstance(relational, And):
result = UniversalSet()
for i in relational.args:
result = result.intersection(to_interval(i))
return result
elif isinstance(relational, Or):
return Union(*[to_interval(i) for i in relational.args])
elif isinstance(relational, Not):
return Complement(*[to_interval(i) for i in relational.args])
if relational == S.true:
return Interval(S.NegativeInfinity,
S.Infinity,
left_open=True,
right_open=True)
if len(relational.free_symbols) != 1:
raise ValueError('Relational must only have one free symbol')
if len(relational.args) != 2:
raise ValueError('Relational must only have two arguments')
free_symbol = list(relational.free_symbols)[0]
lhs = relational.args[0]
rhs = relational.args[1]
if isinstance(relational, LessThan):
if rhs == free_symbol:
return Interval(lhs, S.Infinity, left_open=False, right_open=True)
else:
return Interval(S.NegativeInfinity,
rhs,
left_open=True,
right_open=False)
elif isinstance(relational, StrictLessThan):
if rhs == free_symbol:
return Interval(lhs, S.Infinity, left_open=True, right_open=False)
else:
return Interval(S.NegativeInfinity,
rhs,
left_open=False,
right_open=True)
else:
raise ValueError('Unsupported Relational: {}'.format(
relational.__class__.__name__))
def test_UniversalSet():
U = UniversalSet()
x = Symbol("x")
assert U.union(Interval(2, 4)) == U
assert U.intersection(Interval(2, 4)) == Interval(2, 4)
assert U.contains(0) == true