@@ -34,7 +34,7 @@ Imports:

 Suggests:

     testthat,

     lintr

-LinkingTo: Rcpp

+LinkingTo: Rcpp, BH

 License: GPL (==2)

 biocViews: GeneExpression, Transcription, GeneSetEnrichment,

     DifferentialExpression, Bayesian, Clustering, TimeCourse, RNASeq, Microarray,

@@ -9,6 +9,7 @@ export(calcZ)

 export(createGWCoGAPSSets)

 export(gapsMapRun)

 export(gapsRun)

+export(gapsRunFromCheckpoint)

 export(generateSeeds)

 export(patternMarkers)

 export(patternMatch4Parallel)

@@ -5,6 +5,10 @@ cogaps <- function(DMatrix, SMatrix, nFactor, alphaA, alphaP, nEquil, nEquilCool

     .Call('_CoGAPS_cogaps', PACKAGE = 'CoGAPS', DMatrix, SMatrix, nFactor, alphaA, alphaP, nEquil, nEquilCool, nSample, maxGibbsMassA, maxGibbsMassP, fixedPatterns, whichMatrixFixed, seed, messages, singleCellRNASeq, numOutputs, numSnapshots)

 }

+cogapsFromCheckpoint <- function(fileName) {

+    .Call('_CoGAPS_cogapsFromCheckpoint', PACKAGE = 'CoGAPS', fileName)

+}

+

 run_catch_unit_tests <- function() {

     .Call('_CoGAPS_run_catch_unit_tests', PACKAGE = 'CoGAPS')

 }

@@ -138,3 +138,56 @@ gapsRun <- function(D, S, ABins = data.frame(), PBins = data.frame(),

     message(paste("Chi-Squared of Mean:", calcChiSq))

     return(cogapResult);

 }

+

+#' @export

+gapsRunFromCheckpoint <- function(D, S, path)

+{

+    # call to C++ Rcpp code

+    cogapResult <- cogapsFromCheckpoint(path)

+

+    # convert returned files to matrices to simplify visualization and processing

+    cogapResult$Amean <- as.matrix(cogapResult$Amean);

+    cogapResult$Asd <- as.matrix(cogapResult$Asd);

+    cogapResult$Pmean <- as.matrix(cogapResult$Pmean);

+    cogapResult$Psd <- as.matrix(cogapResult$Psd);

+

+    geneNames <- rownames(D);

+    sampleNames <- colnames(D);

+

+    # label patterns as Patt N

+    patternNames <- c("0");

+    for(i in 1:ncol(cogapResult$Amean))

+    {

+        patternNames[i] <- paste('Patt', i);

+    }

+

+    ## label matrices

+    colnames(cogapResult$Amean) <- patternNames;

+    rownames(cogapResult$Amean) <- geneNames;

+    colnames(cogapResult$Asd) <- patternNames;

+    rownames(cogapResult$Asd) <- geneNames;

+    colnames(cogapResult$Pmean) <- sampleNames;

+    rownames(cogapResult$Pmean) <- patternNames;

+    colnames(cogapResult$Psd) <- sampleNames;

+    rownames(cogapResult$Psd) <- patternNames;

+

+    ## calculate chi-squared of mean, this should be smaller than individual

+    ## chi-squared sample values if sampling is good

+    calcChiSq <- c(0);

+    MMatrix <- (cogapResult$Amean %*% cogapResult$Pmean);

+

+    for(i in 1:(nrow(MMatrix)))

+    {

+        for(j in 1:(ncol(MMatrix)))

+        {

+            calcChiSq <- calcChiSq + ((D[i,j] - MMatrix[i,j])/S[i,j])^2;

+        }

+    }

+

+    cogapResult = c(cogapResult, calcChiSq);

+    

+    # names(cogapResult)[13] <- "meanChi2";

+

+    message(paste("Chi-Squared of Mean:", calcChiSq))

+    return(cogapResult);

+}

\ No newline at end of file

new file mode 100644

@@ -0,0 +1,43 @@

+#ifndef __COGAPS_ARCHIVE_H__

+#define __COGAPS_ARCHIVE_H__

+

