@@ -1,10 +1,6 @@

 # Generated by roxygen2: do not edit by hand

 export(CoGAPS)

-<<<<<<< HEAD

-export(CoGAPSFromFile)

-=======

->>>>>>> develop

 export(CoGapsFromCheckpoint)

 export(GWCoGAPS)

 export(GWCoGapsFromCheckpoint)

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

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

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

-<<<<<<< HEAD

 cogapsFromFile_cpp <- function(D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq) {

     .Call('_CoGAPS_cogapsFromFile_cpp', PACKAGE = 'CoGAPS', D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq)

 }

 cogaps_cpp <- function(D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq, nCores) {

     .Call('_CoGAPS_cogaps_cpp', PACKAGE = 'CoGAPS', D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq, nCores)

-=======

-cogaps_cpp <- function(D, S, nFactor, nEquil, nEquilCool, nSample, nOutputs, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seed, messages, singleCellRNASeq, whichMatrixFixed, FP, checkpointInterval, cptFile, pumpThreshold, nPumpSamples, nCores) {

-    .Call('_CoGAPS_cogaps_cpp', PACKAGE = 'CoGAPS', D, S, nFactor, nEquil, nEquilCool, nSample, nOutputs, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seed, messages, singleCellRNASeq, whichMatrixFixed, FP, checkpointInterval, cptFile, pumpThreshold, nPumpSamples, nCores)

-}

-

-cogapsFromCheckpoint_cpp <- function(D, S, nFactor, nEquil, nSample, cptFile) {

-    .Call('_CoGAPS_cogapsFromCheckpoint_cpp', PACKAGE = 'CoGAPS', D, S, nFactor, nEquil, nSample, cptFile)

-}

-

-cogapsFromFile_cpp <- function(D) {

-    invisible(.Call('_CoGAPS_cogapsFromFile_cpp', PACKAGE = 'CoGAPS', D))

->>>>>>> develop

 }

 getBuildReport_cpp <- function() {

@@ -5,19 +5,11 @@

 \title{CoGAPS Matrix Factorization Algorithm}

 \usage{

 CoGAPS(D, S, nFactor = 7, nEquil = 250, nSample = 250, nOutputs = 1000,

-<<<<<<< HEAD

   nSnapshots = 0, alphaA = 0.01, alphaP = 0.01, maxGibbmassA = 100,

   maxGibbmassP = 100, seed = NA, messages = TRUE,

   singleCellRNASeq = FALSE, whichMatrixFixed = "N",

   fixedPatterns = matrix(0), checkpointInterval = 0,

   checkpointFile = "gaps_checkpoint.out", nCores = 1, ...)

-=======

-  alphaA = 0.01, alphaP = 0.01, maxGibbmassA = 100, maxGibbmassP = 100,

-  seed = -1, messages = TRUE, singleCellRNASeq = FALSE,

-  whichMatrixFixed = "N", fixedPatterns = matrix(0),

-  checkpointInterval = 0, checkpointFile = "gaps_checkpoint.out",

-  nCores = 1, ...)

->>>>>>> develop

 }

 \arguments{

 \item{D}{data matrix}

@@ -48,6 +48,8 @@ private:

     std::vector<GapsRunner*> mRunners;

+    char mFixedMatrix;

+

     void runOneCycle(unsigned k);

 public:

@@ -55,7 +57,8 @@ public:

     GapsDispatcher(uint32_t seed=0) : mNumPatterns(3), mMaxIterations(1000),

         mOutputFrequency(250), mSeed(seed), mAlphaA(0.01), mAlphaP(0.01),

         mMaxGibbsMassA(100.f), mMaxGibbsMassP(100.f), mPrintMessages(true),

-        mSingleCell(false), mDataIsLoaded(false), mNumCoresPerSet(1)

+        mSingleCell(false), mDataIsLoaded(false), mNumCoresPerSet(1),

+        mFixedMatrix('N')

     {

         gaps::random::setSeed(mSeed);

     }

@@ -87,6 +90,12 @@ public:

         mMaxGibbsMassA = maxA;

         mMaxGibbsMassP = maxP;

     }

+

+    void setFixedMatrix(char which, const RowMatrix &mat)

+    {

+        mFixedMatrix = which;

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

+    }

     void loadCheckpointFile(const std::string &pathToCptFile);

@@ -14,20 +14,11 @@ GapsRunner::GapsRunner(const RowMatrix &data, unsigned nPatterns, float alphaA,

 float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool singleCell)

     :

 mNumRows(data.nRow()), mNumCols(data.nCol()),

-mASampler(data, data.pmax(0.1f), nPatterns, alphaA, maxGibbsMassA),

-mPSampler(data, data.pmax(0.1f), nPatterns, alphaP, maxGibbsMassP),

+mASampler(data, nPatterns, alphaA, maxGibbsMassA, singleCell),

+mPSampler(data, nPatterns, alphaP, maxGibbsMassP, singleCell),

 mStatistics(data.nRow(), data.nCol(), nPatterns),

 mSamplePhase(false), mNumUpdatesA(0), mNumUpdatesP(0)

 {

-    if (mFixedMatrix == 'A')

-    {

-        mASampler.setMatrix(ColMatrix(FP));

-    }

-    else if (mFixedMatrix == 'P')

-    {

-        mPSampler.setMatrix(RowMatrix(FP));

-    }

-

     mASampler.sync(mPSampler);

     mPSampler.sync(mASampler);

 }

@@ -37,8 +28,8 @@ float alphaA, float alphaP, float maxGibbsMassA, float maxGibbsMassP,

 bool singleCell)

     :

 mNumRows(FileParser(pathToData).nRow()), mNumCols(FileParser(pathToData).nCol()),

-mASampler(pathToData, nPatterns, alphaA, maxGibbsMassA),

-mPSampler(pathToData, nPatterns, alphaP, maxGibbsMassP),

+mASampler(pathToData, nPatterns, alphaA, maxGibbsMassA, singleCell),

+mPSampler(pathToData, nPatterns, alphaP, maxGibbsMassP, singleCell),

 mStatistics(mNumRows, mNumCols, nPatterns),

 mSamplePhase(false), mNumUpdatesA(0), mNumUpdatesP(0)

 {

@@ -46,6 +37,18 @@ mSamplePhase(false), mNumUpdatesA(0), mNumUpdatesP(0)

     mPSampler.sync(mASampler);

 }

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

+{

+    if (which == 'A')

+    {

+        mASampler.setMatrix(ColMatrix(mat));

+    }

+    else if (which == 'P')

+    {

+        mPSampler.setMatrix(mat);

+    }

+}

+

 void GapsRunner::setUncertainty(const std::string &pathToMatrix)

 {

     mASampler.setUncertainty(pathToMatrix);

@@ -47,6 +47,8 @@ public:

     void displayStatus(unsigned outFreq, unsigned current, unsigned total);

+    void setFixedMatrix(char which, const RowMatrix &mat);

+

     ColMatrix AMean() const { return mStatistics.AMean(); }

     RowMatrix PMean() const { return mStatistics.PMean(); }

     ColMatrix AStd() const { return mStatistics.AStd(); }

@@ -158,19 +158,19 @@ float GapsStatistics::meanChiSq(const AmplitudeGibbsSampler &ASampler) const

         M);

 }

-Rcpp::NumericMatrix GapsStatistics::pumpMatrix() const

+RowMatrix GapsStatistics::pumpMatrix() const

 {

     unsigned denom = mPumpStatUpdates != 0 ? mPumpStatUpdates : 1.f;

-    return (mPumpMatrix / denom).rMatrix();

+    return RowMatrix(mPumpMatrix / denom);

 }

-Rcpp::NumericMatrix GapsStatistics::meanPattern()

+RowMatrix GapsStatistics::meanPattern()

 {

     ColMatrix Amean(mAMeanMatrix / static_cast<float>(mStatUpdates));

     RowMatrix Pmean(mPMeanMatrix / static_cast<float>(mStatUpdates));

     ColMatrix mat(mAMeanMatrix.nRow(), mAMeanMatrix.nCol());

     patternMarkers(Amean, Pmean, mat);

-    return mat.rMatrix();

+    return RowMatrix(mat);

 }

 Archive& operator<<(Archive &ar, GapsStatistics &stat)

@@ -43,6 +43,9 @@ public:

     void updatePump(const AmplitudeGibbsSampler &ASampler,

         const PatternGibbsSampler &PSampler);

+    RowMatrix pumpMatrix() const;

+    RowMatrix meanPattern();

+

     void patternMarkers(ColMatrix normedA, RowMatrix normedP, ColMatrix &statMatrix);

     // serialization

@@ -1,9 +1,21 @@

 #include "GibbsSampler.h"

 #include "math/SIMD.h"

-AmplitudeGibbsSampler::AmplitudeGibbsSampler(const RowMatrix &D,

-const RowMatrix &S, unsigned nFactor, float alpha, float maxGibbsMass)

-    : GibbsSampler(D, S, D.nRow(), nFactor, alpha)

+/******************** AmplitudeGibbsSampler Implementation ********************/

+

+AmplitudeGibbsSampler::AmplitudeGibbsSampler(const RowMatrix &D, 

+unsigned nFactor, float alpha, float maxGibbsMass, bool singleCell)

+    :

+GibbsSampler(D, D.nRow(), nFactor, nFactor, alpha, maxGibbsMass, singleCell)

+{

+    mQueue.setDimensionSize(mBinSize, mNumCols);

+}

+

+AmplitudeGibbsSampler::AmplitudeGibbsSampler(const std::string &pathToData,

+unsigned nFactor, float alpha, float maxGibbsMass, bool singleCell)

+    :

+GibbsSampler(pathToData, FileParser(pathToData).nRow(), nFactor, nFactor, alpha, 

+maxGibbsMass, singleCell)

 {

     mQueue.setDimensionSize(mBinSize, mNumCols);

 }

@@ -95,9 +107,21 @@ unsigned r2, unsigned c2, float m2)

     return computeDeltaLL(r1, c1, m1) + computeDeltaLL(r2, c2, m2);

 }

+/********************* PatternGibbsSampler Implementation *********************/

+

 PatternGibbsSampler::PatternGibbsSampler(const RowMatrix &D,

-const RowMatrix &S, unsigned nFactor, float alpha, float maxGibbsMass)

-    : GibbsSampler(D, S, nFactor, D.nCol(), alpha)

+unsigned nFactor, float alpha, float maxGibbsMass, bool singleCell)

+    :

+GibbsSampler(D, nFactor, D.nCol(), nFactor, alpha, maxGibbsMass, singleCell)

+{

+    mQueue.setDimensionSize(mBinSize, mNumRows);

+}

+

+PatternGibbsSampler::PatternGibbsSampler(const std::string &pathToData,

+unsigned nFactor, float alpha, float maxGibbsMass, bool singleCell)

+    :

+GibbsSampler(pathToData, nFactor, FileParser(pathToData).nCol(), nFactor, alpha,

+maxGibbsMass, singleCell)

 {

     mQueue.setDimensionSize(mBinSize , mNumRows);

 }

@@ -80,35 +80,23 @@ protected:

 public:

-    GibbsSampler(const RowMatrix &D, const RowMatrix &S, unsigned nrow,

-        unsigned ncol, float alpha);

-

-    GibbsSampler(const std::string pathToData, unsigned nrow, unsigned ncol,

-    float alpha)

-        :

-    mMatrix(nrow, ncol), mOtherMatrix(NULL), mDMatrix(pathToData),

