Question

我正在寻找一个将浮点数分类为任意二进制数的类。垃圾箱。所需的语法类似于：

std::vector<double> bin_vector;

// ..... fill the vector with 1, 1.4, 5, etc not evenly spaced values

Binner bins(bin_vector); 

for (std::vector<double>::const_iterator d_itr = some_vector.begin(); 
     d_itr != some_vector.end(); d_itr++) { 
  int bin = bins.categorize(*d_itr); 

  // bin would be 0 for x < 1, 1 for 1 < x < 1.4, etc
  // do something with bin
}

不幸的是，由于便携性要求，我只限于提升和stl。我使用地图和重载<为自定义范围对象编译了我自己的O（log n）解决方案，但该解决方案似乎容易出错并且充其量只是丑陋。

是否有一些简单的stl或boost对象解决方案？

Answer 1

使用std :: map，将间隔边界映射到bin编号。然后使用.upper_bound（）来查找bin。

Answer 2

这是一个未经测试的通用算法，它采用任意长度M的输入向量和N-1个bin边界的排序向量，并返回N个bin计数的向量。 Bin i计算区间中的值[breaks [i-1]，breaks [i]）。 T1和T2类型应相互比较。复杂度等于O（M * log（N））。

#include<algorithm>     // std::is_sorted, std::lower_bound
#include<cassert>       // assert
#include<iterator>      // std::distance
#include<vector>        // std::vector

template<typename T1, typename T2>
std::vector<std::size_t> bin_count(const std::vector<T1>& input, const std::vector<T2>& breaks)
{
    // breaks is a sorted vector -INF < a0 < a1 < ... < aN-2 < +INF
    assert(std::is_sorted(breaks.begin(), breaks.end()));
    auto N = breaks.size() + 1;

    std::vector<std::size_t> output(N, 0);

    if (N == 1) {
        // everything is inside [-INF, INF)
        output[0] = input.size();
        return output;
    }

    for(auto it = input.begin(), it != input.end(); ++it) {
        if (*it < breaks.front()) {
            // first bin counts values in [-INF, a0)
            ++output[0];
            break;
        }
        if (*it >= breaks.back()) {
            // last bin counts values in [aN-1, +INF)
            ++output[N-1];
            break;
        }

        const auto break_it = std::lower_bound(breaks.begin(), breaks.end(), *it);
        bin_index = std::distance(breaks.begin(), break_it) + 1;
        ++output[bin_index];
    }

    return output;  
}

将double分类为任意bin

2 个答案: