Sort.h

#ifndef PSCF_SORT_H
#define PSCF_SORT_H
 
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/containers/Pair.h>
#include <util/containers/GArray.h>
#include <vector>
 
namespace Pscf {
 
   using namespace Util;

   namespace Sort {

      template <typename T>
      struct Item {
         T value;
         int id;
      };
 
      /*
      * A Bunch represents a slice of the sorted array of items.
      *
      * A Bunch is used to represent a contiguous slice of the sorted
      * array of items produced by the Sort::sort function within which
      * values are equal to within some tolerance. If x is a Bunch, then
      * x[0] is the array index of the first element in a slice, and
      * x[1] an integer is one greater than the index of the last element
      * in that slice.
      *
      * \ingroup Pscf_Math_Sort_Module
      */
      using Bunch = Pair<int>;

      template <typename T>
      bool operator < (Item<T> const & a, Item<T> const & b)
      {  return (a.value < b.value); }

      template <typename T>
      void sort(std::vector< Item<T> >& items);

      template <typename T>
      void findBunches(std::vector< Item<T> > const & items,
                       GArray< Bunch >& bunches,
                       T epsilon);
 
 
      // Explicit instantiation declarations
 
      extern template void sort<double>(std::vector< Item<double> >& );
      extern template void sort<float>(std::vector< Item<float> >& );
 
      extern template
      void findBunches<double>(std::vector< Item<double> > const &,
                               GArray< Bunch >&, double);
 
      extern template
      void findBunches<float>(std::vector< Item<float> > const &,
                              GArray< Bunch >&, float);
 
   } // namespace Sort
 
} // namespace Pscf
#endif