对于一个多项式方程：$a_0+a_1x+a_2x^2+...+a^nx^n=0$而言，想要准确求得解析解是一件比较困难的事，特别是次数比较高的时候，一般我们可以利用数值方法求得数值解。
先说明一下多项式方程的根的特点，对于n次多项式方程，实数根的可能情况包括（此处只说明实数根）：

1、有n个不同实根；

2、根的数量小于n，大于0，即有多个相同实根；

3、无实数根，即方程所表示的曲线与X轴无交点；
在OpenCV中提供了cv::sovlePoly函数可以用来求解多项式方程的数值解，非常方便。

官方文档中给出了定义：


输入为系数矩阵，从0次到n次排布，

输出为一个列数为2的矩阵，每一行是一个根，由实部和虚部组成，从这也能看出这个函数能够求出方程所有的根，包括虚根。

返回值为误差值。
直接上测试代码：
#include <iostream>
#include <opencv2/opencv.hpp>
#include <cmath>
using std::cout;
using std::endl;

int main() {
    std::vector<double> coefs = {1, 0, 0};
    std::vector<double> coefs1 = {1, 5, 4};
    std::vector<double> coefs2 = {0, 0, 4};
    std::vector<double> coefs3 = {0, 0, 0};
    std::vector<double> roots;
    cv::Mat rots;
    auto ret = cv::solvePoly(coefs3, rots);
    cout<<rots.type()<<" "<<CV_64FC1<<endl;
    cout<<ret<<endl;

    cout<<rots<<endl;

    return 0;
}

注意区分使用不同的系数时求得的根的结果的不同。
【参考】

1、OpenCV:solvePoly多项式方程求解函数

参考别人的博客,顺便借鉴过来作个笔记.

一.使用多项式的伴随矩阵进行求解

多项式:  

多项式的伴随矩阵:



的特征值就是的根.



其中是个方阵,是个列向量,是个常量,其中是矩阵的特征向量,是矩阵的特征值.

使用Eigen进行多项式的求解：

#include <iostream>
#include <Eigen/Core>
// 稠密矩阵的代数运算（逆，特征值等）
#include <Eigen/Dense>
using namespace std;

int main( int argc, char** argv )
{

    Eigen::Matrix<double, 4, 4> matrix_44;
    //复数动态矩阵
    //P(x) = x^4 + 2*x^3 +3*x^2 +4*x + 5;
	Eigen::Matrix<complex<double>, Eigen::Dynamic, Eigen::Dynamic> matrix_eigenvalues;
	//同样测试 12345
    matrix_44 <<                 0, 0, 0, -5,
				 1, 0, 0, -4,
				 0, 1, 0, -3,
				 0, 0, 1, -2;

	std::cout<<"matrix_44: "<<std::endl<<matrix_44<<std::endl<<std::endl;

	matrix_eigenvalues = matrix_44.eigenvalues();
	//std::cout<<"matrix_44.eigenvalues: "<<std::endl<<matrix_44.eigenvalues()<<std::endl;
	std::cout<<"matrix_eigenvalues: "<<std::endl<<matrix_eigenvalues<<std::endl;
	return 0;
}




或者使用Eigen多项式

#include<iostream>
#include <Eigen/Eigen>
#include <unsupported/Eigen/Polynomials>
using namespace std;

int main()
{
    Eigen::PolynomialSolver<double,Eigen::Dynamic> solver; //多项式求根
    Eigen::VectorXd coeff(5);
    coeff[0] = 5;
    coeff[1] = 4;
    coeff[2] = 3;
    coeff[3] = 2;
    coeff[4] = 1;
    solver.compute(coeff);  //compute()计算多项式复数根
    const Eigen::PolynomialSolver<double,Eigen::Dynamic>::RootsType& r = solver.roots();  //roots()返回多项式复数根
    std::vector<double> real_root;
    for (int i = 0; i< r.rows();++i)
    {
        if (r[i].imag() != 0.0)
        {
            continue;
        }
        real_root.push_back(r[i].real());
    }
   
for(int i=0;i<real_root.size();++i)
{
  cout<<"多项式方程的实根:"<<real_root[i]<<std::endl;
}
return 0;
  
}

参看链接:

https://blog.csdn.net/fb_941219/article/details/102984587