+#include <boost/random/mersenne_twister.hpp>

+#include <fstream>

+

+#define ARCHIVE_READ  std::ios::in

+#define ARCHIVE_WRITE std::ios::out | std::ios::trunc

+

+class Archive

+{

+private:

+

+    std::fstream mStream;

+

+public:

+

+    Archive(const std::string &path, std::ios_base::openmode flags)

+        : mStream(path.c_str(), std::ios::binary | flags)

+    {}

+

+    void close() {mStream.close();}

+

+    template<typename T>

+    friend void operator<<(Archive &ar, T val);

+

+    template<typename T>

+    friend void operator>>(Archive &ar, T &val);

+};

+

+template<typename T>

+void operator<<(Archive &ar, T val)

+{

+    ar.mStream.write(reinterpret_cast<char*>(&val), sizeof(T));

+}

+

+template<typename T>

+void operator>>(Archive &ar, T &val)

+{

+    ar.mStream.read(reinterpret_cast<char*>(&val), sizeof(T));

+}

+

+#endif

\ No newline at end of file

@@ -192,4 +192,52 @@ MatrixChange AtomicSupport::getMatrixChange(const AtomicProposal &prop) const

     {   

         return MatrixChange(prop.label, getRow(prop.pos1), getCol(prop.pos1), prop.delta1);

     }

+}

+

+void operator<<(Archive &ar, AtomicSupport &domain)

+{

+    ar << domain.mLabel;

+    ar << domain.mNumAtoms;

+    ar << domain.mMaxNumAtoms;

+    ar << domain.mTotalMass;

+    ar << domain.mNumRows;

+    ar << domain.mNumCols;

+    ar << domain.mNumBins;

+    ar << domain.mBinSize;

+    ar << domain.mAlpha;

+    ar << domain.mLambda;

+    

+    std::map<uint64_t, double>::iterator iter = domain.mAtomicDomain.begin();

+    for (; iter != domain.mAtomicDomain.end(); ++iter)

+    {

+        uint64_t pos = iter->first;

+        double mass = iter->second;

+        ar << pos;

+        ar << mass;

+        //ar << iter->first;

+        //ar << iter->second;

+    }

+}

+

+void operator>>(Archive &ar, AtomicSupport &domain)

+{

+    ar >> domain.mLabel;

+    ar >> domain.mNumAtoms;

+    ar >> domain.mMaxNumAtoms;

+    ar >> domain.mTotalMass;

+    ar >> domain.mNumRows;

+    ar >> domain.mNumCols;

+    ar >> domain.mNumBins;

+    ar >> domain.mBinSize;

+    ar >> domain.mAlpha;

+    ar >> domain.mLambda;

+

+    uint64_t pos = 0;

+    double mass = 0.0;

+    for (unsigned i = 0; i < domain.mNumAtoms; ++i)

+    {

+        ar >> pos;

+        ar >> mass;

+        domain.mAtomicDomain.insert(std::pair<uint64_t, double>(pos, mass));

+    }    

 }

\ No newline at end of file

@@ -62,23 +62,6 @@ public:

     // expected magnitude of each atom (must be > 0)

     double mLambda;

-    /*friend class boost::serialization::access;

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mLabel;

-        ar & mAtomicDomain;

-        ar & mNumAtoms;

-        ar & mMaxNumAtoms;

-        ar & mTotalMass;

-        ar & mNumRows;

-        ar & mNumCols;

-        ar & mNumBins;

-        ar & mBinSize;

-        ar & mAlpha;

-        ar & mLambda;

-    }*/

-

     // convert atomic position to row/col of the matrix

     uint64_t getRow(uint64_t pos) const;

     uint64_t getCol(uint64_t pos) const;

@@ -99,7 +82,6 @@ public:

 public:

     // constructors

-    AtomicSupport(std::ifstream &file);

     AtomicSupport(char label, uint64_t nrow, uint64_t ncol, double alpha=1.0,

         double lambda=1.0);

@@ -122,6 +104,9 @@ public:

     void setLambda(double lambda) {mLambda = lambda;}

     void serializeAndWrite(const std::ofstream &file);

+

+    friend void operator<<(Archive &ar, AtomicSupport &sampler);

+    friend void operator>>(Archive &ar, AtomicSupport &sampler);

 };

 #endif

@@ -1,5 +1,6 @@

 #include "GibbsSampler.h"

 #include "Matrix.h"

+#include "Archive.h"

 #include <Rcpp.h>

 #include <ctime>

@@ -8,6 +9,8 @@

 #include <boost/archive/text_oarchive.hpp>

 #include <boost/archive/text_iarchive.hpp>

+#define ARCHIVE_MAGIC_NUM 0xCE45D32A

+

 typedef std::vector<Rcpp::NumericMatrix> SnapshotList;

 enum GapsPhase

@@ -63,32 +66,59 @@ struct GapsInternalState

             maxGibbsMassA, maxGibbsMassP, singleCellRNASeq, fixedPatterns,

             whichMatrixFixed)

     {}

+

+    GapsInternalState(unsigned nE, unsigned nS, unsigned nRow, unsigned nCol,

+    unsigned nFactor)

+            :

+        chi2VecEquil(nE), nAtomsAEquil(nE), nAtomsPEquil(nE),

+        chi2VecSample(nS), nAtomsASample(nS), nAtomsPSample(nS),

+        sampler(nRow, nCol, nFactor)

+    {}

 };

-/*template<class Archive>

-void boost::serialization::serialize(Archive &ar, GapsInternalState &state)

+void operator<<(Archive &ar, GapsInternalState &state)

+{

+    ar << state.chi2VecEquil;

+    ar << state.nAtomsAEquil;

+    ar << state.nAtomsPEquil;

+    ar << state.chi2VecSample;

+    ar << state.nAtomsASample;

+    ar << state.nAtomsPSample;

+    ar << state.nIterA;

+    ar << state.nIterP;

+    ar << state.nEquil;

+    ar << state.nEquilCool;

+    ar << state.nSample;

+    ar << state.nSnapshots;

+    ar << state.nOutputs;

+    ar << state.messages;

+    ar << state.iter;

+    ar << state.phase;

+    ar << state.seed;

+    ar << state.sampler;

+}

+

+void operator>>(Archive &ar, GapsInternalState &state)

 {

-    ar & state.chi2VecEquil;

-    ar & state.nAtomsAEquil;

-    ar & state.nAtomsPEquil;

-    ar & state.chi2VecSample;

-    ar & state.nAtomsASample;

-    ar & state.nAtomsPSample;

-    ar & state.nIterA;

-    ar & state.nIterP;

-    ar & state.nEquil;

-    ar & state.nEquilCool;

-    ar & state.nSample;

-    ar & state.nSnapshots;

-    ar & state.nOutputs;

-    ar & state.messages;

-    ar & state.iter;

-    ar & state.phase;

-    ar & state.seed;

-    ar & state.sampler;

-    //ar & state.snapshotsA;

-    //ar & state.snapshotsP;

-}*/

+    ar >> state.chi2VecEquil;

+    ar >> state.nAtomsAEquil;

+    ar >> state.nAtomsPEquil;

+    ar >> state.chi2VecSample;

+    ar >> state.nAtomsASample;

+    ar >> state.nAtomsPSample;

+    ar >> state.nIterA;

+    ar >> state.nIterP;

+    ar >> state.nEquil;

+    ar >> state.nEquilCool;

+    ar >> state.nSample;

+    ar >> state.nSnapshots;

+    ar >> state.nOutputs;

+    ar >> state.messages;

+    ar >> state.iter;

+    ar >> state.phase;

+    ar >> state.seed;

+    ar >> state.sampler;

+}

 static void runGibbsSampler(GapsInternalState &state, unsigned nIterTotal,

 Vector &chi2Vec, Vector &aAtomVec, Vector &pAtomVec)

@@ -152,12 +182,16 @@ static Rcpp::List runCogaps(GapsInternalState &state)

         state.phase = GAPS_COOLING;

     }

-    std::ofstream ofs("gaps_checkpoint.out");

-    {

-        boost::archive::text_oarchive oa(ofs);

-        //oa << state;

-    }

-    ofs.close();

