Tpetra_Details_shortSort.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_DETAILS_SHORTSORT_HPP
#define TPETRA_DETAILS_SHORTSORT_HPP
 
 
#include "TpetraCore_config.h"
#include "Kokkos_Macros.hpp"
#include <type_traits>
 
namespace Tpetra {
namespace Details {
 
// Make sure that the macro defined below wasn't defined somewhere else.
#ifdef TPETRA_DETAILS_SWAP_KEYSANDVALUES
#error "The TPETRA_DETAILS_SWAP_KEYSANDVALUES macro is already defined."
#endif  // TPETRA_DETAILS_SWAP_KEYSANDVALUES
 
#define TPETRA_DETAILS_SWAP_KEYSANDVALUES(i, j) \
  if (keys[i] > keys[j]) {                      \
    const KeyType tmpKey(keys[i]);              \
    keys[i] = keys[j];                          \
    keys[j] = tmpKey;                           \
    const ValueType tmpVal(values[i]);          \
    values[i] = values[j];                      \
    values[j] = tmpVal;                         \
  }
 
// Make sure that the macro defined below wasn't defined somewhere else.
#ifdef TPETRA_DETAILS_SWAP_KEYS
#error "The TPETRA_DETAILS_SWAP_KEYS macro is already defined."
#endif  // TPETRA_DETAILS_SWAP_KEYSANDVALUES
 
#define TPETRA_DETAILS_SWAP_KEYS(i, j) \
  if (keys[i] > keys[j]) {             \
    const KeyType tmpKey(keys[i]);     \
    keys[i] = keys[j];                 \
    keys[j] = tmpKey;                  \
  }
 
template <class KeyType, class ValueType>
KOKKOS_FUNCTION void
shortSortKeysAndValues_2(KeyType keys[2], ValueType values[2]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  For 2 entries, the sorting network is
  // nearly trivial.
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 1);
}
 
template <class KeyType>
KOKKOS_FUNCTION void
shortSortKeys_2(KeyType keys[2]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  For 2 entries, the sorting network is
  // nearly trivial.
  TPETRA_DETAILS_SWAP_KEYS(0, 1);
}
 
template <class KeyType, class ValueType>
KOKKOS_FUNCTION void
shortSortKeysAndValues_3(KeyType keys[3], ValueType values[3]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 2);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 2);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 1);
}
 
template <class KeyType>
KOKKOS_FUNCTION void
shortSortKeys_3(KeyType keys[3]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYS(1, 2);
  TPETRA_DETAILS_SWAP_KEYS(0, 2);
  TPETRA_DETAILS_SWAP_KEYS(0, 1);
}
 
template <class KeyType, class ValueType>
KOKKOS_FUNCTION void
shortSortKeysAndValues_4(KeyType keys[4], ValueType values[4]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 1);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(2, 3);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 2);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 3);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 2);
}
 
template <class KeyType>
KOKKOS_FUNCTION void
shortSortKeys_4(KeyType keys[4]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYS(0, 1);
  TPETRA_DETAILS_SWAP_KEYS(2, 3);
  TPETRA_DETAILS_SWAP_KEYS(0, 2);
  TPETRA_DETAILS_SWAP_KEYS(1, 3);
  TPETRA_DETAILS_SWAP_KEYS(1, 2);
}
 
template <class KeyType, class ValueType>
KOKKOS_FUNCTION void
shortSortKeysAndValues_8(KeyType keys[8], ValueType values[8]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 1);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(2, 3);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 2);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 3);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 2);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(4, 5);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(6, 7);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(4, 6);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(5, 7);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(5, 6);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(0, 4);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 5);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(1, 4);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(2, 6);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(3, 7);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(3, 6);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(2, 4);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(3, 5);
  TPETRA_DETAILS_SWAP_KEYSANDVALUES(3, 4);
}
 
template <class KeyType>
KOKKOS_FUNCTION void
shortSortKeys_8(KeyType keys[8]) {
  // Since this function takes a constant number of entries, I use a
  // sorting network here.  To make the network, I used the generator
  // at
  //
  // http://pages.ripco.net/~jgamble/nw.html
  //
  // "Best" algorithm in this case is the Bose-Nelson Algorithm.
  TPETRA_DETAILS_SWAP_KEYS(0, 1);
  TPETRA_DETAILS_SWAP_KEYS(2, 3);
  TPETRA_DETAILS_SWAP_KEYS(0, 2);
  TPETRA_DETAILS_SWAP_KEYS(1, 3);
  TPETRA_DETAILS_SWAP_KEYS(1, 2);
  TPETRA_DETAILS_SWAP_KEYS(4, 5);
  TPETRA_DETAILS_SWAP_KEYS(6, 7);
  TPETRA_DETAILS_SWAP_KEYS(4, 6);
  TPETRA_DETAILS_SWAP_KEYS(5, 7);
  TPETRA_DETAILS_SWAP_KEYS(5, 6);
  TPETRA_DETAILS_SWAP_KEYS(0, 4);
  TPETRA_DETAILS_SWAP_KEYS(1, 5);
  TPETRA_DETAILS_SWAP_KEYS(1, 4);
  TPETRA_DETAILS_SWAP_KEYS(2, 6);
  TPETRA_DETAILS_SWAP_KEYS(3, 7);
  TPETRA_DETAILS_SWAP_KEYS(3, 6);
  TPETRA_DETAILS_SWAP_KEYS(2, 4);
  TPETRA_DETAILS_SWAP_KEYS(3, 5);
  TPETRA_DETAILS_SWAP_KEYS(3, 4);
}
 
