src/meta.h

/*****************************************************************************
* This file is provided under the Creative Commons Attribution 3.0 license.
*
* You are free to share, copy, distribute, transmit, or adapt this work
* PROVIDED THAT you attribute the work to the authors listed below.
* For more information, please see the following web page:
* http://creativecommons.org/licenses/by/3.0/
*
* This file is a component of the Sleipnir library for functional genomics,
* authored by:
* Curtis Huttenhower (chuttenh@princeton.edu)
* Mark Schroeder
* Maria D. Chikina
* Olga G. Troyanskaya (ogt@princeton.edu, primary contact)
*
* If you use this library, the included executable tools, or any related
* code in your work, please cite the following publication:
* Curtis Huttenhower, Mark Schroeder, Maria D. Chikina, and
* Olga G. Troyanskaya.
* "The Sleipnir library for computational functional genomics"
*****************************************************************************/
#ifndef META_H
#define META_H

#include <float.h>
#include <math.h>
#include <vector>

#include "metai.h"

#ifdef _MSC_VER
#include <windows.h>
#include <winsock.h>
#else // _MSC_VER
#include <stdarg.h>
#include <sys/time.h>

#define _finite isfinite

typedef size_t  HANDLE;

inline int sprintf_s( char* szDest, const char* szFormat, ... ) {
    va_list valArgs;

    va_start( valArgs, szFormat );
    return vsprintf( szDest, szFormat, valArgs ); }

#if !defined(__PIC__) && defined(__GLIBC__) && defined(__GTHREAD_HAS_COND)
asm(".globl pthread_cond_wait");
asm(".globl pthread_cond_broadcast");
#endif
#endif // _MSC_VER

#ifndef ARRAYSIZE
#define ARRAYSIZE(a)    (sizeof(a)/sizeof(*a))
#endif // ARRAYSIZE
#ifndef SIZE_MAX
#define SIZE_MAX        ((size_t)-1)
#endif // SIZE_MAX

namespace Sleipnir {

class CMeta : CMetaImpl {
public:
    static const char   c_szWS[];

    static std::string Filename( const std::string& strString, char cReplacement = '_' );
    static std::string Basename( const char* szPath );
    static void Tokenize( const char* szString, std::vector<std::string>& vecstrTokens,
        const char* szSeparators = "\t", bool fNoEmpties = false );
    static std::string Trim( const char* szString );
    static bool MapRead( unsigned char*& pbData, HANDLE& hndlMap, size_t& iSize, const char* szFile );
    static bool MapWrite( unsigned char*& pbData, HANDLE& hndlMap, size_t iSize, const char* szFile );
    static void Unmap( const unsigned char* pbData, HANDLE hndlMap, size_t iSize );
    static size_t GetMemoryUsage( );

    template<class tType>
    static bool IsNaN( tType Value ) {


        return !_finite( Value ); }

    static float GetNaN( ) {

        return (float)HUGE_VAL; }

    static std::string Deextension( const std::string& strName ) {
        size_t  i;

        return ( ( ( i = strName.rfind( c_cPeriod ) ) == std::string::npos ) ? strName :
            strName.substr( 0, i ) ); }

    template <class tIterator>
    static void Permute( tIterator Items, const std::vector<size_t>& veciOrder ) {
        std::vector<size_t>                     veciMap, veciCopy;
        size_t                                  i;
          typename iterator_traits<tIterator>::value_type   Temp;

        veciCopy.resize( veciOrder.size( ) );
        veciMap.resize( veciOrder.size( ) );
        for( i = 0; i < veciOrder.size( ); ++i ) {
            veciCopy[ i ] = veciOrder[ i ];
            veciMap[ veciOrder[ i ] ] = i; }

        for( i = 0; i < veciOrder.size( ); ++i ) {
            if( veciCopy[ i ] == i )
                continue;
            Temp = Items[ i ];
            Items[ i ] = Items[ veciCopy[ i ] ];
            Items[ veciCopy[ i ] ] = Temp;
            veciCopy[ veciMap[ i ] ] = veciCopy[ i ];
            veciMap[ veciCopy[ i ] ] = veciMap[ i ]; } }

    template <class tType>
    static void Permute( std::vector<tType>& vecItems, const std::vector<size_t>& veciOrder ) {

        Permute( vecItems.begin( ), veciOrder ); }

    template <class tType>
    static size_t Quantize( tType Value, const std::vector<tType>& vecQuants ) {

        if( IsNaN( Value ) )
            return -1;

        /*
        size_t i;
        for( i = 0; i < vecQuants.size( ); ++i )
            if( Value <= vecQuants[ i ] )
                break;
        size_t r = min(i, vecQuants.size()-1);
        return r;
         */
        
        size_t mid = vecQuants.size() / 2;
        int i = mid;

        if(Value <= vecQuants[i]){
            i--;
            //LEFT direction
            while(i>=0){
                if(Value <= vecQuants[i]){
                    i--;
                }else{
                    i++;
                    break;
                }
            }
            if(i==-1){
                i = 0;
            }
        }else{
            i++;
            //RIGHT direction
            while(i<vecQuants.size()){
                if(Value > vecQuants[i]){
                    i++;
                }else{
                    break;
                }
            }
            if(i==vecQuants.size()){
                i = vecQuants.size() - 1;
            }
        }

        size_t ii = i;

        return ii;
    }

    static size_t GetMicroseconds( const struct timeval& sBegin, const struct timeval& sEnd ) {

        return ( ( sBegin.tv_sec == sEnd.tv_sec ) ? ( sEnd.tv_usec - sBegin.tv_usec ) :
            ( ( 1000000 * ( sEnd.tv_sec - sBegin.tv_sec ) ) + sEnd.tv_usec - sBegin.tv_usec ) ); }

    static bool SkipEdge( bool fAnswer, size_t i, size_t j, const std::vector<bool>& vecfHere, const std::vector<bool>& vecfUbik, bool fCtxtPos, bool fCtxtNeg, bool fBridgePos, bool fBridgeNeg, bool fOutPos, bool fOutNeg ) {
        if ( vecfHere.size( ) ) {
        bool fIn = vecfHere[ i ] && vecfHere[ j ];
                if( fIn ) {
                if ( fAnswer && !fCtxtPos ) {
                    return true;
            }
            else if ( !fAnswer && !fCtxtNeg ) {
                        return true;
                }
            }
        bool fBridge;
            if ( vecfUbik.size( ) ) {
            fBridge = !fIn && ( ( vecfUbik[ i ] && vecfHere[ j ] ) || ( vecfHere[ i ] && vecfUbik[ j ] ) );
        }
        else {
            fBridge = ( !!vecfHere[ i ] ^ !!vecfHere[ j ] );
        }
        if( fBridge ) {
            if ( fAnswer && !fBridgePos ) {
            return true;
            }
            else if ( !fAnswer && !fBridgeNeg ) {
            return true;
            }
        }
        bool fOut = !( fIn || fBridge );
        if( fOut ) {
            if ( fAnswer && !fOutPos) {
            return true;
            }
            else if ( !fAnswer && !fOutNeg ) {
            return true;
            }
        }
        }
        return false;
    }

    static bool IsExtension( const std::string& strFile, const std::string& strExtension ) {
        size_t  i;

        return ( ( strFile.length( ) >= strExtension.length( ) ) &&
            ( ( i = strFile.rfind( strExtension ) ) ==
            ( strFile.length( ) - strExtension.length( ) ) ) ); }

    CMeta( int iVerbosity, size_t iRandomSeed = 0 );
    /* 
     * \brief
     * Perform Sleipnir cleanup.
     */
    ~CMeta( );
};

}

#endif // META_H