update sources to v12.2.4

[ceph.git] / ceph / src / boost / libs / sort / test / float_sort_test.cpp

//  Boost Sort library float_sort_test.cpp file  -----------------------------//\r
\r
//  Copyright Steven Ross 2014. Use, modification and\r
//  distribution is subject to the Boost Software License, Version\r
//  1.0. (See accompanying file LICENSE_1_0.txt or copy at\r
//  http://www.boost.org/LICENSE_1_0.txt)\r
\r
//  See http://www.boost.org/libs/sort for library home page.\r
\r
#include <boost/sort/spreadsort/spreadsort.hpp>\r
// Include unit test framework\r
#include <boost/test/included/test_exec_monitor.hpp>\r
#include <boost/test/test_tools.hpp>\r
#include <vector>\r
\r
\r
using namespace std;\r
using namespace boost::sort::spreadsort;\r
\r
//Casting to an integer before bitshifting\r
struct rightshift {\r
  int operator()(const float &x, const unsigned offset) const { \r
    return float_mem_cast<float, int>(x) >> offset; \r
  }\r
};\r
\r
struct rightshift_64 {\r
  boost::int64_t operator()(const double &x, const boost::uint64_t offset) const\r
  { \r
    return float_mem_cast<double, boost::int64_t>(x) >> offset; \r
  }\r
};\r
\r
boost::int32_t \r
rand_32(bool sign = true) {\r
   boost::int32_t result = rand() | (rand()<< 16);\r
   if (rand() % 2)\r
     result |= 1 << 15;\r
   //Adding the sign bit\r
   if (sign && (rand() % 2))\r
     result *= -1;\r
   return result;\r
}\r
\r
static const unsigned input_count = 1000000;\r
\r
// Helper class to run tests across all float_sort interface variants.\r
template<class FloatType, class RightShift>\r
void test_vector(vector<FloatType> base_vec, RightShift shifter) {\r
  vector<FloatType> sorted_vec = base_vec;\r
  vector<FloatType> test_vec = base_vec;\r
  std::sort(sorted_vec.begin(), sorted_vec.end());\r
  //Testing boost::sort::spreadsort version\r
  test_vec = base_vec;\r
  boost::sort::spreadsort::spreadsort(test_vec.begin(), test_vec.end());\r
  BOOST_CHECK(test_vec == sorted_vec);\r
  //One functor\r
  test_vec = base_vec;\r
  float_sort(test_vec.begin(), test_vec.end(), shifter);\r
  BOOST_CHECK(test_vec == sorted_vec);\r
  //Both functors\r
  test_vec = base_vec;\r
  float_sort(test_vec.begin(), test_vec.end(), shifter, less<FloatType>());\r
  BOOST_CHECK(test_vec == sorted_vec);\r
}\r
\r
void float_test()\r
{\r
  // Prepare inputs\r
  vector<float> base_vec;\r
\r
  //Generating semirandom numbers that will work for basic testing\r
  for (unsigned u = 0; u < input_count; ++u) {\r
    float val = float(rand_32());\r
    //As std::sort gives arbitrary results for NaNs and 0.0 vs. -0.0, treat all\r
    //those as just 0.0 for testing\r
    if (!(val < 0.0) && !(0.0 < val))\r
      base_vec.push_back(0.0);\r
    else\r
      base_vec.push_back(val);\r
  }\r
  test_vector(base_vec, rightshift());\r
\r
  // Trying both positive and negative sorted and reverse sorted data.\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(-i);\r
  test_vector(base_vec, rightshift());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i - input_count);\r
  test_vector(base_vec, rightshift());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(input_count - i);\r
  test_vector(base_vec, rightshift());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i);\r
  test_vector(base_vec, rightshift());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i);\r
  for (size_t i = 0; i < input_count; i += 2) base_vec[i] *= -1;\r
  test_vector(base_vec, rightshift());\r
}\r
\r
void double_test() {\r
  vector<double> base_vec;\r
  for (unsigned u = 0; u < input_count; ++u) {\r
    double val = double\r
    ((((boost::int64_t)rand_32()) << ((8 * sizeof(int)) -1)) + rand_32(false));\r
    //As std::sort gives arbitrary results for NaNs and 0.0 vs. -0.0, \r
    //treat all those as just 0.0 for testing\r
    if (!(val < 0.0) && !(0.0 < val))\r
      base_vec.push_back(0.0);\r
    else\r
      base_vec.push_back(val);\r
  }\r
  test_vector(base_vec, rightshift_64());\r
\r
  // Trying both positive and negative sorted and reverse sorted data.\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(-i);\r
  test_vector(base_vec, rightshift_64());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i - input_count);\r
  test_vector(base_vec, rightshift_64());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(input_count - i);\r
  test_vector(base_vec, rightshift_64());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i);\r
  test_vector(base_vec, rightshift_64());\r
  base_vec.clear();\r
  for (size_t i = 0; i < input_count; ++i) base_vec.push_back(i);\r
  for (size_t i = 0; i < input_count; i += 2) base_vec[i] *= -1;\r
  test_vector(base_vec, rightshift_64());\r
}\r
\r
// Verify that 0 and 1 elements work correctly.\r
void corner_test() {\r
  vector<float> test_vec;\r
  boost::sort::spreadsort::spreadsort(test_vec.begin(), test_vec.end());\r
  const float test_value = -0.0;\r
  test_vec.push_back(test_value);\r
  boost::sort::spreadsort::spreadsort(test_vec.begin(), test_vec.end());\r
  BOOST_CHECK(test_vec.size() == 1);\r
  BOOST_CHECK(test_vec[0] == test_value);\r
}\r
\r
// test main \r
int test_main( int, char*[] )\r
{\r
  srand(1);\r
  float_test();\r
  double_test();\r
  corner_test();\r
  return 0;\r
}\r