+    Archive ar("gaps_checkpoint.out", ARCHIVE_WRITE);

+    ar << ARCHIVE_MAGIC_NUM;

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

+    ar << state.nEquil;

+    ar << state.nSample;

+    ar << state.sampler.nRow();

+    ar << state.sampler.nCol();

+    ar << state.sampler.nFactor();

+    ar << state;

+    ar.close();

     if (state.phase == GAPS_COOLING)

     {

@@ -222,26 +256,37 @@ unsigned numOutputs, unsigned numSnapshots)

     return runCogaps(state);

 }

-/*

+// [[Rcpp::export]]

 Rcpp::List cogapsFromCheckpoint(const std::string &fileName)

 {   

     // open file

-    std::ifstream file(fileName);

+    Archive ar(fileName, ARCHIVE_READ);

     // verify magic number

     uint32_t magicNum = 0;

-    file.read(reinterpret_cast<char*>(&magicNum), sizeof(uint32_t));

-    if (magicNum != 0xCE45D32A)

+    ar >> magicNum;

+    if (magicNum != ARCHIVE_MAGIC_NUM)

     {

         std::cout << "invalid checkpoint file" << std::endl;

         return Rcpp::List::create();

     }

     // seed random number generator and create internal state

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

-    GapsInternalState state(file);

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

+

+    // read needed parameters

+    unsigned nE = 0, nS = 0, nRow = 0, nCol = 0, nFactor = 0;

+    ar >> nE;

+    ar >> nS;

+    ar >> nRow;

+    ar >> nCol;

+    ar >> nFactor;

+    

+    // construct empty state of the correct size, populate from file

+    GapsInternalState state(nE, nS, nRow, nCol, nFactor);

+    ar >> state;

     // run cogaps from this internal state

     return runCogaps(state);

 }

-*/

+

@@ -5,6 +5,15 @@

 static const double EPSILON = 1.e-10;

+GibbsSampler::GibbsSampler(unsigned nRow, unsigned nCol, unsigned nFactor)

+    :

+mDMatrix(nRow, nCol), mSMatrix(nRow, nCol), mAPMatrix(nRow, nCol),

+mAMatrix(nRow, nFactor), mPMatrix(nFactor, nCol), mADomain('A', nRow, nFactor),

+mPDomain('P', nFactor, nCol), mAMeanMatrix(nRow, nFactor),

+mAStdMatrix(nRow, nFactor), mPMeanMatrix(nFactor, nCol),

+mPStdMatrix(nFactor, nCol)

+{}

+

 GibbsSampler::GibbsSampler(Rcpp::NumericMatrix D, Rcpp::NumericMatrix S,

 unsigned int nFactor, double alphaA, double alphaP, double maxGibbsMassA,

 double maxGibbsMassP, bool singleCellRNASeq, Rcpp::NumericMatrix fixedPat,

@@ -437,4 +446,50 @@ void GibbsSampler::updateStatistics()

         mPStdMatrix.getRow(r) += gaps::algo::squaredScalarDivision(mPMatrix.getRow(r),

             normVec(r));

     }

+}

+

+void operator<<(Archive &ar, GibbsSampler &sampler)

+{

+    ar << sampler.mDMatrix;

+    ar << sampler.mSMatrix;

+    ar << sampler.mAPMatrix;

+    ar << sampler.mAMatrix;

+    ar << sampler.mPMatrix;

+    ar << sampler.mADomain;

+    ar << sampler.mPDomain;

+    ar << sampler.mAMeanMatrix;

+    ar << sampler.mAStdMatrix;

+    ar << sampler.mPMeanMatrix;

+    ar << sampler.mPStdMatrix;

+    ar << sampler.mStatUpdates;

+    ar << sampler.mMaxGibbsMassA;

+    ar << sampler.mMaxGibbsMassP;

+    ar << sampler.mAnnealingTemp;

+    ar << sampler.mChi2;

+    ar << sampler.mSingleCellRNASeq;

+    ar << sampler.mNumFixedPatterns;

+    ar << sampler.mFixedMat;

+}

+

+void operator>>(Archive &ar, GibbsSampler &sampler)

