GenSort.h

Go to the documentation of this file.

// # GenSort.h: General sort functions
// # Copyright (C) 1993,1994,1995,1996,1997,1999
// # Associated Universities, Inc. Washington DC, USA.
// #
// # This library is free software; you can redistribute it and/or modify it
// # under the terms of the GNU Library General Public License as published by
// # the Free Software Foundation; either version 2 of the License, or (at your
// # option) any later version.
// #
// # This library is distributed in the hope that it will be useful, but WITHOUT
// # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
// # License for more details.
// #
// # You should have received a copy of the GNU Library General Public License
// # along with this library; if not, write to the Free Software Foundation,
// # Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
// #
// # Correspondence concerning AIPS++ should be addressed as follows:
// #        Internet email: casa-feedback@nrao.edu.
// #        Postal address: AIPS++ Project Office
// #                        National Radio Astronomy Observatory
// #                        520 Edgemont Road
// #                        Charlottesville, VA 22903-2475 USA
 
#ifndef CASA_GENSORT_H
#define CASA_GENSORT_H
 
#include <casacore/casa/aips.h>
#include <casacore/casa/Arrays/ArrayFwd.h>
#include <casacore/casa/Utilities/Sort.h>
 
namespace casacore {  // # NAMESPACE CASACORE - BEGIN
 
// # Forward declarations.
template <class T>
class Block;
 
// <summary> General in-place sort functions </summary>
// <use visibility=local>
// <reviewed reviewer="Friso Olnon" date="1995/03/16" tests="tGenSort" demos="">
 
// <synopsis>
//
// The static member functions of this templated class are highly optimized
// sort functions.  They do an in-place sort of an array of values.  The
// functions are templated, so they can in principle be used with any
// data type. However, if used with non-builtin data types, their
// class must provide certain functions (see <em>Template Type Argument
// Requirements</em>).
//
// If it is impossible or too expensive to define these functions, the
// <linkto class=Sort>Sort</linkto> class can be used instead. This sorts
// indirectly using an index array. Instead of the functions mentioned
// above it requires a comparison routine.
//
// The <src>GenSort</src> functions can sort:
// <ul>
//  <li> C-arrays of values;
//  <li> <src>Array</src>s of values -- the array can have any shape
//         and the increment can be >1;
//  <li> <src>Block</src>s of values -- there is a special function to
//         sort less elements than the size of the <src>Block</src>.
// </ul>
//
// The sort order can be specified in the order field:
// <dl>
//   <dt> <src>Sort::Ascending</src> (default),
//   <dt> <src>Sort::Descending</src>.
// </dl>
//
// Previously the sort algorithm to use could be given in the options field.
// <dl>
//   <dt> <src>Sort::QuickSort</src> (default)
//   <dd> is the fastest. It is about 4-6 times faster
//     than the qsort function on the SUN. No worst case has been
//     found, even not for cases where qsort is terribly slow.
//   <dt> <src>Sort::HeapSort</src>
//   <dd> is about twice as slow as quicksort.
//     It has the advantage that the worst case is always o(n*log(n)),
//     while quicksort can have hypothetical inputs with o(n*n).
//   <dt> <src>Sort::InsSort</src>
//   <dd> is o(n*n) for random inputs. It is, however, the
//     only stable sort (i.e. equal values remain in the original order).
// </dl>
// However, these options are not used anymore because the sort now always
// uses a merge sort that is equally fast for random input and much faster for
// degenerated cases like an already ordered or reversely ordered array.
// Furthermore, merge sort is always stable and will be parallelized if OpenMP
// support is enabled giving a 6-fold speedup on 8 cores.
// <br><src>Sort::NoDuplicates</src> in the options field indicates that
// duplicate values will be removed (only the first occurrance is kept).
// <br>The previous sort functionality is still available through the functions
// quickSort, heapSort, and insSort.
// <p>
// All the sort functions return the number of values sorted as their
// function value; when duplicate values have been removed, the number of
// unique valuess will be returned.
// <p>
// The class also provides a function to find the k-th largest value
// in an array of values. This uses a stripped-down version of quicksort
// and is at least 6 times faster than a full quicksort.
// </synopsis>
 
// <templating arg=T>
//   <li> <src>operator=</src> to assign when swapping elements
//   <li> <src>operator<</src>, <src>operator></src> and
//        <src>operator==</src>  to compare elements
//   <li> default constructor to allocate a temporary
// </templating>
 
template <class T>
class GenSort {
 public:
  // Sort a C-array containing <src>nr</src> <src>T</src>-type objects.
  // The sort is done in place and is always stable (thus equal keys keep
  // their original order). It returns the number of values, which
  // can be different if a NoDuplicates sort is done.
  // <br>Insertion sort is used for short arrays (<50 elements). Otherwise,
  // a merge sort is used which will be parallelized if casacore is built
  // with OpenMP support.
  // <group>
  static uInt sort(T*, uInt nr, Sort::Order = Sort::Ascending, int options = 0);
 
