Question

我正在尝试创建一个函数来计算包含复数的4次多项式的4个根。在我寻找公式的过程中，我遇到了this discussion中包含的一个相当简单的公式，由Tito Piezas III描述在页面底部。

现在，我相信真正的错误并不是我的代码真正的错误（因为我肯定会对校对很烦）但是我对所涉及的方法的理解。我的问题是，二次根是复杂的，我不知道如何在以编程方式计算四次根时使用复数。

他建议使用两个二次方程的根来推导四次根。我尝试使用下面的代码尽可能地模仿公式。我的想法是，我计算了两个二次根（在前提下它们只是正面 - 我不知道怎么会这样），然后，使用这些结果，我可以计算出qurtic根，然后我保存真实和复杂值分别为x1,x2,x3,x4到r1,r2,r3,r4,c1,c2,c3,c4。但是，在计算二次根时，u，后来用来计算四次根的值是很复杂的！

这是他的公式和步骤image。 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

尝试使用Efficient Java Matrix Library。您可以在此处下载这些罐子：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

这是期望的结果。

无法弄清楚如何计算四次多项式

1 个答案: