sts_cluster.h

Go to the documentation of this file.

//=============================================================================================================
 
#ifndef STS_CLUSTER_H
#define STS_CLUSTER_H
 
//=============================================================================================================
// INCLUDES
//=============================================================================================================
 
#include "sts_global.h"
#include "sts_types.h"
 
//=============================================================================================================
// QT INCLUDES
//=============================================================================================================
 
#include <QVector>
#include <QPair>
 
//=============================================================================================================
// EIGEN INCLUDES
//=============================================================================================================
 
#include <Eigen/Core>
#include <Eigen/SparseCore>
 
//=============================================================================================================
// DEFINE NAMESPACE STSLIB
//=============================================================================================================
 
namespace STSLIB
{
 
//=============================================================================================================
struct STSSHARED_EXPORT StatsClusterResult
{
    Eigen::MatrixXd matTObs;         
    QVector<double> vecClusterStats; 
    QVector<double> vecClusterPvals; 
    Eigen::MatrixXi matClusterIds;   
    double clusterThreshold;         
};
 
//=============================================================================================================
class STSSHARED_EXPORT StatsCluster
{
public:
    //=========================================================================================================
    static StatsClusterResult permutationTest(
        const QVector<Eigen::MatrixXd>& dataA,
        const QVector<Eigen::MatrixXd>& dataB,
        const Eigen::SparseMatrix<int>& adjacency,
        int nPermutations = 1024,
        double clusterAlpha = 0.05,
        double pThreshold = 0.05,
        StatsTailType tail = StatsTailType::Both);
 
    //=========================================================================================================
    static StatsClusterResult oneSamplePermutationTest(
        const QVector<Eigen::MatrixXd>& data,
        const Eigen::SparseMatrix<int>& adjacency,
        double threshold,
        int nPermutations,
        StatsTailType tail);
 
    //=========================================================================================================
    static StatsClusterResult fTestPermutationTest(
        const QVector<QVector<Eigen::MatrixXd>>& conditions,
        const Eigen::SparseMatrix<int>& adjacency,
        double threshold,
        int nPermutations);
 
    //=========================================================================================================
    static Eigen::MatrixXd tfce(
        const Eigen::MatrixXd& statMap,
        const Eigen::SparseMatrix<int>& adjacency,
        double E = 0.5,
        double H = 2.0,
        int nSteps = 100);
 
private:
    //=========================================================================================================
    static Eigen::MatrixXd computeTMap(
        const QVector<Eigen::MatrixXd>& dataA,
        const QVector<Eigen::MatrixXd>& dataB);
 
    //=========================================================================================================
    static QPair<Eigen::MatrixXi, QVector<double>> findClusters(
        const Eigen::MatrixXd& tMap,
        double threshold,
        const Eigen::SparseMatrix<int>& adjacency,
        StatsTailType tail);
 
    //=========================================================================================================
    static double permuteOnce(
        const QVector<Eigen::MatrixXd>& allData,
        int nA,
        const Eigen::SparseMatrix<int>& adjacency,
        double threshold,
        StatsTailType tail);
 
    //=========================================================================================================
    static double inverseTCdf(double p, int df);
 
    //=========================================================================================================
    static Eigen::MatrixXd computeOneSampleTMap(
        const QVector<Eigen::MatrixXd>& data);
 
    //=========================================================================================================
    static Eigen::MatrixXd computeFMap(
        const QVector<QVector<Eigen::MatrixXd>>& conditions);
 
    //=========================================================================================================
    static QPair<Eigen::MatrixXi, QVector<double>> findClustersFlat(
        const Eigen::MatrixXd& statMap,
        double threshold,
        const Eigen::SparseMatrix<int>& adjacency,
        bool positiveOnly);
 
    //=========================================================================================================
    static double permuteOnceOneSample(
        const QVector<Eigen::MatrixXd>& data,
        const Eigen::SparseMatrix<int>& adjacency,
        double threshold,
        StatsTailType tail);
 
    //=========================================================================================================
    static double permuteOnceFTest(
        const QVector<Eigen::MatrixXd>& allData,
        const QVector<int>& groupSizes,
        const Eigen::SparseMatrix<int>& adjacency,
        double threshold);
};
 
} // namespace STSLIB
 
#endif // STS_CLUSTER_H