utils.h

#ifndef DEF_UTIL
#define DEF_UTIL
#include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
#include <fstream>
#include "boost/random/binomial_distribution.hpp"
#include "boost/random/poisson_distribution.hpp"
#include "boost/random/variate_generator.hpp"
#include "boost/random/mersenne_twister.hpp"
#include <sstream>
#include <climits>

// Try to sniff out whether or not a long is 64 bits, or 32.  This is needed to decide whether to apply a "ULL" or "UL" suffix to 64-bit numeric literals.
//#ifdef __SIZEOF_LONG__
//#if __SIZEOF_LONG__ == 8
//#define LONG_IS_64_BITS
//#endif
//#endif
#if ULONG_MAX > 0xFFFFFFFFUL
#define LONG_IS_64_BITS
#endif

// If compiling with g++ on a 32-bit machine, g++ demands that 64-bit unsigned constants have a special "ULL" ("unsigned long long") suffix.
// (Hopefully this nonstandard suffix works on other compilers.)  But if we're compiling on a 64-bit machine, these constants need only a "UL" suffix.
// This macro attempts to figure out the right suffix, and glue it on.  LONG_IS_64_BITS needs to be
// either set by the user or guessed from other predefined constants.
#ifdef LONG_IS_64_BITS
#define U64(x) x##UL
#else
#define U64(x) x##ULL
#endif

#if defined(_MSC_VER) || defined(__BORLANDC__) // windobe version 64bits int
typedef unsigned __int64 ulong64;
typedef signed __int64 long64;
#define CRUMB 32 // number of base that can be coded in a number, 64 for uint128, 32 for ulong64
#define typeDNA  __ulong64
#else //linux version 128 bits int
typedef unsigned long long ulong64;
typedef signed long long long64;
#define CRUMB 32 // number of base that can be coded in a number, 64 for uint128, 32 for ulong64
#define typeDNA  ulong64

#endif

#define rand2 (int)((rand()/((double)RAND_MAX+1)*2))

int rBinom(int, double ); 
int rPoisson(double);
int * poisson_array(int N,double lambda);
int myrand(int);
int logrand(int);
ptrdiff_t myrand(ptrdiff_t);
int dist_dna(int, int);
unsigned long long int dist_dna(unsigned long long int, unsigned long long int);
unsigned long long convertDnaToInt(std::string dna);
std::vector<unsigned long long> convertDnaToIntSplit(std::string dna);
#ifdef HAS_UINT128
__uint128_t dist_dna(__uint128_t a, __uint128_t b);// NOT WORKING
#endif  // HAS_UINT128
double harmonic(int n);
int * poisson_array_smart(int Nparents, int Nchildren);
char convertToChar(unsigned number);
std::string convertIntToQuaternaryString(typeDNA dna,int nbcrumb = CRUMB);
double tajima_a1(int n); // warning in tajima D computaion call with n-1
double tajima_a2(int n); // warning in tajima D computaion call with n-1
double tajima_b1(int n);
double tajima_b2(int n);
double tajima_c1(int n);
double tajima_c2(int n);
unsigned long long dna_distance(unsigned long long c);
std::vector<std::string> split_string(std::string tosplit,std::string sep);
std::vector<typeDNA> dna_string_to_int(std::string);
double harm_square(int i);
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems);
std::vector<std::string> split(const std::string &s, char delim);
bool isFloat(std::string myString);
bool isInt(std::string myString);

template <class T>
inline std::string to_string (const T& t)
{
std::stringstream ss;
ss << t;
return ss.str();
}

template<class T >
std::string convertToStr(T number)
{
  switch(number){
  case(0):    
    return "A";
  case(1):
    return "G";
  case(2):
    return "C";
  case(3):
    return "T";
  default:
    return "-";
  }  
}

template<class T >
int convertToInt(T letter)
{
  switch(letter){
  case('A'):
    return 0;
  case('G'):
    return 1;
  case('C'):
    return 2;
  case('T'):
    return 3;
  default:
    return 0;
  }
}




#endif