不知道如何计算四次多项式

Question

我试图创建一个函数来计算包含复数的4次多项式的4个根。在我寻找公式的过程中，我发现了这一讨论中包含的一个相当简单的公式，由Tito向页面底部描述。

现在，我相信真正的错误并不是代码中的真正错误(因为我肯定会让人讨厌校对)，而是我对所涉及的方法的理解。我的问题是，二次根是复的，我不知道在计算四次根时如何使用复数。

他建议用两个二次方程的根导出四次根。我试着用下面的代码尽可能地模仿这个公式。我的想法是，我计算两个二次根(前提是它们只是正数-我不知道其他情况如何)，然后，利用这些结果，我可以计算出qurtic根，然后将实际值和复数值分别保存到x1,x2,x3,x4中，放入r1,r2,r3,r4,c1,c2,c3,c4中。但是，在计算二次根时，u，一个后来用来计算四次根的值:是复杂的！

这是他的公式和步骤的图像。Blow是我的代码，在大多数步骤上都有标题。

double a, b, c, d;
double c1, c2, c3, c4;      //complex values
double r1, r2, r3, r4;      //real values

//      x^4+ax^3+bx^2+cx+d=0
a = 3;     
b = 4; 
c = 5;     //<--- example coefficients
d = 6;
if (a != 0) {

    double u,v1,v2;       
    double x,y,z;        //essentially a,b,c that he uses

    x=1;
    y= -2*b*b*b+9*a*b*c-27*c*c-27*a*a*d+72*b*d;
    z= Math.pow((b*b-3*a*c+12*d),3);

      //calculation of the v roots
    v1 = -y+(Math.sqrt(y*y-4*x*z))/(2*x);  // < negative root
    v2 = -y-(Math.sqrt(y*y-4*x*z))/(2*x);  // < negative root

//---calculations after this are invalid since v1 and v2 are NaN---       

    u = (a*a)/4 + ((-2*b+Math.pow(v1,1/3)+Math.pow(v2,1/3))/3);

    double x12sub,x34sub;

    x12sub= 3*a*a-8*b-4*u+((-a*a*a+4*a*b-8*c)/(Math.sqrt(u)));
    x34sub= 3*a*a-8*b-4*u-((-a*a*a+4*a*b-8*c)/(Math.sqrt(u)));

    r1 = -(1/4)*a +(1/2)*(Math.sqrt(u));
    r2 = -(1/4)*a +(1/2)*(Math.sqrt(u));
    r3 = -(1/4)*a -(1/2)*(Math.sqrt(u));
    r4 = -(1/4)*a -(1/2)*(Math.sqrt(u));

//--casting results into their orderly variables--

    if(x12sub<0){
        x12sub= x12sub*-1;
        x12sub = Math.sqrt(x12sub);
        x12sub = x12sub*(1/4);
        c1=x12sub;
        c2=x12sub;
    }
    else{
        r1=r1+x12sub;
        r2=r2-x12sub;
    }
    if(x34sub<0){
        x34sub= x34sub*-1;
        x34sub = Math.sqrt(x34sub);
        x34sub = x34sub*(1/4);
        c3=x34sub;
        c4=x34sub;  
    }
    else{
        r3=r3+x34sub;
        r4=r4+x34sub;
    }
}

我愿意接受任何解决方案。即使是那些涉及到图书馆的使用也能帮助我。谢谢你的帮助。

Answer 1

尝试使用高效的Java矩阵库。您可以在这里下载这些罐子：https://sourceforge.net/projects/ejml/files/v0.28/

您需要在您的类中使用此方法：

public static Complex64F[] findRoots(double... coefficients) {
    int N = coefficients.length-1;

    // Construct the companion matrix
    DenseMatrix64F c = new DenseMatrix64F(N,N);

    double a = coefficients[N];
    for( int i = 0; i < N; i++ ) {
        c.set(i,N-1,-coefficients[i]/a);
    }
    for( int i = 1; i < N; i++ ) {
        c.set(i,i-1,1);
    }

    // use generalized eigenvalue decomposition to find the roots
    EigenDecomposition<DenseMatrix64F> evd =  DecompositionFactory.eig(N,false);

    evd.decompose(c);

    Complex64F[] roots = new Complex64F[N];

    for( int i = 0; i < N; i++ ) {
        roots[i] = evd.getEigenvalue(i);
    }

    return roots;
}

然后您可以使用它查找，例如，x^2 + 4x +4的根：

Complex64F[] c = findRoots(4, 4, 1);
    for(Complex64F f : c)
        System.out.println(f.toString());

这将打印出来：

-2
-2

这就是我们想要的结果。

Answer 2

您可以通过变量的线性变化将多项式az^4+bz^3+cz^2+dz+e耗尽为t^4+pt^2+qt+r形式。然后考虑为(t^2 + ux + v)(t^2 - ux + w).这导致了p=v+w- u^2，q=u (w - v)，r= vw。由此，2w =p+ u^2 +q/ u，2v =p+u^2-q/u，最后(p + u^2 +q/ u)(p +u^2-q/ u) = 4r。重新排列后，这是u^2中的一个立方方程。

要求解立方az^3+bz^2+cz+d，您可以再次耗尽到t^3+pt+q，并编写t=u/ 3u。这给出u^3 +q- p^3 / 27u^3 = 0，这是u^3中的一个二次方程。

要求解二次多项式ax^2 + bx + c，可以用t^2 +p= 0来表示。根为明显的±√(-p)。

因此，求解u^3的二次型，并取其中一个根的三次根。从它中，你应用反耗竭变换，得到一个立方的解。现在你可以计算因子的系数，并分别求解这两个因素，得到四个根。最后，取消最初的损耗。

别紧张，不是吗？

若要消耗一个多项式，将所有系数除以前导系数，然后设置x=t+ s，然后在多项式中替换并展开，取消第二个项的系数。给出了s=-b/ ka，其中k是多项式的阶数。其他系数来自s。

对于实系数多项式，注意三次方程总是有一个实解，给出了两个二次多项式的因式分解。

无论如何，一个立方的实系数的分辨率可能涉及到不可避免的采用复数。

Answer 3

您可以使用渐近python模块，它可以解决您的问题。sympy.solve("any equation")或者，如你所知，多项式的根是为X或其他变量的值找到0。喜欢。X x=2 -16= 0有类似于2，-2的根，所以这里对于⁴，-2我得到了0。所以，如果我在某个范围内计算一些x值，我们就能找到根。让我们看看JavaScript中的代码，它有点慢，但是它给出了准确的结果。

equation="x**4-9"
//document.getElementById("equation").value.toLowerCase();

//xxx=document.getElementById("roots")

   for(var x=-20;x<=20;x+=0.00001){
    var x=parseFloat(x.toFixed(6))
    //var x=-0.83333
    //var gg="(x**3)+(2*x**2)-(9*x)-18"
    
    cg=eval(equation)
    //console.log(x)
    //console.log(cg)
    if(Math.abs(cg)<0.0002 || cg==0){
roots.add(parseFloat(x.toFixed(4)))
    }
         
     }
    if(roots.size>=1){
    
    //xxx.innerText=[...roots]+"\n";
console.log([..roots]);
}
    else{
        alert("this function not convarges")
    }