@@ -55,6 +55,7 @@ Collate:

     'class-CogapsResult.R'

     'createGWCoGAPSSets.R'

     'createscCoGAPSSets.R'

+    'distributedCogaps.R'

     'generateSeeds.R'

     'package.R'

     'patternMarkers.R'

@@ -15,6 +15,7 @@ export(createscCoGAPSSets)

 export(getMeanChiSq)

 export(getParam)

 export(patternMarkers)

+export(patternMatch)

 export(patternMatch4Parallel)

 export(plot.CogapsResult)

 export(plotResiduals)

@@ -30,8 +31,6 @@ import(shiny)

 importClassesFrom(S4Vectors,Annotated)

 importClassesFrom(S4Vectors,DataFrame)

 importClassesFrom(S4Vectors,character_OR_NULL)

-importClassesFrom(SingleCellExperiment,SingleCellExperiment)

-importClassesFrom(SummarizedExperiment,SummarizedExperiment)

 importFrom(RColorBrewer,brewer.pal)

 importFrom(Rcpp,evalCpp)

 importFrom(cluster,agnes)

@@ -73,7 +72,6 @@ importFrom(stats,sd)

 importFrom(stats,update)

 importFrom(stats,variable.names)

 importFrom(stats,weighted.mean)

-importFrom(tools,file_ext)

 importFrom(utils,file_test)

 importFrom(utils,read.table)

 importFrom(utils,str)

@@ -32,14 +32,14 @@ NULL

 #' params <- setParam(params, "nPatterns", 5)

 #' resultC <- CoGAPS(GIST.D, params)

 #' @importFrom methods new

-CoGAPS <- function(data, params=new("CogapsParams"), nCores=NULL,

+CoGAPS <- function(data, params=new("CogapsParams"), nThreads=NULL,

 messages=TRUE, outputFrequency=1000, uncertainty=NULL,

 checkpointOutFile="gaps_checkpoint.out", checkpointInterval=1000,

 checkpointInFile=NULL, transposeData=FALSE, ...)

 {

     # parse parameters from ...

     allParams <- list("gaps"=params,

-        "nCores"=nCores,

+        "nThreads"=nThreads,

         "messages"=messages,

         "outputFrequency"=outputFrequency,

         "checkpointOutFile"=checkpointOutFile,

@@ -113,7 +113,7 @@ checkpointInFile=NULL, transposeData=FALSE, ...)

         meanChiSq   = gapsReturnList$meanChiSq,

         diagnostics = gapsReturnList$diagnostics

     ))

-})

+}

 #' Check that provided data is valid

 #'

@@ -1,12 +1,12 @@

 # Generated by using Rcpp::compileAttributes() -> do not edit by hand

 # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

