std:map中的浮点键

pok*_*909 31 c++ floating-point stl

下面的代码应该找到问题的关键3.0std::map其是否存在.但由于浮点精度,它将无法找到.

map<double, double> mymap;
mymap[3.0] = 1.0;

double t = 0.0;
for(int i = 0; i < 31; i++)
{
  t += 0.1;
  bool contains = (mymap.count(t) > 0);
}
Run Code Online (Sandbox Code Playgroud)

在上面的例子中,contains将永远是false.我目前的解决方法是乘以t0.1而不是加0.1,如下所示:

for(int i = 0; i < 31; i++)
{
  t = 0.1 * i;
  bool contains = (mymap.count(t) > 0);
}
Run Code Online (Sandbox Code Playgroud)

现在的问题是:

有没有办法将ifCompare引入std::mapif if use double键?浮点数比较的常见解决方案通常是这样的a-b < epsilon.但我没有看到这样做的简单方法std::map.我是否真的必须在double类中封装类型并覆盖operator<(...)以实现此功能?

Yak*_*ont 26

因此,在使用双精度键作为键时存在一些问题std::map.

首先,NaN比较本身的比较是一个问题.如果有可能NaN被插入,请使用:

struct safe_double_less {
  bool operator()(double left, double right) const {
    bool leftNaN = std::isnan(left);
    bool rightNaN = std::isnan(right);
    if (leftNaN != rightNaN)
      return leftNaN<rightNaN;
    return left<right;
  }
};
Run Code Online (Sandbox Code Playgroud)

但这可能过于偏执.不要,我重复一遍,不要在比较运算符中包含一个epsilon阈值,传递给一个std::set或类似的东西:这将违反容器的排序要求,并导致不可预测的未定义行为.

(我的排序NaN比我所有double的要大,包括+inf,在我的订单中,没有充分的理由.少于所有的doubles也会起作用).

所以要么使用默认值operator<,要么使用上面的safe_double_less或类似的东西.

接下来,我建议使用std::multimapstd::multiset,因为您应该期望每次查找多个值.您也可以将内容管理作为日常事务而不是极端情况,以增加代码的测试覆盖率.(我很少推荐这些容器)加上这个块operator[],当你使用浮点键时不建议使用它.

在您查询容器时,您要使用epsilon的点.而不是使用直接接口,创建一个这样的辅助函数:

// works on both `const` and non-`const` associative containers:
template<class Container>
auto my_equal_range( Container&& container, double target, double epsilon = 0.00001 )
-> decltype( container.equal_range(target) )
{
  auto lower = container.lower_bound( target-epsilon );
  auto upper = container.upper_bound( target+epsilon );
  return std::make_pair(lower, upper);
}
Run Code Online (Sandbox Code Playgroud)

它适用于两者std::mapstd::set(和multi版本).

(在一个更现代的代码库中,我期望一个range<?>对象从equal_range函数返回更好.但是现在,我将使它兼容equal_range).

这会找到一系列键,这些键的键与您要求的键"足够接近",而容器在内部维护其排序保证并且不执行未定义的行为.

要测试密钥是否存在,请执行以下操作:

template<typename Container>
bool key_exists( Container const& container, double target, double epsilon = 0.00001 ) {
  auto range = my_equal_range(container, target, epsilon);
  return range.first != range.second;
}
Run Code Online (Sandbox Code Playgroud)

如果你想删除/替换条目,你应该处理可能有多个条目命中的可能性.

较短的答案是"不要使用浮点值作为键std::setstd::map",因为它有点麻烦.

如果你使用浮点键std::setstd::map,几乎可以肯定永远不会.find[]他们,因为这是非常非常有可能是错误的来源.您可以将它用于自动排序的东西集合,只要确切的顺序无关紧要(即,一个特定的1.0位于前方或后方或与另一个1.0位于同一位置).即使这样,我也会使用multimap/multiset,因为依赖于碰撞或缺乏碰撞并不是我所依赖的.

关于IEEE浮点值的确切值的推理是困难的,并且依赖于它的代码的脆弱性是常见的.


Evg*_*eev 5

这是使用软比较(又名epsilon或几乎相等)如何导致问题的简化示例。

让我们epsilon = 2为简单起见。把14到您map。现在看起来像这样:

1
 \
  4
Run Code Online (Sandbox Code Playgroud)

所以,1是树的根。

现在,摆在数234的顺序。每个都将替换根,因为它与根相等。所以你有

4
 \
  4
Run Code Online (Sandbox Code Playgroud)

已经坏了 (假设没有试图重新平衡树而成。)我们可以跟上去567

7
 \
  4
Run Code Online (Sandbox Code Playgroud)

甚至更糟,因为现在如果我们询问是否4在其中,它会说“ no”,并且如果我们要求一个小于的值的迭代器7,则不会包含4

尽管我必须说,我过去曾map多次使用基于该模糊比较运算符的s,而且每当我发现一个bug时,都不会因此而来。这是因为我的应用程序区域中的数据集实际上从不构成压力测试此问题的方法。

  • 如果您想看到使用 epsilon 进行比较会破坏一切的真实案例,请尝试在类似 Fortune 的 Voronoi 图算法中使用“set”或“map”。在那里,如果两个键即将变得相等,您*仅*查看树中的某个位置。 (2认同)

Nas*_*zta 1

您可以实现自己的比较功能。

#include <functional>

class own_double_less : public std::binary_function<double,double,bool>
{
public:
  own_double_less( double arg_ = 1e-7 ) : epsilon(arg_) {}
  bool operator()( const double &left, const double &right  ) const
  {
    // you can choose other way to make decision
    // (The original version is: return left < right;) 
    return (abs(left - right) > epsilon) && (left < right);
  }
  double epsilon;
};
// your map:
map<double,double,own_double_less> mymap;
Run Code Online (Sandbox Code Playgroud)

更新:请参阅有效 STL 中的第 40 条!根据建议进行更新。

  • 此版本可能会导致未定义的行为,因为它根据参数的顺序给出不一致的结果。如果 a == b,own_double_less(a,b) 返回 true,但 own_double_less(b,a) 也返回 true。他们两个不能比对方差! (13认同)
  • 需要明确的是,在 `std::map` 中使用上述代码很容易导致 `std::map` 执行未定义的行为(实际上包括崩溃、无限循环或破坏堆栈)。@jcoffland 给出了一个明确的例子来说明这是如何发生的。这个答案和 @MarkRansom 的答案都是对 `std::map` 做出的鲁莽的事情。 (9认同)
  • 如果您走这条路,请记住比较器必须创建严格的弱排序。`comp(a, b) &amp;&amp; comp(b, c)` 意味着 `comp(a, c)`,`comp(a, a) == false`,而 `comp(a, b)` 意味着 `!comp (b,a)`。这很容易搞砸......例如,如果“epsilon &gt; 0”,则“own_double_less(-1, -1) == true” (6认同)
  • 我同意其他评论者的观点。在一般情况下,这个解决方案是错误的,因为 a == b &amp;&amp; b == c =&gt; a == c 并不总是成立,你的地图会搞砸。 (6认同)
  • 不要使用这个答案,它已损坏。 (6认同)
  • -1:请参阅我的答案中暴露该缺陷的示例。对于许多实际目的来说,这是可行的,但当有合理的替代方案可用时,鼓励传播有缺陷的想法并不好。 (4认同)
  • @Naszta:如果你已经“测试了这个工作”,那么你还没有对其进行足够的测试。 (3认同)