-    mSMatrix(mDMatrix.pmax(0.1f)), mAPMatrix(mDMatrix.nRow(), mDMatrix.nCol()),

-    mQueue(nrow * ncol, alpha), mLambda(0.f), mMaxGibbsMass(0.f),

-    mAnnealingTemp(0.f), mNumRows(nrow), mNumCols(ncol), mAvgQueue(0.f),

-    mNumQueues(0.f)

-    {

-        mBinSize = std::numeric_limits<uint64_t>::max()

-            / static_cast<uint64_t>(mNumRows * mNumCols);

-        uint64_t remain = std::numeric_limits<uint64_t>::max()

-            % static_cast<uint64_t>(mNumRows * mNumCols);

-        mQueue.setDomainSize(std::numeric_limits<uint64_t>::max() - remain);

-        mDomain.setDomainSize(std::numeric_limits<uint64_t>::max() - remain);

-    }

+    GibbsSampler(const RowMatrix &D, unsigned nrow, unsigned ncol,

+        unsigned nPatterns, float alpha, float maxGibbsMass, bool singleCell);

+

+    GibbsSampler(const std::string &pathToData, unsigned nrow, unsigned ncol,

+        unsigned nPatterns, float alpha, float maxGibbsMass, bool singleCell);

+

+    void setUncertainty(const RowMatrix &S);

+    void setUncertainty(const std::string &path);

     void update(unsigned nSteps, unsigned nCores);

     void setAnnealingTemp(float temp);

-    float getAvgQueue() const { return mAvgQueue; }

+    float getAvgQueue() const;

     float chi2() const;

     uint64_t nAtoms() const;

-    void setUncertainty(const RowMatrix &S) { mSMatrix = MatB(S); }

-    void setUncertainty(const std::string &path) { mSMatrix = MatB(path); }

+    void setMatrix(const MatA &mat);

     // serialization

     friend Archive& operator<< <T, MatA, MatB> (Archive &ar, GibbsSampler &samp);

@@ -130,19 +118,11 @@ private:

 public:

-    AmplitudeGibbsSampler(const RowMatrix &D, const RowMatrix &S,

-        unsigned nFactor, float alpha=0.f, float maxGibbsMass=0.f);

+    AmplitudeGibbsSampler(const RowMatrix &D, unsigned nFactor,

+        float alpha=0.f, float maxGibbsMass=0.f, bool singleCell=false);

     AmplitudeGibbsSampler(const std::string &pathToData, unsigned nFactor,

-    float alpha=0.f, float maxGibbsMass=0.f)

-        :

-    GibbsSampler(pathToData, FileParser(pathToData).nRow(), nFactor, alpha)

-    {

-        float meanD = gaps::algo::mean(mDMatrix);

-        mLambda = alpha * std::sqrt(nFactor / meanD);

-        mMaxGibbsMass = maxGibbsMass / mLambda;

-        mQueue.setDimensionSize(mBinSize, mNumCols);

-    }

+    float alpha=0.f, float maxGibbsMass=0.f, bool singleCell=false);

     void sync(PatternGibbsSampler &sampler);

@@ -170,19 +150,11 @@ private:

 public:

-    PatternGibbsSampler(const RowMatrix &D, const RowMatrix &S,

-        unsigned nFactor, float alpha=0.f, float maxGibbsMass=0.f);

+    PatternGibbsSampler(const RowMatrix &D, unsigned nFactor,

+        float alpha=0.f, float maxGibbsMass=0.f, bool singleCell=false);

     PatternGibbsSampler(const std::string &pathToData, unsigned nFactor,

-    float alpha=0.f, float maxGibbsMass=0.f)

-        :

-    GibbsSampler(pathToData, nFactor, FileParser(pathToData).nCol(), alpha)

-    {

-        float meanD = gaps::algo::mean(mDMatrix);

-        mLambda = alpha * std::sqrt(nFactor / meanD);

-        mMaxGibbsMass = maxGibbsMass / mLambda;

-        mQueue.setDimensionSize(mBinSize , mNumRows);

-    }

+        float alpha=0.f, float maxGibbsMass=0.f, bool singleCell=false);

     void sync(AmplitudeGibbsSampler &sampler);

@@ -199,12 +171,14 @@ public:

 template <class T, class MatA, class MatB>

 GibbsSampler<T, MatA, MatB>::GibbsSampler(const RowMatrix &D,

-const RowMatrix &S, unsigned nrow, unsigned ncol, float alpha)

+unsigned nrow, unsigned ncol, unsigned nPatterns, float alpha,

+float maxGibbsMass, bool singleCell)

     :

-mMatrix(nrow, ncol), mOtherMatrix(NULL), mDMatrix(D), mSMatrix(S),

-mAPMatrix(D.nRow(), D.nCol()), mQueue(nrow * ncol, alpha), mLambda(0.f),

-mMaxGibbsMass(0.f), mAnnealingTemp(0.f), mNumRows(nrow), mNumCols(ncol),

-mAvgQueue(0.f), mNumQueues(0.f)

+mMatrix(nrow, ncol), mOtherMatrix(NULL), mDMatrix(D),

+mSMatrix(mDMatrix.pmax(0.1f)), mAPMatrix(D.nRow(), D.nCol()),

+mQueue(nrow * ncol, alpha), mLambda(0.f), mMaxGibbsMass(maxGibbsMass),

+mAnnealingTemp(0.f), mNumRows(nrow), mNumCols(ncol), mAvgQueue(0.f),

+mNumQueues(0.f)

 {

     mBinSize = std::numeric_limits<uint64_t>::max()

         / static_cast<uint64_t>(mNumRows * mNumCols);

@@ -215,7 +189,31 @@ mAvgQueue(0.f), mNumQueues(0.f)

     float meanD = singleCell ? gaps::algo::nonZeroMean(mDMatrix) :

         gaps::algo::mean(mDMatrix);

-    mLambda = alpha * std::sqrt(nFactor / meanD);

+    mLambda = alpha * std::sqrt(nPatterns / meanD);

+    mMaxGibbsMass = maxGibbsMass / mLambda;

+}

+

+template <class T, class MatA, class MatB>

+GibbsSampler<T, MatA, MatB>::GibbsSampler(const std::string &pathToData,

+unsigned nrow, unsigned ncol, unsigned nPatterns, float alpha,

+float maxGibbsMass, bool singleCell)

+    :

+mMatrix(nrow, ncol), mOtherMatrix(NULL), mDMatrix(pathToData),

+mSMatrix(mDMatrix.pmax(0.1f)), mAPMatrix(mDMatrix.nRow(), mDMatrix.nCol()),

+mQueue(nrow * ncol, alpha), mLambda(0.f), mMaxGibbsMass(maxGibbsMass),

+mAnnealingTemp(0.f), mNumRows(nrow), mNumCols(ncol), mAvgQueue(0.f),

+mNumQueues(0.f)

+{

+    mBinSize = std::numeric_limits<uint64_t>::max()

+        / static_cast<uint64_t>(mNumRows * mNumCols);

+    uint64_t remain = std::numeric_limits<uint64_t>::max()

+        % static_cast<uint64_t>(mNumRows * mNumCols);

+    mQueue.setDomainSize(std::numeric_limits<uint64_t>::max() - remain);

+    mDomain.setDomainSize(std::numeric_limits<uint64_t>::max() - remain);

+

+    float meanD = singleCell ? gaps::algo::nonZeroMean(mDMatrix) :

+        gaps::algo::mean(mDMatrix);

+    mLambda = alpha * std::sqrt(nPatterns / meanD);

     mMaxGibbsMass = maxGibbsMass / mLambda;

 }