-cogaps_cpp_from_file <- function(data, params, unc, fixedMatrix, checkpointInFile) {

-    .Call('_CoGAPS_cogaps_cpp_from_file', PACKAGE = 'CoGAPS', data, params, unc, fixedMatrix, checkpointInFile)

+cogaps_cpp_from_file <- function(data, allParams, uncertainty, indices = numericVector(1), fixedMatrix = matrix(1,1)) {

+    .Call('_CoGAPS_cogaps_cpp_from_file', PACKAGE = 'CoGAPS', data, allParams, uncertainty, indices, fixedMatrix)

 }

-cogaps_cpp <- function(data, params, unc, fixedMatrix, checkpointInFile) {

-    .Call('_CoGAPS_cogaps_cpp', PACKAGE = 'CoGAPS', data, params, unc, fixedMatrix, checkpointInFile)

+cogaps_cpp <- function(data, allParams, uncertainty, indices = numericVector(1), fixedMatrix = matrix(1,1)) {

+    .Call('_CoGAPS_cogaps_cpp', PACKAGE = 'CoGAPS', data, allParams, uncertainty, indices, fixedMatrix)

 }

 getBuildReport_cpp <- function() {

@@ -22,22 +22,13 @@ distributedCogaps <- function(data, allParams, uncertainty)

     consensusMatrix <- findConsensusMatrix(initialResult, allParams)

     # set fixed matrix

-    initialA <- initialP <- matrix(0)

-    if (allParams$gaps@distributed == "genome-wide")

-    {

-        allParams$whichMatrixFixed <- "P"

-        initialP <- consensusMatrix

-    }

-    else

-    {

-        allParams$whichMatrixFixed <- "A"

-        initialA <- consensusMatrix

-    }

+    allParams$whichMatrixFixed <- ifelse(allParams$gaps@distributed

+        == "genome-wide", "P", "A")

     # run all subsets with the same fixed matrix

     finalResult <- foreach(i=1:nSets) %dopar%

     {

-        cogaps_cpp(data, allParams, uncertainty, sets[[i]], initialA, initialP)

+        cogaps_cpp(data, allParams, uncertainty, sets[[i]], consensusMatrix)

     }

     # get result 

@@ -3,32 +3,12 @@

 \docType{methods}

 \name{CoGAPS}

 \alias{CoGAPS}

-\alias{CoGAPS,SingleCellExperiment,CogapsParams-method}

-\alias{CoGAPS,SummarizedExperiment,CogapsParams-method}

-\alias{CoGAPS,character,CogapsParams-method}

-\alias{CoGAPS,data.frame,CogapsParams-method}

-\alias{CoGAPS,matrix,CogapsParams-method}

 \title{CoGAPS Matrix Factorization Algorithm}

 \usage{

-CoGAPS(data, params = new("CogapsParams"), uncertainty = NULL,

-  fixedMatrix = matrix(0), checkpointInFile = "", ...)

-

-\S4method{CoGAPS}{character,CogapsParams}(data, params = new("CogapsParams"),

-  uncertainty = NULL, fixedMatrix = matrix(0), checkpointInFile = "", ...)

-

-\S4method{CoGAPS}{matrix,CogapsParams}(data, params = new("CogapsParams"),

-  uncertainty = NULL, fixedMatrix = matrix(0), checkpointInFile = "", ...)

-

-\S4method{CoGAPS}{data.frame,CogapsParams}(data, params = new("CogapsParams"),

-  uncertainty = NULL, fixedMatrix = matrix(0), checkpointInFile = "", ...)

-

-\S4method{CoGAPS}{SummarizedExperiment,CogapsParams}(data,

-  params = new("CogapsParams"), uncertainty = NULL,

-  fixedMatrix = matrix(0), checkpointInFile = "", ...)

-

-\S4method{CoGAPS}{SingleCellExperiment,CogapsParams}(data,

-  params = new("CogapsParams"), uncertainty = NULL,

-  fixedMatrix = matrix(0), checkpointInFile = "", ...)

+CoGAPS(data, params = new("CogapsParams"), nThreads = NULL,

+  messages = TRUE, outputFrequency = 1000, uncertainty = NULL,

+  checkpointOutFile = "gaps_checkpoint.out", checkpointInterval = 1000,

+  checkpointInFile = NULL, transposeData = FALSE, ...)

 }

 \arguments{

 \item{data}{File name or R object (see details for supported types)}

@@ -37,12 +17,12 @@ CoGAPS(data, params = new("CogapsParams"), uncertainty = NULL,

 \item{uncertainty}{uncertainty matrix (same supported types as data)}

-\item{fixedMatrix}{data for fixing the values of either the A or P matrix;

-used in conjuction with whichMatrixFixed (see CogapsParams)}

-

 \item{checkpointInFile}{name of the checkpoint file}

 \item{...}{keeps backwards compatibility with arguments from older versions}

+

+\item{fixedMatrix}{data for fixing the values of either the A or P matrix;

+used in conjuction with whichMatrixFixed (see CogapsParams)}

 }

 \value{

 CogapsResult object

@@ -53,8 +33,7 @@ matrix factorization returning the two matrices that reconstruct

 the data matrix

 }

 \details{

-Currently, raw count matrices are the only supported R object. For

- file types CoGAPS supports csv, tsv, and mtx

+For file types CoGAPS supports csv, tsv, and mtx

 }

 \examples{

 # Running from R object

new file mode 100644

@@ -0,0 +1,26 @@

+% Generated by roxygen2: do not edit by hand

+% Please edit documentation in R/distributedCogaps.R

+\name{distributedCogaps}

+\alias{distributedCogaps}

+\title{CoGAPS Distributed Matrix Factorization Algorithm}

+\usage{

+distributedCogaps(data, allParams, uncertainty)

+}

+\arguments{

+\item{data}{File name or R object (see details for supported types)}

+

+\item{allParams}{list of all parameters used in computation}

+

+\item{uncertainty}{uncertainty matrix (same supported types as data)}

+}

+\value{

+list

+}

+\description{

+runs CoGAPS over subsets of the data and stitches the results

+back together

+}

+\details{

+For file types CoGAPS supports csv, tsv, and mtx

+}

+

new file mode 100644

@@ -0,0 +1,33 @@

+% Generated by roxygen2: do not edit by hand

+% Please edit documentation in R/distributedCogaps.R

+\name{patternMatch}

+\alias{patternMatch}

+\title{Match Patterns Across Multiple Runs}

+\usage{

+patternMatch(allPatterns, allParams)

+}

+\arguments{

+\item{Atot}{a matrix containing the total by set estimates of Pmean output from \code{reOrderBySet}}

+

+\item{nSets}{number of parallel sets used to generate \code{Atot}}

+

+\item{cnt}{number of branches at which to cut dendrogram}

+

+\item{minNS}{minimum of individual set contributions a cluster must contain}

+

+\item{maxNS}{maximum of individual set contributions a cluster must contain}

+

+\item{ignore.NA}{logical indicating whether or not to ignore NAs from potential over dimensionalization. Default is FALSE.}

+

+\item{bySet}{logical indicating whether to return list of matched set solutions from \code{Atot}}

+

+\item{...}{additional parameters for \code{agnes}}

+}

+\value{

+a matrix of consensus patterns by samples. If \code{bySet=TRUE} then a list of the set contributions to each

+consensus pattern is also returned.

+}

+\description{

+Match Patterns Across Multiple Runs

+}

+

@@ -1,10 +1,13 @@

-#include "GapsDispatcher.h"

+#include "GapsRunner.h"

 #include "math/SIMD.h"

 #include <Rcpp.h>

 #include <string>

+// these are helper functions for converting matrix/vector types

+// to and from R objects

+

 static std::vector<unsigned> convertRVec(const Rcpp::NumericVector &rvec)

 {

     std::vector<unsigned> vec;

@@ -15,9 +18,9 @@ static std::vector<unsigned> convertRVec(const Rcpp::NumericVector &rvec)

     return vec;

 }

-static RowMatrix convertRMatrix(const Rcpp::NumericMatrix &rmat)

+static Matrix convertRMatrix(const Rcpp::NumericMatrix &rmat)

 {

-    RowMatrix mat(rmat.nrow(), rmat.ncol());

+    Matrix mat(rmat.nrow(), rmat.ncol());

     for (unsigned i = 0; i < mat.nRow(); ++i)

     {

         for (unsigned j = 0; j < mat.nCol(); ++j)

@@ -42,7 +45,10 @@ static Rcpp::NumericMatrix createRMatrix(const Matrix &mat)

     return rmat;

 }

-static bool isNull(const RowMatrix &mat)

+// this provides a standard way for communicating which parameters

+// are null between R and C++

+

+static bool isNull(const Matrix &mat)

 {

     return mat.nRow() == 1 && mat.nCol() == 1;

 }

@@ -62,105 +68,97 @@ static bool isNull(const std::string &path)

     return path.empty();

 }

-template <class T>

-static Rcpp::List cogapsRun(const T &data, const Rcpp::List &allParams,

-const T &uncertainty, const Rcpp::NumericVector &indices,

-const Rcpp::NumericMatrix &initialA, const Rcpp::NumericMatrix &initialP)

+// this is the main function that creates a GapsRunner and runs CoGAPS

+

+template <class DataType>

+static Rcpp::List cogapsRun(const DataType &data, const Rcpp::List &allParams,

+const DataType &uncertainty, const Rcpp::NumericVector &indices,

+const Rcpp::NumericMatrix &fixedMatrix)

 {

-    GapsDispatcher dispatcher;

+    // convert string parameters

+    Rcpp::S4 gapsParams = allParams["gaps"];

+    std::string checkpointInFile = Rcpp::as<std::string>(allParams["checkpointInFile"]);

+    std::string distributed = Rcpp::as<std::string>(gapsParams.slot("distributed"));

+    GAPS_ASSERT(distributed == "genome-wide" || distributed == "single-cell");

+    bool partitionRows = (distributed == "genome-wide");

+    

+    // read number of patterns from checkpoint file

+    unsigned nPatterns = gapsParams.slot("nPatterns");

+    unsigned seed = gapsParams.slot("seed"); // so we can return seed

+    Archive ar(checkpointInFile, ARCHIVE_READ);

+    if (!isNull(checkpointInFile))

+    {

+        gaps::random::load(ar);

+        ar >> nPatterns >> seed;

+    }

-    // check if we're initializing with a checkpoint or not

-    if (!isNull(Rcpp::as<std::string>(allParams["checkpointInFile"])))

+    // construct GapsRunner

+    GapsRunner runner(data, allParams["transposeData"], nPatterns, seed,

+        partitionRows, convertRVec(indices));

+

+    // populate GapsRunner from checkpoint file

+    if (!isNull(checkpointInFile))

     {

-        dispatcher.initialize(data, allParams["transposeData"],

-            allParams["checkpointInFile"]);

+        ar >> runner;

+        ar.close();

     }

     else

     {

-        Rcpp::S4 gapsParams = allParams["gaps"];

-

-        if (!isNull(Rcpp::as<std::string>(gapsParams.slot("distributed"))))

+        // set fixed matrix

+        if (!isNull(fixedMatrix))

         {

-            dispatcher.initialize(data, allParams["transposeData"],

-                gapsParams.slot("nPatterns"), gapsParams.slot("seed"),

-                gapsParams.slot("distributed") == "genome-wide",

-                convertRVec(indices));

-

-            if (!isNull(uncertainty))

-            {

-                dispatcher.setUncertainty(uncertainty,

-                    allParams["transposeData"],

-                    gapsParams.slot("distributed") == "genome-wide",

-                    convertRVec(indices));

-            }

-        }

-        else

-        {

-            dispatcher.initialize(data, allParams["transposeData"],

-                gapsParams.slot("nPatterns"), gapsParams.slot("seed"));

-

-            if (!isNull(uncertainty))

-            {

-                dispatcher.setUncertainty(uncertainty, allParams["transposeData"]);

-            }

+            std::string which = Rcpp::as<std::string>(allParams["whichMatrixFixed"]);

+            GAPS_ASSERT(!isNull(which));

+            runner.setFixedMatrix(which[0], convertRMatrix(fixedMatrix));

         }

-        // set optional parameters

-        dispatcher.setMaxIterations(gapsParams.slot("nIterations"));

-        dispatcher.setSparsity(gapsParams.slot("alphaA"),

+        // set parameters that would be saved in the checkpoint 

+        gaps::random::setSeed(seed);

+        runner.setMaxIterations(gapsParams.slot("nIterations"));

+        runner.setSparsity(gapsParams.slot("alphaA"),

             gapsParams.slot("alphaP"), gapsParams.slot("singleCell"));

-        dispatcher.setMaxGibbsMass(gapsParams.slot("maxGibbsMassA"),

+        runner.setMaxGibbsMass(gapsParams.slot("maxGibbsMassA"),

             gapsParams.slot("maxGibbsMassP"));

-

-        // set initial values for A and P matrix

-        if (!isNull(initialA))

-        {

-            dispatcher.setAMatrix(convertRMatrix(initialA));

-        }

-        if (!isNull(initialP))

-        {

-            dispatcher.setPMatrix(convertRMatrix(initialP));

-        }

-

-        // check if running with a fixed matrix

-        if (!isNull(Rcpp::as<std::string>(allParams["whichMatrixFixed"])))

-        {

-            dispatcher.setFixedMatrix(allParams["whichMatrixFixed"]);

-        }

     }

-    // set the uncertainty matrix

+    // set uncertainty

+    if (!isNull(uncertainty))

+    {

+        runner.setUncertainty(uncertainty, allParams["transposeData"],

+            partitionRows, convertRVec(indices));

+    }

     // set parameters that aren't saved in the checkpoint

-    dispatcher.setNumCoresPerSet(allParams["nCores"]);

-    dispatcher.printMessages(allParams["messages"]);

-    dispatcher.setOutputFrequency(allParams["outputFrequency"]);

-    dispatcher.setCheckpointOutFile(allParams["checkpointOutFile"]);

-    dispatcher.setCheckpointInterval(allParams["checkpointInterval"]);

-

-    // run the dispatcher and return the GapsResult in an R list

-    GapsResult result(dispatcher.run());

+    runner.setMaxThreads(allParams["nThreads"]);

+    runner.setPrintMessages(allParams["messages"]);

+    runner.setOutputFrequency(allParams["outputFrequency"]);

+    runner.setCheckpointOutFile(allParams["checkpointOutFile"]);

+    runner.setCheckpointInterval(allParams["checkpointInterval"]);

+

+    // run cogaps and return the GapsResult in an R list

+    GapsResult result(runner.run());

     GAPS_ASSERT(result.meanChiSq > 0.f);

     return Rcpp::List::create(

         Rcpp::Named("Amean") = createRMatrix(result.Amean),

         Rcpp::Named("Pmean") = createRMatrix(result.Pmean),

         Rcpp::Named("Asd") = createRMatrix(result.Asd),

         Rcpp::Named("Psd") = createRMatrix(result.Psd),

-        Rcpp::Named("seed") = result.seed,

+        Rcpp::Named("seed") = seed,

         Rcpp::Named("meanChiSq") = result.meanChiSq,

         Rcpp::Named("diagnostics") = Rcpp::List::create()

     );

 }

+// these are the functions exposed to the R package

+

 // [[Rcpp::export]]

 Rcpp::List cogaps_cpp_from_file(const std::string &data,

 const Rcpp::List &allParams,

 const std::string &uncertainty,

 const Rcpp::NumericVector &indices=Rcpp::NumericVector(1),

-const Rcpp::NumericMatrix &initialA=Rcpp::NumericMatrix(1,1),

-const Rcpp::NumericMatrix &initialP=Rcpp::NumericMatrix(1,1))

+const Rcpp::NumericMatrix &fixedMatrix=Rcpp::NumericMatrix(1,1))

 {

-    return cogapsRun(data, allParams, uncertainty, indices, initialA, initialP);

+    return cogapsRun(data, allParams, uncertainty, indices, fixedMatrix);

 }

 // [[Rcpp::export]]

@@ -168,11 +166,10 @@ Rcpp::List cogaps_cpp(const Rcpp::NumericMatrix &data,

 const Rcpp::List &allParams,

 const Rcpp::NumericMatrix &uncertainty,

 const Rcpp::NumericVector &indices=Rcpp::NumericVector(1),

-const Rcpp::NumericMatrix &initialA=Rcpp::NumericMatrix(1,1),

-const Rcpp::NumericMatrix &initialP=Rcpp::NumericMatrix(1,1))

+const Rcpp::NumericMatrix &fixedMatrix=Rcpp::NumericMatrix(1,1))

 {

     return cogapsRun(convertRMatrix(data), allParams,

-        convertRMatrix(uncertainty), indices, initialA, initialP);

+        convertRMatrix(uncertainty), indices, fixedMatrix);

 }

 // [[Rcpp::export]]

deleted file mode 100644

@@ -1,155 +0,0 @@

-#include "GapsDispatcher.h"

-

-#include <string>

-

-#ifdef __GAPS_OPENMP__

-    #include <omp.h>

-#endif

-

-GapsDispatcher::GapsDispatcher() : mSeed(0), mNumPatterns(3),

-    mMaxIterations(1000), mNumCoresPerSet(1), mPrintMessages(true),

-    mCheckpointsCreated(0), mPhase('C'), mCheckpointInterval(0),

-    mCheckpointOutFile("gaps_checkpoint.out"), mInitialized(false)

-{}

-

-GapsDispatcher::~GapsDispatcher()

-{

-    for (unsigned i = 0; i < mRunners.size(); ++i)

-    {

-        delete mRunners[i];

-    }

-}

-

-void GapsDispatcher::setMaxIterations(unsigned n)

-{

-    mMaxIterations = n;

-}

-

-void GapsDispatcher::printMessages(bool print)

-{

-    GAPS_ASSERT(mInitialized);

-    mPrintMessages = print;

-    mRunners[0]->printMessages(print);

-}

-

-void GapsDispatcher::setOutputFrequency(unsigned n)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setOutputFrequency(n);

-}

-

-void GapsDispatcher::setSparsity(float alphaA, float alphaP, bool singleCell)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setSparsity(alphaA, alphaP, singleCell);

-}

-

-void GapsDispatcher::setMaxGibbsMass(float maxA, float maxP)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setMaxGibbsMass(maxA, maxP);

-}

-

-void GapsDispatcher::setAMatrix()

-{

-    GAPS_ASSERT(mInitialized);

-}

-

-void GapsDispatcher::setPMatrix()

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->

-}

