sorter_alt.h

Go to the documentation of this file.

 
#ifndef SORTER_INCLUDED
#define SORTER_INCLUDED
 
#include <cmath>
#include <algorithm>
#include <cassert>
#include <vector>
#include <string>
 
#include "bridge_complex.h"
 
//    sort utility class.
//
//  usage:
//    Sorter sorter(sort_type);
//      sort_type =
//        abs_ascending  : absolute ascending order   |v_0| <= |v_1| <= ...
//        abs_descending : absolute descending order  |v_0| >= |v_1| >= ...
//        ascending      : arithmetic ascending order  v_0 <= v_1 <= ...
//        descending     : arithmetic descending order v_0 >= v_1 >= ...
//    sorter.sort(vec);  to sort vec : vector<double>. destructive.
//    sorter.sort_index(vec);  returns index of vec in sorted order.
//    sorter.comp(a, b);  compare two values a, b with the sort condition.
//
// 2022.02.15: I.Kanamori
//   added fcomplex
 
template<typename T>
class Sorter
{
 public:
 
  Sorter(const std::string& type);
 
  virtual ~Sorter();
 
  void sort(std::vector<T>& v);
 
  void sort(std::vector<T>& v, const size_t nelem);
 
  std::vector<int> sort_index(std::vector<T>& v);
 
  std::vector<int> sort_index(std::vector<T>& v, const size_t nelem);
 
  bool comp(const T& lhs, const T& rhs);
 
 private:
 
  // sort order
  struct by_abs_ascend;
  struct by_abs_descend;
  struct by_ascend;
  struct by_descend;
 
  struct by_order;
  struct proxy;
 
  typedef std::pair<int, T> pair_t;
 
  by_order *m_order;
 
  // non-copyable
  Sorter(const Sorter&);
  Sorter& operator=(const Sorter&);
};
 
//====================================================================
template<typename T>
struct Sorter<T>::by_order
{
  virtual ~by_order() {}
 
  virtual
  bool operator()(const T& lhs, const T& rhs) const = 0;
 
  bool operator()(const pair_t& lhs, const pair_t& rhs) const
  {
    return operator()(lhs.second, rhs.second);
  }
};
 
//====================================================================
//  i.e. |v_0| <= |v_1| <= ... <= |v_{n-1}|
template<typename T>
struct Sorter<T>::by_abs_ascend : public Sorter::by_order
{
  bool operator()(const T& lhs, const T& rhs) const
  { return abs(lhs) < abs(rhs); }
};
 
//====================================================================
//  i.e. |v_0| >= |v_1| >= ... >= |v_{n-1}|
template<typename T>
struct Sorter<T>::by_abs_descend : public Sorter::by_order
{
  bool operator()(const T& lhs, const T& rhs) const
  {
    return abs(lhs) > abs(rhs);
  }
};
 
//====================================================================
//  i.e. v_0 <= v_1 <= ... <= v_{n-1}
template<typename T>
struct Sorter<T>::by_ascend : public Sorter::by_order
{
  virtual
  bool operator()(const T& lhs, const T& rhs) const
  {
    return lhs < rhs;
  }
};
 
//====================================================================
//  i.e. v_0 >= v_1 >= ... >= v_{n-1}
template<typename T>
struct Sorter<T>::by_descend : public Sorter::by_order
{
  virtual
  bool operator()(const T& lhs, const T& rhs) const
  {
    return rhs < lhs;
  }
};
 
//====================================================================
template<typename T>
struct Sorter<T>::proxy
{
 private:
  const Sorter::by_order& m_order;
 
 public:
  proxy(const Sorter::by_order& order) : m_order(order) {}
 
  bool operator()(const T& lhs, const T& rhs) const
  {
    return m_order(lhs, rhs);
  }
 
  bool operator()(const pair_t& lhs, const pair_t& rhs) const
  {
    return m_order(lhs, rhs);
  }
};
 
