/Users/jst/src/grafalgo/cpp/include/Util.h

Go to the documentation of this file.

#ifndef UTIL_H
#define UTIL_H

#include "stdinc.h"

using namespace std;

namespace grafalgo {

class Util {
public:
        static const int32_t BIGINT32 = 0x7ffffff;

        // basic input helper functions
        static bool skipSpace(istream& in, bool=false);
        static bool skipBlank(istream& in);
        static bool readWord(istream&, string&, bool= false);
        static bool readInt(istream&, int&, bool= false);
        static bool verify(istream&, char c, bool=false);

        // other stuff
        static bool prefix(string&, string&);   
        static int strnlen(char*, int);
        static void genPerm(int, int*); 
        static uint32_t getTime();
        static void warning(const string&);
        static void fatal(const string&);

        // convenience functions for random number generation
        // Should eventually replace with C++11 <random> variants
        static double randfrac();
        static int randint(int, int);
        static double randexp(double);
        static int randgeo(double);
        static int randTruncGeo(double, int);
        static double randpar(double, double);
};

inline void Util::warning(const string& msg) {
        cerr << "Warning: " << msg << endl;
}

inline void Util::fatal(const string& msg) {
        cerr << "Fatal: " << msg << endl;
        if (errno != 0) perror("");
        exit(1);
}


inline double Util:: randfrac() { return ((double) random())/BIGINT32; }

inline int Util::randint(int lo, int hi) {
        return lo + (random() % (hi + 1 - lo));
}

// Return a random number from an exponential distribution with mean mu 
inline double Util::randexp(double mu) { return -mu*log(randfrac()); }

inline int Util::randgeo(double p) {
        return p > .999999 ? 1 :
                max(1,int(.999999 +log(randfrac())/log(1-p)));
}

inline int Util::randTruncGeo(double p, int k) {
        double x = 1 - exp((k-1)*log(1-p));
        int r = int(.999999+log(randfrac()/x)/log(1-p));
        return p > .999999 ? 1 : max(1,min(r,k));
}

inline double Util::randpar(double mu, double s) {
        return mu*(1-1/s)/exp((1/s)*log(randfrac()));
}

} // ends namespace

#endif