  static uInt sort(Array<T>&, Sort::Order = Sort::Ascending, int options = 0);
 
  static uInt sort(Block<T>&, uInt nr, Sort::Order = Sort::Ascending, int options = 0);
  // <group>
 
  // Find the k-th largest value.
  // <br>Note: it does a partial quicksort, thus the data array gets changed.
  static T kthLargest(T* data, uInt nr, uInt k);
 
  // Sort C-array using quicksort.
  static uInt quickSort(T*, uInt nr, Sort::Order = Sort::Ascending, int options = 0);
  // Sort C-array using heapsort.
  static uInt heapSort(T*, uInt nr, Sort::Order = Sort::Ascending, int options = 0);
  // Sort C-array using insertion sort.
  static uInt insSort(T*, uInt nr, Sort::Order = Sort::Ascending, int options = 0);
  // Sort C-array using parallel merge sort (using OpenMP).
  // By default OpenMP determines the number of threads that can be used.
  static uInt parSort(T*, uInt nr, Sort::Order = Sort::Ascending, int options = 0, int nthread = 0);
 
  // Swap 2 elements in array.
  static inline void swap(T&, T&);
 
  // Reverse the elements in <src>res</src> and put them into <src>data</src>.
  // Care is taken if both pointers reference the same data.
  static void reverse(T* data, const T* res, uInt nrrec);
 
 private:
  // The<src>data</src> buffer is divided in <src>nparts</src> parts.
  // In each part the values are in ascending order.
  // The index tells the nr of elements in each part.
  // Recursively each two subsequent parts are merged until only part is left
  // (giving the sorted array). Alternately <src>data</src> and <src>tmp</src>
  // are used for the merge result. The pointer containing the final result
  // is returned.
  // <br>If possible, merging the parts is done in parallel (using OpenMP).
  static T* merge(T* data, T* tmp, uInt nrrec, uInt* index, uInt nparts);
 
  // Quicksort in ascending order.
  static void quickSortAsc(T*, Int, Bool multiThread = False, Int rec_lim = 128);
 
  // Heapsort in ascending order.
  static void heapSortAsc(T*, Int);
  // Helper function for ascending heapsort.
  static void heapAscSiftDown(Int, Int, T*);
 
