@@ -256,7 +256,6 @@ double gaps::algo::deltaLL(const MatrixChange &ch, const TwoWayMatrix &D,

 const TwoWayMatrix &S, const ColMatrix &A, const RowMatrix &P,

 const TwoWayMatrix &AP)

 {

-    // change in A matrix

     if (ch.label == 'A' && ch.nChanges == 2 && ch.row1 != ch.row2)

     {

         return deltaLL_A(D, S, P, AP, ch.row1, ch.col1, ch.delta1)

@@ -267,14 +266,12 @@ const TwoWayMatrix &AP)

         return deltaLL_A(D, S, P, AP, ch.row1, ch.col1, ch.delta1, ch.col2,

             ch.delta2, ch.nChanges == 2);

     }

-

-    // change in P matrix

-    if (ch.label == 'P' && ch.nChanges == 2 && ch.col1 != ch.col2)

+    else if (ch.label == 'P' && ch.nChanges == 2 && ch.col1 != ch.col2)

     {

         return deltaLL_P(D, S, A, AP, ch.col1, ch.row1, ch.delta1)

             + deltaLL_P(D, S, A, AP, ch.col2, ch.row2, ch.delta2);

     }

-    else if (ch.label == 'P')

+    else

     {

         return deltaLL_P(D, S, A, AP, ch.col1, ch.row1, ch.delta1, ch.row2,

             ch.delta2, ch.nChanges == 2);

@@ -5,10 +5,11 @@ static const double EPSILON = 1.e-10;

 AtomicSupport::AtomicSupport(char label, uint64_t nrow, uint64_t ncol,

 double alpha, double lambda)

     :

-mNumRows(nrow), mNumCols(ncol), mNumBins(nrow * ncol),

-mNumAtoms(0), mTotalMass(0.0), mLabel(label), mAlpha(alpha), 

-mMaxNumAtoms(std::numeric_limits<uint64_t>::max()), mLambda(lambda),

-mBinSize(std::numeric_limits<uint64_t>::max() / (nrow * ncol))

+mLabel(label), mNumAtoms(0),

+mMaxNumAtoms(std::numeric_limits<uint64_t>::max()),

+mTotalMass(0.0), mNumRows(nrow), mNumCols(ncol), mNumBins(nrow * ncol),

+mBinSize(std::numeric_limits<uint64_t>::max() / (nrow * ncol)),

+mAlpha(alpha), mLambda(lambda)

 {}

 uint64_t AtomicSupport::getRow(uint64_t pos) const

@@ -113,7 +114,7 @@ AtomicProposal AtomicSupport::proposeExchange() const

     return AtomicProposal(mLabel, 'E', pos1, delta1, pos2, delta2);

 }

-double AtomicSupport::updateAtomMass(char type, uint64_t pos, double delta)

+double AtomicSupport::updateAtomMass(uint64_t pos, double delta)

 {

     if (mAtomicDomain.count(pos)) // update atom if it exists

     {

@@ -172,10 +173,10 @@ AtomicProposal AtomicSupport::makeProposal() const

 MatrixChange AtomicSupport::acceptProposal(const AtomicProposal &prop)

 {

     MatrixChange change = getMatrixChange(prop);

-    change.delta1 = updateAtomMass(prop.type, prop.pos1, prop.delta1);

+    change.delta1 = updateAtomMass(prop.pos1, prop.delta1);

     if (prop.nChanges > 1)

     {

-        change.delta2 = updateAtomMass(prop.type, prop.pos2, prop.delta2);

+        change.delta2 = updateAtomMass(prop.pos2, prop.delta2);

     }

     return change;

 }

@@ -76,14 +76,14 @@ public:

     AtomicProposal proposeExchange() const;

     // update the mass of an atom, return the total amount changed

-    double updateAtomMass(char type, uint64_t pos, double delta);

+    double updateAtomMass(uint64_t pos, double delta);

 public:

-    // constructor

+    // constructors

+    AtomicSupport(std::ifstream &file);

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

         double lambda=1.0);

-    AtomicSupport(const std::ifstream &file);

     // create and accept a proposal

     AtomicProposal makeProposal() const;

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

     void setAlpha(double alpha) {mAlpha = alpha;}

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

-    // serialize and write to file

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

 };

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

 #include "GibbsSampler.h"

