import expresso.pycas as pc
from . import rule_symbols as s
evaluator = pc.RewriteEvaluator(recursive=True, split_binary=True)
evaluator.add_rule(s.a * (s.b + s.c), s.a * s.b + s.a * s.c)
evaluator.add_rule(s.a**-1 * (s.b + s.c)**-1, (s.a * s.b + s.a * s.c)**-1)
from .logic_evaluator import is_pure_numeric, is_atomic
is_positive_numeric_integer = pc.And(is_pure_numeric(s.n),
pc.is_in_type(s.n, pc.Types.Integer),
s.n > 1)
evaluator.add_rule((s.a + s.b)**s.n, (s.a + s.b) * (s.a + s.b)**(s.n - 1),
condition=is_positive_numeric_integer)
evaluator.add_rule((s.a + s.b)**-s.n,
(s.a + s.b)**(-s.n + 1) * (s.a + s.b)**-1,
condition=is_positive_numeric_integer)
evaluator.add_rule(s.x * s.x, s.x**2, condition=is_atomic(s.x))
evaluator.add_rule(s.x * s.x**s.n, s.x**(s.n + 1), condition=is_atomic(s.x))
evaluator.add_rule(s.x**s.m * s.x**s.n,
s.x**(s.n + s.m),
condition=is_atomic(s.x))
evaluator.add_rule((s.a * s.b)**s.c, s.a**s.c * s.b**s.c)
from .canonical_form import canonical_form
from .logic_evaluator import logic_evaluator
from .numeric_evaluator import numeric_evaluator
def is_uneven(x):
return pc.And(issubtype(x, pc.Types.Integer), pc.Not(is_even(x)))
def are_explicit_numbers(*args):
return pc.And(*[is_explicit_natural(arg) for arg in args])
evaluator.add_rule(pc.equal(s.x, s.y * s.z**-1),
pc.equal(s.z * s.x, s.y),
condition=are_explicit_numbers(s.y, s.z))
evaluator.add_rule(pc.equal(s.x, -(s.y * s.z**-1)),
pc.equal(s.z * s.x, -s.y),
condition=are_explicit_numbers(s.y, s.z))
evaluator.add_rule(pc.equal(s.x, -(s.y * s.z**-1)),
pc.equal(s.z * s.x, -s.y),
condition=are_explicit_numbers(s.y, s.z))
from .logic_evaluator import is_pure_numeric, is_numeric
evaluator.add_rule(s.a + s.b * s.c**-1, (s.a * s.c + s.b) * s.c**-1,
condition=pc.And(is_pure_numeric(s.a),
are_explicit_numbers(s.b, s.c)))
evaluator.add_rule(s.a - s.b * s.c**-1, (s.a * s.c - s.b) * s.c**-1,
condition=pc.And(is_pure_numeric(s.a),
are_explicit_numbers(s.b, s.c)))
evaluator.add_rule(s.a + s.c**-1, (s.a * s.c + 1) * s.c**-1,
condition=pc.And(is_pure_numeric(s.a),
is_explicit_natural(s.c)))
evaluator.add_rule(s.a - s.c**-1, (s.a * s.c - 1) * s.c**-1,
condition=pc.And(is_pure_numeric(s.a),
is_explicit_natural(s.c)))
evaluator.add_rule((s.a + s.b)**2, (s.a**2 + 2 * s.a * s.b + s.b**2),
condition=pc.And(is_numeric(s.a), is_numeric(s.b)))
evaluator.add_rule(s.a * (s.b + s.c),
s.a * s.b + s.a * s.c,
def is_numeric_evaluator(m):
m[s.y] = pc.And(*[is_numeric(arg) for arg in m[s.x].args])
False,
condition=is_atomic(s.x))
logic_evaluator.add_rule(contains_atomic(s.x, s.y),
s.z,
contains_evaluator,
condition=is_function(s.x))
logic_evaluator.add_rule(pc.Xor(False, False), False)
logic_evaluator.add_rule(pc.Xor(True, False), True)
logic_evaluator.add_rule(pc.Xor(False, True), True)
logic_evaluator.add_rule(pc.Xor(True, True), False)
logic_evaluator.add_rule(pc.Not(True), False)
logic_evaluator.add_rule(pc.Not(False), True)
logic_evaluator.add_rule(pc.And(s.x, True), s.x)
logic_evaluator.add_rule(pc.And(s.x, False), False)
logic_evaluator.add_rule(pc.Or(s.x, True), True)
logic_evaluator.add_rule(pc.Or(s.x, False), s.x)
logic_evaluator.add_rule(pc.Not(pc.Not(s.x)), s.x)
logic_evaluator.add_rule(pc.And(s.x, pc.Not(s.x)), False)
logic_evaluator.add_rule(pc.Or(s.x, pc.Not(s.x)), True)
logic_evaluator.add_rule(pc.And(s.x, s.x), s.x)
logic_evaluator.add_rule(pc.Or(s.x, s.x), s.x)
logic_evaluator.add_rule(pc.equal(s.x, s.x), True)
logic_evaluator.add_rule(-s.x < -s.y, s.y < s.x)
'''
factor_evaluator.add_rule(s.x * s.x, s.x**2)
evaluator.add_rule(s.x * s.x**-1, 1)
evaluator.add_rule(
(s.x**s.a)**s.b,
s.x**(s.a * s.b),
condition=pc.equal(pc.DominantType(pc.Type(s.b), pc.Types.Integer),
pc.Types.Integer))
from .numeric_evaluator import is_even, is_uneven
from .type_evaluator import issubtype
evaluator.add_rule((s.x**s.a)**(s.a**-1),
abs(s.x),
condition=pc.And(issubtype(s.x, pc.Types.Real),
is_even(s.a)))
evaluator.add_rule((s.x**s.a)**(s.a**-1),
s.x,
condition=pc.And(issubtype(s.x, pc.Types.Real),
is_uneven(s.a)))
evaluator.add_rule((-s.x)**(s.a), s.x**s.a, condition=is_even(s.a))
evaluator.add_rule((-s.x)**(s.a), -(s.x)**s.a, condition=is_uneven(s.a))
factor_evaluator.add_rule(s.x**s.n * s.y**-s.n, (s.x * s.y**-1)**s.n,
condition=pc.Or(s.y > 0,
issubtype(s.n, pc.Types.Integer)))
factor_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)))
evaluator.add_rule(s.x<s.z**-1,s.z*s.x<1 ,condition=is_explicit_natural(s.z)) evaluator.add_rule(s.z**-1<s.y,1<s.y*s.z ,condition=is_explicit_natural(s.z)) evaluator.add_rule(s.x<-(s.z**-1),s.z*s.x<-1 ,condition=is_explicit_natural(s.z)) evaluator.add_rule(-(s.z**-1)<s.y,-1<s.y*s.z ,condition=is_explicit_natural(s.z)) evaluator.add_rule(pc.equal(s.x,s.y*s.z**-1),pc.equal(s.z*s.x,s.y),condition=are_explicit_numbers(s.y,s.z)) evaluator.add_rule(pc.equal(s.x,-(s.y*s.z**-1)),pc.equal(s.z*s.x,-s.y),condition=are_explicit_numbers(s.y,s.z)) evaluator.add_rule(pc.equal(s.x,-(s.y*s.z**-1)),pc.equal(s.z*s.x,-s.y),condition=are_explicit_numbers(s.y,s.z)) from .logic_evaluator import is_pure_numeric,is_numeric evaluator.add_rule(s.a+s.b*s.c**-1,(s.a*s.c+s.b)*s.c**-1,condition=pc.And(is_pure_numeric(s.a),are_explicit_numbers(s.b,s.c))) evaluator.add_rule(s.a-s.b*s.c**-1,(s.a*s.c-s.b)*s.c**-1,condition=pc.And(is_pure_numeric(s.a),are_explicit_numbers(s.b,s.c))) evaluator.add_rule(s.a+s.c**-1,(s.a*s.c+1)*s.c**-1,condition=pc.And(is_pure_numeric(s.a),is_explicit_natural(s.c))) evaluator.add_rule(s.a-s.c**-1,(s.a*s.c-1)*s.c**-1,condition=pc.And(is_pure_numeric(s.a),is_explicit_natural(s.c))) evaluator.add_rule((s.a+s.b)**2,(s.a**2+2*s.a*s.b+s.b**2),condition=pc.And(is_numeric(s.a),is_numeric(s.b))) evaluator.add_rule(s.a*(s.b+s.c),s.a*s.b+s.a*s.c,condition=pc.And(is_pure_numeric(s.a),is_numeric(s.b),is_numeric(s.c))) evaluator.add_rule(pc.I**s.n,(-1)**(s.n/2),condition=is_even(s.n)) evaluator.add_rule(pc.I**s.n,pc.I*(-1)**(s.n/2-0.5),condition=is_uneven(s.n)) evaluator.add_rule(pc.sign(-s.x),-1,condition=is_explicit_natural(s.x)) evaluator.add_rule(pc.sign(s.x),1,condition=is_explicit_natural(s.x))