-

-void GapsDispatcher::setFixedMatrix(char which)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setFixedMatrix(which, mat);

-}

-

-void GapsDispatcher::setNumCoresPerSet(unsigned n)

-{

-    mNumCoresPerSet = n;

-}

-

-void GapsDispatcher::setCheckpointInterval(unsigned n)

-{

-    mCheckpointInterval = n;

-}

-

-void GapsDispatcher::setCheckpointOutFile(const std::string &path)

-{

-    mCheckpointOutFile = path;

-}

-

-GapsResult GapsDispatcher::run()

-{

-    GAPS_ASSERT(mInitialized);

-    GAPS_ASSERT(mPhase == 'C' || mPhase == 'S');

-

-    // calculate appropiate number of cores if compiled with openmp

-    #ifdef __GAPS_OPENMP__

-    if (mPrintMessages)

-    {

-        unsigned availableCores = omp_get_max_threads();

-        mNumCoresPerSet = std::min(availableCores, mNumCoresPerSet);

-        gaps_printf("Running on %d out of %d available cores\n",

-            mNumCoresPerSet, availableCores);

-    }

-    #endif

-

-    // this switch allows for the algorithm to be interruptable

-    mRunners[0]->startClock();

-    switch (mPhase)

-    {

-        case 'C':

-            if (mPrintMessages)

-            {

-                gaps_printf("-- Calibration Phase --\n");

-            }

-            runOneCycle(mMaxIterations);

-            mPhase = 'S';

-

-        case 'S':

-            if (mPrintMessages)

-            {

-                gaps_printf("-- Sampling Phase --\n");

-            }

-            mRunners[0]->startSampling();

-            runOneCycle(mMaxIterations);

-            break;

-    }

-

-    // extract useful information from runners

-    GapsResult result(mRunners[0]->nRow(), mRunners[0]->nCol(), mSeed);

-    result.Amean = mRunners[0]->Amean();

-    result.Pmean = mRunners[0]->Pmean();

-    result.Asd = mRunners[0]->Asd();

-    result.Psd = mRunners[0]->Psd();

-    result.meanChiSq = mRunners[0]->meanChiSq();

-    return result;

-}

