是否有一个 C/C++ 函数可以安全地处理除以零？

Question

我们有一种情况，我们想要对两个值 w1 和 w2 进行加权平均，基于另外两个值 v1 & v2 远离零...例如：

• 如果 v1 为零，则根本不会加权，因此我们返回 w2
• 如果 v2 为零，则根本不会加权，因此我们返回 w1
• 如果两个值均远离零，我们进行平均并返回 (w1 + w2 )/2

我继承了如下代码：

float calcWeightedAverage(v1,v2,w1,w2)
{
  v1=fabs(v1);
  v2=fabs(v2);
  return (v1/(v1+v2))*w1 + (v2/(v1+v2)*w2);
}

对于一些背景知识，v1 和 v2 表示两个不同的旋钮转动了多远，它们各自产生的效果的权重仅取决于它们转动了 多少，而不是朝哪个方向转动.

很明显，当v1==v2==0 出现问题时，因为我们以return (0/0)*w1 + (0/0)*w2 结尾，而您不能这样做 0/0。对 v1==v2==0 进行特殊测试在数学上听起来很糟糕，即使浮点数的做法也不错。

所以我想知道

• 有一个标准库函数来处理这个问题
• 有更简洁的数学表示

Answer 1

你正在尝试实现这个数学函数：

F(x, y) = (W1 * |x| + W2 * |y|) / (|x| + |y|)

这个函数在x = 0, y = 0 点是不连续的。不幸的是，正如 R. 在评论中所说，不连续性是不可移除的 - 在这一点上没有任何合理的价值可供使用。

这是因为“合理值”会根据您到达x = 0, y = 0 的路径而变化。例如，考虑从r = R1 到r = 0 的路径F(0, r)（这相当于将X 旋钮设置为零，并平滑地将Y 旋钮从R1 向下调整为0）。 F(x, y) 的值将保持在 W2 不变，直到您到达不连续点。

现在考虑遵循F(r, 0)（将 Y 旋钮保持为零并将 X 旋钮平滑地调整到零） - 输出将保持在 W1 不变，直到您到达不连续点。

现在考虑关注F(r, r)（将两个旋钮保持在相同的值，并同时将它们调低至零）。此处的输出将保持在W1 + W2 / 2，直到您到达不连续点。

这意味着W1 和W2 之间的任何 值与x = 0, y = 0 的输出同样有效。在它们之间没有明智的选择。 （此外，始终选择 0 作为输出是完全错误的 - 否则输出将在区间 W1..W2 上（即，对于您接近不连续性的任何路径，F() 的限制始终在该区间内)，而 0 甚至可能不在这个区间内！）

---

您可以通过稍微调整函数来“修复”该问题 - 在fabs() 之后为v1 和v2 添加一个常量（例如1.0）。这将使每个旋钮的最小贡献不能为零 - 只是“接近零”（常数定义了接近程度）。

将这个常数定义为“一个非常小的数字”可能很诱人，但这只会导致输出发生剧烈变化，因为旋钮被操纵到接近零点，这可能是不可取的。

Answer 2

这是我能很快想到的最好的方法

float calcWeightedAverage(float v1,float v2,float w1,float w2)
{
    float a1 = 0.0;
    float a2 = 0.0;

    if (v1 != 0)
    { 
        a1 = v1/(v1+v2) * w1;
    }

    if (v2 != 0)
    { 
        a2 = v2/(v1+v2) * w2;
    }

    return a1 + a2;
}

Answer 3

我看不出这样做有什么问题：

float calcWeightedAverage( float v1, float v2, float w1, float w2 ) {
    static const float eps = FLT_MIN; //Or some other suitably small value.
    v1 = fabs( v1 );
    v2 = fabs( v2 );

    if( v1 + v2 < eps )
        return (w1+w2)/2.0f;
    else
        return (v1/(v1+v2))*w1 + (v2/(v1+v2)*w2);
}

当然，没有什么“花哨”的东西可以弄清楚你的部门，但为什么要让它变得更难呢？

Answer 4

我个人认为明确检查除以零有什么问题。我们都这样做，所以可以说没有它更丑。

