Python mod示例

示例#1

文件： type_evaluator.py 项目： TheLartians/Expresso

evaluator.add_rule(pc.OperationType(s.x*s.y),pc.DominantType(s.x,s.y),condition=pc.Not(pc.Or(is_function_type(s.x,pc.Type),is_function_type(s.y,pc.Type))))
evaluator.add_rule(pc.OperationType(s.x)**s.y,pc.DominantType(s.x,s.y),condition=pc.Not(pc.Or(is_function_type(s.x,pc.Type),is_function_type(s.y,pc.Type))))


evaluator.add_rule(pc.Type(s.x+s.y),pc.DominantType(pc.Type(s.x),pc.Type(s.y)))
evaluator.add_rule(pc.Type(-s.x),pc.DominantType(pc.Types.Integer,pc.Type(s.x)))
evaluator.add_rule(pc.Type(pc.pi),pc.Types.Real)
evaluator.add_rule(pc.Type(pc.e),pc.Types.Real)
evaluator.add_rule(pc.Type(pc.I),pc.Types.Imaginary)

evaluator.add_rule(pc.Type(pc.factorial(s.x)),pc.Types.Natural)
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)

示例#2

文件： numeric_evaluator.py 项目： Python3pkg/Expresso

def is_even(x):
    return pc.equal(pc.mod(x, 2), 0)

示例#3

文件： numeric_evaluator.py 项目： Python3pkg/Expresso

    import math as m
    return m.log10(a) * b


evaluator.add_rule(
    s.x**s.y,
    s.z,
    binary_rule(lambda x, y: x**y if exp_length(x, y) < 100 else None),
    condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(
    s.x**-s.y,
    s.z**-1,
    binary_rule(lambda x, y: x**y if exp_length(x, y) < 100 else None),
    condition=are_explicit_numbers(s.x, s.y))

evaluator.add_rule(pc.mod(s.x, s.y),
                   s.z,
                   binary_rule(lambda x, y: x % y),
                   condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.mod(s.x, -s.y),
                   s.z,
                   binary_rule(lambda x, y: x % (-y)),
                   condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.mod(-s.x, s.y),
                   s.z,
                   binary_rule(lambda x, y: (-x) % (-y)),
                   condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.equal(s.x, s.y),
                   s.z,
                   binary_rule(lambda x, y: x == y),
                   condition=are_explicit_numbers(s.x, s.y))

示例#4

文件： type_evaluator.py 项目： Python3pkg/Expresso

                             is_function_type(s.y, pc.Type))))

evaluator.add_rule(pc.Type(s.x + s.y),
                   pc.DominantType(pc.Type(s.x), pc.Type(s.y)))
evaluator.add_rule(pc.Type(-s.x),
                   pc.DominantType(pc.Types.Integer, pc.Type(s.x)))
evaluator.add_rule(pc.Type(pc.pi), pc.Types.Real)
evaluator.add_rule(pc.Type(pc.e), pc.Types.Real)
evaluator.add_rule(pc.Type(pc.I), pc.Types.Imaginary)

evaluator.add_rule(pc.Type(pc.factorial(s.x)), pc.Types.Natural)
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)

示例#5

文件： numeric_evaluator.py 项目： TheLartians/Expresso

def is_even(x):
    return pc.equal(pc.mod(x,2),0)

示例#6

文件： numeric_evaluator.py 项目： TheLartians/Expresso

    return pc.And(*[is_explicit_natural(arg) for arg in args])

evaluator.add_rule(s.x + s.y, s.z, binary_rule(lambda x, y: x + y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(-s.x-s.y, -s.z, binary_rule(lambda x, y: x + y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(s.x - s.y, s.z, binary_rule(lambda x, y: x - y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(s.x * s.y, s.z, binary_rule(lambda x, y: x * y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(s.x ** s.a * s.y ** s.a, s.z ** s.a, binary_rule(lambda x, y: x * y), condition=are_explicit_numbers(s.x, s.y))

def exp_length(a,b):
    import math as m
    return m.log10(a)*b

evaluator.add_rule(s.x ** s.y, s.z, binary_rule(lambda x, y: x ** y if exp_length(x,y)<100 else None), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(s.x ** -s.y, s.z ** -1, binary_rule(lambda x, y: x ** y if exp_length(x,y)<100 else None), condition=are_explicit_numbers(s.x, s.y))

evaluator.add_rule(pc.mod(s.x,s.y), s.z, binary_rule(lambda x, y: x % y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.mod(s.x,-s.y), s.z, binary_rule(lambda x, y: x % (-y)), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.mod(-s.x,s.y), s.z, binary_rule(lambda x, y: (-x) % (-y)), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.equal(s.x,s.y), s.z, binary_rule(lambda x, y: x == y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(pc.equal(s.x,-s.y), False, condition=are_explicit_numbers(s.x, s.y))

evaluator.add_rule(s.x < s.y, s.z, binary_rule(lambda x, y: x < y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(s.x < -s.y, s.z, binary_rule(lambda x, y: x < -y), condition=are_explicit_numbers(s.x, s.y))
evaluator.add_rule(-s.x < s.y, s.z, binary_rule(lambda x, y: -x < y), condition=are_explicit_numbers(s.x, s.y))


#evaluator.add_rule(s.a**s.x*s.b**-s.x, (s.a*s.b**-1)**(s.x),condition=are_explicit_numbers(s.a, s.b))

def is_even(x):
    return pc.equal(pc.mod(x,2),0)