std.h

Go to the documentation of this file.

// -*- C++ -*-
//
// std.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_std_H
#define ThePEG_std_H
 
#include <map>
#include <set>
#include <string>
#include <array>
#include <vector>
#include <list>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <stack>
#include <utility>
#include <typeinfo>
#include <stdexcept>
#include <cmath>
 
namespace std {
 
template <>
struct less<const type_info *> {
  typedef type_info first_argument_type;
  typedef type_info second_argument_type;
  typedef bool result_type;
  bool operator()(const type_info * x, const type_info * y) const {
    return x->before(*y); }
};
}
 
namespace ThePEG {
 
using std::array;
using std::deque;
using std::stack;
using std::vector;
using std::multiset;
using std::set;
using std::map;
using std::list;
using std::multimap;
using std::pair;
using std::make_pair;
using std::less;
using std::string;
using std::type_info;
using std::exception;
using std::range_error;
using std::ios;
using std::ostream;
using std::istream;
using std::ofstream;
using std::ifstream;
using std::ostringstream;
using std::istringstream;
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::flush;
using std::setprecision;
using std::setw;
using std::swap;
using std::min;
using std::max;
using std::mem_fn;
//using std::mem_fun;
using std::sqrt;
//using std::pow;
using std::abs;
using std::atan2;
using std::isfinite;
 
template <class ExponentT>
inline constexpr double pow(double x, ExponentT p) {
  return std::pow(x,double(p));
}
 
inline double sqrt(int x) {
  return std::sqrt(double(x));
}
 
inline constexpr long double factorial(unsigned int n) {
  return (n < 2) ? 1.0 : n * factorial(n - 1);
}
 
template <typename Container, typename Key>
inline bool member(const Container & c, const Key & k) {
  return c.find(k) != c.end();
}
 
template <typename T, typename Key>
inline bool member(const vector<T> & v, const Key & k) {
  for ( typename vector<T>::const_iterator i = v.begin(); i != v.end(); ++i )
    if ( *i == k ) return true;
  return false;
  // return find(v.begin(), v.end(), k) != v.end();
}
 
template <typename Cont>
inline std::insert_iterator<Cont> inserter(Cont & c) {
  return std::insert_iterator<Cont>(c, c.end());
}
 
 
template <typename T, typename A>
inline std::back_insert_iterator< vector<T,A> > inserter(vector<T,A> & v) {
  return back_inserter(v);
}
 
template <typename T, typename A>
inline std::back_insert_iterator< deque<T,A> > inserter(deque<T,A> & v) {
  return back_inserter(v);
}
 
inline ostream& left(ostream& os) {
  os.setf(ios::left, ios::adjustfield);
  return os;
}
 
inline ostream& right(ostream& os) {
  os.setf(ios::right, ios::adjustfield);
  return os;
}
 
}
 
#define ThePEG_DECLARE_SET(VALTYPE,NAME)                               \
                                             \
  typedef set<VALTYPE, less<VALTYPE> > NAME
 
#define ThePEG_DECLARE_MULTISET(VALTYPE,NAME)                          \
                                        \
  typedef multiset<VALTYPE, less<VALTYPE> > NAME
 
#define ThePEG_DECLARE_MAP(KEYTYPE,VALTYPE,NAME)                       \
                          \
  typedef map<KEYTYPE, VALTYPE, less<KEYTYPE> > NAME
 
#endif /* ThePEG_std_H */