-

-void GapsDispatcher::createCheckpoint() const

-{

-    Archive ar(mCheckpointOutFile, ARCHIVE_WRITE);

-

-    gaps::random::save(ar);

-    ar << mSeed << mNumPatterns << mMaxIterations << mPrintMessages <<

-        mCheckpointsCreated << mPhase;

-

-    ar << *mRunners[0];

-}

-

-void GapsDispatcher::runOneCycle(unsigned k)

-{

-    unsigned nCheckpoints = mCheckpointInterval > 0 ? k / mCheckpointInterval : 0;

-    while (mCheckpointsCreated < nCheckpoints)

-    {

-        mRunners[0]->run(mCheckpointInterval, mNumCoresPerSet);

-        createCheckpoint();

-        ++mCheckpointsCreated;

-    }

-    mRunners[0]->run(k - mCheckpointInterval * mCheckpointsCreated, mNumCoresPerSet);

-    mCheckpointsCreated = 0; // reset checkpoint count for next cycle

-}

deleted file mode 100644

@@ -1,180 +0,0 @@

-#ifndef __COGAPS_GAPS_DISPATCHER_H__

-#define __COGAPS_GAPS_DISPATCHER_H__

-

-#include "GapsRunner.h"

-#include "math/SIMD.h"

-

-#include <string>

-

-struct GapsResult

-{

-    ColMatrix Amean;

-    ColMatrix Asd;

-    RowMatrix Pmean;

-    RowMatrix Psd;

-    

-    float meanChiSq;

-    uint32_t seed;

-

-    GapsResult(unsigned nrow, unsigned ncol, uint32_t rngSeed) :

-        Amean(nrow, ncol), Asd(nrow, ncol), Pmean(nrow, ncol), Psd(nrow, ncol),

-        meanChiSq(0.f), seed(rngSeed)

-    {}

-

-    void writeCsv(const std::string &path);

-    void writeTsv(const std::string &path);

-    void writeGct(const std::string &path);

-};

-

-// should be agnostic to external caller (R/Python/CLI)

-class GapsDispatcher

-{

-private:

-

-    uint32_t mSeed;

-    unsigned mNumPatterns;

-

-    unsigned mMaxIterations;

-    unsigned mNumCoresPerSet;

-    bool mPrintMessages;

-

-    unsigned mCheckpointsCreated;

-    char mPhase; // 'C' for calibration, 'S' for sample

-

-    unsigned mCheckpointInterval;

-    std::string mCheckpointOutFile;

-

-    bool mInitialized;    

-    std::vector<GapsRunner*> mRunners;

-

-    void runOneCycle(unsigned k);

-    void createCheckpoint() const;

-

-    GapsDispatcher(const GapsDispatcher &p); // don't allow copies

-    GapsDispatcher& operator=(const GapsDispatcher &p); // don't allow copies

-

-    template <class DataType>

-    void loadData(const DataType &data, bool transposeData);

-

-    template <class DataType>

-    void loadData(const DataType &data, bool transposeData, bool partitionRows,

-        const std::vector<unsigned> &indices);

-

-public:

-

-    GapsDispatcher();

-    ~GapsDispatcher();

-

-    template <class DataType>

-    void initialize(const DataType &data, bool transposeData,

-        unsigned nPatterns, uint32_t seed);

-

-    template <class DataType>

-    void initialize(const DataType &data, bool transposeData,

-        unsigned nPatterns, uint32_t seed, bool partitionRows,

-        const std::vector<unsigned> &indices);

-

-    template <class DataType>

-    void initialize(const DataType &data, bool transposeData,

-        const std::string &cptFile);

-

-    template <class DataType>

-    void setUncertainty(const DataType &unc, bool transposeData);

-

-    template <class DataType>

-    void setUncertainty(const DataType &unc, bool transposeData,

-        bool partitionRows, const std::vector<unsigned> &indices);

-

-    void setMaxIterations(unsigned n);

-    void printMessages(bool print);

-    void setOutputFrequency(unsigned n);

-    void setSparsity(float alphaA, float alphaP, bool singleCell);

-    void setMaxGibbsMass(float maxA, float maxP);

-

-    void setAMatrix(const RowMatrix &mat);

-    void setPMatrix(const RowMatrix &mat);

-    void setFixedMatrix(char which);

-    

-    void setNumCoresPerSet(unsigned n);

-    void setCheckpointInterval(unsigned n);

-    void setCheckpointOutFile(const std::string &path);

-    

-    GapsResult run();

-};

-

-template <class DataType>

-void GapsDispatcher::initialize(const DataType &data, bool transposeData,

-unsigned nPatterns, uint32_t seed)

-{

-    mSeed = seed;

-    mNumPatterns = nPatterns;

-    gaps::random::setSeed(mSeed);

-    

-    loadData(data, transposeData);

-    mInitialized = true;

-}

-

-template <class DataType>

-void GapsDispatcher::initialize(const DataType &data, bool transposeData,

-unsigned nPatterns, uint32_t seed, bool partitionRows,

-const std::vector<unsigned> &indices)

-{

-    mSeed = seed;

-    mNumPatterns = nPatterns;

-    gaps::random::setSeed(mSeed);

-    

-    loadData(data, transposeData, partitionRows, indices);

-    mInitialized = true;

-}

-

-template <class DataType>

-void GapsDispatcher::initialize(const DataType &data, bool transposeData,

-const std::string &cptFile)

-{

-    Archive ar(cptFile, ARCHIVE_READ);

-    gaps::random::load(ar);

-

-    ar >> mSeed >> mNumPatterns >> mMaxIterations >> mPrintMessages >>

-        mCheckpointsCreated >> mPhase;

-

-    loadData(data, transposeData);

-    ar >> *mRunners[0];

-    mInitialized = true;

-}

