Question

我正在尝试简化n的幂的巨大表达，而sympy的结果之一抛出（n + 1）^ 1.0，我注意到

f=n*((n+1)**1.0) sympy.expand(f)

不起作用，它保持不变，而不是给出n ^ 2 + n，所以我想知道是否有任何方法可以执行这样的操作

Answer 1

当幂是整数时，Sympy将按预期扩展表达式。如果力量存储为有理数或浮点数，则将无法使用。您的选择是使用整数重写表达式，或者编写一些代码来自动检查浮点数是否存储了整数（不超过数值精度错误）并采取相应措施。

这是一个起点：

def rewrite_polynomial(p):

    args_list = []

    if not p.is_Mul:
        return None
    for m in p.args:
        if not m.is_Pow:
            args_list.append(m)
        else:
            pow_val = m.args[1]
            if pow_val.is_Float:
                pow_val_int = int(pow_val)
                if pow_val.epsilon_eq(pow_val_int):
                    args_list.append(Pow(m.args[0],Integer(pow_val_int)))
                else:
                    args_list.append(m)
            else:
                args_list.append(m)                


    return Mul(*args_list)

n = Symbol('n')
f= n*((n+1)**1.0)
g = rewrite_polynomial(f)
print(g)

Answer 2

基于Yakovs的答案，我制定了一条重写规则，该规则使DFS遍历表达式树，并将幂替换为浮点型整数。

该代码可能效率不高，但适用于我的用例。

由于我不是专家，所以我认为在某些极端情况下，此代码会中断。

无论如何，你去！

pt_depth = model.layers[0].compute_output_shape(input_shape)

有输出

import sympy as s


def recurse_replace(expr,pred,func):
    if len(expr.args) == 0:
        return expr
    else: 
        new_args = tuple(recurse_replace(a,pred,func) for a in expr.args)
        if pred(expr):
            return func(expr,new_args)
        else: 
            return type(expr)(*new_args)

def rewrite(expr,new_args):
    new_args = list(new_args)
    pow_val = new_args[1]
    pow_val_int = int(new_args[1])
    if pow_val.epsilon_eq(pow_val_int):
        new_args[1] = s.Integer(pow_val_int)
    new_node = type(expr)(*new_args)
    return new_node

def isfloatpow(expr):
    out = expr.is_Pow and expr.args[1].is_Float
    return out

def clean_exponents(expr):
    return recurse_replace(expr,isfloatpow,rewrite)

x=s.symbols('x')
expr = (1+x) ** 1.0
s.pprint(expr)
expr2 = recurse_replace(expr,isfloatpow,rewrite)
s.pprint(expr2)

Sympy不会用小数来简化或扩展指数

2 个答案: