在 Sympy 中部分分解表达式

Suppose I have an expression of the form . I know that I can simplify the expression like so: . However, sympy.simplify and sympy.factor both return the original expression.

为了解决这个问题，我一直在低级别上操作表达式：

factor_map = defaultdict(set)
additive_terms = expr.as_coeff_add()[-1]
for term1, term2 in combinations(additive_terms, 2):
    common_terms = (
        set(term1.as_coeff_mul()[-1])
        & set(term2.as_coeff_mul()[-1])
    )
    if common_terms:
        common_factor = sympy.Mul(*common_terms)
        factor_map[common_factor] |= {term1, term2}

factor_map现在看起来像这样：

{
    a: {a⋅x, -a⋅y}, 
    b: {b⋅x, -b⋅y}, 
    c: {-c⋅x, c⋅y}, 
    x: {a⋅x, b⋅x, -c⋅x}, 
    y: {-a⋅y, -b⋅y, c⋅y}
}

我按照术语所代表的操作数量对其进行排序：

factor_list = sorted(
    factor_map.items(),
    key = lambda i: (i[0].count_ops() + 1) * len(i[1])
)[::-1]

然后我重建表达式：

used = set()
new_expr = 0
for item in factor_list:
    factor = item[0]
    appearances = item[-1]
    terms = 0
    for instance in appearances:
        if instance not in used:
            terms += instance.as_coefficient(factor)
            used.add(instance)
    new_expr += factor * terms
for term in set(additive_terms) - used:
    new_expr += term

这给出了new_expr = d + x*(a + b - c) + y*(-a - b + c)。不是很好，但更好。

我还可以通过将加法项的每个组合彼此相除，检查结果是否为数字，并使用该信息进一步将输出减少到new_expr = d + (x - y)*(a + b - c).

我也尝试过申请sympy.factor到每一种可能的加法项组合，但显然对于任何相当大的表达式来说，它都会很快爆炸。

编辑：这是一个使用的实现sympy.factor在加性项集合的所有分区上（分区函数借用自这个答案):

def partition(collection):
    if len(collection) == 1:
        yield [ collection ]
        return

    first = collection[0]
    for smaller in partition(collection[1:]):
        # insert `first` in each of the subpartition's subsets
        for n, subset in enumerate(smaller):
            yield smaller[:n] + [[ first ] + subset]  + smaller[n+1:]
        # put `first` in its own subset 
        yield [ [ first ] ] + smaller


def partial_factor(expr):
    args = list(expr.as_coeff_add()[-1])
    # Groupings is just a cache to avoid duplicating factor operations
    groupings = {}

    unique = set()

    for p in partition(args):
        new_expr = 0
        for group in p:
            add_group = sympy.Add(*group)
            new_expr += groupings.setdefault(add_group, sympy.factor(add_group))
        unique.add(new_expr)
    return sorted(unique, key=sympy.count_ops)[0]

对于像这样的表达式a*x + b*y + c*z + d + e*x + f*y + h*z，在我的计算机上运行需要 7.8 秒，而另一种方法需要 378 微秒并给出相同的结果。看来应该有一种方法比第一种方法更严格，而且不用花两万倍的时间来解决。

我觉得得到我想要的东西不应该那么难。有没有更简单的方法来做到这一点？

这个类似的问题有一个答案涉及func参数为collect()。尽管您必须明确提及，但它似乎也适用于这种特殊情况d:

from sympy import *
a, b, c, d, x, y = symbols('a, b, c, d, x, y')
expr = a * x + b * x - c * x - a * y - b * y + c * y + d
collect(expr, d, func=factor)
=> d + (x - y)*(a + b - c)

这在这种特定情况下有所帮助，但是不存在更通用和自动的解决方案。

我也找不到这方面的任何文档func任何地方的参数，除了现有的参数。

Github问题跟踪这个问题