+{

+    ar >> sampler.mDMatrix;

+    ar >> sampler.mSMatrix;

+    ar >> sampler.mAPMatrix;

+    ar >> sampler.mAMatrix;

+    ar >> sampler.mPMatrix;

+    ar >> sampler.mADomain;

+    ar >> sampler.mPDomain;

+    ar >> sampler.mAMeanMatrix;

+    ar >> sampler.mAStdMatrix;

+    ar >> sampler.mPMeanMatrix;

+    ar >> sampler.mPStdMatrix;

+    ar >> sampler.mStatUpdates;

+    ar >> sampler.mMaxGibbsMassA;

+    ar >> sampler.mMaxGibbsMassP;

+    ar >> sampler.mAnnealingTemp;

+    ar >> sampler.mChi2;

+    ar >> sampler.mSingleCellRNASeq;

+    ar >> sampler.mNumFixedPatterns;

+    ar >> sampler.mFixedMat;

 }

\ No newline at end of file

@@ -36,31 +36,6 @@ public:

     unsigned mNumFixedPatterns;

     char mFixedMat;

-    /*friend class boost::serialization::access;    

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mDMatrix;

-        ar & mSMatrix;

-        ar & mAPMatrix;

-        ar & mAMatrix;

-        ar & mPMatrix;

-        ar & mADomain;  

-        ar & mPDomain;

-        ar & mAMeanMatrix;

-        ar & mAStdMatrix;

-        ar & mPMeanMatrix;

-        ar & mPStdMatrix;

-        ar & mStatUpdates;

-        ar & mMaxGibbsMassA;

-        ar & mMaxGibbsMassP;

-        ar & mAnnealingTemp;

-        ar & mChi2;

-        ar & mSingleCellRNASeq;

-        ar & mNumFixedPatterns;

-        ar & mFixedMat;

-    }*/

-

     bool death(AtomicSupport &domain, AtomicProposal &proposal);

     bool birth(AtomicSupport &domain, AtomicProposal &proposal);

     bool move(AtomicSupport &domain, AtomicProposal &proposal);

@@ -82,7 +57,7 @@ public:

 public:

-    GibbsSampler(std::ifstream &file);

+    GibbsSampler(unsigned nRow, unsigned nCol, unsigned nFactor);

     GibbsSampler(Rcpp::NumericMatrix D, Rcpp::NumericMatrix S, unsigned nFactor,

         double alphaA, double alphaP, double maxGibbsMassA, double maxGibbsMassP,

         bool singleCellRNASeq, Rcpp::NumericMatrix fixedPat, char whichMat);

@@ -102,7 +77,12 @@ public:

     Rcpp::NumericMatrix getNormedMatrix(char mat);

-    void serializeAndWrite(const std::ofstream &file);

+    unsigned nRow() const {return mDMatrix.nRow();}

+    unsigned nCol() const {return mDMatrix.nCol();}

+    unsigned nFactor() const {return mAMatrix.nCol();}

+

+    friend void operator<<(Archive &ar, GibbsSampler &sampler);

+    friend void operator>>(Archive &ar, GibbsSampler &sampler);

 };

 #endif

@@ -1,5 +1,4 @@

-PKG_CPPFLAGS = -Wall -Wextra -O2 -I.

-PKG_LIBS = `$(R_HOME)/bin/Rscript -e "Rcpp:::LdFlags()"` -lboost_serialization

+PKG_CPPFLAGS = -Wall -Wextra -O2

 OBJECTS =   Algorithms.o \

             AtomicSupport.o \

             Cogaps.o \

@@ -50,6 +50,22 @@ void Vector::operator+=(const Vector &vec)

     }

 }

+void operator<<(Archive &ar, Vector &vec)

+{

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

+    {

+        ar << vec[i];

+    }

+}

+

+void operator>>(Archive &ar, Vector &vec)

+{

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

+    {

+        ar >> vec.mValues[i];

+    }

+}

+

 /****************************** ROW MATRIX *****************************/

 RowMatrix::RowMatrix(unsigned nrow, unsigned ncol)

