Question

请指点一个算法，该算法采用（二进制）解析树来评估单个变量中的多项式表达式，并返回一个等效的解析树，根据Horner的规则计算多项式。

预期用例位于表达式模板中。这个想法是对于矩阵x从

获得的解析树

a + bx + c * x*x + d * x*x*x...

将优化到

的相应解析树中

a + x *( b + x( c + x*d))

Answer 1

您可以使用以下转换。

假设：多项式的解析树按指数递增的顺序排列 - 如果此假设不成立，则可以在解析树中交换部分多项式以使假设成立

假设：解析树保存变量的指数形式（例如x^2）而不是乘法形式（例如x*x），但x^0除外 - - 简单的转换可以在两个方向之间进行转换

假设：多项式中的系数（如果常数）不为零 - 这是为了避免必须处理（a+0*x+c*x^2 - > a+x(cx)而不是a+cx^2）

a+b*x^1+c*x^2+d*x^3的解析树：

  .+..
 /    \
a   ...+....
   /        \
  *         .+..
 / \       /    \
b  ^      *      *
  / \    / \    / \
 x   1  c   ^  d   ^
           / \    / \
          x   2  x   3

转换为a+x(b+c*x^1+d*x^2)

  +
 / \
a   *
   / \
  x   +
     / \
    b   .+..
       /    \
      *      *
     / \    / \
    c   ^  d   ^
       / \    / \
      x   1  x   2

转换为a+x(b+x(c+d*x^1))

最后（a+x(b+x(c+d*x))）：

常见的转变是：

 .            ->    .
  .           ->     .
   .          ->      .
    +         ->      .*..
   / \        ->     /    \
  *   N(k+1)  ->    ^      +
 / \          ->   / \    / \
ck  ^         ->  x   k  ck  N'(k+1)
   / \        -> 
  x   k       ->

其中N'(k+1)与N(k+1)的子树相同，每个指数j都替换为j-k（如果k为1，则替换x^k子树x）

然后在N'(k+1)上再次应用算法（*），直到其根为*（而不是+），表示已达到最终的部分多项式。如果最终指数为1，则将指数部分替换为x（x^1 - ＆gt; x）

（*）这里是递归部分

注意：如果您累计跟踪N(k+1)子树中的指数变化，您可以将最后两个步骤放在一起，一次递归地转换N(k+1) < / p>

注意：如果你想允许负指数，那么

a）提取最高负指数作为第一项：

a*x^-2 + b*x^-1 + c + d*x + e*x^2  ->  x^-2(a+b*x+c*x^2+d*x^3+d*x^4)

并应用上述转换

或b）将方程的正负指数部分分开并分别对上面的转换进行分别（你需要“翻转”负指数侧的操作数并用乘法代替乘法）：

a*x^-2 + b*x^-1 + c + d*x + e*x^2  ->  [a+x^-2 + b*x-1] + [c + d*x + e*x^2] ->
-> [(a/x + b)/x] + [c+x(d+ex)]

这种方法似乎比a）更复杂。

Answer 2

您只需要应用以下规则，直到无法再应用它们为止。

((x*A)*B)     -> (x*(A*B))
((x*A)+(x*B)) -> (x*(A+B)))
(A+(n+B))     -> (n+(A+B))  if n is a number

其中A和B是子树。

这是一个OCaml代码：

type poly = X | Num of int | Add of poly * poly | Mul of poly * poly

let rec horner = function
  | X -> X
  | Num n -> Num n
  | Add (X, X) -> Mul (X, Num 2)
  | Mul (X, p)
  | Mul (p, X) -> Mul (X, horner p)
  | Mul (p1, Mul (X, p2))
  | Mul (Mul (X, p1), p2) -> Mul (X, horner (Mul (p1, p2)))
  | Mul (p1, p2) -> Mul (horner p1, horner p2) (* This case should never be used *)
  | Add (Mul (X, p1), Mul (X, p2)) -> Mul (X, horner (Add (p1, p2)))
  | Add (X, Mul (X, p))
  | Add (Mul (X, p), X) -> Mul (X, Add (Num 1, horner p))
  | Add (Num n, p)
  | Add (p, Num n) -> Add (Num n, horner p)
  | Add (p1, Add (Num n, p2))
  | Add (Add (Num n, p1), p2) -> Add (Num n, horner (Add (p1, p2)))
  | Add (p1, p2) -> horner (Add (horner p1, horner p2))

Answer 3

您可以通过递归函数获取树的monomial coefficients。根据霍纳定律转换这些系数并获得表达式将是simple。