+#include "Matrix.h"

 #include <Rcpp.h>

 #include <ctime>

@@ -8,7 +9,7 @@ typedef std::vector<Rcpp::NumericMatrix> SnapshotList;

 enum GapsPhase

 {

-    GAPS_CALIBRATION=,

+    GAPS_CALIBRATION,

     GAPS_COOLING,

     GAPS_SAMPLING

 };

@@ -17,8 +18,6 @@ enum GapsPhase

 // initialization depends on it

 struct GapsInternalState

 {

-    GibbsSampler sampler;

-    

     Vector chi2VecEquil;

     Vector nAtomsAEquil;

     Vector nAtomsPEquil;

@@ -34,35 +33,35 @@ struct GapsInternalState

     unsigned nEquilCool;

     unsigned nSample;

+    unsigned nSnapshots;

+    unsigned nOutputs;

+    bool messages;

+

     unsigned iteration;

     GapsPhase phase;

+    uint32_t seed;

+

+    GibbsSampler sampler;

     SnapshotList snapshotsA;

     SnapshotList snapshotsP;

-    uint32_t seed;

-

     GapsInternalState(Rcpp::NumericMatrix DMatrix, Rcpp::NumericMatrix SMatrix,

         unsigned nFactor, double alphaA, double alphaP, unsigned nE,

         unsigned nEC, unsigned nS, double maxGibbsMassA,

         double maxGibbsMassP, Rcpp::NumericMatrix fixedPatterns,

-        char whichMatrixFixed, bool messages, bool singleCellRNASeq,

-        unsigned numOutputs, unsigned numSnapshots)

+        char whichMatrixFixed, bool msg, bool singleCellRNASeq,

+        unsigned numOutputs, unsigned numSnapshots, uint32_t in_seed)

             :

-        chi2VecEquil(nEquil), nAtomsAEquil(nEquil), nAtomsPEquil(nEquil),

-        chi2VecSample(nSample), nAtomsASample(nSample), nAtomsPSample(nSample),

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

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

         nIterA(10), nIterP(10), nEquil(nE), nEquilCool(nEC), nSample(nS),

-        iteration(0), phase(GAPS_CALIBRATION),

+        nSnapshots(numSnapshots), nOutputs(numOutputs), messages(msg),

+        iteration(0), phase(GAPS_CALIBRATION), seed(in_seed),

         sampler(DMatrix, SMatrix, nFactor, alphaA, alphaP,

             maxGibbsMassA, maxGibbsMassP, singleCellRNASeq, fixedPatterns,

             whichMatrixFixed)

     {}

-

-    GapsInternalState(std::ifstream &file)

-        :

-    {}

-

-

 };

 static void runGibbsSampler(GapsInternalState &state, unsigned nIterTotal,

@@ -89,31 +88,29 @@ Vector &chi2Vec, Vector &aAtomVec, Vector &pAtomVec)

         if (state.phase == GAPS_SAMPLING)

         {

             state.sampler.updateStatistics();

-            if (state.numSnapshots > 0 && (i + 1) % (nIterTotal / state.numSnapshots) == 0)

+            if (state.nSnapshots > 0 && (i + 1) % (nIterTotal / state.nSnapshots) == 0)

             {

                 state.snapshotsA.push_back(state.sampler.getNormedMatrix('A'));

                 state.snapshotsP.push_back(state.sampler.getNormedMatrix('P'));

             }

         }

-        if (phase != GAPS_COOLING)