@@ -93,6 +109,22 @@ Rcpp::NumericMatrix RowMatrix::rMatrix() const

     return convertToRMatrix<RowMatrix>(*this);

 }

+void operator<<(Archive &ar, RowMatrix &mat)

+{

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

+    {

+        ar << mat.mRows[i];

+    }

+}

+

+void operator>>(Archive &ar, RowMatrix &mat)

+{

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

+    {

+        ar >> mat.mRows[i];

+    }

+}

+

 /**************************** COLUMN MATRIX ****************************/

 ColMatrix::ColMatrix(unsigned nrow, unsigned ncol)

@@ -135,3 +167,33 @@ Rcpp::NumericMatrix ColMatrix::rMatrix() const

 {

     return convertToRMatrix<ColMatrix>(*this);

 }

+

+void operator<<(Archive &ar, ColMatrix &mat)

+{

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

+    {

+        ar << mat.mCols[j];

+    }

+}

+

+void operator>>(Archive &ar, ColMatrix &mat)

+{

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

+    {

+        ar >> mat.mCols[j];

+    }

+}

+

+/**************************** TWO-WAY MATRIX ***************************/

+

+void operator<<(Archive &ar, TwoWayMatrix &mat)

+{

+    ar << mat.mRowMatrix;

+    ar << mat.mColMatrix;

+}

+

+void operator>>(Archive &ar, TwoWayMatrix &mat)

+{

+    ar >> mat.mRowMatrix;

+    ar >> mat.mColMatrix;

+}

\ No newline at end of file

@@ -1,9 +1,10 @@

 #ifndef __COGAPS_MATRIX_H__

 #define __COGAPS_MATRIX_H__

+#include "Archive.h"

+

 #include <Rcpp.h>

 #include <vector>

-//#include <boost/serialization/vector.hpp>

 // temporary: used for testing performance of float vs double

 typedef double matrix_data_t;

@@ -33,22 +34,12 @@ struct MatrixChange

     {}

 };

-// no polymorphism to prevent virtual function overhead, not really

-// needed anyways since few functions are used on all types of matrices

-

 class Vector

 {

 private:

     std::vector<matrix_data_t> mValues;

-    /*friend class boost::serialization::access;

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mValues;

-    }*/

-

 public:

     Vector(unsigned size) : mValues(std::vector<matrix_data_t>(size, 0.0)) {}

@@ -64,6 +55,9 @@ public:

     Rcpp::NumericVector rVec() const {return Rcpp::wrap(mValues);}

     void concat(const Vector& vec);

     void operator+=(const Vector &vec);

+

+    friend void operator<<(Archive &ar, Vector &vec);

+    friend void operator>>(Archive &ar, Vector &vec);

 };

 class RowMatrix

@@ -73,15 +67,6 @@ private:

     std::vector<Vector> mRows;

     unsigned mNumRows, mNumCols;

-    /*friend class boost::serialization::access;

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mRows;

-        ar & mNumRows;

-        ar & mNumCols;

-    }*/

-

 public:

     RowMatrix(unsigned nrow, unsigned ncol);

@@ -99,6 +84,9 @@ public:

     void update(const MatrixChange &change);

     Rcpp::NumericMatrix rMatrix() const;

+

+    friend void operator<<(Archive &ar, RowMatrix &mat);

+    friend void operator>>(Archive &ar, RowMatrix &mat);

 };

 class ColMatrix

@@ -108,15 +96,6 @@ private:

     std::vector<Vector> mCols;

     unsigned mNumRows, mNumCols;

-    /*friend class boost::serialization::access;

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mCols;

-        ar & mNumRows;

-        ar & mNumCols;

-    }*/

-

 public:

     ColMatrix(unsigned nrow, unsigned ncol);

@@ -134,6 +113,9 @@ public:

     void update(const MatrixChange &change);

     Rcpp::NumericMatrix rMatrix() const;

+

+    friend void operator<<(Archive &ar, ColMatrix &mat);

+    friend void operator>>(Archive &ar, ColMatrix &mat);

 };

 // gain performance at the expense of memory

@@ -144,14 +126,6 @@ private:

     RowMatrix mRowMatrix;

     ColMatrix mColMatrix;

