Search on this site

 Parallel Sorting Template Functions

template <class Range, class Less>

void CoSort(Range&& c, const Less& less)

Sorts range c with ordering is defined by less. The order of elements with the same value can be changed (unstable sort).

template <class Range>

void CoSort(Range&& c)

Sorts range c with ordering is defined by operator<. The order of elements with the same value can be changed (unstable sort).

template <class Range, class Less>

void CoStableSort(Range&& r, const Less& less)

Sorts container c with ordering is defined by less. The order of elements with the same value stays unchanged (stable sort).

template <class Range>

void CoStableSort(Range&& r)

Sorts container c with ordering is defined by operator<. The order of elements with the same value stays unchanged (stable sort).

template <class MasterRange, class Range2, class Less>

void CoIndexSort(MasterRange&& r, Range2&& r2, const Less& less)

template <class MasterRange, class Range2, class Range3, class Less>

void CoIndexSort2(MasterRange&& r, Range2&& r2, Range3&& r3, const Less& less)

template <class MasterRange, class Range2, class Range3, class Range4, class Less>

void CoIndexSort3(MasterRange&& r, Range2&& r2, Range3&& r3, Range4&& r4, const Less& less)

Sorts 2, 3 or 4 containers. All containers must have same number of items. Resulting order is defined by the r container. Ordering is defined by less.

template <class MasterRange, class Range2>

void CoIndexSort(MasterRange&& r, Range2&& r2)

template <class MasterRange, class Range2, class Range3>

void CoIndexSort2(MasterRange&& r, Range2&& r2, Range3&& r3)

template <class MasterRange, class Range2, class Range3, class Range4>

void CoIndexSort3(MasterRange&& r, Range2&& r2, Range3&& r3, Range4&& r4)

Sorts 2, 3 or 4 containers. All containers must have same number of items. Resulting order is defined by the r container. Ordering is defined by operator<.

template <class MasterRange, class Range2, class Less>

void CoStableIndexSort(MasterRange&& r, Range2&& r2, const Less& less)

template <class MasterRange, class Range2, class Range3,class Less>

void CoStableIndexSort2(MasterRange&& r, Range2&& r2, Range3&& r3, const Less& less)

template <class MasterRange, class Range2, class Range3, class Range4, class Less>

void CoStableIndexSort3(MasterRange&& r, Range2&& r2, Range3&& r3, Range4&& r4, const Less& less)

Sorts 2, 3 or 4 containers. All containers must have same number of items. Resulting order is defined by the r container. Ordering is defined by less. The order of elements with the same value stays unchanged (stable sort).

template <class MasterRange, class Range2>

void CoStableIndexSort(MasterRange&& r, Range2&& r2)

template <class MasterRange, class Range2, class Range3>

void CoStableIndexSort2(MasterRange&& r, Range2&& r2, Range3&& r3)

template <class MasterRange, class Range2, class Range3, class Range4>

void CoStableIndexSort3(MasterRange&& r, Range2&& r2, Range3&& r3, Range4&& r4)

Sorts pair of containers. Both containers must have same number of items. Resulting order is determined by the r container. Ordering is determined by operator<.

template <class Range, class Less>

Vector<intCoGetSortOrder(const Range& r, const Less& less)

Creates ascending order of values in container. Ordering is determined by less. The order of elements with the same value can be changed (unstable sort).

template <class Range>

Vector<intCoGetSortOrder(const Range& r)

Creates ascending order of values in container. Ordering is determined by operator<. The order of elements with the same value can be changed (unstable sort).

template <class Range, class Less>

Vector<intCoGetStableSortOrder(const Range& r, const Less& less)

Creates ascending order of values in container. Ordering is determined by less. The order of elements with the same value stays unchanged (stable sort).

template <class Range>

Vector<intCoGetStableSortOrder(const Range& r)

Creates ascending order of values in container. Ordering is determined by operator<. The order of elements with the same value stays unchanged (stable sort).

template <class Map, class Less>

void CoSortByKey(Map& map, const Less& less)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by keys, using less as sorting predicate.

template <class Map>

void CoSortByKey(Map& map)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by keys, using operator< as sorting predicate.

template <class Map, class Less>

void CoSortByValue(Map& map, const Less& less)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by values, using less as sorting predicate.

template <class Map>

void CoSortByValue(Map& map)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by values, using operator< as sorting predicate.

template <class Map, class Less>

void CoStableSortByKey(Map& map, const Less& less)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by keys, using less as sorting predicate. Stable: retains the order of equal elements.

template <class Map>

void CoStableSortByKey(Map& map)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by keys, using operator< as sorting predicate. Stable: retains the order of equal elements.

template <class Map, class Less>

void CoStableSortByValue(Map& map, const Less& less)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by values, using less as sorting predicate. Stable: retains the order of equal elements.

template <class Map>

void CoStableSortByValue(Map& map)

Sorts VectorMap or ArrayMap (or any other hypothetical container that supports required interfaces) map by values, using operator< as sorting predicate. Stable: retains the order of equal elements.

template <class Index, class Less>

void CoSortIndex(Index& index, const Less& less)

Sorts Index or ArrayIndex using less as sorting predicate.

template <class Index>

void CoSortIndex(Index& index)

Sorts Index or ArrayIndex.

template <class Index, class Less>

void CoStableSortIndex(Index& index, const Less& less)

Sorts Index or ArrayIndex using less as sorting predicate. Stable: retains the order of equal elements.

template <class Index>

void CoStableSortIndex(Index& index)

Sorts Index or ArrayIndex.  Stable: retains the order of equal elements.

 Last edit by klugier on 05/17/2018. Do you want to contribute?. T++