Add 'indirect_sort' #117

mclow · 2023-06-15T01:36:09Z

No description provided.

Flamefire

Looks potentially useful.

Added some ideas for improving the description and pointed out a few places for improvement/typo-fixing.

Flamefire · 2023-06-15T08:31:52Z

doc/indirect_sort.qbk

+There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them.  Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around.   An example of this might be a sequence of records from a database.
+
+Nevertheless, you might want to sort them.  That's where indirect sorting comes in.  In a "normal" sort, the elements of the sequence to be sorted are shuffled in place.  In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.


How about this a bit shorter wording especially avoiding to mention the need to sort twice:

Suggested change

There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them. Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.

There are times that you want a sorted version of a sequence, but for some reason you don't want to modify it. Maybe the elements in the sequence can't be moved/copied, e.g. the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns a "permutation" of the elements that, when applied, will put the elements in the sequence in a sorted order.

Are the double-spaces after each sentence intended?

Flamefire · 2023-06-15T08:32:57Z

doc/indirect_sort.qbk

+
+Nevertheless, you might want to sort them.  That's where indirect sorting comes in.  In a "normal" sort, the elements of the sequence to be sorted are shuffled in place.  In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.
+
+Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:


Suggested change

Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:

Assume a sequence `[first, last)` of 1000 items that are expensive to swap:

Flamefire · 2023-06-15T08:34:16Z

include/boost/algorithm/indirect_sort.hpp

+
+#include <algorithm>        // for std::sort (and others)
+#include <functional>       // for std::less
+#include <vector>           // for std:;vector


Typo:

Suggested change

#include <vector> // for std:;vector

#include <vector> // for std::vector

But is that comment really required?

Flamefire · 2023-06-15T08:35:14Z

include/boost/algorithm/indirect_sort.hpp

+///
+
+#ifndef BOOST_ALGORITHM_IS_INDIRECT_SORT
+#define BOOST_ALGORITHM_IS_INDIRECT_SORT


Unusual include guard. Why not BOOST_ALGORITHM_INDIRECT_SORT?

Flamefire · 2023-06-15T08:36:28Z

include/boost/algorithm/indirect_sort.hpp

+/// \fn indirect_sort (RAIterator first, RAIterator las )
+/// \returns a permutation of the elements in the range [first, last)
+///     such that when the permutation is applied to the sequence,
+///     the result is sorted according to the predicate pred.


Suggested change

/// the result is sorted according to the predicate pred.

/// the result is sorted in non-descending order.

Flamefire · 2023-06-15T08:38:45Z

include/boost/algorithm/indirect_sort.hpp

+/// \param last   The end of the input sequence
+///
+template <typename RAIterator>
+std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {


Suggested change

std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {

Permutation indirect_sort (RAIterator first, RAIterator last) {

Flamefire · 2023-06-15T08:40:49Z

test/indirect_sort_test.cpp

+
+
+void test_sort () {
+    BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };


Suggested change

BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

or int *first = &num[0]; is invalid isn't it?

Flamefire · 2023-06-15T08:41:33Z

test/indirect_sort_test.cpp

+
+// A permutation of size N is a sequence of values in the range [0..N)
+// such that no value appears more than once in the permutation.
+bool isa_permutation(Permutation p, size_t N) {


Suggested change

bool isa_permutation(Permutation p, size_t N) {

bool is_a_permutation(Permutation p, size_t N) {

is more readable.

Flamefire · 2023-06-15T08:43:39Z

test/indirect_sort_test.cpp

+	test_one_sort(v.begin(), v.end(), std::greater<int>());
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )


Why that extra method and not using BOOST_AUTO_TEST_CASE(test_sort) directly?

Because I expect there to be more test cases in the future.

But the whole idea of BOOST_AUTO_TEST_CASE is that you simply "decorate" each test case with that and NOT have a "main" function. By default it will run each such function sequentially even allowing you to filter test based on their name from the CLI.

-->

BOOST_AUTO_TEST_CASE( test_sort ){ ... } BOOST_AUTO_TEST_CASE( test_indirect_stable_sort ){ ... }

Flamefire · 2023-06-15T08:44:27Z

test/indirect_sort_test.cpp

@@ -0,0 +1,100 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.


Suggested change

Copyright (c) Marshall Clow 2011-2012.

Copyright (c) Marshall Clow 2023.

…'nth_element'

Flamefire · 2023-06-21T07:54:30Z

include/boost/algorithm/indirect_sort.hpp

+	return ret;
+}
+
+/// \fn indirect_partial_sort (RAIterator first, RAIterator last)


C&P mistake in the signature inside this (and below) docstrings

Flamefire · 2023-06-21T07:54:50Z

include/boost/algorithm/indirect_sort.hpp

+/// \fn indirect_nth_element (RAIterator first, RAIterator last, Predicate p)
+/// \returns a permutation of the elements in the range [first, last)
+///     such that when the permutation is applied to the sequence,
+///     the result is sorted according to the predicate pred.


Similar C&P mistake in signature and description.

Nice catch - thanks!

Add 'indirect_sort'

17c47e8

Flamefire reviewed Jun 15, 2023

View reviewed changes

mclow added 3 commits June 18, 2023 11:31

Update docs based on feedback, add 'stable_sort', 'partial_sort' and …

814f8a5

…'nth_element'

Add more tests

3ae9ee2

Split test cases

8be54b3

Flamefire suggested changes Jun 21, 2023

View reviewed changes

mclow added 3 commits June 23, 2023 19:32

Update docs; fix copy-pasta

a7ae53d

Replace call to 'iota' with hand-rolled loop

25ab833

Replace hand-rolled loop with 'iota_n' and back_insert_iterator

62922bd

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add 'indirect_sort' #117

Add 'indirect_sort' #117

mclow commented Jun 15, 2023

Flamefire left a comment

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

Flamefire Jun 15, 2023

mclow Jun 18, 2023

Flamefire Jun 20, 2023

Flamefire Jun 15, 2023

Flamefire Jun 21, 2023

Flamefire Jun 21, 2023

mclow Jun 22, 2023

		There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them. Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

		Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.


		Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.

		Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:

	Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:
	Assume a sequence `[first, last)` of 1000 items that are expensive to swap:

	#include <vector> // for std:;vector
	#include <vector> // for std::vector

	/// the result is sorted according to the predicate pred.
	/// the result is sorted in non-descending order.

	std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {
	Permutation indirect_sort (RAIterator first, RAIterator last) {



		void test_sort () {
		BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

	BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };
	int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

	bool isa_permutation(Permutation p, size_t N) {
	bool is_a_permutation(Permutation p, size_t N) {

	Copyright (c) Marshall Clow 2011-2012.
	Copyright (c) Marshall Clow 2023.

Add 'indirect_sort' #117

Are you sure you want to change the base?

Add 'indirect_sort' #117

Conversation

mclow commented Jun 15, 2023

Flamefire left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment