src/datapair.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 DATAPAIR_H
#define DATAPAIR_H

#include "datapairi.h"

namespace Sleipnir {

class CSlim;

class CDataPair : public CDataPairImpl {
public:
    bool Open( const char* szDatafile, bool fContinuous, bool fMemmap = false, size_t iSkip = 2,
        bool fZScore = false, bool fSeek = false );
    bool Open( const CSlim& Slim );
    bool Open( const CDat& dat );
    bool OpenQuants( const char* szDatafile );
    void SetQuants( const float* adBinEdges, size_t iBins ){
      SetQuants(adBinEdges, iBins );
    }
    void SetQuants( const std::vector<float>& vecdBinEdges );
    std::vector<float> GetQuants(){
        std::vector<float> v;
        size_t i;
        for(i=0; i<m_vecdQuant.size(); i++){
            v.push_back(m_vecdQuant[i]);
        }
        return v;
    }

    size_t Quantize( float dValue ) const;
    void Quantize( );
    size_t Quantize( size_t iY, size_t iX, size_t iZero ) const;

    void Save( const char* szFile ) const;
    
    
    unsigned char GetValues( ) const {

        return (unsigned char)m_vecdQuant.size( ); }

    bool IsContinuous( ) const {

        return m_fContinuous; }

    bool Open( const CDat& DatKnown, const std::vector<CGenes*>& vecpOther, const CGenome& Genome,
        bool fKnownNegatives ) {

        return CDat::Open( DatKnown, vecpOther, Genome, fKnownNegatives ); }

    bool Open( const std::vector<std::string>& vecstrGenes, const CDistanceMatrix& MatScores ) {

        return CDat::Open( vecstrGenes, MatScores ); }
};

class CPCLPair : public CPCLPairImpl {
public:
    bool Open( const char* szDatafile, size_t iSkip );
    size_t Quantize( float dValue, size_t iExperiment ) const;
    void Quantize( );

    unsigned char GetValues( size_t iExperiment ) const {
      
      return (unsigned char)m_vecvecdQuants[ iExperiment ].size( ); }
    

};

class CDatFilter : public CDatFilterImpl {
public:

    bool Attach( const CDataPair& Dat, const CGenes& Genes, CDat::EFilter eFilter,
        const CDat* pAnswers = NULL );
    bool Attach( const CDatFilter& Dat, const CGenes& Genes, CDat::EFilter eFilter,
        const CDat* pAnswers = NULL );

    bool Attach( const CDataPair& Dat ) {

        return CDatFilterImpl::Attach( &Dat, NULL, NULL, CDat::EFilterInclude, NULL ); }

    size_t GetValues( ) const {

        return ( m_pFilter ? m_pFilter->GetValues( ) : ( m_pDat ? m_pDat->GetValues( ) : -1 ) ); }

    size_t GetGene( const std::string& strGene ) const {

        return ( m_pFilter ? m_pFilter->GetGene( strGene ) : ( m_pDat ? m_pDat->GetGene( strGene ) : -1 ) ); }

    std::string GetGene( size_t iGene ) const {

        return CDatFilterImpl::GetGene( iGene ); }

    size_t Quantize( float dValue ) const {

        return ( m_pFilter ? m_pFilter->Quantize( dValue ) : ( m_pDat ? m_pDat->Quantize( dValue ) : -1 ) ); }


    size_t Quantize( size_t iY, size_t iX, size_t iZero ) const {
        float d;
        if( iY == -1 || iX == -1 ) {
            return -1;
        }else if( CMeta::IsNaN( (d = Get( iY, iX )) ) ) {
            return iZero;
        }else {
            return Quantize(d);
        }
    }



    float& Get( size_t iY, size_t iX ) const {
        static float    c_dNaN  = CMeta::GetNaN( );

        if( !( m_pDat || m_pFilter ) )
            return c_dNaN;
        if( m_vecfGenes.empty( ) )
            return ( m_pFilter ? m_pFilter->Get( iY, iX ) : ( m_pDat ? m_pDat->Get( iY, iX ) : c_dNaN ) );

        switch( m_eFilter ) {
            case CDat::EFilterInclude:
                if( !( m_vecfGenes[ iX ] && m_vecfGenes[ iY ] ) )
                    return c_dNaN;
                break;

            case CDat::EFilterExclude:
                if( m_vecfGenes[ iX ] || m_vecfGenes[ iY ] )
                    return c_dNaN;
                break;

            case CDat::EFilterEdge:
                if( !( m_vecfGenes[ iX ] || m_vecfGenes[ iY ] ) )
                    return c_dNaN;
                break;

            case CDat::EFilterTerm:
                float   d;
                size_t  iOne, iTwo;

                if( !m_pAnswers )
                    return c_dNaN;
                d = ( ( ( iOne = m_veciAnswers[ iX ] ) != -1 ) && ( ( iTwo = m_veciAnswers[ iY ] ) != -1 ) ) ?
                    m_pAnswers->Get( iTwo, iOne ) : CMeta::GetNaN( );
                if( !( m_vecfGenes[ iX ] || m_vecfGenes[ iY ] ) ||
                    ( ( m_vecfGenes[ iX ] != m_vecfGenes[ iY ] ) && !CMeta::IsNaN( d ) && ( d > 0 ) ) )
                    return c_dNaN;
                break; }

        return ( m_pFilter ? m_pFilter->Get( iY, iX ) : m_pDat->Get( iY, iX ) ); }
};

}

#endif // DATAPAIR_H