我可以给你一个简单的递归函数来计算这些值，即使存在一个更有效的可能。

理论内容

首先，让我们制定表达方式。表达式E：

E = a0 + a1x + a2x^2 + ... + anx^n

可以写成（n + 1） - 元组：

(a0, a1, a2, ..., an)

然后，我们定义了两个操作：

添加：给定两个表达式E1 = (a0, ..., an)和E2 = (b0, ..., bm)，E1 + E2的对应元组为：

          {(a0+b0, a1+b1, ..., am+bm, a(m+1), ..., an) (n > m)
E1 + E2 = {(a0+b0, a1+b1, ..., an+bn, b(n+1), ..., bm) (n < m)
          {(a0+b0, a1+b1, ..., an+bn)                  (n = m)

即有max(n,m)+1个元素，i ^th元素由（使用C-ish语法）计算：

i<=n?ai:0 + i<=m?bi:0

乘法：给定两个表达式E1 = (a0, ..., an)和E2 = (b0, ..., bm)，E1 * E2的对应元组为：
```
E1 * E2 = (a0*b0, a0*b1+a1*b0, a0*b2+a1*b1+a2*b0, ... , an*bm)
```
即有n+m+1个元素，i ^th元素由
计算
```
sigma over {ar*bs | 0<=r<=n, 0<=s<=m, r+s=i}
```

因此，递归函数定义如下：

tuple get_monomial_coef(node)
    if node == constant
        return (node.value)  // Note that this is a tuple
    if node == variable
        return (0, 1)        // the expression is E = x
    left_expr = get_monomial_coef(node.left)
    right_expr = get_monomial_coef(node.right)
    if node == +
        return add(left_expr, right_expr)
    if node == *
        return mul(left_expr, right_expr)

，其中

tuple add(tuple one, tuple other)
    n = one.size
    m = other.size
    for i = 0 to max(n, m)
        result[i] = i<=n?one[i]:0 + i<=m?other[i]:0
    return result

tuple mul(tuple one, tuple other)
    n = one.size
    m = other.size
    for i = 0 to n+m
        result[i] = 0
        for j=max(0,i-m) to min(i,n)
            result[i] += one[j]*other[i-j]
    return result

注意：在mul的实施中，j应该从0迭代到i，同时还必须符合以下条件：

j <= n (because of one[j])
i-j <= m (because of other[i-j]) ==> j >= i-m

因此，j可以来自max(0,i-m)和min(i,n)（自n起等于n <= i）

C ++实现

既然您拥有伪代码，那么实现应该不会很难。对于元组类型，简单的std::vector就足够了。因此：

vector<double> add(const vector<double> &one, const vector<double> &other)
{
    size_t n = one.size() - 1;
    size_t m = other.size() - 1;
    vector<double> result((n>m?n:m) + 1);
    for (size_t i = 0, size = result.size(); i < size; ++i)
        result[i] = (i<=n?one[i]:0) + (i<=m?other[i]:0);
    return result;
}

vector<double> mul(const vector<double> &one, const vector<double> &other)
{
    size_t n = one.size() - 1;
    size_t m = other.size() - 1;
    vector<double> result(n + m + 1);
    for (size_t i = 0, size = n + m + 1; i < size; ++i)
    {
        result[i] = 0.0;
        for (size_t j = i>m?i-m:0; j <= n; ++j)
            result[i] += one[j]*other[i-j];
    }
    return result;
}

vector<double> get_monomial_coef(const Node &node)
{
    vector<double> result;
    if (node.type == CONSTANT)
    {
        result.push_back(node.value);
        return result;
    }
    if (node.type == VARIABLE)
    {
        result.push_back(0.0);
        result.push_back(1);  // be careful about floating point errors
                              // you might want to choose a better type than
                              // double for example a class that distinguishes
                              // between constants and variable coefficients
                              // and implement + and * for it
        return result;
    }
    vector<double> left_expr = get_monomial_coef(node.left);
    vector<double> right_expr = get_monomial_coef(node.right);
    if (node.type == PLUS)
        return add(left_expr, right_expr);
    if (node.type == MULTIPLY)
        return mul(left_expr, right_expr);
    // unknown node.type
}

vector<double> get_monomial_coef(const Tree &tree)
{
    return get_monomial_coef(tree.root);
}

注意：此代码未经测试。它可能包含错误或错误检查不足。确保你理解并自己实现，而不是复制粘贴。

从这里开始，您只需要根据此函数为您提供的值构建表达式树。

根据Horner的方案将多项式的解析树转换为其评估的解析树

3 个答案:

理论内容

C ++实现