src/dat.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 DAT_H
#define DAT_H

#include <iostream>
#include <string>
#include <vector>

#include "dati.h"

namespace Sleipnir {

class CGenes;
class CGenome;

class CDat : protected CDatImpl {
public:
    enum EFilter {
        EFilterInclude      = 0,
        EFilterTerm         = EFilterInclude + 1,
        EFilterExclude      = EFilterTerm + 1,
        EFilterPixie        = EFilterExclude + 1,
        EFilterEdge         = EFilterPixie + 1,
        EFilterHefalmp      = EFilterEdge + 1,
        EFilterIncludePos   = EFilterHefalmp +1,        
        EFilterExEdge   = EFilterIncludePos +1

    };

    enum EFormat {
        EFormatBinary   = 0,
        EFormatText     = EFormatBinary + 1,
        EFormatPCL      = EFormatText + 1,
        EFormatSparse   = EFormatPCL + 1,

        EFormatQdab = EFormatSparse + 1

    };

    enum ENormalize {
        ENormalizeNone      = 0,
        ENormalizeMinMax    = ENormalizeNone + 1,
        ENormalizeMinMaxNPone   = ENormalizeMinMax + 1,
        ENormalizeZScore    = ENormalizeMinMaxNPone + 1,
        ENormalizeSigmoid   = ENormalizeZScore + 1,
        ENormalizeNormCDF   = ENormalizeSigmoid + 1,
        ENormalizePCC       = ENormalizeNormCDF + 1
    };


    bool Open( const char* szFile, bool fMemmap = false, size_t iSkip = 2, bool fZScore = false,
        bool fDuplicates = false, bool fSeek = false );
    bool Open( std::istream& istm, EFormat eFormat = EFormatBinary, float dDefault = HUGE_VAL,
        bool fDuplicates = false, size_t iSkip = 2, bool fZScore = false, bool fSeek = false );
    bool Open( const CSlim& Slim );
    bool Open( const CSlim& SlimPositives, const CSlim& SlimNonnegatives );
    bool Open( const std::vector<std::string>& vecstrGenes, bool fClear = true, const char* szFile = NULL );
    bool Open( const std::vector<std::string>& vecstrGenes, const CDistanceMatrix& MatValues );
    bool Open( const std::vector<CGenes*>& vecpPositives, const std::vector<CGenes*>& vecpNonnegatives,
        float dPValue, const CGenome& Genome, bool fIncident = false );
    bool Open( const CDat& DatKnown, const std::vector<CGenes*>& vecpOther, const CGenome& Genome,
           bool fKnownNegatives, bool fIncident = false );
    bool Open( const CPCL& PCL, const IMeasure* pMeasure, bool fMeasureMemory );
    bool Open( const CDat& Dat );

    bool OpenGenes( std::istream& istm, bool fBinary, bool fPCL = false );
    bool OpenGenes( const char* szFile, size_t iSkip = 2 );
    void Save( std::ostream& ostm, EFormat eFormat = EFormatBinary ) const;
    void Save( const char* szFile ) const;
    void SaveDOT( std::ostream& ostm, float dCutoff = HUGE_VAL, const CGenome* pGenome = NULL,
        bool fUnlabeled = false, bool fHashes = true, const std::vector<float>* pvecdColors = NULL,
        const std::vector<float>* pvecdBorders = NULL ) const;
    void SaveGDF( std::ostream& ostm, float dCutoff = HUGE_VAL ) const;
    void SaveNET( std::ostream& ostm, float dCutoff = HUGE_VAL ) const;
    void SaveMATISSE( std::ostream& ostm, float dCutoff = HUGE_VAL, const CGenome* pGenome = NULL ) const;
    void Invert( );
    void Rank( );
    bool FilterGenes( const char* szGenes, EFilter eFilter, size_t iLimit = -1 );
    void FilterGenes( const CGenes& Genes, EFilter eFilter, size_t iLimit = -1,
              float dEdgeAggressiveness = 0.5, bool fAbsolute = false, const std::vector<float>* pvecdWeights = NULL );
    void NormalizeQuantiles( size_t iQuantiles );

