Python real Examples, expresso.pycas.real Python Examples

Example #1

0

Show file

File: canonical_form.py Project: TheLartians/Expresso

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)

Example #2

0

Show file

File: type_evaluator.py Project: TheLartians/Expresso

evaluator.add_rule(pc.Type(pc.sign(s.x)),pc.Types.Integer)
evaluator.add_rule(pc.Type(pc.floor(s.x)),pc.Types.Integer)
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))))

Example #3

0

Show file

File: main_evaluator.py Project: TheLartians/Expresso



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) ,

Example #4

0

Show file

File: canonical_form.py Project: Python3pkg/Expresso

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)

Example #5

0

Show file

                   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)

Example #6

0

Show file

File: type_evaluator.py Project: Python3pkg/Expresso

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.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)))