-

-template <class DataType>

-void GapsDispatcher::setUncertainty(const DataType &unc, bool transposeData)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setUncertainty(unc, transposeData);

-}

-

-template <class DataType>

-void GapsDispatcher::setUncertainty(const DataType &unc, bool transposeData,

-bool partitionRows, const std::vector<unsigned> &indices)

-{

-    GAPS_ASSERT(mInitialized);

-    mRunners[0]->setUncertainty(unc, transposeData, partitionRows, indices);

-}

-

-template <class DataType>

-void GapsDispatcher::loadData(const DataType &data, bool transposeData)

-{

-    gaps_printf("Loading Data...");

-    gaps_flush();

-    mRunners.push_back(new GapsRunner(data, transposeData, mNumPatterns));

-    gaps_printf("Done!\n");

-}

-

-template <class DataType>

-void GapsDispatcher::loadData(const DataType &data, bool transposeData,

-bool partitionRows, const std::vector<unsigned> &indices)

-{

-    gaps_printf("Loading Data...");

-    gaps_flush();

-    mRunners.push_back(new GapsRunner(data, transposeData, partitionRows,

-        indices, mNumPatterns));

-    gaps_printf("Done!\n");

-}

-

-#endif // __COGAPS_GAPS_DISPATCHER_H__

