util.h

Go to the documentation of this file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 */




#ifndef __defined_libdai_util_h
#define __defined_libdai_util_h


#include <string>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <boost/foreach.hpp>
#include <boost/functional/hash.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <cerrno>

#if defined(WINDOWS)
#include <cstdint> // only defined in C++11 and higher, but needed for Win64 builds in order to enable conditional code in MPIR library
#endif
#include <gmpxx.h>

#include <dai/exceptions.h>


#if defined(WINDOWS)
    #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
#elif defined(CYGWIN)
    #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
#elif defined(MACOSX)
    #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
#else
    #include <tr1/unordered_map> // only present in modern GCC distributions
#endif


#define bforeach BOOST_FOREACH

#ifdef DAI_DEBUG

#define DAI_PV(x) do {std::cerr << #x "= " << (x) << std::endl;} while(0)
#define DAI_DMSG(str) do {std::cerr << str << std::endl;} while(0)
#else
#define DAI_PV(x) do {} while(0)
#define DAI_DMSG(str) do {} while(0)
#endif

#define DAI_IFVERB(n, stmt) if(props.verbose>=n) { std::cerr << stmt; }


#ifdef WINDOWS
    double atanh( double x );

    double log1p( double x );

    #define INFINITY (std::numeric_limits<Real>::infinity())

    #define NAN (std::numeric_limits<Real>::quiet_NaN())

    #if defined(_MSC_VER)
      // Disable unsafe warning (use of the function 'strcpy' instead of 
      // 'strcpy_s' for portability reasons;
      #pragma warning( disable : 4996 )
      // Workaround for the char16_t type defined in Matlab and MSVC 2010
      #if (_MSC_VER >= 1600)
        #define __STDC_UTF_16__
      #endif
    #endif
#endif


namespace dai {


typedef double Real;

typedef mpz_class BigInt;

inline size_t BigInt_size_t( const BigInt &N ) {
    DAI_ASSERT( N <= (BigInt)std::numeric_limits<size_t>::max() );
    return N.get_ui();
}

bool isnan( Real x );

inline Real log( Real x ) {
    return std::log(x);
}

inline Real log0( Real x ) {
    return x ? std::log(x) : 0;
}

inline Real exp( Real x ) {
    return std::exp(x);
}


inline Real pow( Real x, Real y ) {
    errno = 0;
    if( x == 0.0 && y < 0.0 )
        return 0.0;
    Real result = std::pow(x, y);
    DAI_DEBASSERT( errno == 0 );
    return result;
}



template <typename T, typename U, typename H = boost::hash<T> >
    class hash_map : public std::tr1::unordered_map<T,U,H> {};


double toc();


template<class T>
inline T abs( const T &t ) {
    return (t < 0) ? (-t) : t;
}


void rnd_seed( size_t seed );

Real rnd_uniform();

Real rnd_stdnormal();

int rnd_int( int min, int max );

inline int rnd( int n ) {
    return rnd_int( 0, n-1 );
}


template<class T>
std::string toString( const T& x ) {
    return boost::lexical_cast<std::string>(x);
}


template<class T>
T fromString( const std::string& x ) {
    return boost::lexical_cast<T>(x);
}


template<class T>
std::ostream& operator << (std::ostream& os, const std::vector<T> & x) {
    os << "(";
    for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
        os << (it != x.begin() ? ", " : "") << *it;
    os << ")";
    return os;
}

template<class T>
std::ostream& operator << (std::ostream& os, const std::set<T> & x) {
    os << "{";
    for( typename std::set<T>::const_iterator it = x.begin(); it != x.end(); it++ )
        os << (it != x.begin() ? ", " : "") << *it;
    os << "}";
    return os;
}

template<class T1, class T2>
std::ostream& operator << (std::ostream& os, const std::map<T1,T2> & x) {
    os << "{";
    for( typename std::map<T1,T2>::const_iterator it = x.begin(); it != x.end(); it++ )
        os << (it != x.begin() ? ", " : "") << it->first << "->" << it->second;
    os << "}";
    return os;
}

template<class T1, class T2>
std::ostream& operator << (std::ostream& os, const std::pair<T1,T2> & x) {
    os << "(" << x.first << ", " << x.second << ")";
    return os;
}

template<class T>
std::vector<T> concat( const std::vector<T>& u, const std::vector<T>& v ) {
    std::vector<T> w;
    w.reserve( u.size() + v.size() );
    for( size_t i = 0; i < u.size(); i++ )
        w.push_back( u[i] );
    for( size_t i = 0; i < v.size(); i++ )
        w.push_back( v[i] );
    return w;
}


std::vector<std::string> tokenizeString( const std::string& s, bool singleDelim, const std::string& delim="\t\n" );



typedef enum { NORMPROB, NORMLINF } ProbNormType;


typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL, DISTHEL } ProbDistType;


} // end of namespace dai


#endif