def compare(e1, e2):
result = Expression(p, e1, e2).evaluate(evaluation)
if result.is_true():
result = Expression(p, e2, e1).evaluate(evaluation)
if result.is_true():
return 0
else:
return -1
else:
return 1
def compare(e1, e2):
result = Expression(p, e1, e2).evaluate(evaluation)
if result.is_true():
result = Expression(p, e2, e1).evaluate(evaluation)
if result.is_true():
return 0
else:
return -1
else:
return 1
def apply_generic(self, expr, cond, evaluation):
"ConditionalExpression[expr_, cond_]"
# What we need here is a way to evaluate
# cond as a predicate, using assumptions.
# Let's delegate this to the And (and Or) symbols...
if not cond.is_atom() and cond._head == SymbolList:
cond = Expression("System`And", *(cond._leaves))
else:
cond = Expression("System`And", cond)
if cond is None:
return
if cond.is_true():
return expr
if cond == SymbolFalse:
return SymbolUndefined
return
def apply(self, f, expr, n, evaluation, options):
"FixedPoint[f_, expr_, n_:DirectedInfinity[1], OptionsPattern[FixedPoint]]"
if n == Expression("DirectedInfinity", 1):
count = None
else:
count = n.get_int_value()
if count is None or count < 0:
evaluation.message("FixedPoint", "intnn")
return
if count is None:
count = self.get_option(options, "MaxIterations", evaluation)
if count.is_numeric():
count = count.get_int_value()
else:
count = None
result = expr
index = 0
sametest = self.get_option(options, "SameTest", evaluation)
if sametest == Symbol("Automatic"):
sametest = None
while count is None or index < count:
evaluation.check_stopped()
new_result = Expression(f, result).evaluate(evaluation)
if sametest:
same = Expression(sametest, result,
new_result).evaluate(evaluation)
same = same.is_true()
if same:
break
else:
if new_result == result:
result = new_result
break
result = new_result
index += 1
return result