但是，可以关闭 IEEE 除零异常。你如何做到这一点取决于你的平台。我知道在 Windows 上它必须在整个进程范围内完成，所以如果你不小心的话，你可能会无意中弄乱其他线程（以及它们与你）。

但是，如果您这样做，您的结果值将是 NaN，而不是 0。我非常怀疑这就是你想要的。如果您在得到 NaN 时无论如何都必须使用不同的逻辑在其中进行特殊检查，那么您最好只在前面检查分母中的 0。

Answer 5

因此，对于加权平均值，您需要查看两者都为零的特殊情况。在这种情况下，您希望将其视为 0.5 * w1 + 0.5 * w2，对吗？这个怎么样？

float calcWeightedAverage(float v1,float v2,float w1,float w2)
{
  v1=fabs(v1);
  v2=fabs(v2);
  if (v1 == v2) {
    v1 = 0.5;
  } else {
    v1 = v1 / (v1 + v2); // v1 is between 0 and 1
  }
  v2 = 1 - v1; // avoid addition and division because they should add to 1      

  return v1 * w1 + v2 * w2;
}

Answer 6

您应该测试fabs(v1)+fabs(v2)==0（这似乎是最快的，因为您已经计算了它们），并返回在这种情况下有意义的任何值（w1+w2/2?）。否则，保持代码不变。

但是，如果v1==v2==0 是可能的，我怀疑算法本身会被破坏。当旋钮“接近 0”​​时，这种数值不稳定性似乎是不可取的。

如果行为实际上是正确的并且您想避免特殊情况，您可以在获取绝对值后将给定类型的最小正浮点值添加到v1 和v2。 （请注意，DBL_MIN 和朋友不是正确的值，因为它们是最小 标准化 值；您需要所有正值中的最小值，包括次正态值。）除非它们'已经非常小了；在通常情况下，添加只会产生v1 和v2。

Answer 7

使用显式检查为零的问题在于，除非您按照 cafs 响应中的概述小心谨慎（如果它在您的算法的核心，则 if 可能会很昂贵 - 但不要在意关于那个，直到你测量......）

我倾向于使用一些可以使权重接近零的东西。

float calcWeightedAverage(v1,v2,w1,w2)
{
  eps = 1e-7; // Or whatever you like...
  v1=fabs(v1)+eps;
  v2=fabs(v2)+eps;
  return (v1/(v1+v2))*w1 + (v2/(v1+v2)*w2);
}

您的函数现在是平滑的，没有渐近线或被零除，只要 v1 或 v2 之一显着高于 1e-7，它就无法与“真实”加权平均值区分开来。

Answer 8

如果分母为零，你希望它如何默认？你可以这样做：

static inline float divide_default(float numerator, float denominator, float default) {
    return (denominator == 0) ? default : (numerator / denominator);
}

float calcWeightedAverage(v1, v2, w1, w2)
{
  v1 = fabs(v1);
  v2 = fabs(v2);
  return w1 * divide_default(v1, v1 + v2, 0.0) + w2 * divide_default(v2, v1 + v2, 0.0);
}

注意，静态内联的函数定义和使用应该真正让编译器知道它可以内联。

Answer 9

这应该可以工作

#include <float.h>

float calcWeightedAverage(v1,v2,w1,w2)
{
  v1=fabs(v1);
  v2=fabs(v2);
  return (v1/(v1+v2+FLT_EPSILON))*w1 + (v2/(v1+v2+FLT_EPSILON)*w2);
}

编辑： 我看到某些精度可能存在问题，因此不要使用 FLT_EPSILON，而是使用 DBL_EPSILON 来获得准确的结果（我猜你会返回一个浮点值）。

Answer 10

我会这样做：

float calcWeightedAverage(double v1, double v2, double w1, double w2)
{
  v1 = fabs(v1);
  v2 = fabs(v2);
  /* if both values are equally far from 0 */
  if (fabs(v1 - v2) < 0.000000001) return (w1 + w2) / 2;
  return (v1*w1 + v2*w2) / (v1 + v2);
}