generic.h

/*
 * generic.h
 *
 *  Created on: Jun 16, 2011
 *
 *  Author: ahsanur<rahman.md.ahsanur@gmail.com>
 *  Purpose: frequently used headers + functions related to random numbers
 *
 */

#ifndef GENERIC_H_
#define GENERIC_H_

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <ctime>
#include <sys/time.h>
#include <assert.h>
#include <cstdlib>
#include <climits>
#include <sstream>
using namespace std;

typedef unsigned long NaturalNumber;
typedef double MyNT;

namespace myNamespace
{
        void getIndexedOutFile(ofstream &file, string filenamePrefix, NaturalNumber index);

        void getIndexedInFile(ifstream &file, string filenamePrefix, NaturalNumber index);


        template <typename T>
        inline NaturalNumber round(T x) {       x = x+0.5; return (-(NaturalNumber)(x < 0)) + (NaturalNumber)x;}

        template <class X>
        string getString(X val)
        {
                std::stringstream out;
                out << val;
                return out.str();
        }


        double getCPUTime();

        //
        // Reset the random number generator with the system clock.

        void seed();


        void seed(int p);

        //
        // Generate a random number between 0 and 1
        // return a uniform random number in [0,1].

        double unifRand();

        //
        // Generate a random number in a real interval.
        // param a one end point of the interval
        // param b the other end of the interval
        // return a inform rand numberin [a,b].

        double unifRand(double a, double b);

        //
        // Generate a random integer between 1 and a given value.
        // param n the largest value
        // return a uniform random value in [1,...,n]

        long unifRand(long n);

        template < typename setX>
        void getRandomItems(setX &random, setX &items, NaturalNumber size)
        {
                assert(size <= items.size());

                vector< typename setX::iterator > index;
                for(typename setX::iterator it = items.begin(); it != items.end(); it ++)
                        index.push_back(it);

                random_shuffle(index.begin(), index.end());

                for(NaturalNumber i = 0; i < size; i ++)
                        random.insert(*index[i]);
/*
 * ALT implementation
 *
                //set of randomly selected indices for items
                set<NaturalNumber> index;
                NaturalNumber r, i;

                while(index.size() < size)
                {
                        r = unifRand(0,items.size()-1);
                        index.insert(r);
                }

                set<NaturalNumber>::iterator it;
                typename setX::iterator sit = items.begin();
                for(i = 0, it = index.begin(); it != index.end(); it ++)
                {
                        //find the r-th elt in index
                        r = *it;
                        for(; i < r; i ++)
                                sit++;

                        random.insert(*sit);
                }
*/

        }


//      template void getRandomItems< set<string> >(set<string> &random, set<string> &items, NaturalNumber size);

//      template <typename setX>
//      void getRandomItems(NaturalNumber size, setX &random, setX &items);

        template <typename setX>
        void eraseSubset(setX &originalSet, setX &subset)
        {
                typename setX::iterator it, sit = originalSet.begin();
                for(it = subset.begin(); it != subset.end(); it ++)
                {
                        sit = originalSet.find(*it);

                        assert(sit != originalSet.end());

                        originalSet.erase(sit);
                }
        }

//      class MultiRandSeqGenerator;

}       //end of namespace

/*
class MultiRandSeqGenerator
{
private:

#ifndef MULTIRAND
#define MULTIRAND
//#include <tr1/random>
//using namespace __gnu_cxx;

        vector< std::tr1::mt19937 > _seq;
        std::tr1::uniform_int<NaturalNumber> *_distr;
        NaturalNumber _maxRandNum, _numSeq;

#endif // MULTIRAND

public:

        MultiRandSeqGenerator(NaturalNumber numSeq, NaturalNumber maxRandNum = ULONG_MAX);

        MyNT rand(NaturalNumber index);

};      //class
*/

#endif /* GENERIC_H_ */