17 #ifndef BOOST_SORT_SPREADSORT_DETAIL_FLOAT_SORT_HPP 
   18 #define BOOST_SORT_SPREADSORT_DETAIL_FLOAT_SORT_HPP 
   23 #include <boost/static_assert.hpp> 
   24 #include <boost/serialization/static_warning.hpp> 
   25 #include <boost/utility/enable_if.hpp> 
   29 #include <boost/cstdint.hpp> 
   35     template<
class Cast_type, 
class RandomAccessIter>
 
   39       typedef typename std::iterator_traits<RandomAccessIter>::value_type
 
   42       BOOST_STATIC_ASSERT(
sizeof(Cast_type) == 
sizeof(Data_type));
 
   43       BOOST_STATIC_ASSERT(std::numeric_limits<Data_type>::is_iec559);
 
   44       BOOST_STATIC_ASSERT(std::numeric_limits<Cast_type>::is_integer);
 
   46       std::memcpy(&result, &(*floatiter), 
sizeof(Data_type));
 
   52     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift>
 
   55                   Div_type & max, Div_type & min, Right_shift rshift)
 
   57       min = max = rshift(*current, 0);
 
   60       while (++current < last) {
 
   61         Div_type value = rshift(*current, 0);
 
   62         sorted &= value >= prev;
 
   73     template <
class RandomAccessIter, 
class Div_type>
 
   75                         const RandomAccessIter & nextbinstart, 
unsigned ii
 
   76                         , 
const unsigned log_divisor, 
const Div_type div_min)
 
   78       RandomAccessIter * local_bin = bins + ii;
 
   79       for (RandomAccessIter current = *local_bin; current < nextbinstart;
 
   81         for (RandomAccessIter * target_bin =
 
   82             (bins + ((cast_float_iter<Div_type, RandomAccessIter>(current) >>
 
   83                       log_divisor) - div_min));  target_bin != local_bin;
 
   84           target_bin = bins + ((cast_float_iter<Div_type, RandomAccessIter>
 
   85                                (current) >> log_divisor) - div_min)) {
 
   86           typename std::iterator_traits<RandomAccessIter>::value_type tmp;
 
   87           RandomAccessIter b = (*target_bin)++;
 
   89                               RandomAccessIter>(b) >> log_divisor) - div_min);
 
   92           if (b_bin != local_bin) {
 
   93             RandomAccessIter c = (*b_bin)++;
 
  103       *local_bin = nextbinstart;
 
  106     template <
class RandomAccessIter, 
class Div_type>
 
  108                           RandomAccessIter & nextbinstart, 
unsigned ii,
 
  109                           const size_t *bin_sizes,
 
  110                           const unsigned log_divisor, 
const Div_type div_min)
 
  112       nextbinstart += bin_sizes[ii];
 
  113       inner_float_swap_loop<RandomAccessIter, Div_type>
 
  114         (bins, nextbinstart, ii, log_divisor, div_min);
 
  119     template <
