Util.hh

Go to the documentation of this file.

#ifndef UTIL_H_
#define UTIL_H_
 
#include <vector>
#include <set>
#include <string>
#include <iostream>
#include <sstream>
#include <random>
#include <boost/random.hpp>
#include <boost/functional/hash.hpp>
#include <chrono>
#include <functional>
#include "cuddObj.hh"
#include "State.hh"
 
namespace Util {
  void replace(std::string & str, std::string const & from,
               std::string const & to);
  void replaceAll(std::string & str, std::string const & from,
                  std::string const & to);
  char ** cStringArrayAlloc(std::vector<std::string> const & sv);
  void cStringArrayFree(char ** sa, size_t n);
 
  template<typename T> std::string to_string(T const & num)
  {
    std::ostringstream oss;
    oss << num;
    return oss.str();
  }
 
  class BddCompare {
  public:
    bool operator()(BDD const & bdd1, BDD const & bdd2) const
    {
      return bdd1.getNode() < bdd2.getNode();
    }
  };
 
  template<typename T>
  class PairWithBddCompare {
  public:
    using pwbdd = std::pair<T,BDD>; 
    bool operator()(pwbdd const & p1, pwbdd const & p2) const
    {
      return std::tuple<T,DdNode *>(p1.first, p1.second.getNode()) <
        std::tuple<T,DdNode *>(p2.first, p2.second.getNode());
    }
  };
 
  template<typename T1, typename T2>
  class PairHash {
  public:
    size_t operator()(std::pair<T1,T2> const & p) const
    {
      size_t seed = std::hash<T1>()(p.first);
      boost::hash_combine(seed, std::hash<T2>()(p.second));
      return seed;
    }
  };
 
  template<typename T, typename Comp>
  std::vector< std::set<T, Comp> > mapToPartition(
    std::map<T,unsigned,Comp> const & m)
  {
    if (m.size() == 0) {
      return std::vector< std::set<T, Comp> >{};
    }
    unsigned maxindex = 0;
    for (auto const & e : m) {
      if (e.second > maxindex)
        maxindex = e.second;
    }
    std::vector< std::set<T, Comp> >  partition(maxindex+1);
    for (auto const & e : m) {
      partition[e.second].insert(e.first);
    }
    return partition;
  }
 
  using RandomEngine = std::mt19937;
 
  RandomEngine & urng();
 
  void seed_urng();
 
  void seed_urng(unsigned seed);
 
  unsigned int get_urng_seed();
 
  template <typename Iterator>
  typename std::iterator_traits<Iterator>::value_type
  sample_discrete_distribution(Iterator first, Iterator last)
  {
    using Distribution = boost::random::discrete_distribution<>;
    using Parameter = Distribution::param_type;
    thread_local static Distribution dist{};
    return dist(urng(), Parameter{first, last});
  }
 
  int sample_discrete_distribution(std::vector<double> const & weights);
 
  template <typename IntType>
  IntType sample_uniform_distribution(IntType low, IntType hi)
  {
    using Distribution = boost::random::uniform_int_distribution<IntType>;
    using Parameter = typename Distribution::param_type;
    thread_local static Distribution dist{};
    return dist(urng(), Parameter{low, hi});
  }
 
  std::chrono::time_point<std::chrono::system_clock> stopwatch();
 
  void printElapsedTag(std::ostream & os = std::cout);
 
  double getElapsedTime();
 
  char const * to_decimal(int number);
 
  bool is_prefix(std::string const & str, std::string const & pre);
 
}
 
#endif