general.h

Go to the documentation of this file.

 
#ifndef INTARNA_GENERAL_H_
#define INTARNA_GENERAL_H_
 
 
 
#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif
 
#include "IntaRNA/intarna_config.h"
 
#include <algorithm>
#include <cassert>
 
#if defined(_DEBUG) || !defined(NDEBUG)
    #define INTARNA_IN_DEBUG_MODE 1
#else
    #define INTARNA_IN_DEBUG_MODE 0
#endif
 
 
#include "easylogging++.h"
 
 
template<class T> void INTARNA_CLEANUP( T *& pointer) { if (pointer != NULL) {delete pointer; pointer=NULL;} }
 
 
#include <stdexcept>
 
    #define INTARNA_NOT_IMPLEMENTED(message)    \
        throw std::runtime_error( \
                    std::string("\nSTOP DUE TO MISSING IMPLEMENTATION : ") \
                    + message \
                );
 
 
#include <stdexcept>
 
    #define INTARNA_CHECK_NOT_NULL(pointer,message) if (pointer == NULL) {  \
        throw std::runtime_error( \
                    std::string("\nSTOP DUE TO NULL POINTER : ") \
                    + message \
                ); }
 
 
 
#include <boost/lexical_cast.hpp>
 
    #ifdef toString
        #error toString already defined
    #endif
    #define toString( x ) boost::lexical_cast<std::string>(x)
 
 
 
#include <cmath>
#include <limits>
 
#if INTARNA_MULTIPRECISION
    #include <boost/multiprecision/float128.hpp>
#endif
 
namespace IntaRNA {
 
    typedef float E_kcal_type;
 
    typedef int E_type;
    const E_type E_INF = (std::numeric_limits<E_type>::max() / 8) + 1;
    const E_type E_MAX = E_INF / 2;
 
#if INTARNA_MULTIPRECISION
    typedef boost::multiprecision::float128 Z_type;
    #define Z_log boost::multiprecision::log
    #define Z_exp boost::multiprecision::exp
#else
    typedef double Z_type;
    #define Z_log std::log
    #define Z_exp std::exp
#endif
    const Z_type Z_INF = std::numeric_limits<Z_type>::infinity();
 
} // namespace
 
#ifdef IntaRNA_precisionEpsilon
    #error IntaRNA_precisionEpsilon already defined
#endif
#define IntaRNA_precisionEpsilon std::sqrt(std::numeric_limits<float>::min())
 
#ifdef E_2_Ekcal
  #error E_2_Ekcal already defined
#endif
#define E_2_Ekcal( e ) ( static_cast<E_kcal_type>(e) / 100.0 )
 
#ifdef Ekcal_2_E
  #error Ekcal_2_E already defined
#endif
#define Ekcal_2_E( e ) ( static_cast<E_type>(e * 100) )
 
#ifdef E_2_Z
  #error E_2_Z already defined
#endif
#define E_2_Z( e ) ( static_cast<Z_type>(e) / 100.0 )
 
#ifdef Z_2_E
  #error Z_2_E already defined
#endif
#define Z_2_E( e ) ( static_cast<E_type>(e * 100) )
 
#ifdef E_equal
    #error E_equal already defined
#endif
#define E_equal( e1, e2 ) ( e1 == e2 )
 
#ifdef E_isNotINF
    #error E_isNotINF already defined
#endif
#define E_isNotINF( e ) ( E_INF > e )
 
#ifdef E_isINF
    #error E_isINF already defined
#endif
#define E_isINF( e ) ( E_INF <= e )
 
 
 
#ifdef Z_equal
    #error Z_equal already defined
#endif
#if INTARNA_MULTIPRECISION
    #define Z_equal( e1, e2 ) ( boost::multiprecision::abs((e1)-(e2)) < IntaRNA_precisionEpsilon)
#else
    #define Z_equal( e1, e2 ) ( std::abs((e1)-(e2)) < IntaRNA_precisionEpsilon)
#endif
// another option from http://en.cppreference.com/w/cpp/types/numeric_limits/epsilon
//#define Z_equal_ULP 2
//#define Z_equal( e1, e2 ) ( \
//  /* the machine epsilon has to be scaled to the magnitude of the values used */ \
//  /* and multiplied by the desired precision in ULPs (units in the last place) */ \
//  std::abs(e1-e2) < std::numeric_limits<T>::epsilon() * std::abs(e1+e2) * Z_equal_ULP \
//  /* unless the result is subnormal */ \
//  || std::abs(e1-e2) < std::numeric_limits<T>::min() \
//)
 
#ifdef Z_isNotINF
    #error Z_isNotINF already defined
#endif
#define Z_isNotINF( e ) ( std::numeric_limits<Z_type>::max() >= e )
 
#ifdef Z_isINF
    #error Z_isINF already defined
#endif
#define Z_isINF( e ) (  std::numeric_limits<Z_type>::max() < e )
 
 
 
#include <iostream>
#include <string>
 
namespace IntaRNA {
 
std::ostream *
newOutputStream( const std::string & outName );
 
 
void
deleteOutputStream( std::ostream *& outStream );
 
std::istream *
newInputStream( const std::string & inName );
 
 
void
deleteInputStream( std::istream *& inStream );
 
} // namespace
 
#endif /* GENERAL_H_ */