src/pcl.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 PCL_H
#define PCL_H

#include <algorithm>
#include <fstream>
#include <string>

#include "pcli.h"
#include "measure.h"

namespace Sleipnir {

class CDat;

class CPCL: protected CPCLImpl {
public:
    enum ENormalize {
        ENormalizeNone,
        ENormalizeZScore,
        ENormalizeRow,
        ENormalizeMinMax,
        ENormalizeColumn,
        ENormalizeMean,
        ENormalizeColumnCenter,
        ENormalizeColumnFraction,
        EMeanSubtractColumn
    };

    static int Distance(const char* szFile, size_t iSkip,
            const char* szSimilarityMeasure, bool fNormalize, bool fZScore,
            bool fAutocorrelate, const char* szGeneFile, float dCutoff,
            size_t iLimit, CPCL& PCL, CDat& Dat, IMeasure::EMap eMap =
                    IMeasure::EMapCenter, bool fFrequencyWeight = false, float dAlpha = 0, int nThreads = 1);

    static int Distance(const char* szFile, size_t iSkip, const char* szWeights,
            const char* szSimilarityMeasure, bool fNormalize, bool fZScore,
            bool fAutocorrelate, const char* szGeneFile, float dCutoff,
            size_t iLimit, CPCL& PCL, CDat& Dat, IMeasure::EMap eMap =
                    IMeasure::EMapCenter, bool fFrequencyWeight = false, float dAlpha = 0, int nThreads = 1);

    static size_t GetSkip() {

        return c_iSkip;
    }

    static const char* GetExtension() {

        return CPCLImpl::c_szExtension;
    }

    CPCL(bool fHeader = true) :
        CPCLImpl(fHeader) {
    }

    void Open(const CPCL& PCL);
    void Open(const std::vector<size_t>& veciGenes, const std::vector<
            std::string>& vecstrGenes,
            const std::vector<std::string>& vecstrExperiments);
    void Open(const std::vector<std::string>& vecstrGenes, const std::vector<
            std::string>& vecstrExperiments,
            const std::vector<std::string>& vecstrFeatures);
    bool OpenBinary(std::istream& istm);
    bool Save(const char* szFile, const std::vector<size_t>* pveciGenes = NULL) const;
    void Save(std::ostream& ostm, const std::vector<size_t>* pveciGenes = NULL) const;
    void SaveBinary(std::ostream& ostm) const;
    void SaveGene(std::ostream& ostm, size_t iGene, size_t iOriginal = -1) const;
    void SaveHeader(std::ostream& ostm, bool fCDT = false) const;
    bool SortGenes(const std::vector<size_t>& veciOrder);
    void RankTransform();
    bool AddGenes(const std::vector<std::string>& vecstrGenes);
    void Normalize(ENormalize eNormalize = ENormalizeRow);
    void Impute(size_t iNeighbors, float dMinimumPresent,
            const CDat& DatSimilarity);
    void Impute(size_t iNeighbors, float dMinimumPresent,
            const IMeasure* pMeasure, bool fPrecompute = true);
    void MedianMultiples(size_t iSample = 100000, size_t iBins = 40,
            float dBinSize = 0.25);
    
    bool populate(const char* szFile, float dDefault = HUGE_VAL);
    
    void Save(const char* szFile = NULL);

    bool Open(const char* szFile, size_t iSkip = 2, bool fMemmap = false, bool rTable = false);
    
    bool Open(std::istream& istm, size_t iSkip, bool rTable = false);

    bool Open(std::istream& istm) {

        return Open(istm, GetSkip());
    }

    void Reset() {

        CPCLImpl::Reset();
    }

    void Clear() {

        m_Data.Clear();
    }

    size_t GetFeatures() const {

        return m_vecstrFeatures.size();
    }

    const std::string& GetFeature(size_t iFeature) const {

        return m_vecstrFeatures[iFeature];
    }

    const std::string& GetFeature(size_t iGene, size_t iFeature) const {

        return m_vecvecstrFeatures[iFeature - 1][iGene];
    }

    void SetFeature(size_t iGene, size_t iFeature, const std::string& strValue) {

        m_vecvecstrFeatures[iFeature-1][iGene] = strValue;
    }

    float& Get(size_t iGene, size_t iExperiment) const {

        return m_Data.Get(iGene, iExperiment);
    }

    float* Get(size_t iGene) const {

        return m_Data.Get(iGene);
    }

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

        m_Data.Set(iGene, adValues);
    }

    const CDataMatrix& Get() const {

        return m_Data;
    }

    size_t GetGenes() const {

        return m_vecstrGenes.size();
    }

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

        return m_vecstrGenes;
    }

    const std::vector<std::string>& GetExperimentNames() const {
        return m_vecstrExperiments;
    }
    size_t GetExperiments() const {

        return m_vecstrExperiments.size();
    }

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

        return m_vecstrGenes[iGene];
    }

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

        CPCLImpl::SetGene(iGene, strGene);
    }

    const std::string& GetExperiment(size_t iExperiment) const {

        return m_vecstrExperiments[iExperiment];
    }

    size_t GetExperiment(const std::string& strExperiment) const {
        size_t i;

        for (i = 0; i < m_vecstrExperiments.size(); ++i)
            if (m_vecstrExperiments[i] == strExperiment)
                return i;

        return -1;
    }

    void SetExperiment(size_t iExperiment, const std::string& strExperiment) {

        m_vecstrExperiments[iExperiment] = strExperiment;
    }

    void MaskGene(size_t iGene, bool fMask = true) {

        if (fMask)
            m_setiGenes.insert(iGene);
        else
            m_setiGenes.erase(iGene);
    }

    bool IsMasked(size_t iGene) const {

        return (m_setiGenes.find(iGene) != m_setiGenes.end());
    }

    void Set(size_t iGene, size_t iExperiment, float dValue) {

        m_Data.Set(iGene, iExperiment, dValue);
    }

    size_t GetGene(const std::string& strGene) const {
        TMapStrI::const_iterator iterGene;

        return (((iterGene = m_mapstriGenes.find(strGene))
                == m_mapstriGenes.end()) ? -1 : iterGene->second);
    }

    std::string GetFeature(size_t iGene, const char* szFeature) const {
        size_t i;

        for (i = 0; i < m_vecstrFeatures.size(); ++i)
            if (m_vecstrFeatures[i] == szFeature)
                return GetFeature(iGene, i);

        return "";
    }

    size_t AddFeature(string strName){
        m_vecstrFeatures.push_back(strName);
        size_t iF=m_vecstrFeatures.size()-1;
        m_vecvecstrFeatures.resize(iF);
        m_vecvecstrFeatures[iF-1].resize(GetGenes());
        return iF;
    }

    void Randomize() {
        size_t i;

        for (i = 0; i < GetGenes(); ++i)
            std::random_shuffle(Get(i), Get(i) + GetExperiments());
    }
};

}

#endif // PCL_H