class RandomAccessIter, 
class Cast_type>
 
  122                   Cast_type & max, Cast_type & min)
 
  124       min = max = cast_float_iter<Cast_type, RandomAccessIter>(current);
 
  125       Cast_type prev = min;
 
  127       while (++current < last) {
 
  128         Cast_type value = cast_float_iter<Cast_type, RandomAccessIter>(current);
 
  129         sorted &= value >= prev;
 
  133         else if (value < min)
 
  140     template <
class RandomAccessIter, 
class Div_type, 
class Size_type>
 
  143               std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset
 
  147       if (is_sorted_or_find_extremes<RandomAccessIter, Div_type>(first, last, 
 
  150       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  152       Div_type div_min = min >> log_divisor;
 
  153       Div_type div_max = max >> log_divisor;
 
  154       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  156       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  157                                           cache_end, bin_count);
 
  160       for (RandomAccessIter current = first; current != last;)
 
  161         bin_sizes[
unsigned((cast_float_iter<Div_type, RandomAccessIter>(
 
  162             current++) >> log_divisor) - div_min)]++;
 
  164       for (
unsigned u = 0; u < bin_count - 1; u++)
 
  165         bins[u + 1] = bins[u] + bin_sizes[u];
 
  169       RandomAccessIter nextbinstart = first;
 
  170       for (
unsigned u = 0; u < bin_count - 1; ++u)
 
  171         float_swap_loop<RandomAccessIter, Div_type>
 
  172           (bins, nextbinstart, u, bin_sizes, log_divisor, div_min);
 
  173       bins[bin_count - 1] = last;
 
  183       RandomAccessIter lastPos = first;
 
  184       for (
unsigned u = cache_offset; u < cache_end; lastPos = bin_cache[u],
 
  186         size_t count = bin_cache[u] - lastPos;
 
  189         if (count < max_count)
 
  190           std::sort(lastPos, bin_cache[u]);
 
  192           positive_float_sort_rec<RandomAccessIter, Div_type, Size_type>
 
  193             (lastPos, bin_cache[u], bin_cache, cache_end, bin_sizes);
 
  199     template <
class RandomAccessIter, 
class Div_type, 
class Size_type>
 
  202                         std::vector<RandomAccessIter> &bin_cache,
 
  203                         unsigned cache_offset, 
size_t *bin_sizes)
 
  206       if (is_sorted_or_find_extremes<RandomAccessIter, Div_type>(first, last, 
 
  209       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  211       Div_type div_min = min >> log_divisor;
 
  212       Div_type div_max = max >> log_divisor;
 
  213       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  215       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  216                                           cache_end, bin_count);
 
  219       for (RandomAccessIter current = first; current != last;)
 
  220         bin_sizes[
unsigned((cast_float_iter<Div_type, RandomAccessIter>(
 
  221             current++) >> log_divisor) - div_min)]++;
 
  222       bins[bin_count - 1] = first;
 
  223       for (
int ii = bin_count - 2; ii >= 0; --ii)
 
  224         bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];
 
  227       RandomAccessIter nextbinstart = first;
 
  229       for (
int ii = bin_count - 1; ii > 0; --ii)
 
  230         float_swap_loop<RandomAccessIter, Div_type>
 
  231           (bins, nextbinstart, ii, bin_sizes, log_divisor, div_min);
 
  233       bin_cache[cache_offset] = last;
 
  243       RandomAccessIter lastPos = first;
 
  244       for (
int ii = cache_end - 1; ii >= 
static_cast<int>(cache_offset);
 
  245           lastPos = bin_cache[ii], --ii) {
 
  246         size_t count = bin_cache[ii] - lastPos;
 
  249         if (count < max_count)
 
  250           std::sort(lastPos, bin_cache[ii]);
 
  252           negative_float_sort_rec<RandomAccessIter, Div_type, Size_type>
 
  253             (lastPos, bin_cache[ii], bin_cache, cache_end, bin_sizes);
 
  259     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  263               std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset
 
  264               , 
size_t *bin_sizes, Right_shift rshift)
 
  269       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  271       Div_type div_min = min >> log_divisor;
 
  272       Div_type div_max = max >> log_divisor;
 
  273       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  275       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  276                                           cache_end, bin_count);
 
  279       for (RandomAccessIter current = first; current != last;)
 
  280         bin_sizes[
unsigned(rshift(*(current++), log_divisor) - div_min)]++;
 
  281       bins[bin_count - 1] = first;
 
  282       for (
int ii = bin_count - 2; ii >= 0; --ii)
 
  283         bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];
 
  286       RandomAccessIter nextbinstart = first;
 
  288       for (
int ii = bin_count - 1; ii > 0; --ii)
 
  289         swap_loop<RandomAccessIter, Div_type, Right_shift>
 
  290           (bins, nextbinstart, ii, rshift, bin_sizes, log_divisor, div_min);
 
  292       bin_cache[cache_offset] = last;
 
  302       RandomAccessIter lastPos = first;
 
  303       for (
int ii = cache_end - 1; ii >= 
static_cast<int>(cache_offset);
 
  304           lastPos = bin_cache[ii], --ii) {
 
  305         size_t count = bin_cache[ii] - lastPos;
 
  308         if (count < max_count)
 
  309           std::sort(lastPos, bin_cache[ii]);
 
  313             (lastPos, bin_cache[ii], bin_cache, cache_end, bin_sizes, rshift);
 
  317     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  318               class Compare, 
class Size_type>
 
  321             std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset,
 
  322             size_t *bin_sizes, Right_shift rshift, Compare comp)
 
  327       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  329       Div_type div_min = min >> log_divisor;
 
  330       Div_type div_max = max >> log_divisor;
 
  331       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  333       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  334                                           cache_end, bin_count);
 
  337       for (RandomAccessIter current = first; current != last;)
 
  338         bin_sizes[
unsigned(rshift(*(current++), log_divisor) - div_min)]++;
 
  339       bins[bin_count - 1] = first;
 
  340       for (
int ii = bin_count - 2; ii >= 0; --ii)
 
  341         bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];
 
  344       RandomAccessIter nextbinstart = first;
 
  346       for (
int ii = bin_count - 1; ii > 0; --ii)
 
  347         swap_loop<RandomAccessIter, Div_type, Right_shift>
 
  348           (bins, nextbinstart, ii, rshift, bin_sizes, log_divisor, div_min);
 
  350       bin_cache[cache_offset] = last;
 
  360       RandomAccessIter lastPos = first;
 
  361       for (
int ii = cache_end - 1; ii >= 
static_cast<int>(cache_offset);
 
  362           lastPos = bin_cache[ii], --ii) {
 
  363         size_t count = bin_cache[ii] - lastPos;
 
  366         if (count < max_count)
 
  367           std::sort(lastPos, bin_cache[ii], comp);
 
  370                                   Compare, Size_type>(lastPos, bin_cache[ii],
 
  371                                                       bin_cache, cache_end,
 
  372                                                       bin_sizes, rshift, comp);
 
  377     template <
class RandomAccessIter, 
class Div_type, 
class Size_type>
 
  380                 std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset
 
  384       if (is_sorted_or_find_extremes<RandomAccessIter, Div_type>(first, last, 
 
  387       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  389       Div_type div_min = min >> log_divisor;
 
  390       Div_type div_max = max >> log_divisor;
 
  391       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  393       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  394                                           cache_end, bin_count);
 
  397       for (RandomAccessIter current = first; current != last;)
 
  398         bin_sizes[
unsigned((cast_float_iter<Div_type, RandomAccessIter>(
 
  399             current++) >> log_divisor) - div_min)]++;
 
  402       unsigned first_positive = (div_min < 0) ? 
unsigned(-div_min) : 0;
 
  404       if (cache_offset + first_positive > cache_end)
 
  405         first_positive = cache_end - cache_offset;
 
  410       if (first_positive > 0) {
 
  411         bins[first_positive - 1] = first;
 
  412         for (
int ii = first_positive - 2; ii >= 0; --ii) {
 
  413           bins[ii] = first + bin_sizes[ii + 1];
 
  414           bin_sizes[ii] += bin_sizes[ii + 1];
 
  417         if (first_positive < bin_count) {
 
  418           bins[first_positive] = first + bin_sizes[0];
 
  419           bin_sizes[first_positive] += bin_sizes[0];
 
  424       for (
unsigned u = first_positive; u < bin_count - 1; u++) {
 
  425         bins[u + 1] = first + bin_sizes[u];
 
  426         bin_sizes[u + 1] += bin_sizes[u];
 
  430       RandomAccessIter nextbinstart = first;
 
  431       for (
unsigned u = 0; u < bin_count; ++u) {
 
  432         nextbinstart = first + bin_sizes[u];
 
  433         inner_float_swap_loop<RandomAccessIter, Div_type>
 
  434           (bins, nextbinstart, u, log_divisor, div_min);
 
  444       RandomAccessIter lastPos = first;
 
  445       for (
int ii = cache_offset + first_positive - 1; 
 
  446            ii >= 
static_cast<int>(cache_offset);
 
  447            lastPos = bin_cache[ii--]) {
 
  448         size_t count = bin_cache[ii] - lastPos;
 
  451         if (count < max_count)
 
  452           std::sort(lastPos, bin_cache[ii]);
 
  455           negative_float_sort_rec<RandomAccessIter, Div_type, Size_type>
 
  456             (lastPos, bin_cache[ii], bin_cache, cache_end, bin_sizes);
 
  459       for (
unsigned u = cache_offset + first_positive; u < cache_end;
 
  460           lastPos = bin_cache[u], ++u) {
 
  461         size_t count = bin_cache[u] - lastPos;
 
  464         if (count < max_count)
 
  465           std::sort(lastPos, bin_cache[u]);
 
  468           positive_float_sort_rec<RandomAccessIter, Div_type, Size_type>
 
  469             (lastPos, bin_cache[u], bin_cache, cache_end, bin_sizes);
 
  474     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift
 
  478               std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset
 
  479               , 
size_t *bin_sizes, Right_shift rshift)
 
  484       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  486       Div_type div_min = min >> log_divisor;
 
  487       Div_type div_max = max >> log_divisor;
 
  488       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  490       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  491                                           cache_end, bin_count);
 
  494       for (RandomAccessIter current = first; current != last;)
 
  495         bin_sizes[
unsigned(rshift(*(current++), log_divisor) - div_min)]++;
 
  497       unsigned first_positive = (div_min < 0) ? 
unsigned(-div_min) : 0;
 
  499       if (cache_offset + first_positive > cache_end)
 
  500         first_positive = cache_end - cache_offset;
 
  505       if (first_positive > 0) {
 
  506         bins[first_positive - 1] = first;
 
  507         for (
int ii = first_positive - 2; ii >= 0; --ii) {
 
  508           bins[ii] = first + bin_sizes[ii + 1];
 
  509           bin_sizes[ii] += bin_sizes[ii + 1];
 
  512         if (static_cast<unsigned>(first_positive) < bin_count) {
 
  513           bins[first_positive] = first + bin_sizes[0];
 
  514           bin_sizes[first_positive] += bin_sizes[0];
 
  519       for (
unsigned u = first_positive; u < bin_count - 1; u++) {
 
  520         bins[u + 1] = first + bin_sizes[u];
 
  521         bin_sizes[u + 1] += bin_sizes[u];
 
  525       RandomAccessIter next_bin_start = first;
 
  526       for (
unsigned u = 0; u < bin_count; ++u) {
 
  527         next_bin_start = first + bin_sizes[u];
 
  528         inner_swap_loop<RandomAccessIter, Div_type, Right_shift>
 
  529           (bins, next_bin_start, u, rshift, log_divisor, div_min);
 
  540       RandomAccessIter lastPos = first;
 
  541       for (
int ii = cache_offset + first_positive - 1; 
 
  542            ii >= 
static_cast<int>(cache_offset);
 
  543            lastPos = bin_cache[ii--]) {
 
  544         size_t count = bin_cache[ii] - lastPos;
 
  547         if (count < max_count)
 
  548           std::sort(lastPos, bin_cache[ii]);
 
  552             Right_shift, Size_type>(lastPos, bin_cache[ii], bin_cache,
 
  553                                     cache_end, bin_sizes, rshift);
 
  556       for (
unsigned u = cache_offset + first_positive; u < cache_end;
 
  557           lastPos = bin_cache[u], ++u) {
 
  558         size_t count = bin_cache[u] - lastPos;
 
  561         if (count < max_count)
 
  562           std::sort(lastPos, bin_cache[u]);
 
  565           spreadsort_rec<RandomAccessIter, Div_type, Right_shift, Size_type,
 
  568             (lastPos, bin_cache[u], bin_cache, cache_end, bin_sizes, rshift);
 
  572     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  573               class Compare, 
class Size_type>
 
  576             std::vector<RandomAccessIter> &bin_cache, 
unsigned cache_offset,
 
  577             size_t *bin_sizes, Right_shift rshift, Compare comp)
 
  582       unsigned log_divisor = get_log_divisor<float_log_mean_bin_size>(
 
  584       Div_type div_min = min >> log_divisor;
 
  585       Div_type div_max = max >> log_divisor;
 
  586       unsigned bin_count = unsigned(div_max - div_min) + 1;
 
  588       RandomAccessIter * bins = 
size_bins(bin_sizes, bin_cache, cache_offset,
 
  589                                           cache_end, bin_count);
 
  592       for (RandomAccessIter current = first; current != last;)
 
  593         bin_sizes[
unsigned(rshift(*(current++), log_divisor) - div_min)]++;
 
  595       unsigned first_positive = 
 
  596         (div_min < 0) ? static_cast<unsigned>(-div_min) : 0;
 
  598       if (cache_offset + first_positive > cache_end)
 
  599         first_positive = cache_end - cache_offset;
 
  604       if (first_positive > 0) {
 
  605         bins[first_positive - 1] = first;
 
  606         for (
int ii = first_positive - 2; ii >= 0; --ii) {
 
  607           bins[ii] = first + bin_sizes[ii + 1];
 
  608           bin_sizes[ii] += bin_sizes[ii + 1];
 
  611         if (static_cast<unsigned>(first_positive) < bin_count) {
 
  612           bins[first_positive] = first + bin_sizes[0];
 
  613           bin_sizes[first_positive] += bin_sizes[0];
 
  618       for (
unsigned u = first_positive; u < bin_count - 1; u++) {
 
  619         bins[u + 1] = first + bin_sizes[u];
 
  620         bin_sizes[u + 1] += bin_sizes[u];
 
  624       RandomAccessIter next_bin_start = first;
 
  625       for (
unsigned u = 0; u < bin_count; ++u) {
 
  626         next_bin_start = first + bin_sizes[u];
 
  627         inner_swap_loop<RandomAccessIter, Div_type, Right_shift>
 
  628           (bins, next_bin_start, u, rshift, log_divisor, div_min);
 
  639       RandomAccessIter lastPos = first;
 
  640       for (
int ii = cache_offset + first_positive - 1; 
 
  641            ii >= 
static_cast<int>(cache_offset);
 
  642            lastPos = bin_cache[ii--]) {
 
  643         size_t count = bin_cache[ii] - lastPos;
 
  646         if (count < max_count)
 
  647           std::sort(lastPos, bin_cache[ii], comp);
 
  651                                   Compare, Size_type>(lastPos, bin_cache[ii],
 
  652                                                       bin_cache, cache_end,
 
  653                                                       bin_sizes, rshift, comp);
 
  656       for (
unsigned u = cache_offset + first_positive; u < cache_end;
 
  657           lastPos = bin_cache[u], ++u) {
 
  658         size_t count = bin_cache[u] - lastPos;
 
  661         if (count < max_count)
 
  662           std::sort(lastPos, bin_cache[u], comp);
 
  665           spreadsort_rec<RandomAccessIter, Div_type, Right_shift, Compare,
 
  668       (lastPos, bin_cache[u], bin_cache, cache_end, bin_sizes, rshift, comp);
 
  673     template <
class RandomAccessIter>
 
  674     inline typename boost::enable_if_c< 
sizeof(boost::uint32_t) ==
 
  675       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type)
 
  676       && std::numeric_limits<
typename 
  677       std::iterator_traits<RandomAccessIter>::value_type>::is_iec559,
 
  682       std::vector<RandomAccessIter> bin_cache;
 
  683       float_sort_rec<RandomAccessIter, boost::int32_t, boost::uint32_t>
 
  684         (first, last, bin_cache, 0, bin_sizes);
 
  688     template <
class RandomAccessIter>
 
  689     inline typename boost::enable_if_c< 
sizeof(boost::uint64_t) ==
 
  690       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type)
 
  691       && std::numeric_limits<
typename 
  692       std::iterator_traits<RandomAccessIter>::value_type>::is_iec559,
 
  697       std::vector<RandomAccessIter> bin_cache;
 
  698       float_sort_rec<RandomAccessIter, boost::int64_t, boost::uint64_t>
 
  699         (first, last, bin_cache, 0, bin_sizes);
 
  702     template <
class RandomAccessIter>
 
  703     inline typename boost::disable_if_c< (
sizeof(boost::uint64_t) ==
 
  704       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type)
 
  705       || 
sizeof(boost::uint32_t) ==
 
  706       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type))
 
  707       && std::numeric_limits<
typename 
  708       std::iterator_traits<RandomAccessIter>::value_type>::is_iec559,
 
  712       BOOST_STATIC_WARNING(!(
sizeof(boost::uint64_t) ==
 
  713       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type)
 
  714       || 
sizeof(boost::uint32_t) ==
 
  715       sizeof(
typename std::iterator_traits<RandomAccessIter>::value_type))
 
  716       || !std::numeric_limits<
typename 
  717       std::iterator_traits<RandomAccessIter>::value_type>::is_iec559);
 
  718       std::sort(first, last);
 
  723     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift>
 
  724     inline typename boost::enable_if_c< sizeof(size_t) >= 
sizeof(Div_type),
 
  726     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  730       std::vector<RandomAccessIter> bin_cache;
 
  731       float_sort_rec<RandomAccessIter, Div_type, Right_shift, size_t>
 
  732         (first, last, bin_cache, 0, bin_sizes, rshift);
 
  736     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift>
 
  737     inline typename boost::enable_if_c< 
sizeof(size_t) < 
sizeof(Div_type)
 
  738       && 
sizeof(boost::uintmax_t) >= 
sizeof(Div_type), 
void >::type
 
  739     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  743       std::vector<RandomAccessIter> bin_cache;
 
  744       float_sort_rec<RandomAccessIter, Div_type, Right_shift, boost::uintmax_t>
 
  745         (first, last, bin_cache, 0, bin_sizes, rshift);
 
  749     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift>
 
  750     inline typename boost::disable_if_c< sizeof(boost::uintmax_t) >=
 
  751       sizeof(Div_type), 
void >::type
 
  752     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  755       BOOST_STATIC_WARNING(
sizeof(boost::uintmax_t) >= 
sizeof(Div_type));
 
  756       std::sort(first, last);
 
  760     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  762     inline typename boost::enable_if_c< sizeof(size_t) >= 
sizeof(Div_type),
 
  764     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  765                Right_shift rshift, Compare comp)
 
  768       std::vector<RandomAccessIter> bin_cache;
 
  771         (first, last, bin_cache, 0, bin_sizes, rshift, comp);
 
  775     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  777     inline typename boost::enable_if_c< 
sizeof(size_t) < 
sizeof(Div_type)
 
  778       && 
sizeof(boost::uintmax_t) >= 
sizeof(Div_type), 
void >::type
 
  779     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  780                Right_shift rshift, Compare comp)
 
  783       std::vector<RandomAccessIter> bin_cache;
 
  786         (first, last, bin_cache, 0, bin_sizes, rshift, comp);
 
  790     template <
class RandomAccessIter, 
class Div_type, 
class Right_shift,
 
  792     inline typename boost::disable_if_c< sizeof(boost::uintmax_t) >=
 
  793       sizeof(Div_type), 
void >::type
 
  794     float_sort(RandomAccessIter first, RandomAccessIter last, Div_type,
 
  795                Right_shift rshift, Compare comp)
 
  797       BOOST_STATIC_WARNING(
sizeof(boost::uintmax_t) >= 
sizeof(Div_type));
 
  798       std::sort(first, last, comp);
 
void float_sort_rec(RandomAccessIter first, RandomAccessIter last, std::vector< RandomAccessIter > &bin_cache, unsigned cache_offset, size_t *bin_sizes)
Definition: float_sort.hpp:379
Definition: constants.hpp:11
Cast_type cast_float_iter(const RandomAccessIter &floatiter)
Definition: float_sort.hpp:37
Definition: constants.hpp:38
void inner_float_swap_loop(RandomAccessIter *bins, const RandomAccessIter &nextbinstart, unsigned ii, const unsigned log_divisor, const Div_type div_min)
Definition: float_sort.hpp:74
size_t get_min_count(unsigned log_range)
Definition: spreadsort_common.hpp:51
Definition: constants.hpp:19
void float_swap_loop(RandomAccessIter *bins, RandomAccessIter &nextbinstart, unsigned ii, const size_t *bin_sizes, const unsigned log_divisor, const Div_type div_min)
Definition: float_sort.hpp:107
unsigned rough_log_2_size(const T &input)
Definition: spreadsort_common.hpp:34
bool is_sorted_or_find_extremes(RandomAccessIter current, RandomAccessIter last, Div_type &max, Div_type &min, Right_shift rshift)
Definition: float_sort.hpp:54
RandomAccessIter * size_bins(size_t *bin_sizes, std::vector< RandomAccessIter > &bin_cache, unsigned cache_offset, unsigned &cache_end, unsigned bin_count)
Definition: spreadsort_common.hpp:106
Definition: constants.hpp:35
Definition: constants.hpp:32
void negative_float_sort_rec(RandomAccessIter first, RandomAccessIter last, std::vector< RandomAccessIter > &bin_cache, unsigned cache_offset, size_t *bin_sizes)
Definition: float_sort.hpp:201
void positive_float_sort_rec(RandomAccessIter first, RandomAccessIter last, std::vector< RandomAccessIter > &bin_cache, unsigned cache_offset, size_t *bin_sizes)
Definition: float_sort.hpp:142
boost::enable_if_c< sizeof(boost::uint32_t)==sizeof(typename std::iterator_traits< RandomAccessIter >::value_type)&&std::numeric_limits< typename std::iterator_traits< RandomAccessIter >::value_type >::is_iec559, void >::type float_sort(RandomAccessIter first, RandomAccessIter last)
Definition: float_sort.hpp:679