  // Insertion sort in ascending order.
  static uInt insSortAsc(T*, Int, int option);
  // Insertion sort in ascending order allowing duplicates.
  // This is also used by quicksort for its last steps.
  static uInt insSortAscDup(T*, Int);
  // Insertion sort in ascending order allowing no duplicates.
  // This is also used by the other sort algorithms to skip duplicates.
  static uInt insSortAscNoDup(T*, Int);
};
 
// <summary> General indirect sort functions </summary>
// <use visibility=local>
// <reviewed reviewer="" date="" tests="" demos="">
 
// <synopsis>
// This class is similar to <linkto class=GenSort>GenSort</linkto>.
// The only difference is that the functions in this class sort
// indirectly instead of in-place.
// They return the result of the sort as an sorted vector of indices
// This is slower, because an extra indirection is involved in each
// comparison. However, this sort allows to sort const data.
// Another advantage is that this sort is always stable (i.e. equal
// values are kept in their original order).
//
// The class is templated on the type T of the sort key and the type
// INX of the index vector. In principle INX can be any type, but
// it should be a sufficiently large integer type (say uInt or uInt64).
template <class T, class INX = uInt>
class GenSortIndirect {
 public:
  // Sort a C-array containing <src>nr</src> <src>T</src>-type objects.
  // The resulting index vector gives the sorted indices.
  static INX sort(Vector<INX>& indexVector, const T* data, INX nr, Sort::Order = Sort::Ascending,
                  int options = Sort::QuickSort);
 
  // Sort a C-array containing <src>nr</src> <src>T</src>-type objects.
  // The resulting index vector gives the sorted indices.
  static INX sort(Vector<INX>& indexVector, const Array<T>& data, Sort::Order = Sort::Ascending,
                  int options = Sort::QuickSort);
 
  // Sort a C-array containing <src>nr</src> <src>T</src>-type objects.
  // The resulting index vector gives the sorted indices.
  static INX sort(Vector<INX>& indexVector, const Block<T>& data, INX nr,
                  Sort::Order = Sort::Ascending, int options = Sort::QuickSort);
 
  // Find the index of the k-th largest value.
  static INX kthLargest(T* data, INX nr, INX k);
 
  // Sort container using quicksort.
  // The argument <src>inx</src> gives the index defining the order of the
  // values in the data array. Its length must be at least <src>nr</src>
  // and it must be filled with the index values of the data.
  // Usually this is 0..nr, but it could contain a selection of the data.
  static INX quickSort(INX* inx, const T* data, INX nr, Sort::Order, int options);
  // Sort container using heapsort.
  static INX heapSort(INX* inx, const T* data, INX nr, Sort::Order, int options);
  // Sort container using insertion sort.
  static INX insSort(INX* inx, const T* data, INX nr, Sort::Order, int options);
  // Sort container using parallel merge sort (using OpenMP).
  // By default the maximum number of threads is used.
  static INX parSort(INX* inx, const T* data, INX nr, Sort::Order, int options, int nthreads = 0);
 
 private:
  // Swap 2 indices.
  static inline void swapInx(INX& index1, INX& index2);
 
  // The<src>data</src> buffer is divided in <src>nparts</src> parts.
  // In each part the values are in ascending order.
  // The index tells the nr of elements in each part.
  // Recursively each two subsequent parts are merged until only part is left
  // (giving the sorted array). Alternately <src>data</src> and <src>tmp</src>
  // are used for the merge result. The pointer containing the final result
  // is returned.
  // <br>If possible, merging the parts is done in parallel (using OpenMP).
  static INX* merge(const T* data, INX* inx, INX* tmp, INX nrrec, INX* index, INX nparts);
 
  // Check if 2 values are in ascending order.
  // When equal, the order is correct if index1<index2.
  static inline int isAscending(const T* data, INX index1, INX index2);
 
  // Quicksort in ascending order.
  static void quickSortAsc(INX* inx, const T*, INX nr, Bool multiThread = False, Int rec_lim = 128);
 
  // Heapsort in ascending order.
  static void heapSortAsc(INX* inx, const T*, INX nr);
  // Helper function for ascending heapsort.
  static void heapAscSiftDown(INX* inx, INX, INX, const T*);
 
