예제 #1
0
    if len(candidates) != len(f.args):
        exponents += [pc.multiplication(*[arg for arg in f.args if arg not in candidates])**e]

    m[s.z] = pc.multiplication(*exponents)

canonical_form.add_rule(pc.multiplication(s.x),s.x)
canonical_form.add_rule(pc.addition(s.x),s.x)
canonical_form.add_rule(pc.exponentiation(s.x),s.x)

canonical_form.add_rule(1/s.x, s.x**-1)
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(s.x**s.y, s.z, normalize_exponentiation,condition=pc.equal(pc.DominantType(pc.Type(s.y),pc.Types.Real),pc.Types.Real))

canonical_form.add_rule(pc.exp(s.x),pc.e**s.x)
canonical_form.add_rule(pc.sqrt(s.x),s.x**(1/pc.S(2)))


canonical_form.add_rule(s.x>s.y,s.y<s.x)
canonical_form.add_rule(s.x>=s.y,s.y<=s.x)
canonical_form.add_rule(s.x<=s.y,pc.Or(s.x<s.y,pc.equal(s.x,s.y)))
canonical_form.add_rule(pc.unequal(s.x,s.y),pc.Not(pc.equal(s.x,s.y)));


canonical_form.add_rule(abs(s.x),pc.Max(s.x,-s.x),condition=pc.equal(pc.DominantType(pc.Type(s.x),pc.Types.Real),pc.Types.Real))

canonical_form.add_rule(pc.Max(s.a,s.b),-pc.Min(-s.a,-s.b))

canonical_form.add_rule(pc.tan(s.x),pc.sin(s.x)/pc.cos(s.x))
canonical_form.add_rule(pc.cot(s.x),pc.cos(s.x)/pc.sin(s.x))
예제 #2
0
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

def mpmath_type_evaluator(m):
    v = m[s.x].value
    if isinstance(v,mp.mpf):
예제 #3
0
evaluator.add_rule(pc.derivative(s.x,s.x),1)
evaluator.add_rule(pc.derivative(s.y,s.x),0,check_if_excluded_derivative,condition=pc.Not(contains_atomic(s.y,s.x)));

evaluator.add_rule(pc.derivative(s.a+s.b,s.x),pc.derivative(s.a,s.x)+pc.derivative(s.b,s.x))
evaluator.add_rule(pc.derivative(s.a*s.b,s.x),pc.derivative(s.a,s.x)*s.b+pc.derivative(s.b,s.x)*s.a)
evaluator.add_rule(pc.derivative(-s.x,s.x),-1)
evaluator.add_rule(pc.derivative(1/s.x,s.x),-s.x**-2)
evaluator.add_rule(pc.derivative(pc.log(s.x),s.x),1/s.x)


evaluator.add_rule(pc.derivative(pc.sin(s.x),s.x),pc.cos(s.x))
evaluator.add_rule(pc.derivative(pc.cos(s.x),s.x),-pc.sin(s.x))

# TODO: Add assumptions to expressions: the following is only valid if x != -1,1 or x != -i,i
evaluator.add_rule(pc.derivative(pc.asin(s.x),s.x),1/pc.sqrt(1-s.x**2))
evaluator.add_rule(pc.derivative(pc.acos(s.x),s.x),-1/pc.sqrt(1-s.x**2))
evaluator.add_rule(pc.derivative(pc.atan(s.x),s.x),1/(1+s.x**2))
evaluator.add_rule(pc.derivative(pc.acot(s.x),s.x),-1/(1+s.x**2))



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))
예제 #4
0
canonical_form.add_rule(pc.multiplication(s.x), s.x)
canonical_form.add_rule(pc.addition(s.x), s.x)
canonical_form.add_rule(pc.exponentiation(s.x), s.x)

canonical_form.add_rule(1 / s.x, s.x**-1)
canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(s.x**s.y,
                        s.z,
                        normalize_exponentiation,
                        condition=pc.equal(
                            pc.DominantType(pc.Type(s.y), pc.Types.Real),
                            pc.Types.Real))

canonical_form.add_rule(pc.exp(s.x), pc.e**s.x)
canonical_form.add_rule(pc.sqrt(s.x), s.x**(1 / pc.S(2)))

canonical_form.add_rule(s.x > s.y, s.y < s.x)
canonical_form.add_rule(s.x >= s.y, s.y <= s.x)
canonical_form.add_rule(s.x <= s.y, pc.Or(s.x < s.y, pc.equal(s.x, s.y)))
canonical_form.add_rule(pc.unequal(s.x, s.y), pc.Not(pc.equal(s.x, s.y)))

canonical_form.add_rule(abs(s.x),
                        pc.Max(s.x, -s.x),
                        condition=pc.equal(
                            pc.DominantType(pc.Type(s.x), pc.Types.Real),
                            pc.Types.Real))

canonical_form.add_rule(pc.Max(s.a, s.b), -pc.Min(-s.a, -s.b))

canonical_form.add_rule(pc.tan(s.x), pc.sin(s.x) / pc.cos(s.x))
예제 #5
0
                   condition=pc.Not(contains_atomic(s.y, s.x)))

evaluator.add_rule(pc.derivative(s.a + s.b, s.x),
                   pc.derivative(s.a, s.x) + pc.derivative(s.b, s.x))
evaluator.add_rule(
    pc.derivative(s.a * s.b, s.x),
    pc.derivative(s.a, s.x) * s.b + pc.derivative(s.b, s.x) * s.a)
evaluator.add_rule(pc.derivative(-s.x, s.x), -1)
evaluator.add_rule(pc.derivative(1 / s.x, s.x), -s.x**-2)
evaluator.add_rule(pc.derivative(pc.log(s.x), s.x), 1 / s.x)

evaluator.add_rule(pc.derivative(pc.sin(s.x), s.x), pc.cos(s.x))
evaluator.add_rule(pc.derivative(pc.cos(s.x), s.x), -pc.sin(s.x))

# TODO: Add assumptions to expressions: the following is only valid if x != -1,1 or x != -i,i
evaluator.add_rule(pc.derivative(pc.asin(s.x), s.x), 1 / pc.sqrt(1 - s.x**2))
evaluator.add_rule(pc.derivative(pc.acos(s.x), s.x), -1 / pc.sqrt(1 - s.x**2))
evaluator.add_rule(pc.derivative(pc.atan(s.x), s.x), 1 / (1 + s.x**2))
evaluator.add_rule(pc.derivative(pc.acot(s.x), s.x), -1 / (1 + s.x**2))

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),
예제 #6
0
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)),
                       pc.DominantType(pc.Type(s.x), pc.Types.Rational))


def issubtype(x, t):