\ No newline at end of file

@@ -8,14 +8,26 @@

 #include <Rcpp.h>

 #endif

-void GapsRunner::printMessages(bool print)

+#ifdef __GAPS_OPENMP__

+#include <omp.h>

+#endif

+

+void GapsRunner::setFixedMatrix(char which, const Matrix &mat)

 {

-    mPrintMessages = print;

+    mFixedMatrix = which;

+    if (which == 'A')

+    {

+        mASampler.setMatrix(mat);

+    }

+    else if (which == 'P')

+    {

+        mPSampler.setMatrix(mat);

+    }

 }

-void GapsRunner::setOutputFrequency(unsigned n)

+void GapsRunner::setMaxIterations(unsigned nIterations)

 {

-    mOutputFrequency = n;

+    mMaxIterations = nIterations;

 }

 void GapsRunner::setSparsity(float alphaA, float alphaP, bool singleCell)

@@ -30,48 +42,85 @@ void GapsRunner::setMaxGibbsMass(float maxA, float maxP)

     mPSampler.setMaxGibbsMass(maxP);

 }

-void GapsRunner::setFixedMatrix(char which, const RowMatrix &mat)

+void GapsRunner::setMaxThreads(unsigned nThreads)

 {

-    mFixedMatrix = which;

-    if (which == 'A')

-    {

-        gaps_printf("setting fixed A\n");

-        mASampler.setMatrix(ColMatrix(mat));

-        gaps_printf("updating AP\n");

-        mASampler.recalculateAPMatrix();

-        gaps_printf("syncing\n");

-        mPSampler.sync(mASampler);

-    }

-    else if (which == 'P')

-    {

-        gaps_printf("setting fixed P\n");

-        mPSampler.setMatrix(mat);

-        mPSampler.recalculateAPMatrix();

-        mASampler.sync(mPSampler);

-    }

+    mMaxThreads = nThreads;

 }

-void GapsRunner::startSampling()

+void GapsRunner::setPrintMessages(bool print)

 {

-    mSamplePhase = true;

+    mPrintMessages = print;

 }

-void GapsRunner::startClock()

+void GapsRunner::setOutputFrequency(unsigned n)

+{

+    mOutputFrequency = n;

+}

+

+void GapsRunner::setCheckpointOutFile(const std::string &file)

+{

+    mCheckpointOutFile = file;

+}

+

+void GapsRunner::setCheckpointInterval(unsigned interval)

+{

+    mCheckpointInterval = interval;

+}

+

+GapsResult GapsRunner::run()

 {