    float* GetRowSeek(const string &strGene) {
        return CDatImpl::GetRowSeek(m_ifsm, strGene);
    }
    float* GetRowSeek(const size_t &i){
        return CDatImpl::GetRowSeek(m_ifsm, i);
    }

    size_t GetGeneIndex(const string &strGene) const {
        return CDatImpl::GetGeneIndex(strGene);
    }

    void AveStd( double& a, double& b, size_t& c){
        return CDatImpl::AveStd(a, b, c);
    }

    void Clear( float dValue ) {
        size_t  i;

        for( i = 0; i < GetGenes( ); ++i )
            memset( Get( i ), *(int*)&dValue, ( GetGenes( ) - i - 1 ) * sizeof(*Get( i )) ); }

    bool AddGene( const std::string& strGene ) {
        std::vector<std::string>    vecstrGenes;

        vecstrGenes.push_back( strGene );
        return AddGenes( vecstrGenes ); }

    bool AddGenes( const std::vector<std::string>& vecstrGenes ) {

        if( m_pPCL || m_abData || !m_Data.SetSize( m_Data.GetSize( ) + vecstrGenes.size( ), true ) )
            return false;

        m_vecstrGenes.insert( m_vecstrGenes.end( ), vecstrGenes.begin( ), vecstrGenes.end( ) );
        return true; }

    void Normalize( ENormalize eNormalize ) {

        switch( eNormalize ) {
            case ENormalizeMinMax:
                NormalizeMinmax( );
                break;

            case ENormalizeMinMaxNPone:
                NormalizeMinmaxNPone( );
                break;

            case ENormalizeZScore:
                NormalizeStdev( );
                break;

            case ENormalizeNormCDF:
                NormalizeNormCDF( );
                break;

            case ENormalizePCC:
                NormalizePCC( );
                break;

            default:
                NormalizeSigmoid( ); } }

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

        return CDatImpl::GetGene( strGene ); }

    float* GetFullRow( const size_t &iY ) {
        return CDatImpl::GetFullRow(iY);
    }


    float& Get( size_t iY, size_t iX ) const {

        return CDatImpl::Get( iY, iX ); }

    size_t GetGenes( ) const {

        return CDatImpl::GetGenes( ); }

    const CDistanceMatrix& Get( ) const {

        return m_Data; }

    CDistanceMatrix& Get( ) {

        return m_Data; }

    bool Set( size_t iY, size_t iX, float dValue ) {

        return CDatImpl::Set( iY, iX, dValue ); }

    std::string GetGene( size_t iGene ) const {

        return CDatImpl::GetGene( iGene ); }

    const std::vector<std::string>& GetGeneNames( ) const {

        return CDatImpl::GetGeneNames( ); }

    void Set( size_t iY, const float* adValues ) {

        m_Data.Set( iY, adValues ); }

    const float* Get( size_t iY ) const {

        return m_Data.Get( iY ); }

    float* Get( size_t iY ) {

        return m_Data.Get( iY ); }

    void SetGene( size_t iGene, const std::string& strGene ) {

        if( m_pPCL )
            m_pPCL->SetGene( iGene, strGene );
        else
            m_vecstrGenes[ iGene ] = strGene; }

    void Randomize( ) {
        size_t  i, j, iOne, iTwo;
        float   dOne, dTwo;

        for( i = 0; i < GetGenes( ); ++i )
            for( j = ( i + 1 ); j < GetGenes( ); ++j ) {
                if( CMeta::IsNaN( dOne = Get( i, j ) ) )
                    continue;
                while( true ) {
                    iOne = rand( ) % GetGenes( );
                    iTwo = rand( ) % GetGenes( );
                    if( iOne > iTwo )
                        std::swap( iOne, iTwo );
                    if( ( ( iOne != i ) || ( iTwo != j ) ) && !CMeta::IsNaN( dTwo = Get( iOne, iTwo ) ) )
                        break; }
                Set( i, j, dTwo );
                Set( iOne, iTwo, dOne ); } }


};

}

#endif // DAT_H