我正在寻找一个健壮的算法（或描述算法的论文），它可以找到多项式的根（理想情况下，直到第4个debree，但任何事情都可以）使用闭合 - 形式解决方案。我只对真正的根源感兴趣。
我对解决二次方程式的第一次考虑涉及到这一点（我也有类似于立方体/四次方的代码，但现在让我们专注于二次方程式）：
/**
* @brief a simple quadratic equation solver
*
* With double-precision floating-point, this reaches 1e-12 worst-case and 1e-15 average
* precision of the roots (the value of the function in the roots). The roots can be however
* quite far from the true roots, up to 1e-10 worst-case and 1e-18 average absolute difference
* for cases when two roots exist. If only a single root exists, the worst-case precision is
* 1e-13 and average-case precision is 1e-18.
*
* With single-precision floating-point, this reaches 1e-3 worst-case and 1e-7 average
* precision of the roots (the value of the function in the roots). The roots can be however
* quite far from the true roots, up to 1e-1 worst-case and 1e-10 average absolute difference
* for cases when two roots exist. If only a single root exists, the worst-case precision is
* 1e+2 (!) and average-case precision is 1e-2. Do not use single-precision floating point,
* except if pressed by time.
*
* All the precision measurements are scaled by the maximum absolute coefficient value.
*
* @tparam T is data type of the arguments (default double)
* @tparam b_sort_roots is root sorting flag (if set, the roots are
* given in ascending (not absolute) value; default true)
* @tparam n_2nd_order_coeff_log10_thresh is base 10 logarithm of threshold
* on the first coefficient (if below threshold, the equation is a linear one; default -6)
* @tparam n_zero_discriminant_log10_thresh is base 10 logarithm of threshold
* on the discriminant (if below negative threshold, the equation does not
* have a real root, if below threshold, the equation has just a single solution; default -6)
*/
template <class T = double, const bool b_sort_roots = true,
const int n_2nd_order_coeff_log10_thresh = -6,
const int n_zero_discriminant_log10_thresh = -6>
class CQuadraticEq {
protected:
T a; /**< @brief the 2nd order coefficient */
T b; /**< @brief the 1st order coefficient */
T c; /**< @brief 0th order coefficient */
T p_real_root[2]; /**< @brief list of the roots (real parts) */
//T p_im_root[2]; // imaginary part of the roots
size_t n_real_root_num; /**< @brief number of real roots */
public:
/**
* @brief default constructor; solves for roots of \f$ax^2 + bx + c = 0\f$
*
* This finds roots of the given equation. It tends to find two identical roots instead of one, rather
* than missing one of two different roots - the number of roots found is therefore orientational,
* as the roots might have the same value.
*
* @param[in] _a is the 2nd order coefficient
* @param[in] _b is the 1st order coefficient
* @param[in] _c is 0th order coefficient
*/
CQuadraticEq(T _a, T _b, T _c) // ax2 + bx + c = 0
:a(_a), b(_b), c(_c)
{
T _aa = fabs(_a);
if(_aa < f_Power_Static(10, n_2nd_order_coeff_log10_thresh)) { // otherwise division by a yields large numbers, this is then more precise
p_real_root[0] = -_c / _b;
//p_im_root[0] = 0;
n_real_root_num = 1;
return;
}
// a simple linear equation
if(_aa < 1) { // do not divide always, that makes it worse
_b /= _a;
_c /= _a;
_a = 1;
// could copy the code here and optimize away division by _a (optimizing compiler might do it for us)
}
// improve numerical stability if the coeffs are very small
const double f_thresh = f_Power_Static(10, n_zero_discriminant_log10_thresh);
double f_disc = _b * _b - 4 * _a * _c;
if(f_disc < -f_thresh) // only really negative
n_real_root_num = 0; // only two complex roots
else if(/*fabs(f_disc) < f_thresh*/f_disc <= f_thresh) { // otherwise gives problems for double root situations
p_real_root[0] = T(-_b / (2 * _a));
n_real_root_num = 1;
} else {
f_disc = sqrt(f_disc);
int i = (b_sort_roots)? ((_a > 0)? 0 : 1) : 0; // produce sorted roots, if required
p_real_root[i] = T((-_b - f_disc) / (2 * _a));
p_real_root[1 - i] = T((-_b + f_disc) / (2 * _a));
//p_im_root[0] = 0;
//p_im_root[1] = 0;
n_real_root_num = 2;
}
}
/**
* @brief gets number of real roots
* @return Returns number of real roots (0 to 2).
*/
size_t n_RealRoot_Num() const
{
_ASSERTE(n_real_root_num >= 0);
return n_real_root_num;
}
/**
* @brief gets value of a real root
* @param[in] n_index is zero-based index of the root
* @return Returns value of the specified root.
*/
T f_RealRoot(size_t n_index) const
{
_ASSERTE(n_index < 2 && n_index < n_real_root_num);
return p_real_root[n_index];
}
/**
* @brief evaluates the equation for a given argument
* @param[in] f_x is value of the argument \f$x\f$
* @return Returns value of \f$ax^2 + bx + c\f$.
*/
T operator ()(T f_x) const
{
T f_x2 = f_x * f_x;
return f_x2 * a + f_x * b + c;
}
};
代码太可怕了，我讨厌所有的门槛。但是对于根在[-100, 100]区间内的随机方程，这并不是那么糟糕：
root response precision 1e-100: 6315 cases
root response precision 1e-19: 2 cases
root response precision 1e-17: 2 cases
root response precision 1e-16: 6 cases
root response precision 1e-15: 6333 cases
root response precision 1e-14: 3765 cases
root response precision 1e-13: 241 cases
root response precision 1e-12: 3 cases
2-root solution precision 1e-100: 5353 cases
2-root solution precision 1e-19: 656 cases
2-root solution precision 1e-18: 4481 cases
2-root solution precision 1e-17: 2312 cases
2-root solution precision 1e-16: 455 cases
2-root solution precision 1e-15: 68 cases
2-root solution precision 1e-14: 7 cases
2-root solution precision 1e-13: 2 cases
1-root solution precision 1e-100: 3022 cases
1-root solution precision 1e-19: 38 cases
1-root solution precision 1e-18: 197 cases
1-root solution precision 1e-17: 68 cases
1-root solution precision 1e-16: 7 cases
1-root solution precision 1e-15: 1 cases
请注意，此精度相对于系数的大小，通常在10 ^ 6范围内（因此最终精度远非完美，但可能大部分可用）。然而，如果没有门槛，它就几乎没用了。
我尝试过使用多种精确算法，这种算法通常运行良好，但往往会拒绝许多根，因为多项式的系数不是多精度，而且有些多项式不能精确表示（如果有一个双根）一个二次多项式，它主要是将它分成两个根（我不会介意）或者说没有任何根）。如果我想恢复甚至可能稍微不精确的根，我的代码会变得复杂且充满阈值。
到目前为止，我已尝试使用CCmath，但要么我无法正确使用它，要么精确度非常差。此外，它使用plrt()中的迭代（非封闭形式）求解器。
我尝试过使用GNU科学库gsl_poly_solve_quadratic()，但这似乎是一种天真的方法，而且在数值上并不稳定。
天真地使用std::complex数字也是一个非常糟糕的主意，因为精度和速度都很差（特别是对于具有超越函数的代码很重的立方/四次方程式）。
恢复根是复杂的数字是唯一的方法吗？然后没有错过任何根，用户可以选择根需要的精确程度（因此忽略不太精确的根中的小虚构组件）。
答案 0 :(得分：1)
这并没有真正回答你的问题，但我认为你可以改善你已经获得的东西，因为你现在已经失去了重要性＃39; b^2 >> ac时的问题。在这种情况下，您最终得到(-b + (b + eps))/(2 * a)行的公式，其中b的取消可能会丢失eps中的许多有效数字。
正确处理此问题的方法是使用正常的＆＃39;一个根的二次方根的方程和较不为人知的替代方案＆＃39;或者倒挂＆＃39;另一个根的等式。你采取哪种方式取决于_b的标志。
沿着以下这一行对代码进行更改可以减少由此产生的错误。
if( _b > 0 ) {
p_real_root[i] = T((-_b - f_disc) / (2 * _a));
p_real_root[1 - i] = T((2 * _c) / (-_b - f_disc));
}
else{
p_real_root[i] = T((2 * _c) / (-_b + f_disc));
p_real_root[1 - i] = T((-_b + f_disc) / (2 * _a));
}