evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Integer)),pc.Types.Natural)
evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Natural)),pc.Types.Natural)
evaluator.add_rule(pc.Type(pc.real(s.x)),pc.Types.Real)
evaluator.add_rule(pc.Type(pc.imag(s.x)),pc.Types.Real)
evaluator.add_rule(pc.Type(pc.conjugate(s.x)),pc.Types.Complex)
evaluator.add_rule(pc.Type(pc.Indicator(s.x)),pc.Types.Natural)
evaluator.add_rule(pc.Type(pc.OuterPiecewise(s.x)),pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.InnerPiecewise((s.a,s.b),s.x)),pc.DominantType(pc.Type(s.a),pc.Type(pc.InnerPiecewise(s.x))))
evaluator.add_rule(pc.Type(pc.InnerPiecewise((s.a,s.b))),pc.Type(s.a))
evaluator.add_rule(pc.Type(pc.derivative(s.x,s.y)),pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.evaluated_at(s.x,s.y,s.z)),pc.DominantType(pc.Type(s.x),pc.Type(s.z)))
evaluator.add_rule(pc.Type(pc.tmp(s.x)),pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.sqrt(s.x)),pc.Type(s.x**(1/pc.S(2))))
evaluator.add_rule(pc.Type(pc.atan2(s.x,s.y)),pc.DominantType(pc.Type(s.x),pc.Type(s.x),pc.Types.Rational))
for f in [pc.exp,pc.log,pc.sin,pc.cos,pc.asin ,pc.acos,pc.tan,pc.atan,pc.cot,pc.acot,pc.sinh,pc.cosh,pc.asinh,pc.acosh,pc.tanh,pc.atanh,pc.coth,pc.acoth]:
evaluator.add_rule(pc.Type(f(s.x)),pc.DominantType(pc.Type(s.x),pc.Types.Rational))
def issubtype(x,t):
return pc.equal(pc.DominantType(pc.Type(x),t),t)
from .logic_evaluator import is_mpmath
from mpmath import mp
pc.conjugate(s.x) + pc.conjugate(s.y))
evaluator.add_rule(pc.conjugate(s.x * s.y),
pc.conjugate(s.x) * pc.conjugate(s.y))
evaluator.add_rule(pc.conjugate(-s.x), -pc.conjugate(s.x))
evaluator.add_rule(pc.conjugate(1 / s.x), 1 / pc.conjugate(s.x))
evaluator.add_rule(pc.conjugate(s.x**-1), pc.conjugate(s.x)**-1)
evaluator.add_rule(pc.conjugate(s.x**s.n), s.x**s.n, condition=0 < s.x)
def create_tmp_x(m):
m[c] = pc.tmp(s.x)
evaluator.add_rule(
pc.derivative(s.f(s.g(s.x)), s.x),
pc.evaluated_at(pc.derivative(s.f(pc.tmp(s.x)), pc.tmp(s.x)), pc.tmp(s.x),
s.g(s.x)) * pc.derivative(s.g(s.x), s.x))
evaluator.add_rule(pc.evaluated_at(s.f(s.x), s.x, s.c),
s.f(s.c),
condition=pc.Not(is_function_type(s.f(s.x), pc.derivative)))
evaluator.add_rule(pc.Min(s.a, s.b), s.a, condition=s.a <= s.b)
evaluator.add_rule(pc.Min(s.a, s.b), s.b, condition=s.b <= s.a)
from .canonical_form import canonical_form
from .logic_evaluator import logic_evaluator
from .numeric_evaluator import numeric_evaluator
from .type_evaluator import type_evaluator
main_evaluator = pc.MultiEvaluator(recursive=True, split_binary=True)
main_evaluator.add_evaluator(canonical_form)
evaluator.add_rule(pc.imag(s.x),(s.x - pc.conjugate(s.x))/2j)
evaluator.add_rule(pc.conjugate(s.x),s.x,condition=issubtype(s.x,pc.Types.Real))
evaluator.add_rule(pc.conjugate(s.x),-s.x,condition=issubtype(s.x,pc.Types.Imaginary))
evaluator.add_rule(pc.conjugate(s.x+s.y),pc.conjugate(s.x)+pc.conjugate(s.y))
evaluator.add_rule(pc.conjugate(s.x*s.y),pc.conjugate(s.x)*pc.conjugate(s.y))
evaluator.add_rule(pc.conjugate(-s.x),-pc.conjugate(s.x))
evaluator.add_rule(pc.conjugate(1/s.x),1/pc.conjugate(s.x))
evaluator.add_rule(pc.conjugate(s.x**-1),pc.conjugate(s.x)**-1)
def create_tmp_x(m):
m[c] = pc.tmp(s.x)
evaluator.add_rule( pc.derivative(s.f(s.g(s.x)),s.x) ,
pc.evaluated_at( pc.derivative(s.f(pc.tmp(s.x)),pc.tmp(s.x)), pc.tmp(s.x), s.g(s.x) ) * pc.derivative(s.g(s.x),s.x));
evaluator.add_rule(pc.evaluated_at( s.f(s.x), s.x, s.c ), s.f(s.c), condition = pc.Not(is_function_type(s.f(s.x),pc.derivative)) )
evaluator.add_rule(pc.Min(s.a,s.b),s.a,condition=s.a<=s.b)
evaluator.add_rule(pc.Min(s.a,s.b),s.b,condition=s.b<=s.a)
from .canonical_form import canonical_form
from .logic_evaluator import logic_evaluator
from .numeric_evaluator import numeric_evaluator
from .type_evaluator import type_evaluator
main_evaluator = pc.MultiEvaluator(recursive = True, split_binary=True)
main_evaluator.add_evaluator(canonical_form)
pc.Types.Natural)
evaluator.add_rule(pc.Type(pc.real(s.x)), pc.Types.Real)
evaluator.add_rule(pc.Type(pc.imag(s.x)), pc.Types.Real)
evaluator.add_rule(pc.OperationType(abs(s.x)), pc.Types.Real)
#evaluator.add_rule(pc.Type(pc.conjugate(s.x)),pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.Indicator(s.x)), pc.Types.Natural)
evaluator.add_rule(pc.Type(pc.OuterPiecewise(s.x)), pc.Type(s.x))
evaluator.add_rule(
pc.Type(pc.InnerPiecewise((s.a, s.b), s.x)),
pc.DominantType(pc.Type(s.a), pc.Type(pc.InnerPiecewise(s.x))))
evaluator.add_rule(pc.Type(pc.InnerPiecewise((s.a, s.b))), pc.Type(s.a))
evaluator.add_rule(pc.Type(pc.derivative(s.x, s.y)), pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.evaluated_at(s.x, s.y, s.z)),
pc.DominantType(pc.Type(s.x), pc.Type(s.z)))
evaluator.add_rule(pc.Type(pc.tmp(s.x)), pc.Type(s.x))
evaluator.add_rule(pc.Type(pc.sqrt(s.x)), pc.Type(s.x**(1 / pc.S(2))))
evaluator.add_rule(
pc.Type(pc.atan2(s.x, s.y)),
pc.DominantType(pc.Type(s.x), pc.Type(s.x), pc.Types.Rational))
for f in [
pc.exp, pc.log, pc.sin, pc.cos, pc.asin, pc.acos, pc.tan, pc.atan,
pc.cot, pc.acot, pc.sinh, pc.cosh, pc.asinh, pc.acosh, pc.tanh,
pc.atanh, pc.coth, pc.acoth
]:
evaluator.add_rule(pc.Type(f(s.x)),