//====================================================================
template<typename T>
Sorter<T>::Sorter(const std::string& type) : m_order(0)
{
  if (type == "abs_ascending") m_order = new by_abs_ascend;
  if (type == "abs_descending") m_order = new by_abs_descend;
  if (type == "ascending") m_order = new by_ascend;
  if (type == "descending") m_order = new by_descend;
}
 
 
//====================================================================
template<typename T>
Sorter<T>::~Sorter()
{
  if (m_order) delete m_order;
}
 
 
//====================================================================
template<typename T>
void Sorter<T>::sort(std::vector<T>& v)
{
  assert(m_order != NULL);
 
  return std::sort(v.begin(), v.end(), proxy(*m_order));
}
 
 
//====================================================================
template<typename T>
void Sorter<T>::sort(std::vector<T>& v, const size_t nelem)
{
  assert(m_order != NULL);
 
  return std::sort(v.begin(), v.begin() + nelem, proxy(*m_order));
}
 
 
//====================================================================
template<typename T>
std::vector<int> Sorter<T>::sort_index(std::vector<T>& v)
{
  assert(m_order != NULL);
 
  std::vector<pair_t> w(v.size());
 
  for (size_t i = 0, n = v.size(); i < n; ++i) {
    w[i].first  = i;
    w[i].second = v[i];
  }
 
  std::sort(w.begin(), w.end(), proxy(*m_order));
 
  std::vector<int> idx(v.size());
 
  for (size_t i = 0, n = v.size(); i < n; ++i) {
    idx[i] = w[i].first;
    v[i]   = w[i].second;
  }
 
  return idx;
}
 
 
//====================================================================
template<typename T>
std::vector<int> Sorter<T>::sort_index(std::vector<T>& v, const size_t nelem)
{
  assert(m_order != NULL);
 
  std::vector<pair_t> w(v.size());
 
  for (size_t i = 0, n = v.size(); i < n; ++i) {
    w[i].first  = i;
    w[i].second = v[i];
  }
 
  std::sort(w.begin(), w.begin() + nelem, proxy(*m_order));
 
  std::vector<int> idx(v.size());
 
  for (size_t i = 0, n = v.size(); i < n; ++i) {
    idx[i] = w[i].first;
    v[i]   = w[i].second;
  }
 
  return idx;
}
 
 
//====================================================================
template<typename T>
bool Sorter<T>::comp(const T& lhs, const T& rhs)
{
  assert(m_order != NULL);
  return m_order->operator()(lhs, rhs);
}
 
 
//====================================================================
//  i.e. v_0 <= v_1 <= ... <= v_{n-1}
template<>
struct Sorter<dcomplex>::by_ascend : public Sorter::by_order
{
  virtual
  bool operator()(const dcomplex& lhs, const dcomplex& rhs) const
  {
    vout.crucial("by_ascend: unsupported ordering\n");
    exit(EXIT_FAILURE);
    return false;
  }
};
 
//====================================================================
//  i.e. v_0 >= v_1 >= ... >= v_{n-1}
template<>
struct Sorter<dcomplex>::by_descend : public Sorter::by_order
{
  virtual
  bool operator()(const dcomplex& lhs, const dcomplex& rhs) const
  {
    vout.crucial("by_ascend: unsupported ordering\n");
    exit(EXIT_FAILURE);
    return false;
  }
};
 
 
//====================================================================
//  i.e. v_0 <= v_1 <= ... <= v_{n-1}
template<>
struct Sorter<fcomplex>::by_ascend : public Sorter::by_order
{
  virtual
  bool operator()(const fcomplex& lhs, const fcomplex& rhs) const
  {
    vout.crucial("by_ascend: unsupported ordering\n");
    exit(EXIT_FAILURE);
    return false;
  }
};
 
//====================================================================
//  i.e. v_0 >= v_1 >= ... >= v_{n-1}
template<>
struct Sorter<fcomplex>::by_descend : public Sorter::by_order
{
  virtual
  bool operator()(const fcomplex& lhs, const fcomplex& rhs) const
  {
    vout.crucial("by_ascend: unsupported ordering\n");
    exit(EXIT_FAILURE);
    return false;
  }
};
 
 
//==========================================================
#endif /* SORTER_INCLUDED */
//==================================================END=====