template <class KeyType, class ValueType, class IndexType>
KOKKOS_FUNCTION void
shellSortKeysAndValues(KeyType keys[],
                       ValueType values[],
                       const IndexType n) {
  static_assert(std::is_integral<IndexType>::value,
                "IndexType must be a signed integer type.");
  static_assert(std::is_signed<IndexType>::value,
                "IndexType must be a signed integer type.  "
                "This implementation does a count-down loop, "
                "and may thus loop forever "
                "if one attempts to use it with unsigned IndexType.");
  constexpr IndexType ZERO = 0;
  IndexType midpoint       = n / static_cast<IndexType>(2);
 
  while (midpoint > ZERO) {
    // Avoid names like "max" in case they collide with macros.
    const IndexType theMax = n - midpoint;
    for (IndexType j = 0; j < theMax; ++j) {
      // IndexType is signed, so it's legit to compare >= 0.
      for (IndexType k = j; k >= 0; k -= midpoint) {
        if (keys[k + midpoint] >= keys[k]) {
          break;
        }
        const KeyType tmpKey   = keys[k + midpoint];
        keys[k + midpoint]     = keys[k];
        keys[k]                = tmpKey;
        const ValueType tmpVal = values[k + midpoint];
        values[k + midpoint]   = values[k];
        values[k]              = tmpVal;
      }
    }
    midpoint = midpoint / 2;
  }
}
 
template <class KeyType, class IndexType>
KOKKOS_FUNCTION void
shellSortKeys(KeyType keys[], const IndexType n) {
  static_assert(std::is_integral<IndexType>::value,
                "IndexType must be a signed integer type.");
  static_assert(std::is_signed<IndexType>::value,
                "IndexType must be a signed integer type.  "
                "This implementation does a count-down loop, "
                "and may thus loop forever "
                "if one attempts to use it with unsigned IndexType.");
  constexpr IndexType ZERO = 0;
  IndexType midpoint       = n / static_cast<IndexType>(2);
 
  while (midpoint > ZERO) {
    // Avoid names like "max" in case they collide with macros.
    const IndexType theMax = n - midpoint;
    for (int j = 0; j < theMax; ++j) {
      // IndexType must be signed, so it's legit to compare >= 0.
      for (int k = j; k >= 0; k -= midpoint) {
        if (keys[k + midpoint] >= keys[k]) {
          break;
        }
        const KeyType tmpKey = keys[k + midpoint];
        keys[k + midpoint]   = keys[k];
        keys[k]              = tmpKey;
      }
    }
    midpoint = midpoint / 2;
  }
}
 
template <typename KeyType, typename ValueType, typename IndexType>
KOKKOS_FUNCTION void
shellSortKeysAndValues2(KeyType* keys, ValueType* values, IndexType n) {
  IndexType ngaps = 10;
  // Use Ciura's gap choices
  IndexType gaps[] = {3548, 1577, 701, 301, 132, 57, 23, 10, 4, 1};
  for (IndexType gapIndex = 0; gapIndex < ngaps; gapIndex++) {
    auto gap = gaps[gapIndex];
    if (n < gap)
      continue;
    // insertion sort the array {keys[0*gap], keys[1*gap], keys[2*gap], ...}
    for (IndexType gapOffset = 0; gapOffset < gap; gapOffset++) {
      for (IndexType i = gap + gapOffset; i < n; i += gap) {
        // avoid extra swaps: scan for the final position of keys[i]
        if (keys[i - gap] > keys[i]) {
          IndexType finalPos = i - gap;
          while (finalPos - gap >= 0 && keys[finalPos - gap] > keys[i]) {
            finalPos -= gap;
          }
          // save keys/values [i], then shift up all keys/values between finalPos and i-gap (inclusive)
          auto tempKey = keys[i];
          auto tempVal = values[i];
          for (IndexType j = i - gap; j >= finalPos; j -= gap) {
            keys[j + gap]   = keys[j];
            values[j + gap] = values[j];
          }
          keys[finalPos]   = tempKey;
          values[finalPos] = tempVal;
        }
      }
    }
  }
#undef SHELL_SWAP
}
 
}  // namespace Details
}  // namespace Tpetra
 
#endif  // TPETRA_DETAILS_SHORTSORT_HPP