  // Insertion sort in ascending order.
  static INX insSortAsc(INX* inx, const T*, INX nr, int option);
  // Insertion sort in ascending order allowing duplicates.
  // This is also used by quicksort for its last steps.
  static INX insSortAscDup(INX* inx, const T*, INX nr);
  // Insertion sort in ascending order allowing no duplicates.
  // This is also used by the other sort algorithms to skip duplicates.
  static INX insSortAscNoDup(INX* inx, const T*, INX nr);
};
 
// <summary> Global in-place sort functions </summary>
 
// The following global functions are easier to use than the static
// <linkto class=GenSort>GenSort</linkto> member functions.
// They do an in-place sort of data, thus the data themselves are moved
// ending up in the requested order.
// <p>
// The default sorting method is QuickSort, which is the fastest.
// However, there are pathological cases where it can be slow.
// HeapSort is about twice a slow, but its speed is guaranteed.
// InsSort (insertion sort) can be very, very slow, but it is the only
// stable sort method (i.e. equal values are kept in their original order).
// However, <linkto name=genSortIndirect> indirect sorting methods </linkto>
// are available to make QuickSort and HeapSort stable.
// <p>
// All sort methods have an option to skip duplicate values. This is the
// only case where the returned number of values can be less than the
// original number of values.
 
// <group name=genSortInPlace>
 
template <class T>
inline uInt genSort(T* data, uInt nr, Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSort<T>::sort(data, nr, order, options);
}
 
template <class T>
inline uInt genSort(Array<T>& data, Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSort<T>::sort(data, order, options);
}
 
template <class T>
inline uInt genSort(Block<T>& data, Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSort<T>::sort(data, data.nelements(), order, options);
}
 
template <class T>
inline uInt genSort(Block<T>& data, uInt nr, Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSort<T>::sort(data, nr, order, options);
}
// </group>
 
// <summary> Global indirect sort functions </summary>
 
// The following global functions easier to use than the static
// <linkto class=GenSortIndirect>GenSortIndirect</linkto> member functions.
// They do an indirect sort of data, thus the data themselves are not moved.
// Rather an index vector is returned giving the sorted data indices.
// <p>
// The sorting method used is merge sort, which is always stable.
// It is the fastest, especially if it can use multiple threads.
// <p>
// Unlike the <linkto name=genSortInPlace> in-place sorting methods
// </linkto>, all indirect sorting methods are stable (i.e. equal
// values are left in their original order).
// <p>
// All sort methods have an option to skip duplicate values. This is the
// only case where the returned number of values can be less than the
// original number of values.
 
// <group name=genSortIndirect>
 
template <class T, class INX = uInt>
inline uInt genSort(Vector<INX>& indexVector, const T* data, INX nr,
                    Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSortIndirect<T, INX>::sort(indexVector, data, nr, order, options);
}
 
template <class T, class INX = uInt>
inline uInt genSort(Vector<INX>& indexVector, const Array<T>& data,
                    Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSortIndirect<T, INX>::sort(indexVector, data, order, options);
}
 
template <class T, class INX = uInt>
inline uInt genSort(Vector<INX>& indexVector, const Block<T>& data,
                    Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSortIndirect<T, INX>::sort(indexVector, data, data.nelements(), order, options);
}
 
template <class T, class INX = uInt>
inline uInt genSort(Vector<INX>& indexVector, const Block<T>& data, INX nr,
                    Sort::Order order = Sort::Ascending, int options = 0) {
  return GenSortIndirect<T, INX>::sort(indexVector, data, nr, order, options);
}
// </group>
 
// Implement inline member functions.
 
template <class T>
inline void GenSort<T>::swap(T& l, T& r) {
  T t = l;
  l = r;
  r = t;
}
 
template <class T, class INX>
inline void GenSortIndirect<T, INX>::swapInx(INX& i, INX& j) {
  INX t = i;
  i = j;
  j = t;
}
template <class T, class INX>
inline int GenSortIndirect<T, INX>::isAscending(const T* data, INX i, INX j) {
  return (data[i] > data[j] || (data[i] == data[j] && i > j));
}
 
}  // namespace casacore
 
#ifndef CASACORE_NO_AUTO_TEMPLATES
#include <casacore/casa/Utilities/GenSort.tcc>
#endif  // # CASACORE_NO_AUTO_TEMPLATES
#endif