+        if (state.phase != GAPS_COOLING)

         {

-            double numAtomsA = state.sampler.totalNumAtoms('A');

-            double numAtomsP = state.sampler.totalNumAtoms('P');

-            aAtomVec(i) = numAtomsA;

-            pAtomVec(i) = numAtomsP;

+            aAtomVec(i) = state.sampler.totalNumAtoms('A');

+            pAtomVec(i) = state.sampler.totalNumAtoms('P');

             chi2Vec(i) = state.sampler.chi2();

+            state.nIterA = gaps::random::poisson(std::max(aAtomVec(i), 10.0));

+            state.nIterP = gaps::random::poisson(std::max(pAtomVec(i), 10.0));

-            if ((i + 1) % state.numOutputs == 0 && state.messages)

+            if ((i + 1) % state.nOutputs == 0 && state.messages)

             {

                 std::string temp = state.phase == GAPS_CALIBRATION ? "Equil: "

                     : "Samp: ";

                 std::cout << temp << i + 1 << " of " << nIterTotal

-                    << ", Atoms:" << numAtomsA << "(" << numAtomsP

+                    << ", Atoms:" << aAtomVec(i) << "(" << pAtomVec(i)

                     << ") Chi2 = " << state.sampler.chi2() << '\n';

             }

-            state.nIterA = gaps::random::poisson(std::max(numAtomsA, 10.0));

-            state.nIterP = gaps::random::poisson(std::max(numAtomsP, 10.0));

         }

     }

 }

@@ -123,7 +120,7 @@ static Rcpp::List runCogaps(GapsInternalState &state)

     if (state.phase == GAPS_CALIBRATION)

     {

         runGibbsSampler(state, state.nEquil, state.chi2VecEquil,

-            state.nAtomsAEquil, state.nAtomsPEquil)

+            state.nAtomsAEquil, state.nAtomsPEquil);

         state.phase = GAPS_COOLING;

     }

@@ -137,7 +134,7 @@ static Rcpp::List runCogaps(GapsInternalState &state)

     if (state.phase == GAPS_SAMPLING)

     {

         runGibbsSampler(state, state.nSample, state.chi2VecSample,

-            state.nAtomsASample, state.nAtomsPSample)

+            state.nAtomsASample, state.nAtomsPSample);

     }

     // combine chi2 vectors

@@ -155,34 +152,11 @@ static Rcpp::List runCogaps(GapsInternalState &state)

         Rcpp::Named("atomsASamp") = state.nAtomsASample.rVec(),

         Rcpp::Named("atomsPEquil") = state.nAtomsPEquil.rVec(),

         Rcpp::Named("atomsPSamp") = state.nAtomsPSample.rVec(),

-        Rcpp::Named("chiSqValues") = state.chi2Vec.rVec(),

+        Rcpp::Named("chiSqValues") = chi2Vec.rVec(),

         Rcpp::Named("randSeed") = state.seed

     );

 }

-// [[Rcpp::export]]

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

-{   

-    // open file

-    std::ifstream file(fileName);

-

-    // verify magic number

-    uint32_t magicNum = 0;

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

-    if (magicNum != 0xCE45D32A)

-    {

-        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);

-

-    // run cogaps from this internal state

-    return runCogaps(state);

-}

-

 // [[Rcpp::export]]

 Rcpp::List cogaps(Rcpp::NumericMatrix DMatrix, Rcpp::NumericMatrix SMatrix,

 unsigned nFactor, double alphaA, double alphaP, unsigned nEquil,

@@ -206,9 +180,32 @@ unsigned numOutputs, unsigned numSnapshots)

     GapsInternalState state(DMatrix, SMatrix, nFactor, alphaA, alphaP,

         nEquil, nEquilCool, nSample, maxGibbsMassA, maxGibbsMassP,

         fixedPatterns, whichMatrixFixed, messages, singleCellRNASeq,

-        numOutputs, numSnapshots);

+        numOutputs, numSnapshots, seedUsed);

     // run cogaps from this internal state

     return runCogaps(state);

 }

+/*

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

+{   

+    // open file

+    std::ifstream file(fileName);

+

+    // verify magic number

+    uint32_t magicNum = 0;

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

+    if (magicNum != 0xCE45D32A)

+    {

+        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);

+

+    // run cogaps from this internal state

+    return runCogaps(state);

+}

+*/

@@ -10,14 +10,14 @@ unsigned int nFactor, double alphaA, double alphaP, double maxGibbsMassA,

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

 char whichMat)

     :

-mDMatrix(D), mSMatrix(S), mAMatrix(D.nrow(), nFactor),

-mPMatrix(nFactor, D.ncol()), mAPMatrix(D.nrow(), D.ncol()),

+mDMatrix(D), mSMatrix(S), mAPMatrix(D.nrow(), D.ncol()),

+mAMatrix(D.nrow(), nFactor), mPMatrix(nFactor, D.ncol()), 

 mADomain('A', D.nrow(), nFactor), mPDomain('P', nFactor, D.ncol()),