@@ -523,6 +521,24 @@ void GibbsSampler<T, MatA, MatB>::setMatrix(const MatA &mat)

     mMatrix = mat;

 }

+template <class T, class MatA, class MatB>

+float GibbsSampler<T, MatA, MatB>::getAvgQueue() const

+{

+    return mAvgQueue;

+}

+

+template <class T, class MatA, class MatB>

+void GibbsSampler<T, MatA, MatB>::setUncertainty(const RowMatrix &S)

+{

+    mSMatrix = MatB(S);

+}

+

+template <class T, class MatA, class MatB>

+void GibbsSampler<T, MatA, MatB>::setUncertainty(const std::string &path)

+{

+    mSMatrix = MatB(path);

+}

+

 template <class T, class MatA, class MatB>

 Archive& operator<<(Archive &ar, GibbsSampler<T, MatA, MatB> &samp)

 {

@@ -5,7 +5,6 @@

 using namespace Rcpp;

-<<<<<<< HEAD

 // cogapsFromFile_cpp

 Rcpp::List cogapsFromFile_cpp(const std::string& D, unsigned nPatterns, unsigned maxIter, unsigned outputFrequency, unsigned seed, float alphaA, float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool messages, bool singleCellRNASeq);

 RcppExport SEXP _CoGAPS_cogapsFromFile_cpp(SEXP DSEXP, SEXP nPatternsSEXP, SEXP maxIterSEXP, SEXP outputFrequencySEXP, SEXP seedSEXP, SEXP alphaASEXP, SEXP alphaPSEXP, SEXP maxGibbsMassASEXP, SEXP maxGibbsMassPSEXP, SEXP messagesSEXP, SEXP singleCellRNASeqSEXP) {

@@ -17,28 +16,12 @@ BEGIN_RCPP

     Rcpp::traits::input_parameter< unsigned >::type maxIter(maxIterSEXP);

     Rcpp::traits::input_parameter< unsigned >::type outputFrequency(outputFrequencySEXP);

     Rcpp::traits::input_parameter< unsigned >::type seed(seedSEXP);

-=======

-// cogaps_cpp

-Rcpp::List cogaps_cpp(const Rcpp::NumericMatrix& D, const Rcpp::NumericMatrix& S, unsigned nFactor, unsigned nEquil, unsigned nEquilCool, unsigned nSample, unsigned nOutputs, float alphaA, float alphaP, float maxGibbmassA, float maxGibbmassP, unsigned seed, bool messages, bool singleCellRNASeq, char whichMatrixFixed, const Rcpp::NumericMatrix& FP, unsigned checkpointInterval, const std::string& cptFile, unsigned pumpThreshold, unsigned nPumpSamples, unsigned nCores);

-RcppExport SEXP _CoGAPS_cogaps_cpp(SEXP DSEXP, SEXP SSEXP, SEXP nFactorSEXP, SEXP nEquilSEXP, SEXP nEquilCoolSEXP, SEXP nSampleSEXP, SEXP nOutputsSEXP, SEXP alphaASEXP, SEXP alphaPSEXP, SEXP maxGibbmassASEXP, SEXP maxGibbmassPSEXP, SEXP seedSEXP, SEXP messagesSEXP, SEXP singleCellRNASeqSEXP, SEXP whichMatrixFixedSEXP, SEXP FPSEXP, SEXP checkpointIntervalSEXP, SEXP cptFileSEXP, SEXP pumpThresholdSEXP, SEXP nPumpSamplesSEXP, SEXP nCoresSEXP) {

-BEGIN_RCPP

-    Rcpp::RObject rcpp_result_gen;

-    Rcpp::RNGScope rcpp_rngScope_gen;

-    Rcpp::traits::input_parameter< const Rcpp::NumericMatrix& >::type D(DSEXP);

-    Rcpp::traits::input_parameter< const Rcpp::NumericMatrix& >::type S(SSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nFactor(nFactorSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nEquil(nEquilSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nEquilCool(nEquilCoolSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nSample(nSampleSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nOutputs(nOutputsSEXP);

->>>>>>> develop

     Rcpp::traits::input_parameter< float >::type alphaA(alphaASEXP);

     Rcpp::traits::input_parameter< float >::type alphaP(alphaPSEXP);

     Rcpp::traits::input_parameter< float >::type maxGibbsMassA(maxGibbsMassASEXP);

     Rcpp::traits::input_parameter< float >::type maxGibbsMassP(maxGibbsMassPSEXP);

     Rcpp::traits::input_parameter< bool >::type messages(messagesSEXP);

     Rcpp::traits::input_parameter< bool >::type singleCellRNASeq(singleCellRNASeqSEXP);

-<<<<<<< HEAD

     rcpp_result_gen = Rcpp::wrap(cogapsFromFile_cpp(D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq));

     return rcpp_result_gen;

 END_RCPP

@@ -46,27 +29,10 @@ END_RCPP

 // cogaps_cpp

 Rcpp::List cogaps_cpp(const Rcpp::NumericMatrix& D, unsigned nPatterns, unsigned maxIter, unsigned outputFrequency, unsigned seed, float alphaA, float alphaP, float maxGibbsMassA, float maxGibbsMassP, bool messages, bool singleCellRNASeq, unsigned nCores);

 RcppExport SEXP _CoGAPS_cogaps_cpp(SEXP DSEXP, SEXP nPatternsSEXP, SEXP maxIterSEXP, SEXP outputFrequencySEXP, SEXP seedSEXP, SEXP alphaASEXP, SEXP alphaPSEXP, SEXP maxGibbsMassASEXP, SEXP maxGibbsMassPSEXP, SEXP messagesSEXP, SEXP singleCellRNASeqSEXP, SEXP nCoresSEXP) {

-=======

-    Rcpp::traits::input_parameter< char >::type whichMatrixFixed(whichMatrixFixedSEXP);

-    Rcpp::traits::input_parameter< const Rcpp::NumericMatrix& >::type FP(FPSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type checkpointInterval(checkpointIntervalSEXP);

-    Rcpp::traits::input_parameter< const std::string& >::type cptFile(cptFileSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type pumpThreshold(pumpThresholdSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nPumpSamples(nPumpSamplesSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nCores(nCoresSEXP);

-    rcpp_result_gen = Rcpp::wrap(cogaps_cpp(D, S, nFactor, nEquil, nEquilCool, nSample, nOutputs, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seed, messages, singleCellRNASeq, whichMatrixFixed, FP, checkpointInterval, cptFile, pumpThreshold, nPumpSamples, nCores));

-    return rcpp_result_gen;

-END_RCPP

-}

-// cogapsFromCheckpoint_cpp

-Rcpp::List cogapsFromCheckpoint_cpp(const Rcpp::NumericMatrix& D, const Rcpp::NumericMatrix& S, unsigned nFactor, unsigned nEquil, unsigned nSample, const std::string& cptFile);

-RcppExport SEXP _CoGAPS_cogapsFromCheckpoint_cpp(SEXP DSEXP, SEXP SSEXP, SEXP nFactorSEXP, SEXP nEquilSEXP, SEXP nSampleSEXP, SEXP cptFileSEXP) {

->>>>>>> develop

 BEGIN_RCPP

     Rcpp::RObject rcpp_result_gen;

     Rcpp::RNGScope rcpp_rngScope_gen;

     Rcpp::traits::input_parameter< const Rcpp::NumericMatrix& >::type D(DSEXP);

-<<<<<<< HEAD

     Rcpp::traits::input_parameter< unsigned >::type nPatterns(nPatternsSEXP);

     Rcpp::traits::input_parameter< unsigned >::type maxIter(maxIterSEXP);

     Rcpp::traits::input_parameter< unsigned >::type outputFrequency(outputFrequencySEXP);

@@ -79,14 +45,6 @@ BEGIN_RCPP

     Rcpp::traits::input_parameter< bool >::type singleCellRNASeq(singleCellRNASeqSEXP);

     Rcpp::traits::input_parameter< unsigned >::type nCores(nCoresSEXP);

     rcpp_result_gen = Rcpp::wrap(cogaps_cpp(D, nPatterns, maxIter, outputFrequency, seed, alphaA, alphaP, maxGibbsMassA, maxGibbsMassP, messages, singleCellRNASeq, nCores));

-=======

-    Rcpp::traits::input_parameter< const Rcpp::NumericMatrix& >::type S(SSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nFactor(nFactorSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nEquil(nEquilSEXP);

-    Rcpp::traits::input_parameter< unsigned >::type nSample(nSampleSEXP);

-    Rcpp::traits::input_parameter< const std::string& >::type cptFile(cptFileSEXP);

-    rcpp_result_gen = Rcpp::wrap(cogapsFromCheckpoint_cpp(D, S, nFactor, nEquil, nSample, cptFile));

->>>>>>> develop

     return rcpp_result_gen;

 END_RCPP

 }

@@ -112,14 +70,8 @@ END_RCPP

 }

 static const R_CallMethodDef CallEntries[] = {

-<<<<<<< HEAD

     {"_CoGAPS_cogapsFromFile_cpp", (DL_FUNC) &_CoGAPS_cogapsFromFile_cpp, 11},

     {"_CoGAPS_cogaps_cpp", (DL_FUNC) &_CoGAPS_cogaps_cpp, 12},

-=======

-    {"_CoGAPS_cogaps_cpp", (DL_FUNC) &_CoGAPS_cogaps_cpp, 21},

-    {"_CoGAPS_cogapsFromCheckpoint_cpp", (DL_FUNC) &_CoGAPS_cogapsFromCheckpoint_cpp, 6},

-    {"_CoGAPS_cogapsFromFile_cpp", (DL_FUNC) &_CoGAPS_cogapsFromFile_cpp, 1},

->>>>>>> develop

     {"_CoGAPS_getBuildReport_cpp", (DL_FUNC) &_CoGAPS_getBuildReport_cpp, 0},

     {"_CoGAPS_run_catch_unit_tests", (DL_FUNC) &_CoGAPS_run_catch_unit_tests, 0},

     {NULL, NULL, 0}

@@ -4,6 +4,8 @@

 #include "../file_parser/TsvParser.h"

 #include "../file_parser/MtxParser.h"

+#if 0

+

 TEST_CASE("Test Matrix.h")

 {

     SECTION("Matrix/Vector Initialization")

@@ -107,4 +109,7 @@ TEST_CASE("Test Matrix Construction from file")

     testMatrixConstruction(tsvPath);

     testMatrixConstruction(mtxPath);

 }

+

+#endif

+

 #endif

\ No newline at end of file

@@ -46,6 +46,19 @@ RowMatrix::RowMatrix(unsigned nrow, unsigned ncol)

     }

 }

+RowMatrix::RowMatrix(const ColMatrix &mat)

+: mNumRows(mat.nRow()), mNumCols(mat.nCol())

+{

+    for (unsigned i = 0; i < mNumRows; ++i)

+    {

+        mRows.push_back(Vector(mNumCols));

+        for (unsigned j = 0; j < mNumCols; ++j)

+        {

+            this->operator()(i,j) = mat(i,j);

+        }

+    }

+}

+

 RowMatrix::RowMatrix(const std::string &path)

 {

     FileParser p(path);

@@ -24,6 +24,7 @@ public:

     RowMatrix(unsigned nrow, unsigned ncol);

     RowMatrix(const std::string &p);

+    RowMatrix(const ColMatrix &mat);

     //RowMatrix(const std::string &p, bool parseRows, std::vector<unsigned> whichIndices);

     unsigned nRow() const {return mNumRows;}