diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..ef83f48 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,5 @@ +{ + "githubPullRequests.ignoredPullRequestBranches": [ + "develop" + ] +} \ No newline at end of file diff --git a/benchmark/parallel/benchmark_numbers.cpp b/benchmark/parallel/benchmark_numbers.cpp index edf139b..5883ca4 100644 --- a/benchmark/parallel/benchmark_numbers.cpp +++ b/benchmark/parallel/benchmark_numbers.cpp @@ -50,8 +50,7 @@ void Generator_reverse_sorted (void); void Generator_reverse_sorted_end (size_t n_last); void Generator_reverse_sorted_middle (size_t n_last); -template -int Test (std::vector &B, compare comp = compare ()); +void Test (std::vector &B); int main (int argc, char *argv[]) { @@ -66,205 +65,203 @@ int main (int argc, char *argv[]) cout << "************************************************************\n"; cout << std::endl; - cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; - cout<<"[ 3 ] parallel_stable_sort\n\n"; - cout<<" | | | |\n"; - cout<<" | [ 1 ]| [ 2 ]| [ 3 ]|\n"; - cout<<"--------------------+------+------+------+\n"; + cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; + cout << "[ 3 ] parallel_stable_sort\n\n"; + cout << " | | | |\n"; + cout << " | [ 1 ]| [ 2 ]| [ 3 ]|\n"; + cout << "--------------------+------+------+------+\n"; std::string empty_line = " | | | |\n"; - cout<<"random |"; + cout << "random |"; Generator_random (); - cout< A; + vector A; A.reserve (NELEM); A.clear (); if (fill_vector_uint64 ("input.bin", A, NELEM) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - Test> (A); -} -; -void -Generator_sorted (void) + Test (A); +}; +void Generator_sorted (void) { - vector A; - + std::vector A; A.reserve (NELEM); A.clear (); - for (size_t i = 0; i < NELEM; ++i) + for (uint64_t i = 0; i < NELEM; ++i) A.push_back (i); - Test> (A); - -} - -void Generator_sorted_end (size_t n_last) + Test (A); +}; +void Generator_sorted_end (uint64_t n_last) { - vector A; + std::vector A; A.reserve (NELEM); A.clear (); if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; std::sort (A.begin (), A.begin () + NELEM); - - Test> (A); - -} -; -void Generator_sorted_middle (size_t n_last) + Test (A); +}; +void Generator_sorted_middle (uint64_t n_middle) { - vector A, B, C; - A.reserve (NELEM); - A.clear (); - if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) + assert (n_middle > 1 && NELEM >= (n_middle -1)); + std::vector A, aux; + A.reserve (NELEM + n_middle); + aux.reserve (n_middle); + + if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for (size_t i = NELEM; i < A.size (); ++i) - B.push_back (std::move (A[i])); - A.resize ( NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]); - std::sort (A.begin (), A.end ()); - size_t step = NELEM / n_last + 1; - size_t pos = 0; + std::sort (A.begin () + n_middle, A.end ()); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + uint64_t step = NELEM / (n_middle - 1); + A [0] = aux [0]; + uint64_t pos_read = n_middle, pos_write = 1; - for (size_t i = 0; i < B.size (); ++i, pos += step) + for (uint64_t i = 1; i < n_middle; ++i) { - C.push_back (B[i]); - for (size_t k = 0; k < step; ++k) - C.push_back (A[pos + k]); + for (uint64_t k = 0 ; k < step; ++k) + A [pos_write ++] = A [pos_read ++]; + A [pos_write ++] = aux [i]; }; - while (pos < A.size ()) - C.push_back (A[pos++]); - A = C; - Test> (A); -} -; + aux.clear (); + aux.reserve (0); + Test (A); +}; void Generator_reverse_sorted (void) { - vector A; - + std::vector A; A.reserve (NELEM); A.clear (); - for (size_t i = NELEM; i > 0; --i) + for (uint64_t i = NELEM; i > 0; --i) A.push_back (i); - Test> (A); -} -void Generator_reverse_sorted_end (size_t n_last) + Test (A); +}; +void Generator_reverse_sorted_end (uint64_t n_last) { - vector A; + std::vector A; A.reserve (NELEM); A.clear (); if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; std::sort (A.begin (), A.begin () + NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < (NELEM >> 1); ++i) + std::swap (A [i], A [NELEM - 1 - i]); - Test> (A); + Test (A); } -void Generator_reverse_sorted_middle (size_t n_last) +void Generator_reverse_sorted_middle (uint64_t n_middle) { - vector A, B, C; - A.reserve (NELEM); - A.clear (); - if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) + assert (n_middle > 1 && NELEM >= (n_middle -1)); + std::vector A, aux; + A.reserve (NELEM + n_middle); + aux.reserve (n_middle); + + if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for (size_t i = NELEM; i < A.size (); ++i) - B.push_back (std::move (A[i])); - A.resize ( NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]); - std::sort (A.begin (), A.end ()); - size_t step = NELEM / n_last + 1; - size_t pos = 0; + std::sort (A.begin () + n_middle, A.end ()); + uint64_t pos1 = n_middle, pos2 = A.size () - 1; + for (uint64_t i = 0; i < (NELEM >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + uint64_t step = NELEM / (n_middle - 1); + A [0] = aux [0]; + uint64_t pos_read = n_middle, pos_write = 1; - for (size_t i = 0; i < B.size (); ++i, pos += step) + for (uint64_t i = 1; i < n_middle; ++i) { - C.push_back (B[i]); - for (size_t k = 0; k < step; ++k) - C.push_back (A[pos + k]); + for (uint64_t k = 0 ; k < step; ++k) + A [pos_write ++] = A [pos_read ++]; + A [pos_write ++] = aux [i]; }; - while (pos < A.size ()) - C.push_back (A[pos++]); - A = C; - Test> (A); + aux.clear (); + aux.reserve (0); + Test (A); }; - -template -int Test (std::vector &B, compare comp) -{ //---------------------------- begin -------------------------------- +void Test (std::vector &B) +{ + //---------------------------- begin -------------------------------- + std::less comp ; double duration; time_point start, finish; - std::vector A (B); - std::vector V; + std::vector A (B); + std::vector V; //-------------------------------------------------------------------- A = B; @@ -291,11 +288,10 @@ int Test (std::vector &B, compare comp) //----------------------------------------------------------------------- // printing the vector //----------------------------------------------------------------------- - std::cout< #include #include "boost/sort/common/int_array.hpp" - #include -#define NELEM 100000000 -#define NMAXSTRING 10000000 - using namespace std; namespace bsc = boost::sort::common; namespace bsp = boost::sort; @@ -45,52 +41,38 @@ using bsc::int_array; using bsc::H_comp; using bsc::L_comp; - +template +void Generator_random (uint64_t N); template -void Generator_random(uint64_t N); +void Generator_sorted (uint64_t N); template -void Generator_sorted(uint64_t N); -template -void Generator_sorted_end(uint64_t N, size_t n_last ); +void Generator_sorted_end (uint64_t N, size_t n_last); template -void Generator_sorted_middle(uint64_t N, size_t n_last ); +void Generator_sorted_middle (uint64_t N, size_t n_middle); template -void Generator_reverse_sorted(uint64_t N); +void Generator_reverse_sorted (uint64_t N); template -void Generator_reverse_sorted_end(uint64_t N, size_t n_last ); +void Generator_reverse_sorted_end (uint64_t N, size_t n_last); template -void Generator_reverse_sorted_middle(uint64_t N, size_t n_last ); +void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle); -template < class IA > -struct H_rightshift { - inline uint64_t operator()(const IA& A1, unsigned offset) { - return A1.counter() >> offset; - } -}; - -template < class IA > -struct L_rightshift { - inline uint64_t operator()(const IA& A1, unsigned offset) { - return A1.M[0] >> offset; - } -}; - -template -int Test(std::vector &B, rightshift shift, compare comp, std::vector & V ); +template +void Test (std::vector &B, compare comp, std::vector & V ); template -void Test_size ( uint64_t N); +void Test_size (uint64_t N); -void Print_vectors ( std::vector & V1, std::vector & V2); +void Print_vectors (std::vector &V1, std::vector & V2); int main(int argc, char *argv[]) { + const uint64_t NELEM = 100000000; cout << "\n\n"; cout << "************************************************************\n"; cout << "** **\n"; @@ -172,320 +154,349 @@ int main(int argc, char *argv[]) template void Test_size ( uint64_t N) { - cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; - cout<<"[ 3 ] parallel_stable_sort\n\n"; + cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; + cout << "[ 3 ] parallel_stable_sort\n\n"; cout << " | [ 1 ] | [ 2 ] | [ 3 ] |\n"; cout << " | H L | H L | H L |\n"; cout << "--------------------+-----------+-----------+-----------+\n"; std::string empty_line = " | | | |\n"; - cout<<"random |"; - Generator_random(N); + cout << "random |"; + Generator_random (N); - cout<(N); + cout << empty_line; + cout << "sorted |"; + Generator_sorted (N); - cout<<"sorted + 0.1% end |"; - Generator_sorted_end(N, N / 1000); + cout << "sorted + 0.1% end |"; + Generator_sorted_end (N, N / 1000); - cout<<"sorted + 1% end |"; - Generator_sorted_end(N, N / 100); + cout << "sorted + 1% end |"; + Generator_sorted_end< IA> (N, N / 100); - cout<<"sorted + 10% end |"; - Generator_sorted_end(N, N / 10); + cout << "sorted + 10% end |"; + Generator_sorted_end (N, N / 10); - cout<(N, N / 1000); + cout << empty_line; + cout << "sorted + 0.1% mid |"; + Generator_sorted_middle (N, N / 1000); - cout<<"sorted + 1% mid |"; - Generator_sorted_middle(N, N / 100); + cout << "sorted + 1% mid |"; + Generator_sorted_middle (N, N / 100); - cout<<"sorted + 10% mid |"; - Generator_sorted_middle(N, N / 10); + cout << "sorted + 10% mid |"; + Generator_sorted_middle (N, N / 10); - cout<(N); + cout << empty_line; + cout << "reverse sorted |"; + Generator_reverse_sorted (N); - cout<<"rv sorted + 0.1% end|"; - Generator_reverse_sorted_end(N, N / 1000); + cout << "rv sorted + 0.1% end|"; + Generator_reverse_sorted_end (N, N / 1000); - cout<<"rv sorted + 1% end|"; - Generator_reverse_sorted_end(N, N / 100); + cout << "rv sorted + 1% end|"; + Generator_reverse_sorted_end (N, N / 100); - cout<<"rv sorted + 10% end|"; - Generator_reverse_sorted_end(N, N / 10); + cout << "rv sorted + 10% end|"; + Generator_reverse_sorted_end (N, N / 10); - cout<(N, N / 1000); + cout << empty_line; + cout << "rv sorted + 0.1% mid|"; + Generator_reverse_sorted_middle (N, N / 1000); - cout<<"rv sorted + 1% mid|"; - Generator_reverse_sorted_middle(N, N / 100); + cout << "rv sorted + 1% mid|"; + Generator_reverse_sorted_middle (N, N / 100); - cout<<"rv sorted + 10% mid|"; - Generator_reverse_sorted_middle(N, N / 10); - cout<< "--------------------+-----------+-----------+-----------+\n"; - cout< (N, N / 10); + cout << "--------------------+-----------+-----------+-----------+\n"; + cout << endl << endl << endl; } void Print_vectors ( std::vector & V1, std::vector & V2) { assert ( V1.size() == V2.size()); - std::cout< -void Generator_random(uint64_t N) +void Generator_random (uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate(gen)); - Test(A, H_rightshift(), H_comp(), V1); - - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, H_comp (), V1); + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; + template void Generator_sorted(uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen)); - std::sort( A.begin() , A.end(),H_comp() ); - Test(A, H_rightshift(), H_comp(), V1); + std::sort (A.begin (), A.end (), H_comp ()); + Test (A, H_comp (), V1); - std::sort( A.begin() , A.end(),L_comp() ); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + std::sort (A.begin (), A.end (), L_comp ()); + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_sorted_end(uint64_t N, size_t n_last ) +void Generator_sorted_end (uint64_t N, size_t n_last ) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); + gen.reset (); + A.clear (); for (uint32_t i = 0; i < (N + n_last); i++) - A.emplace_back(IA::generate(gen)); - std::sort ( A.begin() , A.begin() + N ,H_comp()); + A.emplace_back (IA::generate (gen)); + + std::sort (A.begin (), A.begin () + N, H_comp ()); - Test(A, H_rightshift(), H_comp(),V1); - std::sort ( A.begin() , A.begin() + N ,L_comp()); + Test (A, H_comp (), V1); + std::sort (A.begin (), A.begin () + N, L_comp ()); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_sorted_middle(uint64_t N, size_t n_last ) +void Generator_sorted_middle (uint64_t N, size_t n_middle ) { - bsc::uint64_file_generator gen("input.bin"); - std::vector V1, V2 ; - vector A; - A.reserve(N + n_last); + assert (n_middle > 1 && N >= (n_middle -1)); + bsc::uint64_file_generator gen ("input.bin"); + + std::vector V1, V2; // vector with the times used + vector A, aux; + A.reserve (N + n_middle); + aux.reserve (n_middle); + + //----------------------------------------------------------------------- + // H _ C O M P + //----------------------------------------------------------------------- + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), H_comp ()); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - { A.clear() ; - gen.reset(); - vector B, C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); - - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,H_comp()); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_comp (), V1); - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); + //---------------------------------------------------------------------- + // L _ C O M P + //----------------------------------------------------------------------- + gen.reset (); + A.clear (); + A.reserve (N + n_middle); + aux.clear (); + aux.reserve (n_middle); + + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), L_comp ()); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + pos_read = n_middle; + pos_write = 1; - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,L_comp()); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_reverse_sorted(uint64_t N) +void Generator_reverse_sorted (uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen)); - std::sort( A.begin() , A.end(),H_comp() ); - for ( size_t i = 0; i < (A.size() >>1) ; ++i) - std::swap ( A[i], A[A.size() - i -1 ]); + std::sort (A.begin (), A.end (), H_comp ()); + for (size_t i = 0; i < (A.size () >>1); ++i) + std::swap (A [i], A [A.size () - i - 1]); - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_comp (), V1); - std::sort( A.begin() , A.end(),L_comp() ); - for ( size_t i = 0; i < (A.size() >>1) ; ++i) - std::swap ( A[i], A[A.size() - i -1 ]); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + std::sort (A.begin (), A.end (), L_comp ()); + for (size_t i = 0; i < (A.size () >> 1); ++i) + std::swap (A [i], A [A.size() - i - 1]); + + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; -template -void Generator_reverse_sorted_end(uint64_t N, size_t n_last ) -{ - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; - gen.reset(); - A.clear(); +template +void Generator_reverse_sorted_end (uint64_t N, size_t n_last ) +{ + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; + + gen.reset (); + A.clear (); for (uint32_t i = 0; i < (N + n_last); i++) - A.emplace_back(IA::generate(gen)); - std::sort ( A.begin() , A.begin() + N ,H_comp()); - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( A[i], A[N-1-i]); + A.emplace_back (IA::generate (gen)); + + std::sort (A.begin (), A.begin () + N , H_comp ()); + for (size_t i =0 ; i < (N >> 1); ++i) + std::swap (A [i], A [N - 1 - i]); - Test(A, H_rightshift(), H_comp(), V1); - std::sort ( A.begin() , A.begin() + N ,L_comp()); - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( A[i], A[N-1-i]); + Test (A, H_comp (), V1); + std::sort (A.begin (), A.begin () + N, L_comp ()); + for (size_t i = 0; i < (N >> 1); ++i) + std::swap (A [i], A [N - 1 - i]); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; + template -void Generator_reverse_sorted_middle(uint64_t N, size_t n_last ) +void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle ) { - bsc::uint64_file_generator gen("input.bin"); - std::vector V1, V2 ; - vector A; - A.reserve(N + n_last); + assert (n_middle > 1 && N >= (n_middle -1)); + bsc::uint64_file_generator gen ("input.bin"); + + std::vector V1, V2; // vector with the times used + vector A, aux; + A.reserve (N + n_middle); + aux.reserve (n_middle); + + //----------------------------------------------------------------------- + // H _ C O M P + //----------------------------------------------------------------------- + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), H_comp ()); + uint64_t pos1 = n_middle, pos2 = A.size () - 1; + for (uint64_t i = 0; i < (N >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); - - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,H_comp()); - - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( C[i], C[N-1-i]); - - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++ ] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_comp (), V1); - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); + //---------------------------------------------------------------------- + // L _ C O M P + //----------------------------------------------------------------------- + gen.reset (); + A.clear (); + A.reserve (N + n_middle); + aux.clear (); + aux.reserve (n_middle); + + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), L_comp ()); + pos1 = n_middle; + pos2 = A.size () - 1; + for (uint64_t i = 0; i < (N >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + pos_read = n_middle; + pos_write = 1; - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,L_comp()); - - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( C[i], C[N-1-i]); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++ ] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_comp (), V2); + Print_vectors (V1, V2) ; }; -template -int Test (std::vector &B, rightshift shift, compare comp,std::vector &V) +template +void Test (std::vector &B, compare comp, std::vector &V) { //---------------------------- begin -------------------------------- double duration; time_point start, finish; @@ -514,52 +525,5 @@ int Test (std::vector &B, rightshift shift, compare comp,std::vector finish = now (); duration = subtract_time (finish, start); V.push_back (duration); - //cout << duration << " secs\n"; -/* - A = B; - start = now (); - spinsort (A.begin (), A.end (), comp); - finish = now (); - duration = subtract_time (finish, start); - V.push_back (duration); - A = B; - start = now (); - timsort (A.begin (), A.end (), comp); - finish = now (); - duration = subtract_time (finish, start); - V.push_back (duration); - - - A = B; - //cout << "Boost spreadsort : "; - int sorted_count = 0; - for (unsigned i = 0; i + 1 < A.size(); ++i) - { - if (comp(A[i], A[i+1])) - { - sorted_count++; - }; - }; - start = now (); - boost::sort::spreadsort::integer_sort (A.begin (), A.end (), shift, comp); - finish = now (); - duration = subtract_time (finish, start); - int identical = 0; - for (unsigned i = 0; i + 1 < A.size(); ++i) - { - if (A[i].counter() != sorted[i].counter()) - { - cout << "incorrect!" << std::endl; - } - if (!comp(A[i], A[i+1]) && !comp(A[i+1], A[i])) - { - identical++; - }; - }; - // cout << "identical: " << identical << " pre-sorted: " << sorted_count << std::endl; - V.push_back (duration); - //cout << duration << " secs\n"; -*/ - return 0; }; diff --git a/benchmark/parallel/benchmark_strings.cpp b/benchmark/parallel/benchmark_strings.cpp index 1f23821..8f861a1 100644 --- a/benchmark/parallel/benchmark_strings.cpp +++ b/benchmark/parallel/benchmark_strings.cpp @@ -40,18 +40,17 @@ using bsc::subtract_time; void Generator_random (void); -void Generator_sorted(void); -void Generator_sorted_end(size_t n_last); -void Generator_sorted_middle (size_t n_last); -void Generator_reverse_sorted(void); -void Generator_reverse_sorted_end(size_t n_last); -void Generator_reverse_sorted_middle(size_t n_last); +void Generator_sorted (void); +void Generator_sorted_end( size_t n_last); +void Generator_sorted_middle (size_t n_middle); +void Generator_reverse_sorted (void); +void Generator_reverse_sorted_end (size_t n_last); +void Generator_reverse_sorted_middle (size_t n_middle); -template -int Test(std::vector &B, compare comp = compare()); +void Test (std::vector &B); -int main(int argc, char *argv[]) +int main(int argc, char *argv []) { cout << "\n\n"; cout << "************************************************************\n"; @@ -64,212 +63,223 @@ int main(int argc, char *argv[]) cout << "************************************************************\n"; cout << std::endl; - cout<<"[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; - cout<<"[ 3 ] parallel_stable_sort\n\n"; - cout<<" | | | |\n"; - cout<<" | [ 1 ]| [ 2 ]| [ 3 ]|\n"; - cout<<"--------------------+------+------+------+\n"; + cout << "[ 1 ] block_indirect_sort [ 2 ] sample_sort\n"; + cout << "[ 3 ] parallel_stable_sort\n\n"; + cout << " | | | |\n"; + cout << " | [ 1 ]| [ 2 ]| [ 3 ]|\n"; + cout << "--------------------+------+------+------+\n"; std::string empty_line = " | | | |\n"; - cout<<"random |"; + cout << "random |"; Generator_random (); - cout< A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - Test>(A); - + Test (A); }; -void Generator_sorted(void) +void Generator_sorted (void) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort( A.begin() , A.end() ); - Test>(A); + std::sort (A.begin (), A.end ()); + Test (A); }; -void Generator_sorted_end(size_t n_last) +void Generator_sorted_end (size_t n_last) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING+ n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort (A.begin() , A.begin() + NMAXSTRING ); - Test>(A); + std::sort (A.begin (), A.begin () + NMAXSTRING ); + Test (A); }; -void Generator_sorted_middle(size_t n_last) +void Generator_sorted_middle (size_t n_middle) { - std::vector A,B,C; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0) + assert (n_middle > 1 && NMAXSTRING >= (n_middle -1)); + vector A, aux; + A.reserve (NMAXSTRING + n_middle); + aux.reserve (n_middle); + + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for ( size_t i = NMAXSTRING ; i < A.size() ; ++i) - B.push_back ( std::move ( A[i])); - A.resize ( NMAXSTRING); - std::sort (A.begin() , A.end() ); - size_t step = NMAXSTRING /n_last +1 ; - size_t pos = 0 ; + for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i])); - for ( size_t i =0 ; i < B.size() ; ++i, pos += step) - { C.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - C.push_back ( A[pos + k] ); + std::sort (A.begin () + n_middle, A.end ()); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = NMAXSTRING / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; + + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - while ( pos < A.size() ) C.push_back ( A[pos++]); - A = C ; - - Test>(A); + aux.clear (); + aux.reserve (0); + Test (A); }; - -void Generator_reverse_sorted(void) +void Generator_reverse_sorted (void) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) + std::vector A; + A.reserve (NMAXSTRING); + { + std::vector B; + B.reserve (NMAXSTRING); + if (bsc::fill_vector_string ("input.bin", B, NMAXSTRING) != 0) + { + std::cout << "Error in the input file\n"; + std::exit (EXIT_FAILURE); + }; + std::sort (B.begin(), B.end()); + A.clear (); + for (size_t i = 0; i < NMAXSTRING; ++i) + A.push_back (B [NMAXSTRING - 1 - i]); + }; + Test (A); +}; +void Generator_reverse_sorted_end (size_t n_last) +{ + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort( A.begin() , A.end()); - size_t nmid = (A.size() >>1), nlast = A.size() -1 ; - for (size_t i = 0 ; i < nmid ;++i) - std::swap ( A[i], A [nlast -i]); - - Test>(A); + std::sort (A.begin (), A.begin () + NMAXSTRING); + for (size_t i = 0; i < (NMAXSTRING >> 1); ++i) + std::swap (A [i], A [NMAXSTRING - 1 - i]); + Test (A); }; -void Generator_reverse_sorted_end(size_t n_last) +void Generator_reverse_sorted_middle (size_t n_middle) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0) + assert (n_middle > 1 && NMAXSTRING >= (n_middle -1)); + vector A, aux; + A.reserve (NMAXSTRING + n_middle); + aux.reserve (n_middle); + + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort (A.begin() , A.begin() + NMAXSTRING ); - for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i) - std::swap ( A[i], A[NMAXSTRING - 1 - i]); + for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i])); - Test>(A); + std::sort (A.begin () + n_middle, A.end ()); + + size_t pos1 = n_middle, pos2 = A.size () - 1; + for (size_t i = 0; i < (NMAXSTRING >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = NMAXSTRING / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; -}; -void Generator_reverse_sorted_middle(size_t n_last) -{ - std::vector A,B,C; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0) + for (size_t i = 1; i < n_middle; ++i) { - std::cout << "Error in the input file\n"; - return; + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - for ( size_t i = NMAXSTRING ; i < A.size() ; ++i) - B.push_back ( std::move ( A[i])); - A.resize ( NMAXSTRING); - - std::sort (A.begin() , A.end() ); - for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i) - std::swap ( A[i], A[NMAXSTRING - 1 - i]); - - size_t step = NMAXSTRING /n_last +1 ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i, pos += step) - { C.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - C.push_back ( A[pos + k] ); - }; - while ( pos < A.size() ) - C.push_back ( A[pos++]); - A = C ; - - Test>(A); + aux.clear (); + aux.reserve (0); + Test (A); }; - -template -int Test (std::vector &B, compare comp) +void Test (std::vector &B) { //---------------------------- begin -------------------------------- + std::less comp; double duration; time_point start, finish; - std::vector A (B); - std::vector V; + std::vector A (B); + std::vector V; //-------------------------------------------------------------------- A = B; @@ -296,11 +306,11 @@ int Test (std::vector &B, compare comp) //----------------------------------------------------------------------- // printing the vector //----------------------------------------------------------------------- - std::cout< -int Test (std::vector &B, compare comp = compare ()); +void Test (const std::vector &B); int main (int argc, char *argv[]) { @@ -129,34 +128,28 @@ int main (int argc, char *argv[]) cout< A; + vector A; A.reserve (NELEM); A.clear (); if (fill_vector_uint64 ("input.bin", A, NELEM) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - Test> (A); -} -; -void -Generator_sorted (void) + Test (A); +}; +void Generator_sorted (void) { vector A; - A.reserve (NELEM); A.clear (); - for (size_t i = 0; i < NELEM; ++i) + for (uint64_t i = 0; i < NELEM; ++i) A.push_back (i); - Test> (A); - -} - -void Generator_sorted_end (size_t n_last) + Test (A); +}; +void Generator_sorted_end (uint64_t n_last) { vector A; A.reserve (NELEM); @@ -164,112 +157,115 @@ void Generator_sorted_end (size_t n_last) if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; std::sort (A.begin (), A.begin () + NELEM); - - Test> (A); - -} -; -void Generator_sorted_middle (size_t n_last) + Test (A); +}; +void Generator_sorted_middle (uint64_t n_middle) { - vector A, B, C; - A.reserve (NELEM); - A.clear (); - if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) + assert (n_middle > 1 && NELEM >= (n_middle -1)); + vector A, aux; + A.reserve (NELEM + n_middle); + aux.reserve (n_middle); + + if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for (size_t i = NELEM; i < A.size (); ++i) - B.push_back (std::move (A[i])); - A.resize ( NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]); - std::sort (A.begin (), A.end ()); - size_t step = NELEM / n_last + 1; - size_t pos = 0; + std::sort (A.begin () + n_middle, A.end ()); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + uint64_t step = NELEM / (n_middle - 1); + A [0] = aux [0]; + uint64_t pos_read = n_middle, pos_write = 1; - for (size_t i = 0; i < B.size (); ++i, pos += step) + for (uint64_t i = 1; i < n_middle; ++i) { - C.push_back (B[i]); - for (size_t k = 0; k < step; ++k) - C.push_back (A[pos + k]); + for (uint64_t k = 0 ; k < step; ++k) + A [pos_write ++] = A [pos_read ++]; + A [pos_write ++] = aux [i]; }; - while (pos < A.size ()) - C.push_back (A[pos++]); - A = C; - Test> (A); -} -; + aux.clear (); + aux.reserve (0); + Test (A); +}; void Generator_reverse_sorted (void) { vector A; - A.reserve (NELEM); A.clear (); - for (size_t i = NELEM; i > 0; --i) + for (uint64_t i = NELEM; i > 0; --i) A.push_back (i); - Test> (A); -} -void Generator_reverse_sorted_end (size_t n_last) + Test (A); +}; +void Generator_reverse_sorted_end (uint64_t n_last) { - vector A; + vector A; A.reserve (NELEM); A.clear (); if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; std::sort (A.begin (), A.begin () + NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < (NELEM >> 1); ++i) + std::swap (A [i], A [NELEM - 1 - i]); - Test> (A); + Test (A); } -void Generator_reverse_sorted_middle (size_t n_last) +void Generator_reverse_sorted_middle (uint64_t n_middle) { - vector A, B, C; - A.reserve (NELEM); - A.clear (); - if (fill_vector_uint64 ("input.bin", A, NELEM + n_last) != 0) + assert (n_middle > 1 && NELEM >= (n_middle -1)); + vector A, aux; + A.reserve (NELEM + n_middle); + aux.reserve (n_middle); + + if (fill_vector_uint64 ("input.bin", A, NELEM + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for (size_t i = NELEM; i < A.size (); ++i) - B.push_back (std::move (A[i])); - A.resize ( NELEM); - for (size_t i = 0; i < (NELEM >> 1); ++i) - std::swap (A[i], A[NELEM - 1 - i]); + for (uint64_t i = 0; i < n_middle; ++i) aux.push_back (A [i]); - std::sort (A.begin (), A.end ()); - size_t step = NELEM / n_last + 1; - size_t pos = 0; + std::sort (A.begin () + n_middle, A.end ()); + uint64_t pos1 = n_middle, pos2 = A.size () - 1; + for (uint64_t i = 0; i < (NELEM >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + uint64_t step = NELEM / (n_middle - 1); + A [0] = aux [0]; + uint64_t pos_read = n_middle, pos_write = 1; - for (size_t i = 0; i < B.size (); ++i, pos += step) + for (uint64_t i = 1; i < n_middle; ++i) { - C.push_back (B[i]); - for (size_t k = 0; k < step; ++k) - C.push_back (A[pos + k]); + for (uint64_t k = 0 ; k < step; ++k) + A [pos_write ++] = A [pos_read ++]; + A [pos_write ++] = aux [i]; }; - while (pos < A.size ()) - C.push_back (A[pos++]); - A = C; - Test> (A); + aux.clear (); + aux.reserve (0); + Test (A); }; - - -template -int Test (std::vector &B, compare comp) -{ //---------------------------- begin -------------------------------- +void Test (const std::vector &B) +{ + //---------------------------- begin -------------------------------- + std::less comp ; double duration; time_point start, finish; - std::vector A (B); - std::vector V; + std::vector A (B); + std::vector V; //-------------------------------------------------------------------- A = B; @@ -307,7 +303,6 @@ int Test (std::vector &B, compare comp) duration = subtract_time (finish, start); V.push_back (duration); - A = B; start = now (); spreadsort (A.begin (), A.end ()); @@ -318,11 +313,10 @@ int Test (std::vector &B, compare comp) //----------------------------------------------------------------------- // printing the vector //----------------------------------------------------------------------- - std::cout< #include #include "boost/sort/common/int_array.hpp" - #include - -#define NELEM 100000000 -#define NMAXSTRING 10000000 - using namespace std; namespace bsort = boost::sort; namespace bsc = bsort::common; @@ -54,49 +49,55 @@ using bsort::pdqsort; template -void Generator_random(uint64_t N); +void Generator_random (uint64_t N); template -void Generator_sorted(uint64_t N); +void Generator_sorted (uint64_t N); template -void Generator_sorted_end(uint64_t N, size_t n_last ); +void Generator_sorted_end (uint64_t N, size_t n_last ); template -void Generator_sorted_middle(uint64_t N, size_t n_last ); +void Generator_sorted_middle (uint64_t N, size_t n_middle ); template -void Generator_reverse_sorted(uint64_t N); +void Generator_reverse_sorted (uint64_t N); template -void Generator_reverse_sorted_end(uint64_t N, size_t n_last ); +void Generator_reverse_sorted_end (uint64_t N, size_t n_last ); template -void Generator_reverse_sorted_middle(uint64_t N, size_t n_last ); +void Generator_reverse_sorted_middle (uint64_t N, size_t n_midlle ); -template < class IA > -struct H_rightshift { - inline uint64_t operator()(const IA& A1, unsigned offset) { - return A1.counter() >> offset; - } +template +struct H_rightshift +{ + inline uint64_t operator () (const IA& A1, unsigned offset) + { + return A1.counter () >> offset; + }; }; -template < class IA > -struct L_rightshift { - inline uint64_t operator()(const IA& A1, unsigned offset) { - return A1.M[0] >> offset; - } +template +struct L_rightshift +{ + inline uint64_t operator () (const IA& A1, unsigned offset) + { + return A1.M[0] >> offset; + }; }; template -int Test(std::vector &B, rightshift shift, compare comp, std::vector & V ); +int Test (std::vector< IA> &B, rightshift shift, + compare comp, std::vector & V ); template -void Test_size ( uint64_t N); +void Test_size (uint64_t N); -void Print_vectors ( std::vector & V1, std::vector & V2); +void Print_vectors ( std::vector &V1, std::vector &V2); -int main(int argc, char *argv[]) +int main(int argc, char *argv []) { + const uint64_t NELEM = 100000000; cout << "\n\n"; cout << "************************************************************\n"; cout << "** **\n"; @@ -130,7 +131,7 @@ int main(int argc, char *argv[]) cout << "** **\n"; cout << "************************************************************\n"; - Test_size >(NELEM); + Test_size >(NELEM); //----------------------------------------------------------------------- // I N T _ A R R A Y < 4 > @@ -140,7 +141,7 @@ int main(int argc, char *argv[]) cout << " "<<(NELEM >>2)<<" OBJECTS UINT64_T [4]\n"; cout << "** **\n"; cout << "************************************************************\n"; - Test_size >(NELEM >> 2); + Test_size >(NELEM >> 2); //----------------------------------------------------------------------- // I N T _ A R R A Y < 8 > @@ -150,7 +151,7 @@ int main(int argc, char *argv[]) cout << " "<<(NELEM >>3)<<" OBJECTS UINT64_T [8]\n"; cout << "** **\n"; cout << "************************************************************\n"; - Test_size >(NELEM >> 3); + Test_size >(NELEM >> 3); //----------------------------------------------------------------------- // I N T _ A R R A Y < 1 6 > @@ -160,7 +161,7 @@ int main(int argc, char *argv[]) cout << " "<<(NELEM >>4)<<" OBJECTS UINT64_T [16]\n"; cout << "** **\n"; cout << "************************************************************\n"; - Test_size >(NELEM >> 4); + Test_size >(NELEM >> 4); //----------------------------------------------------------------------- // I N T _ A R R A Y < 6 4 > @@ -170,13 +171,13 @@ int main(int argc, char *argv[]) cout << " "<< (NELEM >>6)<<" OBJECTS UINT64_T [64]\n"; cout << "** **\n"; cout << "************************************************************\n"; - Test_size >(NELEM >> 6); + Test_size >(NELEM >> 6); return 0; } template -void Test_size ( uint64_t N) +void Test_size (uint64_t N) { cout<<"\n"; cout<<"[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort \n"; @@ -197,317 +198,349 @@ void Test_size ( uint64_t N) " | | | |\n"; cout<<"random |"; - Generator_random(N); + Generator_random (N); cout<(N); + Generator_sorted (N); cout<<"sorted + 0.1% end |"; - Generator_sorted_end(N, N / 1000); + Generator_sorted_end (N, N / 1000); cout<<"sorted + 1% end |"; - Generator_sorted_end(N, N / 100); + Generator_sorted_end (N, N / 100); cout<<"sorted + 10% end |"; - Generator_sorted_end(N, N / 10); + Generator_sorted_end (N, N / 10); cout<(N, N / 1000); + Generator_sorted_middle (N, N / 1000); cout<<"sorted + 1% mid |"; - Generator_sorted_middle(N, N / 100); + Generator_sorted_middle (N, N / 100); cout<<"sorted + 10% mid |"; - Generator_sorted_middle(N, N / 10); + Generator_sorted_middle (N, N / 10); cout<(N); + Generator_reverse_sorted (N); cout<<"rv sorted + 0.1% end|"; - Generator_reverse_sorted_end(N, N / 1000); + Generator_reverse_sorted_end (N, N / 1000); cout<<"rv sorted + 1% end|"; - Generator_reverse_sorted_end(N, N / 100); + Generator_reverse_sorted_end (N, N / 100); cout<<"rv sorted + 10% end|"; - Generator_reverse_sorted_end(N, N / 10); + Generator_reverse_sorted_end (N, N / 10); cout<(N, N / 1000); + Generator_reverse_sorted_middle (N, N / 1000); cout<<"rv sorted + 1% mid|"; - Generator_reverse_sorted_middle(N, N / 100); + Generator_reverse_sorted_middle (N, N / 100); cout<<"rv sorted + 10% mid|"; - Generator_reverse_sorted_middle(N, N / 10); - cout<< "--------------------+-----------+-----------+-----------+"; + Generator_reverse_sorted_middle (N, N / 10); + cout << "--------------------+-----------+-----------+-----------+"; cout << "-----------+-----------+-----------+\n"; cout< & V1, std::vector & V2) { - assert ( V1.size() == V2.size()); - std::cout< -void Generator_random(uint64_t N) +void Generator_random (uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate(gen)); - Test(A, H_rightshift(), H_comp(), V1); - - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test(A, H_rightshift (), H_comp (), V1); + Test(A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; + template void Generator_sorted(uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen)); - std::sort( A.begin() , A.end(),H_comp() ); - Test(A, H_rightshift(), H_comp(), V1); + std::sort (A.begin (), A.end (), H_comp ()); + Test (A, H_rightshift (), H_comp (), V1); - std::sort( A.begin() , A.end(),L_comp() ); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + std::sort (A.begin (), A.end (), L_comp ()); + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_sorted_end(uint64_t N, size_t n_last ) +void Generator_sorted_end (uint64_t N, size_t n_last ) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); + gen.reset (); + A.clear (); for (uint32_t i = 0; i < (N + n_last); i++) - A.emplace_back(IA::generate(gen)); - std::sort ( A.begin() , A.begin() + N ,H_comp()); + A.emplace_back (IA::generate (gen)); + + std::sort (A.begin (), A.begin () + N, H_comp ()); - Test(A, H_rightshift(), H_comp(),V1); - std::sort ( A.begin() , A.begin() + N ,L_comp()); + Test (A, H_rightshift (), H_comp (), V1); + std::sort (A.begin (), A.begin () + N, L_comp ()); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_sorted_middle(uint64_t N, size_t n_last ) +void Generator_sorted_middle (uint64_t N, size_t n_middle ) { - bsc::uint64_file_generator gen("input.bin"); - std::vector V1, V2 ; - vector A; - A.reserve(N + n_last); + assert (n_middle > 1 && N >= (n_middle -1)); + bsc::uint64_file_generator gen ("input.bin"); + + std::vector V1, V2; // vector with the times used + vector A, aux; + A.reserve (N + n_middle); + aux.reserve (n_middle); + + //----------------------------------------------------------------------- + // H _ C O M P + //----------------------------------------------------------------------- + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), H_comp ()); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - { A.clear() ; - gen.reset(); - vector B, C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); - - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,H_comp()); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_rightshift (), H_comp (), V1); - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); + //---------------------------------------------------------------------- + // L _ C O M P + //----------------------------------------------------------------------- + gen.reset (); + A.clear (); + A.reserve (N + n_middle); + aux.clear (); + aux.reserve (n_middle); + + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), L_comp ()); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + pos_read = n_middle; + pos_write = 1; - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,L_comp()); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; template -void Generator_reverse_sorted(uint64_t N) +void Generator_reverse_sorted (uint64_t N) { - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; - gen.reset(); - A.clear(); - for (uint32_t i = 0; i < N; i++) A.emplace_back(IA::generate(gen)); + gen.reset (); + A.clear (); + for (uint32_t i = 0; i < N; i++) A.emplace_back (IA::generate (gen)); - std::sort( A.begin() , A.end(),H_comp() ); - for ( size_t i = 0; i < (A.size() >>1) ; ++i) - std::swap ( A[i], A[A.size() - i -1 ]); + std::sort (A.begin (), A.end (), H_comp ()); + for (size_t i = 0; i < (A.size () >>1); ++i) + std::swap (A [i], A [A.size () - i - 1]); - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_rightshift (), H_comp (), V1); - std::sort( A.begin() , A.end(),L_comp() ); - for ( size_t i = 0; i < (A.size() >>1) ; ++i) - std::swap ( A[i], A[A.size() - i -1 ]); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + std::sort (A.begin (), A.end (), L_comp ()); + for (size_t i = 0; i < (A.size () >> 1); ++i) + std::swap (A [i], A [A.size() - i - 1]); + + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; -template -void Generator_reverse_sorted_end(uint64_t N, size_t n_last ) -{ - bsc::uint64_file_generator gen("input.bin"); - vector A; - A.reserve(N); - std::vector V1, V2 ; - gen.reset(); - A.clear(); +template +void Generator_reverse_sorted_end (uint64_t N, size_t n_last ) +{ + bsc::uint64_file_generator gen ("input.bin"); + vector A; + A.reserve (N); + std::vector V1, V2 ; + + gen.reset (); + A.clear (); for (uint32_t i = 0; i < (N + n_last); i++) - A.emplace_back(IA::generate(gen)); - std::sort ( A.begin() , A.begin() + N ,H_comp()); - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( A[i], A[N-1-i]); + A.emplace_back (IA::generate (gen)); + + std::sort (A.begin (), A.begin () + N , H_comp ()); + for (size_t i =0 ; i < (N >> 1); ++i) + std::swap (A [i], A [N - 1 - i]); - Test(A, H_rightshift(), H_comp(), V1); - std::sort ( A.begin() , A.begin() + N ,L_comp()); - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( A[i], A[N-1-i]); + Test (A, H_rightshift (), H_comp (), V1); + std::sort (A.begin (), A.begin () + N, L_comp ()); + for (size_t i = 0; i < (N >> 1); ++i) + std::swap (A [i], A [N - 1 - i]); - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; + template -void Generator_reverse_sorted_middle(uint64_t N, size_t n_last ) +void Generator_reverse_sorted_middle (uint64_t N, size_t n_middle ) { - bsc::uint64_file_generator gen("input.bin"); - std::vector V1, V2 ; - vector A; - A.reserve(N + n_last); + assert (n_middle > 1 && N >= (n_middle -1)); + bsc::uint64_file_generator gen ("input.bin"); + + std::vector V1, V2; // vector with the times used + vector A, aux; + A.reserve (N + n_middle); + aux.reserve (n_middle); + + //----------------------------------------------------------------------- + // H _ C O M P + //----------------------------------------------------------------------- + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), H_comp ()); + uint64_t pos1 = n_middle, pos2 = A.size () - 1; + for (uint64_t i = 0; i < (N >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); - - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,H_comp()); - - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( C[i], C[N-1-i]); - - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++ ] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, H_rightshift(), H_comp(), V1); + Test (A, H_rightshift (), H_comp (), V1); - { A.clear() ; - gen.reset(); - vector B,C; - C.reserve(N + n_last); - B.reserve ( n_last); - for (uint32_t i = 0; i < (N + n_last); i++) - C.emplace_back(IA::generate(gen)); + //---------------------------------------------------------------------- + // L _ C O M P + //----------------------------------------------------------------------- + gen.reset (); + A.clear (); + A.reserve (N + n_middle); + aux.clear (); + aux.reserve (n_middle); + + for (uint32_t i = 0; i < (N + n_middle); i++) + A.emplace_back (IA::generate (gen)); + + for (size_t i = 0; i < n_middle; ++i) + aux.push_back (std::move (A [i])); + + std::sort (A.begin () + n_middle, A.end (), L_comp ()); + pos1 = n_middle; + pos2 = A.size () - 1; + for (uint64_t i = 0; i < (N >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + step = N / (n_middle - 1); + A [0] = std::move (aux [0]); + pos_read = n_middle; + pos_write = 1; - for ( size_t i = N ; i < C.size() ; ++i) - B.push_back ( std::move ( C[i])); - - C.resize ( N); - - std::sort ( C.begin() , C.end() ,L_comp()); - - for ( size_t i =0 ; i < (N>>1); ++i) - std::swap ( C[i], C[N-1-i]); - size_t step = N /n_last ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i) - { A.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - A.push_back ( C[pos++ ] ); - }; - while ( pos < C.size() ) - A.push_back ( C[pos++]); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - Test(A, L_rightshift(), L_comp(), V2); - Print_vectors ( V1, V2 ) ; + Test (A, L_rightshift (), L_comp (), V2); + Print_vectors (V1, V2) ; }; -template -int Test (std::vector &B, rightshift shift, compare comp,std::vector &V) +template +int Test (std::vector &B, rightshift shift, + compare comp, std::vector &V) { //---------------------------- begin -------------------------------- double duration; time_point start, finish; - std::vector A (B); - V.clear() ; + std::vector A (B); + V.clear () ; //-------------------------------------------------------------------- A = B; diff --git a/benchmark/single/benchmark_strings.cpp b/benchmark/single/benchmark_strings.cpp index df63f8f..7332f36 100644 --- a/benchmark/single/benchmark_strings.cpp +++ b/benchmark/single/benchmark_strings.cpp @@ -47,18 +47,17 @@ using bsort::spreadsort::spreadsort; using bsort::pdqsort; void Generator_random (void); -void Generator_sorted(void); -void Generator_sorted_end(size_t n_last); +void Generator_sorted (void); +void Generator_sorted_end (size_t n_last); void Generator_sorted_middle (size_t n_last); -void Generator_reverse_sorted(void); -void Generator_reverse_sorted_end(size_t n_last); -void Generator_reverse_sorted_middle(size_t n_last); +void Generator_reverse_sorted (void); +void Generator_reverse_sorted_end (size_t n_last); +void Generator_reverse_sorted_middle (size_t n_last); -template -int Test(std::vector &B, compare comp = compare()); +int Test (std::vector &B); -int main(int argc, char *argv[]) +int main (int argc, char *argv []) { cout << "\n\n"; cout << "************************************************************\n"; @@ -72,232 +71,224 @@ int main(int argc, char *argv[]) cout << "************************************************************\n"; cout << std::endl; - cout<<"[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort \n"; - cout<<"[ 4 ] spinsort [ 5 ] flat_stable_sort [ 6 ] spreadsort\n\n"; - cout<<" | | | | | | |\n"; - cout<<" | [ 1 ]| [ 2 ]| [ 3 ]| [ 4 ]| [ 5 ]| [ 6 ]|\n"; - cout<<"--------------------+------+------+------+------+------+------+\n"; + cout << "[ 1 ] std::sort [ 2 ] pdqsort [ 3 ] std::stable_sort\n"; + cout << "[ 4 ] spinsort [ 5 ] flat_stable_sort [ 6 ] spreadsort\n\n"; + cout << " | | | | | | |\n"; + cout << " | [ 1 ]| [ 2 ]| [ 3 ]| [ 4 ]| [ 5 ]| [ 6 ]|\n"; + cout << "--------------------+------+------+------+------+------+------+\n"; std::string empty_line = " | | | | | | |\n"; - cout<<"random |"; + cout << "random |"; Generator_random (); - cout< A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - Test>(A); - + Test (A); }; -void Generator_sorted(void) +void Generator_sorted (void) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort( A.begin() , A.end() ); - Test>(A); + std::sort (A.begin (), A.end ()); + Test (A); }; -void Generator_sorted_end(size_t n_last) +void Generator_sorted_end (size_t n_last) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING+ n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort (A.begin() , A.begin() + NMAXSTRING ); - Test>(A); + std::sort (A.begin (), A.begin () + NMAXSTRING ); + Test (A); }; -void Generator_sorted_middle(size_t n_last) +void Generator_sorted_middle (size_t n_middle) { - std::vector A,B,C; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0) + assert (n_middle > 1 && NMAXSTRING >= (n_middle -1)); + vector A, aux; + A.reserve (NMAXSTRING + n_middle); + aux.reserve (n_middle); + + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for ( size_t i = NMAXSTRING ; i < A.size() ; ++i) - B.push_back ( std::move ( A[i])); - A.resize ( NMAXSTRING); - std::sort (A.begin() , A.end() ); - size_t step = NMAXSTRING /n_last +1 ; - size_t pos = 0 ; + for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i])); - for ( size_t i =0 ; i < B.size() ; ++i, pos += step) - { C.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - C.push_back ( A[pos + k] ); - }; - while ( pos < A.size() ) C.push_back ( A[pos++]); - A = C ; + std::sort (A.begin () + n_middle, A.end ()); + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = NMAXSTRING / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - Test>(A); -}; - -void Generator_reverse_sorted(void) -{ - - std::vector A; - A.reserve(NMAXSTRING); + for (size_t i = 1; i < n_middle; ++i) { - std::vector B; - B.reserve(NMAXSTRING); - if (bsc::fill_vector_string("input.bin", B, NMAXSTRING) != 0) + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); + }; + aux.clear (); + aux.reserve (0); + Test (A); +}; +void Generator_reverse_sorted (void) +{ + std::vector A; + A.reserve (NMAXSTRING); + { + std::vector B; + B.reserve (NMAXSTRING); + if (bsc::fill_vector_string ("input.bin", B, NMAXSTRING) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort(B.begin(), B.end()); - A.clear(); + std::sort (B.begin(), B.end()); + A.clear (); for (size_t i = 0; i < NMAXSTRING; ++i) - A.push_back(B[NMAXSTRING - 1 - i]); + A.push_back (B [NMAXSTRING - 1 - i]); }; - Test>(A); - -/* - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING) != 0) - { - std::cout << "Error in the input file\n"; - return; - }; - std::sort( A.begin() , A.end()); - size_t nmid = (A.size() >>1), nlast = A.size() -1 ; - for (size_t i = 0 ; i < nmid ;++i) - std::swap ( A[i], A [nlast -i]); - - Test>(A); -*/ + Test (A); }; -void Generator_reverse_sorted_end(size_t n_last) +void Generator_reverse_sorted_end (size_t n_last) { - std::vector A; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING+ n_last) != 0) + std::vector A; + A.reserve (NMAXSTRING); + A.clear (); + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_last) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - std::sort (A.begin() , A.begin() + NMAXSTRING ); - for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i) - std::swap ( A[i], A[NMAXSTRING - 1 - i]); - - Test>(A); + std::sort (A.begin (), A.begin () + NMAXSTRING); + for (size_t i = 0; i < (NMAXSTRING >> 1); ++i) + std::swap (A [i], A [NMAXSTRING - 1 - i]); + Test (A); }; -void Generator_reverse_sorted_middle(size_t n_last) +void Generator_reverse_sorted_middle (size_t n_middle) { - std::vector A,B,C; - A.reserve(NMAXSTRING); - A.clear(); - if (bsc::fill_vector_string("input.bin", A, NMAXSTRING + n_last) != 0) + assert (n_middle > 1 && NMAXSTRING >= (n_middle -1)); + vector A, aux; + A.reserve (NMAXSTRING + n_middle); + aux.reserve (n_middle); + + if (bsc::fill_vector_string ("input.bin", A, NMAXSTRING + n_middle) != 0) { std::cout << "Error in the input file\n"; - return; + std::exit (EXIT_FAILURE); }; - for ( size_t i = NMAXSTRING ; i < A.size() ; ++i) - B.push_back ( std::move ( A[i])); - A.resize ( NMAXSTRING); + for (size_t i = 0; i < n_middle; ++i) aux.push_back (std::move (A [i])); - std::sort (A.begin() , A.end() ); - for ( size_t i =0 ; i< (NMAXSTRING >>1); ++i) - std::swap ( A[i], A[NMAXSTRING - 1 - i]); + std::sort (A.begin () + n_middle, A.end ()); + + size_t pos1 = n_middle, pos2 = A.size () - 1; + for (size_t i = 0; i < (NMAXSTRING >> 1); ++i) + std::swap (A [pos1 ++], A [pos2 --]); + + //------------------------------------------------------------------------ + // To insert n_middle elements, must have (n_middle - 1) intervals between + // them. The size of the interval is step + // The elements after the last element of aux don't need to be moved + //------------------------------------------------------------------------- + size_t step = NMAXSTRING / (n_middle - 1); + A [0] = std::move (aux [0]); + size_t pos_read = n_middle, pos_write = 1; - size_t step = NMAXSTRING /n_last +1 ; - size_t pos = 0 ; - - for ( size_t i =0 ; i < B.size() ; ++i, pos += step) - { C.push_back ( B[i]); - for ( size_t k = 0 ; k < step ; ++k ) - C.push_back ( A[pos + k] ); + for (size_t i = 1; i < n_middle; ++i) + { + for (size_t k = 0 ; k < step; ++k) + A [pos_write ++] = std::move (A [pos_read ++]); + A [pos_write ++] = std::move (aux [i]); }; - while ( pos < A.size() ) - C.push_back ( A[pos++]); - A = C ; - - Test>(A); + aux.clear (); + aux.reserve (0); + Test (A); }; - -template -int Test (std::vector &B, compare comp) -{ //---------------------------- begin ----------------------------- +int Test (std::vector &B) +{ + //---------------------------- begin ----------------------------- + std::less comp; double duration; time_point start, finish; - std::vector A (B); - std::vector V; - + std::vector A (B); + std::vector V; A = B; start = now (); @@ -344,11 +335,12 @@ int Test (std::vector &B, compare comp) //----------------------------------------------------------------------- // printing the vector //----------------------------------------------------------------------- - std::cout< &index) while (pos_in_vector < nelem) { - while (pos_in_vector < nelem and + while (pos_in_vector < nelem && (size_t(index[pos_in_vector] - global_first)) == pos_in_vector) { ++pos_in_vector; diff --git a/include/boost/sort/common/merge_block.hpp b/include/boost/sort/common/merge_block.hpp index 1a7eb90..919aa75 100644 --- a/include/boost/sort/common/merge_block.hpp +++ b/include/boost/sort/common/merge_block.hpp @@ -14,7 +14,6 @@ #ifndef __BOOST_SORT_COMMON_MERGE_BLOCK_HPP #define __BOOST_SORT_COMMON_MERGE_BLOCK_HPP -#include #include #include #include @@ -126,7 +125,7 @@ struct merge_block ~ merge_block() { - if (ptr_circ != nullptr and owned) + if (ptr_circ != nullptr && owned) { delete ptr_circ; ptr_circ = nullptr; @@ -171,7 +170,7 @@ struct merge_block //------------------------------------------------------------------------- bool is_tail(size_t pos) const { - return (pos == (nblock - 1) and ntail != 0); + return (pos == (nblock - 1) && ntail != 0); }; //------------------------------------------------------------------------- // function : @@ -223,10 +222,10 @@ template void merge_block ::merge_range_pos(it_index itx_first, it_index itx_mid,it_index itx_last) { - assert((itx_last - itx_mid) >= 0 and (itx_mid - itx_first) >= 0); + assert((itx_last - itx_mid) >= 0 && (itx_mid - itx_first) >= 0); size_t nelemA = (itx_mid - itx_first), nelemB = (itx_last - itx_mid); - if (nelemA == 0 or nelemB == 0) return; + if (nelemA == 0 || nelemB == 0) return; //------------------------------------------------------------------- // Create two index with the position of the blocks to merge @@ -244,17 +243,17 @@ void merge_block Iter_t itA = global_range.first, itB = global_range.first; bool validA = false, validB = false; - while (itxA != indexA.end() and itxB != indexB.end()) + while (itxA != indexA.end() && itxB != indexB.end()) { //---------------------------------------------------------------- // Load valid ranges from the itxA and ItxB positions //---------------------------------------------------------------- - if (not validA) + if (! validA) { rngA = get_range(*itxA); itA = rngA.first; validA = true; }; - if (not validB) + if (! validB) { rngB = get_range(*itxB); itB = rngB.first; @@ -266,7 +265,7 @@ void merge_block //---------------------------------------------------------------- if (ptr_circ->size() == 0) { - if (not cmp(*rngB.front(), *rngA.back())) + if (! cmp(*rngB.front(), *rngA.back())) { *(itx_out++) = *(itxA++); validA = false; @@ -274,7 +273,7 @@ void merge_block }; if (cmp(*rngB.back(), *rngA.front())) { - if (not is_tail(*itxB)) + if (! is_tail(*itxB)) *(itx_out++) = *itxB; else ptr_circ->push_move_back(rngB.first, rngB.size()); ++itxB; @@ -295,7 +294,7 @@ void merge_block } else { // rngB is finished - if (not is_tail(*itxB)) + if (! is_tail(*itxB)) { ptr_circ->pop_move_front(rngB.first, rngB.size()); *(itx_out++) = *itxB; @@ -315,7 +314,7 @@ void merge_block else { // The list B is finished rngA = get_range(*itxA); - if (ntail != 0 and indexB.back() == (nblock - 1)) // exist tail + if (ntail != 0 && indexB.back() == (nblock - 1)) // exist tail { // add the tail block to indexA, and shift the element indexA.push_back(indexB.back()); size_t numA = size_t(itA - rngA.first); @@ -341,7 +340,7 @@ template void merge_block ::move_range_pos_backward(it_index itx_first, it_index itx_last, size_t npos) { - assert((itx_last - itx_first) >= 0 and npos <= BLOCK_SIZE); + assert((itx_last - itx_first) >= 0 && npos <= BLOCK_SIZE); //-------------------------------------------------------------------- // Processing the last block. Must be ready fore to accept npos @@ -391,7 +390,7 @@ void merge_block pos_ini = 0; while (pos_ini < nelem) { - while (pos_ini < nelem and index[pos_ini] == pos_ini) + while (pos_ini < nelem && index[pos_ini] == pos_ini) ++pos_ini; if (pos_ini == nelem) return; pos_dest = pos_src = pos_ini; diff --git a/include/boost/sort/common/range.hpp b/include/boost/sort/common/range.hpp index 73dbd5a..859bf75 100644 --- a/include/boost/sort/common/range.hpp +++ b/include/boost/sort/common/range.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_PARALLEL_DETAIL_UTIL_RANGE_HPP #define __BOOST_SORT_PARALLEL_DETAIL_UTIL_RANGE_HPP -#include #include #include #include @@ -235,7 +234,7 @@ inline bool is_mergeable_stable(const range &src1, //------------------------------------------------------------------------ // Code //------------------------------------------------------------------------ - return not comp(*(src1.back()), *(src2.front())); + return ! comp(*(src1.back()), *(src2.front())); }; // //----------------------------------------------------------------------------- @@ -380,7 +379,7 @@ static void merge_flow(range rng1, range rbuf, //------------------------------------------------------------------------- range rbx(rbuf); range rx1(rng1), rx2(rng2); - assert(rbx.size() == rx1.size() and rx1.size() == rx2.size()); + assert(rbx.size() == rx1.size() && rx1.size() == rx2.size()); while (rx1.first != rx1.last) { *(rx1.first++) = (cmp(*rbx.first, *rx2.first)) ? diff --git a/include/boost/sort/common/rearrange.hpp b/include/boost/sort/common/rearrange.hpp index d32db09..687de29 100644 --- a/include/boost/sort/common/rearrange.hpp +++ b/include/boost/sort/common/rearrange.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_COMMON_REARRANGE_HPP #define __BOOST_SORT_COMMON_REARRANGE_HPP -#include #include #include #include @@ -83,7 +82,7 @@ void rearrange(Iter_data global_first, Iter_index itx_first, pos_ini = 0; while (pos_ini < nelem) { - while (pos_ini < nelem and pos(index[pos_ini]) == pos_ini) + while (pos_ini < nelem && pos(index[pos_ini]) == pos_ini) ++pos_ini; if (pos_ini == nelem) return; pos_dest = pos_src = pos_ini; diff --git a/include/boost/sort/common/sort_basic.hpp b/include/boost/sort/common/sort_basic.hpp index 35121ae..74a5b99 100644 --- a/include/boost/sort/common/sort_basic.hpp +++ b/include/boost/sort/common/sort_basic.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_COMMON_SORT_BASIC_HPP #define __BOOST_SORT_COMMON_SORT_BASIC_HPP -#include #include #include #include @@ -56,7 +55,7 @@ inline Iter_t is_stable_sorted_forward (Iter_t first, Iter_t last, #endif if ((last - first) < 2) return first; Iter_t it2 = first + 1; - for (Iter_t it1 = first; it2 != last and not comp(*it2, *it1); it1 = it2++); + for (Iter_t it1 = first; it2 != last && ! comp(*it2, *it1); it1 = it2++); return it2; } //----------------------------------------------------------------------------- @@ -79,7 +78,7 @@ inline Iter_t is_reverse_stable_sorted_forward(Iter_t first, Iter_t last, #endif if ((last - first) < 2) return first; Iter_t it2 = first + 1; - for (Iter_t it1 = first; it2 != last and comp(*it2, *it1); it1 = it2++); + for (Iter_t it1 = first; it2 != last && comp(*it2, *it1); it1 = it2++); return it2; }; //----------------------------------------------------------------------------- @@ -105,14 +104,14 @@ size_t number_stable_sorted_forward (Iter_t first, Iter_t last, // sorted elements Iter_t it2 = first + 1; - for (Iter_t it1 = first; it2 != last and not comp(*it2, *it1); it1 = it2++); + for (Iter_t it1 = first; it2 != last && ! comp(*it2, *it1); it1 = it2++); size_t nsorted = size_t ( it2 - first); if ( nsorted != 1) return (nsorted >= min_process) ? nsorted: 0; // reverse sorted elements it2 = first + 1; - for (Iter_t it1 = first; it2 != last and comp(*it2, *it1); it1 = it2++); + for (Iter_t it1 = first; it2 != last && comp(*it2, *it1); it1 = it2++); nsorted = size_t ( it2 - first); if ( nsorted < min_process) return 0 ; @@ -140,7 +139,7 @@ inline Iter_t is_stable_sorted_backward(Iter_t first, Iter_t last, #endif if ((last - first) < 2) return first; Iter_t itaux = last - 1; - while (itaux != first and not comp(*itaux, *(itaux - 1))) {--itaux; }; + while (itaux != first && ! comp(*itaux, *(itaux - 1))) {--itaux; }; return itaux; } //----------------------------------------------------------------------------- @@ -163,7 +162,7 @@ inline Iter_t is_reverse_stable_sorted_backward (Iter_t first, Iter_t last, #endif if ((last - first) < 2) return first; Iter_t itaux = last - 1; - for (; itaux != first and comp(*itaux, *(itaux - 1)); --itaux); + for (; itaux != first && comp(*itaux, *(itaux - 1)); --itaux); return itaux; } @@ -188,13 +187,13 @@ size_t number_stable_sorted_backward (Iter_t first, Iter_t last, #endif if ((last - first) < 2) return 0; Iter_t itaux = last - 1; - while (itaux != first and not comp(*itaux, *(itaux - 1))) {--itaux; }; + while (itaux != first && ! comp(*itaux, *(itaux - 1))) {--itaux; }; size_t nsorted = size_t ( last - itaux); if ( nsorted != 1) return ( nsorted >= min_process)?nsorted: 0 ; itaux = last - 1; - for (; itaux != first and comp(*itaux, *(itaux - 1)); --itaux); + for (; itaux != first && comp(*itaux, *(itaux - 1)); --itaux); nsorted = size_t ( last - itaux); if ( nsorted < min_process) return 0 ; util::reverse ( itaux, last ); @@ -238,7 +237,7 @@ inline void internal_sort (const range &rng1, range rng2_left(rng2.first, rng2.first + nelem), rng2_right(rng2.first + nelem, rng2.last); - if (nelem <= 32 and (level & 1) == even) + if (nelem <= 32 && (level & 1) == even) { insert_sort(rng1_left.first, rng1_left.last, comp); insert_sort(rng1_right.first, rng1_right.last, comp); diff --git a/include/boost/sort/common/util/merge.hpp b/include/boost/sort/common/util/merge.hpp index 943e979..6fce04e 100644 --- a/include/boost/sort/common/util/merge.hpp +++ b/include/boost/sort/common/util/merge.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_COMMON_UTIL_MERGE_HPP #define __BOOST_SORT_COMMON_UTIL_MERGE_HPP -#include #include #include #include @@ -107,7 +106,7 @@ static Iter3_t merge(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2, if (buf1 == end_buf1) return move_forward(buf_out, buf2, end_buf2); if (buf2 == end_buf2) return move_forward(buf_out, buf1, end_buf1); - if (not comp(*buf2, *(end_buf1 - 1))) + if (! comp(*buf2, *(end_buf1 - 1))) { Iter3_t mid = move_forward(buf_out, buf1, end_buf1); return move_forward(mid, buf2, end_buf2); @@ -119,9 +118,9 @@ static Iter3_t merge(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2, return move_forward(mid, buf1, end_buf1); }; }; - while ((buf1 != end_buf1) and (buf2 != end_buf2)) + while ((buf1 != end_buf1) && (buf2 != end_buf2)) { - *(buf_out++) = (not comp(*buf2, *buf1)) ? + *(buf_out++) = (! comp(*buf2, *buf1)) ? std::move(*(buf1++)) : std::move(*(buf2++)); }; @@ -168,7 +167,7 @@ static Value_t *merge_construct(Iter1_t first1, const Iter1_t last1, if (first1 == last1) return move_construct(it_out, first2, last2); if (first2 == last2) return move_construct(it_out, first1, last1); - if (not comp(*first2, *(last1 - 1))) + if (! comp(*first2, *(last1 - 1))) { Value_t* mid = move_construct(it_out, first1, last1); return move_construct(mid, first2, last2); @@ -180,10 +179,10 @@ static Value_t *merge_construct(Iter1_t first1, const Iter1_t last1, return move_construct(mid, first1, last1); }; }; - while (first1 != last1 and first2 != last2) + while (first1 != last1 && first2 != last2) { construct_object((it_out++), - (not comp(*first2, *first1)) ? + (! comp(*first2, *first1)) ? std::move(*(first1++)) : std::move(*(first2++))); }; @@ -232,7 +231,7 @@ static Iter2_t merge_half(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2, if (buf1 == end_buf1) return end_buf2; if (buf2 == end_buf2) return move_forward(buf_out, buf1, end_buf1); - if (not comp(*buf2, *(end_buf1 - 1))) + if (! comp(*buf2, *(end_buf1 - 1))) { move_forward(buf_out, buf1, end_buf1); return end_buf2; @@ -244,9 +243,9 @@ static Iter2_t merge_half(Iter1_t buf1, const Iter1_t end_buf1, Iter2_t buf2, return move_forward(mid, buf1, end_buf1); }; }; - while ((buf1 != end_buf1) and (buf2 != end_buf2)) + while ((buf1 != end_buf1) && (buf2 != end_buf2)) { - *(buf_out++) = (not comp(*buf2, *buf1)) ? + *(buf_out++) = (! comp(*buf2, *buf1)) ? std::move(*(buf1++)) : std::move(*(buf2++)); }; return (buf2 == end_buf2)? move_forward(buf_out, buf1, end_buf1) : end_buf2; @@ -295,7 +294,7 @@ static Iter2_t merge_half_backward(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2, if (buf1 == end_buf1) return here::move_backward(end_buf_out, buf2, end_buf2); - if (not comp(*buf2, *(end_buf1 - 1))) + if (! comp(*buf2, *(end_buf1 - 1))) { here::move_backward(end_buf_out, buf2, end_buf2); return buf1; @@ -307,10 +306,10 @@ static Iter2_t merge_half_backward(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2, return here::move_backward(mid, buf2, end_buf2); }; }; - while ((buf1 != end_buf1) and (buf2 != end_buf2)) + while ((buf1 != end_buf1) && (buf2 != end_buf2)) { *(--end_buf_out) = - (not comp(*(end_buf2 - 1), *(end_buf1 - 1))) ? + (! comp(*(end_buf2 - 1), *(end_buf1 - 1))) ? std::move(*(--end_buf2)): std::move(*(--end_buf1)); }; @@ -352,19 +351,19 @@ static bool merge_uncontiguous(Iter1_t src1, const Iter1_t end_src1, //------------------------------------------------------------------------- // Code //------------------------------------------------------------------------- - if (src1 == end_src1 or src2 == end_src2 - or not comp(*src2, *(end_src1 - 1))) return true; + if (src1 == end_src1 || src2 == end_src2 + || ! comp(*src2, *(end_src1 - 1))) return true; - while (src1 != end_src1 and not comp(*src2, *src1)) + while (src1 != end_src1 && ! comp(*src2, *src1)) ++src1; Iter3_t const end_aux = aux + (end_src1 - src1); Iter2_t src2_first = src2; move_forward(aux, src1, end_src1); - while ((src1 != end_src1) and (src2 != end_src2)) + while ((src1 != end_src1) && (src2 != end_src2)) { - *(src1++) = std::move((not comp(*src2, *aux)) ? *(aux++) : *(src2++)); + *(src1++) = std::move((! comp(*src2, *aux)) ? *(aux++) : *(src2++)); } if (src2 == end_src2) @@ -409,11 +408,11 @@ static bool merge_contiguous(Iter1_t src1, Iter1_t src2, Iter1_t end_src2, //------------------------------------------------------------------------- // Code //------------------------------------------------------------------------- - if (src1 == src2 or src2 == end_src2 or not comp(*src2, *(src2 - 1))) + if (src1 == src2 || src2 == end_src2 || ! comp(*src2, *(src2 - 1))) return true; Iter1_t end_src1 = src2; - while (src1 != end_src1 and not comp(*src2, *src1)) + while (src1 != end_src1 && ! comp(*src2, *src1)) ++src1; if (src1 == end_src1) return false; @@ -460,7 +459,7 @@ static bool merge_circular(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2, assert ( circ.free_size() >= size_t ((end_buf1-buf1) + (end_buf2-buf2))); #endif - if (not comp(*buf2, *(end_buf1 - 1))) + if (! comp(*buf2, *(end_buf1 - 1))) { circ.push_move_back(buf1, (end_buf1 - buf1)); it1_out = end_buf1; @@ -474,7 +473,7 @@ static bool merge_circular(Iter1_t buf1, Iter1_t end_buf1, Iter2_t buf2, it2_out = end_buf2; return false; } - while (buf1 != end_buf1 and buf2 != end_buf2) + while (buf1 != end_buf1 && buf2 != end_buf2) { circ.push_back(comp(*buf2, *buf1) ? std::move(*(buf2++)) : std::move(*(buf1++))); diff --git a/include/boost/sort/flat_stable_sort/flat_stable_sort.hpp b/include/boost/sort/flat_stable_sort/flat_stable_sort.hpp index 340b9ff..ea1155f 100644 --- a/include/boost/sort/flat_stable_sort/flat_stable_sort.hpp +++ b/include/boost/sort/flat_stable_sort/flat_stable_sort.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_FLAT_STABLE_SORT_HPP #define __BOOST_SORT_FLAT_STABLE_SORT_HPP -#include #include #include #include @@ -110,9 +109,10 @@ public: //---------------------------------------------------------------------------- // //------------------------------------------------------------------------ -// function : -/// @brief : -/// @param Pos : +// @fn divide +/// @brief Divide a big list of blocks in two parts to be sorted and merged +/// @param itx_first iterator to the first element in the index +/// @param itx_last itarator to to the after the last element in the index /// @return //------------------------------------------------------------------------ template @@ -135,18 +135,17 @@ void flat_stable_sort }; // //------------------------------------------------------------------------ -// function : sort_small -/// @brief : -/// @param -/// @param -/// @param +// @fn sort_small +/// @brief sort an small number of blocks +/// @param itx_first iterator to the first element in the index +/// @param itx_last itarator to to the after the last element in the index //------------------------------------------------------------------------ template void flat_stable_sort ::sort_small(it_index itx_first, it_index itx_last) { size_t nblock = size_t(itx_last - itx_first); - assert(nblock > 0 and nblock < 5); + assert(nblock > 0 && nblock < 5); value_t *paux = ptr_circ->get_buffer(); range_it rng_data = get_group_range(*itx_first, nblock); @@ -172,7 +171,7 @@ void flat_stable_sort }; // //------------------------------------------------------------------------ -// function : is_sorted_forward +// @fn is_sorted_forward /// @brief : return if the data are ordered, /// @param itx_first : iterator to the first block in the index /// @param itx_last : iterator to the last block in the index @@ -213,7 +212,7 @@ bool flat_stable_sort }; // //------------------------------------------------------------------------ -// function : is_sorted_backward +// @fn is_sorted_backward /// @brief : return if the data are ordered, /// @param itx_first : iterator to the first block in the index /// @param itx_last : iterator to the last block in the index @@ -260,7 +259,7 @@ namespace bscu = boost::sort::common::util; namespace flat = boost::sort::flat_internal; // ///--------------------------------------------------------------------------- -// function flat_stable_sort +// @fn flat_stable_sort /// @brief This class is select the block size in the block_indirect_sort /// algorithm depending of the type and size of the data to sort /// @@ -285,7 +284,7 @@ struct block_size_fss // ///--------------------------------------------------------------------------- -// function flat_stable_sort +// @fn flat_stable_sort /// @brief This class is select the block size in the flat_stable_sort /// algorithm depending of the type and size of the data to sort /// diff --git a/include/boost/sort/insert_sort/insert_sort.hpp b/include/boost/sort/insert_sort/insert_sort.hpp index e7fe6f6..068c1cf 100644 --- a/include/boost/sort/insert_sort/insert_sort.hpp +++ b/include/boost/sort/insert_sort/insert_sort.hpp @@ -13,7 +13,6 @@ #ifndef __BOOST_SORT_INTROSORT_DETAIL_INSERT_SORT_HPP #define __BOOST_SORT_INTROSORT_DETAIL_INSERT_SORT_HPP -#include #include #include #include @@ -51,7 +50,7 @@ static void insert_sort (Iter_t first, Iter_t last, value_t Aux = std::move (*it_examine); Iter_t it_insertion = it_examine; - while (it_insertion != first and comp (Aux, *(it_insertion - 1))) + while (it_insertion != first && comp (Aux, *(it_insertion - 1))) { *it_insertion = std::move (*(it_insertion - 1)); --it_insertion;