src/measure.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 MEASURE_H
#define MEASURE_H

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

namespace Sleipnir {

class IMeasure {
public:
    enum EMap {
        EMapNone    = 0,
        EMapCenter  = EMapNone + 1,
        EMapAbs     = EMapCenter + 1
    };

    virtual ~IMeasure( ) { };

    virtual const char* GetName( ) const = 0;
    virtual bool IsRank( ) const = 0;
    virtual IMeasure* Clone( ) const = 0;
    virtual double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const = 0;
};

}

#include "measurei.h"

namespace Sleipnir {

class CMeasureSigmoid : CMeasureSigmoidImpl, public IMeasure {
public:
    CMeasureSigmoid( const IMeasure* pMeasure, bool fMemory, float dMultiplier ) :
        CMeasureSigmoidImpl( pMeasure, fMemory, dMultiplier ) { }

    const char* GetName( ) const {

        return m_pMeasure->GetName( ); }

    bool IsRank( ) const {

        return m_pMeasure->IsRank( ); }

    IMeasure* Clone( ) const {

        return new CMeasureSigmoid( m_pMeasure->Clone( ), true, m_dMult ); }

    double Measure( const float* adX, size_t iM, const float* adY, size_t iN, EMap eMap, const float* adWX,
        const float* adWY ) const {
        double  dRet;

        dRet = m_pMeasure->Measure( adX, iM, adY, iN, eMap, adWX, adWY );
        return ( 2 * ( 1 - ( 1 / ( 1 + exp( -dRet * m_dMult ) ) ) ) ); }
};

class CMeasureNegate : CMeasureImpl, public IMeasure {
public:
    CMeasureNegate( const IMeasure* pMeasure, bool fMemory ) : CMeasureImpl( pMeasure, fMemory ) { }

    const char* GetName( ) const {

        return m_pMeasure->GetName( ); }

    bool IsRank( ) const {

        return m_pMeasure->IsRank( ); }

    IMeasure* Clone( ) const {

        return new CMeasureNegate( m_pMeasure->Clone( ), true ); }

    double Measure( const float* adX, size_t iM, const float* adY, size_t iN, EMap eMap, const float* adWX,
        const float* adWY ) const {

        return -m_pMeasure->Measure( adX, iM, adY, iN, eMap, adWX, adWY ); }
};

class CMeasureInvert : CMeasureImpl, public IMeasure {
public:
    CMeasureInvert( const IMeasure* pMeasure, bool fMemory ) : CMeasureImpl( pMeasure, fMemory ) { }

    const char* GetName( ) const {

        return m_pMeasure->GetName( ); }

    bool IsRank( ) const {

        return m_pMeasure->IsRank( ); }

    IMeasure* Clone( ) const {

        return new CMeasureInvert( m_pMeasure->Clone( ), true ); }

    double Measure( const float* adX, size_t iM, const float* adY, size_t iN, EMap eMap, const float* adWX,
        const float* adWY ) const {
        double  d;

        d = m_pMeasure->Measure( adX, iM, adY, iN, eMap, adWX, adWY );
        return ( d ? ( 1 / d ) : DBL_MAX ); }
};

class CMeasureAutocorrelate : CMeasureImpl, public IMeasure {
public:
    CMeasureAutocorrelate( const IMeasure* pMeasure, bool fMemory ) : CMeasureImpl( pMeasure, fMemory ) { }

    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return m_pMeasure->GetName( ); }

    bool IsRank( ) const {

        return m_pMeasure->IsRank( ); }

    IMeasure* Clone( ) const {

        return new CMeasureAutocorrelate( m_pMeasure->Clone( ), true ); }
};

class CMeasureEuclidean : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "euclidean"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureEuclidean( ); }
};


class CMeasureEuclideanScaled : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "euclid_scaled"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureEuclidean( ); }
};


class CMeasurePearson : public IMeasure {
public:
    static double Pearson( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap,
        const float* adWX = NULL, const float* adWY = NULL, size_t* piCount = NULL );

    const char* GetName( ) const {

        return "pearson"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasurePearson( ); }

    double Measure( const float* adX, size_t iM, const float* adY, size_t iN, EMap eMap, const float* adWX,
        const float* adWY ) const {

        return CMeasurePearson::Pearson( adX, iM, adY, iN, eMap, adWX, adWY ); }
};

class CMeasureQuickPearson : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "quickpear"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureQuickPearson( ); }
};

class CMeasureKolmogorovSmirnov : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "kolm-smir"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureKolmogorovSmirnov( ); }
};

class CMeasureKendallsTau : CMeasureKendallsTauImpl, public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "kendalls"; }

    bool IsRank( ) const {

        return true; }

    IMeasure* Clone( ) const {

        return new CMeasureKendallsTau( ); }
};

class CMeasureSpearman : CMeasureSpearmanImpl, public IMeasure {
public:
    CMeasureSpearman( bool fTransformed ) : CMeasureSpearmanImpl( fTransformed ) { }

    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "spearman"; }

    bool IsRank( ) const {

        return true; }

    IMeasure* Clone( ) const {

        return new CMeasureSpearman( m_fTransformed ); }
};

class CMeasurePearNorm : CMeasurePearNormImpl, public IMeasure {
public:
    CMeasurePearNorm( ) : CMeasurePearNormImpl( HUGE_VAL, HUGE_VAL ) { }

    CMeasurePearNorm( double dAverage, double dStdev ) : CMeasurePearNormImpl( dAverage, dStdev ) { }

    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "pearnorm"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasurePearNorm( m_dAverage, m_dStdDev ); }
};

class CMeasureHypergeometric : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "hypergeom"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureHypergeometric( ); }
};

class CMeasureInnerProduct : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "innerprod"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureInnerProduct( ); }
};

class CMeasureBinaryInnerProduct : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "bininnerprod"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureBinaryInnerProduct( ); }
};

class CMeasureMutualInformation : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "mutinfo"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureMutualInformation( ); }
};

class CMeasureRelativeAUC : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "relauc"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureRelativeAUC( ); }
};

class CMeasurePearsonSignificance : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "pearsig"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasurePearsonSignificance( ); }
};

class CMeasureDistanceCorrelation : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "dcor"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureDistanceCorrelation( ); }
};


class CMeasureSignedDistanceCorrelation : public IMeasure {
public:
    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapNone,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "sdcor"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureSignedDistanceCorrelation( ); }
};

class CMeasureDice : public IMeasure {
public:
    CMeasureDice( float dAlpha = 0.5 ) : m_dAlpha(dAlpha) { }

    double Measure( const float* adX, size_t iN, const float* adY, size_t iM, EMap eMap = EMapCenter,
        const float* adWX = NULL, const float* adWY = NULL ) const;

    const char* GetName( ) const {

        return "dice"; }

    bool IsRank( ) const {

        return false; }

    IMeasure* Clone( ) const {

        return new CMeasureDice( ); }

private:
    float   m_dAlpha;
};

}

#endif // MEASURE_H