http://eigen.tuxfamily.org/dox-devel/unsupported/classEigen_1_1PolynomialSolverBase.html#a07bcd5339be5eacdf7e566d07d81bedb

          最近一直在编写C++的算法程序，因为以前使用过OpenCV，觉得OpenCV当中的矩阵运算做的很不错，所以就拿来用用。
        这两天遇到了一个难题，就是多项式方程的根的求解，因为自己比较懒，不想自己去写一个方程求解的程序，所以想在网上找找，没想到OpenCV2.2种就有（以前只用过OpenCV1.1）一个函数solvePoly就是求解多项式方程的。
        可是这一用问题就有来了，使用之后发现该函数的求解结构和用Matlab求解的结构相差很大，于是乎和往常一样上网查询，可是网上关于较高版本的OpenCV的说明基本上没有，对于OpenCV矩阵操作的一些介绍也都只是停留在简单的矩阵操作上，关于solvePoly函数的唯一的可用资料就是：


        万般无奈之下，一个偶然的机会看到了OpenCV2.4的操作说明（差别在于多项式的系数与矩阵排列的方式）：


        于是欣喜若狂，终于找到问题的所在了。我用一个数组[4.0，3.0，2.0，1.0]来进行验证，果然OpenCV和Matlab的计算结果是一样的。还没来得及高兴，问题就有来了：[40.0，30.0，20.0，10.0]求解得到的多项式的根居然跟上面的不一样！而Matlab计算结果却是正确的。刚刚燃起的一点希望就此破灭了，生活的痛苦就是当你看到希望到来时却得到了绝望。
求解多项式方程的根并不是什么复杂的计算啊，难道OpenCV会把这个求解的过程弄错？通过研究OpenCV函数solvePoly的源代码和反复的实验计算，我终于解决了这个问题——不是函数写的有问题，而是函数的使用说明有问题。要想得到正确的求解结果，可以对原始的系数矩阵（用于Matlab计算）做如下两步变换：
1.将矩阵向量的顺序进行倒转（参看OpenCV2.4的操作说明和Matlab函数roots的说明）；
2.经矩阵当中每一个值都除以矩阵的最后一个元素（也就是说矩阵的最后一个元素必须是1，不知道为什么OpenCV的函数说明里面没有说清楚）。

//用Graeffe法求解多项式方程单实根

#include <iostream>

#include <math.h>

#include <process.h>
using namespace std;
class graeffe

{

private:

 int flag, i, iteration, iteration_max, k, n;

 double eps, pp, pm, root, sum, upper_limit, lower_limit, val, *a, *b, *c;
public:

 graeffe()

 {

  iteration = 0;

  flag = 0;

  iteration_max = 100;

  upper_limit = 1e35;

  lower_limit = 1e-35;

 }

 void solution();

 ~graeffe()

 {

  delete[] a, b, c;

 }

};
void main()

{

 graeffe roots;

 roots.solution();

}
void graeffe::solution()

{

 cout << "\n输入多项式阶数：";

 cin >> n;

 a = new double[n+1];

 b = new double[n+1];

 c = new double[n+1];

 for (i = 0; i <= n; i++)

 {

  cout << "\n输入a[" << i << "] = ";

  cin >> a[i];

 }

 cout << "\n输入可以认为多项式值为0的量：";

 cin >> eps;

 for (i = 1; i <= n; i++)

 {

  a[i] /= a[0];

  c[i] = a[i];

 }

 a[0] = 1.0;

 b[0] = 1.0;

 c[0] = 1.0;

 do

 {

  iteration++;

  for (i = 1; i <= n; i++)

  {

   sum = 0.0;

   for (k = 1; k <= i; k++)

   {

    if ((i + k) <= n)

    {

     sum += pow((-1.0), k) * c[i+k] * c[i-k];

    }

   }

   b[i] = pow((-1.0), i) * (c[i] * c[i] + 2 * sum);

  }

  for (i = 0; i <= n; i++)

  {

   if (b[i] != 0)

   {

    if ((fabs(b[i]) > upper_limit) || (fabs(b[i]) < lower_limit))

    {

     flag = 1;

    }

   }

  }

  if (flag != 1)

  {

   for (i = 1; i <= n; i++)

   {

    c[i] = b[i];

   }

  }

  if (iteration > iteration_max)

  {

   cout << "\n经过" << iteration_max << "次迭代没有找到根。";

   exit(0);

  }

 }while (flag == 0);

 cout << "\n迭代次数 = " << iteration << endl;

 for (i = 1; i <= n; i++)

 {

  if (b[i] == 0)

  {

   cout << "\n错误，A[" << i << "] = 0" << endl;

   exit(0);

  }

 }

 for (i = 1; i <= n; i++)

 {

  root = pow(fabs(b[i] / b[i-1]), pow(2.0, (-iteration)));

  pp = 1.0;

  pm = 1.0;

  for (k = 1; k <= n; k++)

  {

   pp = pp * root + a[k];

   pm = pm * (-root) + a[k];

  }

  if (fabs(pp) > fabs(pm))

  {

   root = -root;

   val = pm;

  }

  else

  {

   val = pp;

  }

  if (fabs(val) < eps)

  {

   cout << "\n找到了根，根 = " << root << endl;

  }

  else

  {

   cout << "\n可能没有根，根的值 = " << root << "。多项式的值 = " << val << endl;

  }

 }

}