format_evaluator.add_rule(s.x**s.a*s.y**-s.a,(s.x/s.y)**s.a,condition=pc.Or(s.x>0,s.y>0,issubtype(s.a,pc.Types.Integer))) format_evaluator.add_rule(pc.Min(s.a,-s.a),-abs(s.a)) format_evaluator.add_rule(pc.Min(-s.a,s.a),-abs(s.a)) format_evaluator.add_rule(pc.Min(s.a,s.b),-abs(s.a),condition=pc.equal(-s.b,s.a)) format_evaluator.add_rule(-(-s.a),s.a) format_evaluator.add_rule(pc.equal(s.a,s.a),True) format_evaluator.add_rule(-(s.a+s.b),-s.a-s.b) format_evaluator.add_rule(pc.sin(s.x)/pc.cos(s.x),pc.tan(s.x)) format_evaluator.add_rule(pc.cos(s.x)/pc.sin(s.x),pc.cot(s.x)) format_evaluator.add_rule((-s.a)*s.b,-(s.a*s.b)) format_evaluator.add_rule(pc.Not(pc.equal(s.x,s.y)),pc.unequal(s.x,s.y)); format_evaluator.add_rule(pc.Or(s.x<s.y,pc.equal(s.x,s.y)),s.x<=s.y) format_evaluator.add_rule((s.x + pc.conjugate(s.x)),2*pc.real(s.x)) format_evaluator.add_rule((s.x - pc.conjugate(s.x)),2j*pc.imag(s.x)) format_evaluator.add_rule(s.x/s.x,1) format_evaluator.add_rule(1*s.x,s.x) format_evaluator.add_rule(s.x/1,s.x) format_evaluator.add_rule(-1*s.x,-s.x) format_evaluator.add_rule(-1*-1,1) format_evaluator.add_rule(pc.I*pc.I,-1)
evaluator.add_rule(pc.Type(pc.ceil(s.x)),pc.Types.Integer) evaluator.add_rule(pc.Type(pc.round(s.x)),pc.Types.Integer) evaluator.add_rule(pc.Type(pc.mod(s.x,s.y)),pc.Types.Integer) evaluator.add_rule(pc.Type(pc.Abs(s.x)),pc.OperationType(pc.Abs(pc.Type(s.x)))) evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Complex)),pc.Types.Real) evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Imaginary)),pc.Types.Real) evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Real)),pc.Types.Real) evaluator.add_rule(pc.OperationType(pc.Abs(pc.Types.Rational)),pc.Types.Rational) 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))
format_evaluator.add_rule(s.x**s.a * s.y**-s.a, (s.x / s.y)**s.a,
condition=pc.Or(s.x > 0, s.y > 0,
issubtype(s.a, pc.Types.Integer)))
format_evaluator.add_rule(pc.Min(s.a, -s.a), -abs(s.a))
format_evaluator.add_rule(pc.Min(-s.a, s.a), -abs(s.a))
format_evaluator.add_rule(pc.Min(s.a, s.b),
-abs(s.a),
condition=pc.equal(-s.b, s.a))
format_evaluator.add_rule(-(-s.a), s.a)
format_evaluator.add_rule(pc.equal(s.a, s.a), True)
format_evaluator.add_rule(-(s.a + s.b), -s.a - s.b)
format_evaluator.add_rule(pc.sin(s.x) / pc.cos(s.x), pc.tan(s.x))
format_evaluator.add_rule(pc.cos(s.x) / pc.sin(s.x), pc.cot(s.x))
format_evaluator.add_rule((-s.a) * s.b, -(s.a * s.b))
format_evaluator.add_rule(pc.Not(pc.equal(s.x, s.y)), pc.unequal(s.x, s.y))
format_evaluator.add_rule(pc.Or(s.x < s.y, pc.equal(s.x, s.y)), s.x <= s.y)
format_evaluator.add_rule((s.x + pc.conjugate(s.x)), 2 * pc.real(s.x))
format_evaluator.add_rule((s.x - pc.conjugate(s.x)), 2j * pc.imag(s.x))
format_evaluator.add_rule(s.x / s.x, 1)
format_evaluator.add_rule(1 * s.x, s.x)
format_evaluator.add_rule(s.x / 1, s.x)
format_evaluator.add_rule(-1 * s.x, -s.x)
format_evaluator.add_rule(-1 * -1, 1)
format_evaluator.add_rule(pc.I * pc.I, -1)
evaluator.add_rule(pc.derivative(s.x**s.n,s.x),s.n*s.x**(s.n-1),condition=(pc.equal(pc.Type(s.n))));
evaluator.add_rule(pc.derivative(s.a**s.b,s.x),pc.derivative(s.b*pc.log(s.a),s.x)*s.a**s.b);
evaluator.add_rule(pc.derivative(pc.OuterPiecewise(s.a),s.x),pc.OuterPiecewise(pc.derivative(s.a,s.x)))
evaluator.add_rule(pc.derivative(pc.InnerPiecewise((s.a,s.b),s.c),s.x),pc.InnerPiecewise((pc.derivative(s.a,s.x),s.b),pc.derivative(pc.InnerPiecewise(s.c),s.x)),condition=pc.Not(contains_atomic(s.b,s.x)))
evaluator.add_rule(pc.derivative(pc.InnerPiecewise((s.a,s.b)),s.x),(pc.derivative(s.a,s.x),s.b),condition=pc.Not(contains_atomic(s.b,s.x)))
evaluator.add_rule(pc.OuterPiecewise(s.a)**s.x,pc.OuterPiecewise(s.a**s.x))
evaluator.add_rule(pc.InnerPiecewise((s.a,s.b),s.c)**s.x,pc.InnerPiecewise((s.a**s.x,s.b),pc.InnerPiecewise(s.c)**s.x))
evaluator.add_rule(pc.InnerPiecewise((s.a,s.b))**s.x,(s.a**s.x,s.b))
evaluator.add_rule(pc.real(s.x),(s.x + pc.conjugate(s.x))/2)
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.InnerPiecewise((pc.derivative(s.a, s.x), s.b),
pc.derivative(pc.InnerPiecewise(s.c),
s.x)),
condition=pc.Not(contains_atomic(s.b, s.x)))
evaluator.add_rule(pc.derivative(pc.InnerPiecewise((s.a, s.b)), s.x),
(pc.derivative(s.a, s.x), s.b),
condition=pc.Not(contains_atomic(s.b, s.x)))
evaluator.add_rule(pc.OuterPiecewise(s.a)**s.x, pc.OuterPiecewise(s.a**s.x))
evaluator.add_rule(
pc.InnerPiecewise((s.a, s.b), s.c)**s.x,
pc.InnerPiecewise((s.a**s.x, s.b),
pc.InnerPiecewise(s.c)**s.x))
evaluator.add_rule(pc.InnerPiecewise((s.a, s.b))**s.x, (s.a**s.x, s.b))
evaluator.add_rule(pc.real(s.x), (s.x + pc.conjugate(s.x)) / 2)
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)