-mMaxGibbsMassA(maxGibbsMassA), mMaxGibbsMassP(maxGibbsMassP),

-mAnnealingTemp(1.0), mChi2(0.0), mSingleCellRNASeq(singleCellRNASeq),

 mAMeanMatrix(D.nrow(), nFactor), mAStdMatrix(D.nrow(), nFactor),

 mPMeanMatrix(nFactor, D.ncol()), mPStdMatrix(nFactor, D.ncol()),

-mStatUpdates(0), mFixedMat(whichMat)

+mStatUpdates(0), mMaxGibbsMassA(maxGibbsMassA), mMaxGibbsMassP(maxGibbsMassP),

+mAnnealingTemp(1.0), mChi2(0.0), mSingleCellRNASeq(singleCellRNASeq),

+mFixedMat(whichMat)

 {

     double meanD = mSingleCellRNASeq ? gaps::algo::nonZeroMean(mDMatrix)

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

@@ -13,14 +13,16 @@ private:

 public:

 #endif

-    AtomicSupport mADomain, mPDomain;

-

     TwoWayMatrix mDMatrix, mSMatrix, mAPMatrix;

-    RowMatrix mPMatrix;

+

     ColMatrix mAMatrix;

+    RowMatrix mPMatrix;

+

+    AtomicSupport mADomain, mPDomain;

-    RowMatrix mPMeanMatrix, mPStdMatrix;

     ColMatrix mAMeanMatrix, mAStdMatrix;

+    RowMatrix mPMeanMatrix, mPStdMatrix;

+

     unsigned mStatUpdates;

     double mMaxGibbsMassA;

@@ -55,10 +57,10 @@ public:

 public:

+    GibbsSampler(std::ifstream &file);

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

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

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

-    GibbsSampler(const std::ifstream &file);

     void update(char matrixLabel);

@@ -75,7 +77,6 @@ public:

     Rcpp::NumericMatrix getNormedMatrix(char mat);

-    // serialize and write to file

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

 };

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

-PKG_CPPFLAGS = 

+PKG_CPPFLAGS = -Wall -Wextra

 OBJECTS =   Algorithms.o \

             AtomicSupport.o \

             Cogaps.o \

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

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

     Vector(const std::vector<matrix_data_t>& v) : mValues(v) {}

+    Vector(const Vector &vec) : mValues(vec.mValues) {}

     matrix_data_t& operator()(unsigned i) {return mValues[i];}

     matrix_data_t operator()(unsigned i) const {return mValues[i];}

@@ -57,7 +57,7 @@ double gaps::random::uniform(double a, double b)

     {

         return a;

     }

-    else if (a < b)

+    else

     {

         boost::random::uniform_real_distribution<> dist(a,b);

         return dist(rng);

@@ -77,7 +77,7 @@ uint64_t gaps::random::uniform64(uint64_t a, uint64_t b)

     {

         return a;

     }

-    else if (a < b)

+    else

     {

         boost::random::uniform_int_distribution<uint64_t> dist(a,b);

         return dist(rng);

@@ -3,6 +3,7 @@

 #include <stdint.h>

 #include <vector>

+#include <fstream>

 namespace gaps

 {

@@ -28,8 +29,8 @@ namespace random

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

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

-    void save(ofstream &file);

-    void load(ofstream &file);

+    void save(std::ofstream &file);

+    void load(std::ifstream &file);

 }

 }

@@ -11537,7 +11537,7 @@ int main (int argc, char * const argv[]) {

 #endif

 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )

-#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )

+//#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )

 #define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )

 #define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )

 #define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )

@@ -42,10 +42,8 @@ TEST_CASE("Test AtomicSupport.h")

             REQUIRE(change.label == 'A');

             REQUIRE(change.nChanges == prop.nChanges);

-            cond = change.row1 >= 0 && change.row2 < nrow;

-            REQUIRE(cond);

-            cond = change.col1 >= 0 && change.col2 < ncol;

-            REQUIRE(cond);

+            REQUIRE(change.row2 < nrow);

+            REQUIRE(change.col2 < ncol);

             REQUIRE(change.delta1 == prop.delta1);

             REQUIRE(change.delta2 == prop.delta2);