-    /*friend class boost::serialization::access;

-    template<class Archive>

-    void serialize(Archive &ar)

-    {

-        ar & mRowMatrix;

-        ar & mColMatrix;

-    }*/

-

 public:

     TwoWayMatrix(unsigned nrow, unsigned ncol)

@@ -165,12 +139,6 @@ public:

     unsigned nRow() const {return mRowMatrix.nRow();}

     unsigned nCol() const {return mRowMatrix.nCol();}

-    // TODO remove since accessing this way defeats the purpose

-    /*matrix_data_t operator()(unsigned r, unsigned c) const

-    {

-        return mRowMatrix(r,c);

-    }*/

-

     const Vector& getRow(unsigned row) const {return mRowMatrix.getRow(row);}

     const Vector& getCol(unsigned col) const {return mColMatrix.getCol(col);}

@@ -184,6 +152,9 @@ public:

     {

         return mRowMatrix.rMatrix();

     }

+

+    friend void operator<<(Archive &ar, TwoWayMatrix &mat);

+    friend void operator>>(Archive &ar, TwoWayMatrix &mat);

 };

 #endif

\ No newline at end of file

@@ -10,21 +10,26 @@

 #include <boost/math/distributions/normal.hpp>

 #include <boost/math/distributions/exponential.hpp>

+#include <boost/random/mersenne_twister.hpp>

+

 #include <stdint.h>

 #define Q_GAMMA_THRESHOLD 1E-6

 #define Q_GAMMA_MIN_VALUE 0.0

+typedef boost::random::mt19937 RNGType;

+//typedef boost::random::mt11213b RNGType; // should be faster

+

 static RNGType rng;

-RNGType gaps::random::getGenerator()

+void gaps::random::save(Archive &ar)

 {

-    return rng;

+    ar << rng;

 }

-void gaps::random::setGenerator(RNGType temp)

+void gaps::random::load(Archive &ar)

 {

-    rng = temp;

+    ar >> rng;

 }

 void gaps::random::setSeed(uint32_t seed)

@@ -1,13 +1,11 @@

 #ifndef __COGAPS_RANDOM_H__

 #define __COGAPS_RANDOM_H__

+#include "Archive.h"

+

 #include <stdint.h>

 #include <vector>

 #include <fstream>

-#include <boost/random/mersenne_twister.hpp>

-

-typedef boost::random::mt19937 RNGType;

-//typedef boost::random::mt11213b RNGType; // should be faster

 namespace gaps

 {

@@ -33,8 +31,8 @@ namespace random

     double q_norm(double q, double mean, double sd);

     double p_norm(double p, double mean, double sd);

-    RNGType getGenerator();

-    void setGenerator(RNGType rng);

+    void save(Archive &ar);

+    void load(Archive &ar);

 }

 }

@@ -32,6 +32,17 @@ BEGIN_RCPP

     return rcpp_result_gen;

 END_RCPP

 }

+// cogapsFromCheckpoint

+Rcpp::List cogapsFromCheckpoint(const std::string& fileName);

+RcppExport SEXP _CoGAPS_cogapsFromCheckpoint(SEXP fileNameSEXP) {

+BEGIN_RCPP

+    Rcpp::RObject rcpp_result_gen;

+    Rcpp::RNGScope rcpp_rngScope_gen;

+    Rcpp::traits::input_parameter< const std::string& >::type fileName(fileNameSEXP);

+    rcpp_result_gen = Rcpp::wrap(cogapsFromCheckpoint(fileName));

+    return rcpp_result_gen;

+END_RCPP

+}

 // run_catch_unit_tests

 int run_catch_unit_tests();

 RcppExport SEXP _CoGAPS_run_catch_unit_tests() {

@@ -45,6 +56,7 @@ END_RCPP

 static const R_CallMethodDef CallEntries[] = {

     {"_CoGAPS_cogaps", (DL_FUNC) &_CoGAPS_cogaps, 17},

+    {"_CoGAPS_cogapsFromCheckpoint", (DL_FUNC) &_CoGAPS_cogapsFromCheckpoint, 1},

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

     {NULL, NULL, 0}

 };

new file mode 100644