@@ -4,7 +4,7 @@ Archive& operator<<(Archive &ar, const GapsParameters &p)

 {

     ar << p.seed << p.nGenes << p.nSamples << p.nPatterns << p.nIterations

         << p.alphaA << p.alphaP << p.maxGibbsMassA << p.maxGibbsMassP

-        << p.singleCell << p.useSparseOptimization;

+        << p.singleCell << p.useSparseOptimization << p.checkpointInterval;

     return ar;

 }

@@ -12,7 +12,7 @@ Archive& operator>>(Archive &ar, GapsParameters &p)

 {

     ar >> p.seed >> p.nGenes >> p.nSamples >> p.nPatterns >> p.nIterations

         >> p.alphaA >> p.alphaP >> p.maxGibbsMassA >> p.maxGibbsMassP

-        >> p.singleCell >> p.useSparseOptimization;

+        >> p.singleCell >> p.useSparseOptimization >> p.checkpointInterval;

     return ar;

 }

@@ -15,6 +15,14 @@

 namespace bpt = boost::posix_time;

 #define bpt_now() bpt::microsec_clock::local_time()

+// for conditionally printing status messages

+#define GAPS_MESSAGE(b, m) \

+    do { \

+        if (b) { \

+            gaps_printf(m); \

+        } \

+    } while(0)

+

 // forward declaration

 template <class Sampler, class DataType>

 static GapsResult runCoGAPSAlgorithm(const DataType &data, GapsParameters &params,

@@ -160,11 +168,12 @@ Sampler &PSampler, unsigned nA, unsigned nP)

 template <class Sampler>

 static void createCheckpoint(const GapsParameters &params,

-const Sampler &ASampler, const Sampler &PSampler, const GapsRandomState *randState,

-const GapsRng &rng, char phase, unsigned iter)

+Sampler &ASampler, Sampler &PSampler, const GapsRandomState *randState,

+const GapsStatistics &stats, const GapsRng &rng, char phase, unsigned iter)

 {

     if (params.checkpointInterval > 0

-    && ((iter + 1) % params.checkpointInterval) == 0)

+    && ((iter + 1) % params.checkpointInterval) == 0

+    && !params.subsetData)

     {

         // create backup file

         std::rename(params.checkpointOutFile.c_str(),

@@ -174,10 +183,28 @@ const GapsRng &rng, char phase, unsigned iter)

         Archive ar(params.checkpointOutFile, ARCHIVE_WRITE);

         ar << params;

         ar << *randState;

-        ar << ASampler << PSampler << phase << iter << rng;

+        ar << ASampler << PSampler << stats << phase << iter << rng;

         // delete backup file

         std::remove((params.checkpointOutFile + ".backup").c_str());

+

+        ASampler.extraInitialization();

+        PSampler.extraInitialization();

+    }

+}

+

+template <class Sampler>

+static void processCheckpoint(GapsParameters &params, Sampler &ASampler,

+Sampler &PSampler, GapsRandomState *randState, GapsStatistics &stats,

+GapsRng &rng, char &phase, unsigned &currentIter)

+{    

+    // check if running from checkpoint, get all saved data

+    if (params.useCheckPoint)

+    {

+        Archive ar(params.checkpointFile, ARCHIVE_READ);

+        ar >> params;

+        ar >> *randState;

+        ar >> ASampler >> PSampler >> stats >> phase >> currentIter >> rng;

     }

 }

@@ -192,8 +219,8 @@ GapsRng &rng, bpt::ptime startTime, char phase, unsigned &currentIter)

         Rcpp::checkUserInterrupt();

         #endif

-        createCheckpoint(params, ASampler, PSampler, randState, rng, phase,

-            currentIter);

+        createCheckpoint(params, ASampler, PSampler, randState, stats,

+            rng, phase, currentIter);

         // set annealing temperature in calibration phase

         if (phase == 'C')

@@ -217,51 +244,10 @@ GapsRng &rng, bpt::ptime startTime, char phase, unsigned &currentIter)

     }

 }

-// here is the CoGAPS algorithm

-template <class Sampler, class DataType>

-static GapsResult runCoGAPSAlgorithm(const DataType &data, GapsParameters &params,

-const DataType &uncertainty, GapsRandomState *randState)

+template <class Sampler>

+static void processFixedMatrix(const GapsParameters &params, Sampler &ASampler,

+Sampler &PSampler)

 {

-    // check if running in debug mode

-    #ifdef GAPS_DEBUG

-    if (params.printMessages)

-    {

-        gaps_printf("Running in debug mode\n");

-    }

-    #endif

-

-    // load data into gibbs samplers

-    // we transpose the data in the A sampler so that the update step

-    // is symmetrical for each sampler, this simplifies the code 

-    // within the sampler, note the subsetting genes/samples flag must be

-    // flipped if we are flipping the transpose flag

-    if (params.printMessages)

-    {

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

-    }

-    Sampler ASampler(data, !params.transposeData, !params.subsetGenes,

-        params.alphaA, params.maxGibbsMassA, params, randState);

-    Sampler PSampler(data, params.transposeData, params.subsetGenes,

-        params.alphaP, params.maxGibbsMassP, params, randState);

-

-    // read in the uncertainty matrix if one is provided

-    if (!uncertainty.empty())

-    {

-        ASampler.setUncertainty(uncertainty, !params.transposeData,

-            !params.subsetGenes, params);

-        PSampler.setUncertainty(uncertainty, params.transposeData,

-            params.subsetGenes, params);

-    }

-    if (params.printMessages)

-    {

-        gaps_printf("Done!\n");

-    }

-

-    // these variables will get overwritten by checkpoint if provided

-    GapsRng rng(randState);

-    char phase = 'C';

-    unsigned currentIter = 0;

-

     // check if we're fixing a matrix

     if (params.useFixedMatrix)

     {

@@ -279,24 +265,10 @@ const DataType &uncertainty, GapsRandomState *randState)

             default: break; // 'N' for none

         }

     }

-     

-    // check if running from checkpoint, get all saved data

-    if (params.useCheckPoint)

-    {

-        Archive ar(params.checkpointFile, ARCHIVE_READ);

-        ar >> params;

-        ar >> *randState;

-        ar >> ASampler >> PSampler >> phase >> currentIter >> rng;

-    }

-

-    // sync samplers, second parameter indicates this should be a full sync

-    ASampler.sync(PSampler);

-    PSampler.sync(ASampler);

-

-    // sampler may need to run additional initialization after parameters set

-    ASampler.extraInitialization();

-    PSampler.extraInitialization();

+}

+static void calculateNumberOfThreads(GapsParameters params)

+{

     // calculate appropiate number of threads if compiled with openmp

     #ifdef __GAPS_OPENMP__

     if (params.printMessages && params.printThreadUsage)

@@ -307,36 +279,79 @@ const DataType &uncertainty, GapsRandomState *randState)

             params.maxThreads, availableThreads);

     }

     #endif

+}

+

+template <class Sampler, class DataType>

+static void processUncertainty(const GapsParameters params, Sampler &ASampler,

+Sampler &PSampler, const DataType &uncertainty)

+{

+    // read in the uncertainty matrix if one is provided

+    if (!uncertainty.empty())

+    {

+        ASampler.setUncertainty(uncertainty, !params.transposeData,

+            !params.subsetGenes, params);

+        PSampler.setUncertainty(uncertainty, params.transposeData,

+            params.subsetGenes, params);

+    }

+}

+

+// here is the CoGAPS algorithm

+template <class Sampler, class DataType>

+static GapsResult runCoGAPSAlgorithm(const DataType &data, GapsParameters &params,

+const DataType &uncertainty, GapsRandomState *randState)

+{

+    // check if running in debug mode

+    #ifdef GAPS_DEBUG

+    GAPS_MESSAGE(params.printMessages, "Running in debug mode\n");

+    #endif

+

+    // load data into gibbs samplers

+    // we transpose the data in the A sampler so that the update step

+    // is symmetrical for each sampler, this simplifies the code 

+    // within the sampler, note the subsetting genes/samples flag must be

+    // flipped if we are flipping the transpose flag

+    GAPS_MESSAGE(params.printMessages, "Loading Data...");

+    Sampler ASampler(data, !params.transposeData, !params.subsetGenes,

+        params.alphaA, params.maxGibbsMassA, params, randState);

+    Sampler PSampler(data, params.transposeData, params.subsetGenes,

+        params.alphaP, params.maxGibbsMassP, params, randState);

+    processUncertainty(params, ASampler, PSampler, uncertainty);

+    processFixedMatrix(params, ASampler, PSampler);

+    GAPS_MESSAGE(params.printMessages, "Done!\n");

+

+    // these variables will get overwritten by checkpoint if provided

+    GapsStatistics stats(params.nGenes, params.nSamples, params.nPatterns);

+    GapsRng rng(randState);

+    char phase = 'C';

+    unsigned currentIter = 0;

+    processCheckpoint(params, ASampler, PSampler, randState, stats, rng,

+        phase, currentIter);

+    calculateNumberOfThreads(params);

+

+    // sync samplers and run any additional initialization needed

+    ASampler.sync(PSampler);

+    PSampler.sync(ASampler);

+    ASampler.extraInitialization();

+    PSampler.extraInitialization();

     // record start time

     bpt::ptime startTime = bpt_now();

-    // cascade through phases, allows algorithm to be resumed in either phase

-    GapsStatistics stats(params.nGenes, params.nSamples, params.nPatterns);

+    // fallthrough through phases, allows algorithm to be resumed in any phase

     GAPS_ASSERT(phase == 'C' || phase == 'S');

     switch (phase)

     {

         case 'C':

-            if (params.printMessages)

-            {

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

-            }

+            GAPS_MESSAGE(params.printMessages, "-- Calibration Phase --\n");

             runOnePhase(params, ASampler, PSampler, stats, randState, rng,

                 startTime, phase, currentIter);

             phase = 'S';

             currentIter = 0;

-

-

         case 'S':

-            if (params.printMessages)

-            {

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

-            }

+            GAPS_MESSAGE(params.printMessages, "-- Sampling Phase --\n");

             runOnePhase(params, ASampler, PSampler, stats, randState, rng,

                 startTime, phase, currentIter);

-

-        default: break;

     }

     // get result

@@ -75,7 +75,23 @@ float GapsStatistics::meanChiSq(const SparseGibbsSampler &PSampler) const

 {

     Matrix A(mAMeanMatrix / static_cast<float>(mStatUpdates));

     Matrix P(mPMeanMatrix / static_cast<float>(mStatUpdates));

-    return 0.f; // TODO

+    

+    float chisq = 0.f;

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

+    {

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

+        {

+            float m = 0.f;

+            for (unsigned k = 0; k < A.nCol(); ++k)

+            {

+                m += A(i,k) * P(j,k);

+            }

+            float d = PSampler.mDMatrix.getCol(j).at(i);

+            float s = gaps::max(d * 0.1f, 0.1f);

+            chisq += GAPS_SQ((d - m) / s);

+        }

+    }

+    return chisq;

 }

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

@@ -12,16 +12,6 @@

 class GapsStatistics

 {

-private:

-

-    Matrix mAMeanMatrix;

-    Matrix mAStdMatrix;

-    Matrix mPMeanMatrix;

-    Matrix mPStdMatrix;

-    

-    unsigned mStatUpdates;

-    unsigned mNumPatterns;

-

 public:

     GapsStatistics(unsigned nGenes, unsigned nSamples, unsigned nPatterns);

@@ -40,6 +30,18 @@ public:

     // serialization

     friend Archive& operator<<(Archive &ar, const GapsStatistics &stat);

     friend Archive& operator>>(Archive &ar, GapsStatistics &stat);

+

+#ifndef GAPS_INTERNAL_TESTS

+private:

+#endif

+

+    Matrix mAMeanMatrix;

+    Matrix mAStdMatrix;

+    Matrix mPMeanMatrix;

+    Matrix mPStdMatrix;

+    

+    unsigned mStatUpdates;

+    unsigned mNumPatterns;

 };

 template <class Sampler>

@@ -32,14 +32,17 @@ OBJECTS =   Cogaps.o \

             math/Random.o \

             math/VectorMath.o \

             cpp_tests/testAtomicDomain.o \

+            cpp_tests/testDenseGibbsSampler.o \

+            cpp_tests/testFileParsers.o \

             cpp_tests/testHashSets.o \

             cpp_tests/testHybridMatrix.o \

             cpp_tests/testHybridVector.o \

             cpp_tests/testMatrix.o \

+            cpp_tests/testSerialization.o \

+            cpp_tests/testSparseGibbsSampler.o \

             cpp_tests/testSparseIterator.o \

             cpp_tests/testSparseMatrix.o \

             cpp_tests/testSparseVector.o \

-            cpp_tests/testVector.o \

-            cpp_tests/testFileParsers.o \

-            cpp_tests/testDenseGibbsSampler.o \

-            cpp_tests/testSparseGibbsSampler.o

\ No newline at end of file

+            cpp_tests/testVector.o

+

+

@@ -30,7 +30,9 @@ public:

     friend Archive& operator<<(Archive& ar, const Atom &a);

     friend Archive& operator>>(Archive& ar, Atom &a);

+#ifndef GAPS_INTERNAL_TESTS

 private:

+#endif

     // used by the allocator

     friend class AtomAllocator;

@@ -51,7 +53,9 @@ public:

     void set(uint64_t n);

     void release(uint64_t n);

+#ifndef GAPS_INTERNAL_TESTS

 private:

+#endif

     uint64_t parts[NUM_INDEX_CHUNKS];

 };

@@ -67,7 +71,9 @@ public:

     void free(Atom* a);

     bool depleted() const;

+#ifndef GAPS_INTERNAL_TESTS

 private:

+#endif

     Atom* mPool;

     IndexFlagSet mIndexFlags;

@@ -86,7 +92,9 @@ public:

     Atom* createAtom(uint64_t pos, float mass);

     void destroyAtom(Atom *a);

+#ifndef GAPS_INTERNAL_TESTS

 private:

+#endif

     std::vector<AtomPool*> mPools;

     unsigned mIndex;

@@ -56,7 +56,7 @@ public:

 private:

 #endif

-    // only the proposal queue can insert

+    // only the proposal queue can insert, insert not thread-safe

     friend class ProposalQueue;

     Atom* insert(uint64_t pos, float mass);

@@ -6,7 +6,8 @@

 //////////////////////////////// AtomicProposal ////////////////////////////////

 AtomicProposal::AtomicProposal(char t, GapsRandomState *randState)

-    : rng(randState), pos(0), atom1(NULL), atom2(NULL), type(t)

+    : rng(randState), pos(0), atom1(NULL), atom2(NULL), r1(0), c1(0), r2(0),

+    c2(0), type(t)

 {}

 //////////////////////////////// ProposalQueue /////////////////////////////////

@@ -46,7 +47,7 @@ void ProposalQueue::populate(AtomicDomain &domain, unsigned limit)

     GAPS_ASSERT(mUsedMatrixIndices.isEmpty());

     GAPS_ASSERT(mProposedMoves.isEmpty());

     GAPS_ASSERT(mMinAtoms == mMaxAtoms);

-    GAPS_ASSERT(mMaxAtoms == domain.size());

+    GAPS_ASSERT_MSG(mMaxAtoms == domain.size(), mMaxAtoms << " != " << domain.size());

     unsigned nIter = 0;

     bool success = true;

@@ -115,6 +116,10 @@ float ProposalQueue::deathProb(double nAtoms) const

 bool ProposalQueue::makeProposal(AtomicDomain &domain)

 {

+    mU1 = mUseCachedRng ? mU1 : mRng.uniform();

+    mU2 = mUseCachedRng ? mU2: mRng.uniform();

+    mUseCachedRng = false;

+

     if (mMinAtoms < 2 && mMaxAtoms >= 2)

     {

         return false; // special indeterminate case

@@ -125,10 +130,6 @@ bool ProposalQueue::makeProposal(AtomicDomain &domain)

         return birth(domain); // always birth when no atoms exist

     }

-    mU1 = mUseCachedRng ? mU1 : mRng.uniform();

-    mU2 = mUseCachedRng ? mU2: mRng.uniform();

-    mUseCachedRng = false;

-

     float lowerBound = deathProb(static_cast<double>(mMinAtoms));

     float upperBound = deathProb(static_cast<double>(mMaxAtoms));

@@ -273,13 +274,15 @@ bool ProposalQueue::exchange(AtomicDomain &domain)

 Archive& operator<<(Archive &ar, const ProposalQueue &q)

 {

     ar << q.mRng << q.mMinAtoms << q.mMaxAtoms << q.mBinLength << q.mNumCols

-        << q.mAlpha << q.mDomainLength << q.mNumBins;

+        << q.mAlpha << q.mDomainLength << q.mNumBins << q.mLambda

+        << q.mUseCachedRng << q.mU1 << q.mU2;

     return ar;

 }

 Archive& operator>>(Archive &ar, ProposalQueue &q)

 {

     ar >> q.mRng >> q.mMinAtoms >> q.mMaxAtoms >> q.mBinLength >> q.mNumCols

-        >> q.mAlpha >> q.mDomainLength >> q.mNumBins;

+        >> q.mAlpha >> q.mDomainLength >> q.mNumBins >> q.mLambda

+        >> q.mUseCachedRng >> q.mU1 >> q.mU2;

     return ar;

 }

\ No newline at end of file

@@ -53,7 +53,9 @@ public:

     friend Archive& operator<<(Archive &ar, const ProposalQueue &queue);

     friend Archive& operator>>(Archive &ar, ProposalQueue &queue);

+#ifndef GAPS_INTERNAL_TESTS

 private:

+#endif

     std::vector<AtomicProposal> mQueue; // not really a queue for now

@@ -1,38 +1,42 @@

 #include "catch.h"

 #include "../utils/Archive.h"

 #include "../data_structures/Matrix.h"

-#include "../GibbsSampler.h"

 #include "../math/Random.h"

+#include "../atomic/AtomicDomain.h"

+#include "../atomic/ProposalQueue.h"

-TEST_CASE("Test utils/Archive.h")

-{

-    GapsRandomState randState(123);

-    GapsRng rng(&randState);

+// put Archive in it's own scope so it gets destructed (file stream closed)

-    SECTION("Reading/Writing to an Archive")

+TEST_CASE("Reading/Writing to an Archive")

+{

     {

         Archive ar1("test_ar.temp", ARCHIVE_WRITE);

         ar1 << 3;

-        ar1.close();

+    }

+    {

         Archive ar2("test_ar.temp", ARCHIVE_READ);

         unsigned i = 0;

         ar2 >> i;

         REQUIRE(i == 3);

-        ar2.close();

     }

-    SECTION("Serialization of primitive types")

-    {

-        // test values

-        unsigned u_read = 0, u_write = 456;

-        uint32_t u32_read = 0, u32_write = 512;

-        uint64_t u64_read = 0, u64_write = 0xAABBCCDDEE;

-        float f_read = 0.f, f_write = 0.123542f;

-        double d_read = 0., d_write = 0.54362;

-        bool b_read = false, b_write = true;

+    // cleanup directory

+    std::remove("test_ar.temp");

+}

+

+TEST_CASE("Serialization of primitive types")

+{

+    // test values

+    unsigned u_read = 0, u_write = 456;

+    uint32_t u32_read = 0, u32_write = 512;

+    uint64_t u64_read = 0, u64_write = 0xAABBCCDDEE;

+    float f_read = 0.f, f_write = 0.123542f;

+    double d_read = 0., d_write = 0.54362;

+    bool b_read = false, b_write = true;

-        // write to archive

+    // write to archive

+    {

         Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

         arWrite << u_write;

         arWrite << u32_write;

@@ -40,9 +44,10 @@ TEST_CASE("Test utils/Archive.h")

         arWrite << f_write;

         arWrite << d_write;

         arWrite << b_write;

-        arWrite.close();

+    }

-        // read from archive

+    // read from archive

+    {

         Archive arRead("test_ar.temp", ARCHIVE_READ);

         arRead >> u_read;

         arRead >> u32_read;

@@ -50,139 +55,387 @@ TEST_CASE("Test utils/Archive.h")

         arRead >> f_read;

         arRead >> d_read;

         arRead >> b_read;

-        arRead.close();

-

-        // test that values are the same

-        REQUIRE(u_read == u_write);

-        REQUIRE(u32_read == u32_write);

-        REQUIRE(u64_read == u64_write);

-        REQUIRE(f_read == f_write);

-        REQUIRE(d_read == d_write);

-        REQUIRE(b_read == b_write);

     }

-    SECTION("Vector Serialization")

+    // test that values are the same

+    REQUIRE(u_read == u_write);

+    REQUIRE(u32_read == u32_write);

+    REQUIRE(u64_read == u64_write);

+    REQUIRE(f_read == f_write);

+    REQUIRE(d_read == d_write);

+    REQUIRE(b_read == b_write);

+

+    // cleanup directory

+    std::remove("test_ar.temp");

+}

+

+TEST_CASE("Vector Serialization")

+{

+    GapsRandomState randState(123);

+    GapsRng rng(&randState);

+

+    Vector vec_read(100), vec_write(100);

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

     {

-        Vector vec_read(100), vec_write(100);

-        for (unsigned i = 0; i < 100; ++i)

-        {

-            vec_write[i] = rng.uniform(0.f, 2.f);

-        }

+        vec_write[i] = rng.uniform(0.f, 2.f);

+    }

+    {

         Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

         arWrite << vec_write;

-        arWrite.close();

+    }

+

+    {

         Archive arRead("test_ar.temp", ARCHIVE_READ);

         arRead >> vec_read;

-        arRead.close();

+    }

-        REQUIRE(vec_read.size() == vec_write.size());

+    REQUIRE(vec_read.size() == vec_write.size());

-        for (unsigned i = 0; i < 100; ++i)

-        {

-            REQUIRE(vec_read[i] == vec_write[i]);

-        }

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

+    {

+        REQUIRE(vec_read[i] == vec_write[i]);

     }

-    SECTION("Matrix Serialization")

-    {

-        ColMatrix cMat_read(100,100), cMat_write(100,100);

+    // cleanup directory

+    std::remove("test_ar.temp");

+}

+

+TEST_CASE("HybridVector Serialization")

+{

-        for (unsigned i = 0; i < 100; ++i)

+}

+

+TEST_CASE("SparseVector Serialization")

+{

+

+}

+

+TEST_CASE("Matrix Serialization")

+{

+    GapsRandomState randState(123);

+    GapsRng rng(&randState);

+

+    Matrix matRead(100,100), matWrite(100,100);

+

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

+    {

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

         {

-            for (unsigned j = 0; j < 100; ++j)

-            {

-                cMat_write(i,j) = rng.uniform(0.f, 2.f);

-            }

+            matWrite(i,j) = rng.uniform(0.f, 2.f);

         }

+    }

+    {

         Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

-        arWrite << cMat_write;

-        arWrite.close();

+        arWrite << matWrite;

+    }

+    {

         Archive arRead("test_ar.temp", ARCHIVE_READ);

-        arRead >> cMat_read;

-        arRead.close();

+        arRead >> matRead;

+    }

-        REQUIRE(cMat_read.nRow() == cMat_write.nRow());

-        REQUIRE(cMat_read.nCol() == cMat_write.nCol());

-    

-        for (unsigned i = 0; i < 100; ++i)

+    REQUIRE(matRead.nRow() == matWrite.nRow());

+    REQUIRE(matRead.nCol() == matWrite.nCol());

+

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

+    {

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

         {

-            for (unsigned j = 0; j < 100; ++j)

-            {

-                REQUIRE(cMat_read(i,j) == cMat_write(i,j));

-            }

+            REQUIRE(matRead(i,j) == matWrite(i,j));

         }

     }

-    SECTION("GibbsSampler Serialization")

-    {

-        Rcpp::Environment env = Rcpp::Environment::global_env();

-        std::string csvPath = Rcpp::as<std::string>(env["gistCsvPath"]);

+    // cleanup directory

+    std::remove("test_ar.temp");

+}

+

+TEST_CASE("HybridMatrix Serialization")

+{

+

+}

+

+TEST_CASE("SparseMatrix Serialization")

+{

+

+}

+

+TEST_CASE("Random Generator Serialization")

+{

+    std::vector<float> randSequence;

-        GibbsSampler Asampler(csvPath, false, 7, false, std::vector<unsigned>());

-        GibbsSampler Psampler(csvPath, true, 7, false, std::vector<unsigned>());

-        Asampler.sync(Psampler);

-        Psampler.sync(Asampler);

-        

-        Asampler.update(10000, 1);

+    GapsRandomState randStateWrite(123);

+    GapsRng rngWrite(&randStateWrite);

+    volatile float burn_in = 0.0;

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

+    {

+        burn_in = rngWrite.uniform(0,1);

+    }

+    REQUIRE(burn_in < 1);

+

+    {

         Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

-        arWrite << Asampler;

-        arWrite.close();

+        arWrite << rngWrite;

+    }

+    

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

+    {

+        randSequence.push_back(rngWrite.uniform());

+        randSequence.push_back(rngWrite.uniform(0.3, 6.4));

+        randSequence.push_back(rngWrite.exponential(5.5));

+    }

+

+    GapsRandomState randStateRead(456);

+    GapsRng rngRead(&randStateRead);

-        GibbsSampler savedAsampler(csvPath, false, 7, false, std::vector<unsigned>());

+    {

         Archive arRead("test_ar.temp", ARCHIVE_READ);

-        arRead >> savedAsampler;

-        arRead.close();

+        arRead >> rngRead;

     }

-#ifdef GAPS_INTERNAL_TESTS    

-    SECTION("AtomicDomain Serialization")

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

     {

-

+        REQUIRE(rngRead.uniform() == randSequence[i++]);

+        REQUIRE(rngRead.uniform(0.3, 6.4) == randSequence[i++]);

+        REQUIRE(rngRead.exponential(5.5) == randSequence[i]);

     }

+

+    // cleanup directory

+    std::remove("test_ar.temp");

+}

+

+TEST_CASE("GibbsSampler Serialization")

+{

+#if 0

+    Rcpp::Environment env = Rcpp::Environment::global_env();

+    std::string csvPath = Rcpp::as<std::string>(env["gistCsvPath"]);

+

+    GibbsSampler Asampler(csvPath, false, 7, false, std::vector<unsigned>());

+    GibbsSampler Psampler(csvPath, true, 7, false, std::vector<unsigned>());

+    Asampler.sync(Psampler);

+    Psampler.sync(Asampler);

+    

+    Asampler.update(10000, 1);

+

+    Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

+    arWrite << Asampler;

+    arWrite.close();

+

+    GibbsSampler savedAsampler(csvPath, false, 7, false, std::vector<unsigned>());

+    Archive arRead("test_ar.temp", ARCHIVE_READ);

+    arRead >> savedAsampler;

+    arRead.close();

+

+    // cleanup directory

+    std::remove("test_ar.temp");

 #endif

+}

+

+TEST_CASE("GapsParameters Serialization")

+{

-/*

-    SECTION("Random Generator Serialization")

+}

+

+TEST_CASE("GapsStatistics Serialization")

+{

+

+}

+

+#ifdef GAPS_INTERNAL_TESTS

+TEST_CASE("AtomicDomain Serialization")

+{

+    GapsRandomState randState(123);

+    GapsRng rng(&randState);

+    

+    AtomicDomain domainWrite(100000);

+

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

+    {

+        domainWrite.insert(rng.uniform64(), rng.uniform(0.f, 100.f));

+    }

+

+    {

+        Archive arWrite("test_ar.temp", ARCHIVE_WRITE);

+        arWrite << domainWrite;

+    }

+

+    AtomicDomain domainRead(1);

+    

+    {

+        Archive arRead("test_ar.temp", ARCHIVE_READ);

+        arRead >> domainRead;

+    }

+

+    REQUIRE(domainWrite.front()->pos == domainRead.front()->pos);

+    REQUIRE(domainWrite.front()->mass == domainRead.front()->mass);

+    REQUIRE(domainWrite.size() == domainRead.size());

+    REQUIRE(domainWrite.mDomainLength == domainRead.mDomainLength);

+

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

     {

-        std::vector<float> randSequence;

+        REQUIRE(domainWrite.mAtoms[i]->pos == domainRead.mAtoms[i]->pos);

+        REQUIRE(domainWrite.mAtoms[i]->mass == domainRead.mAtoms[i]->mass);

+    }

+}

+#endif

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

-        volatile float burn_in = 0.0;

-        for (unsigned i = 0; i < 1000; ++i)

+TEST_CASE("ProposalQueue Serialization")

+{

+    const unsigned nGenes = 10000;

+    const unsigned nPatterns = 100;

+    const unsigned nIterations = 1000;

+

+    GapsRandomState randStateWrite(123);

+    AtomicDomain domainWrite(nGenes * nPatterns);

+    ProposalQueue queueWrite(nGenes, nPatterns, &randStateWrite);

+    queueWrite.setAlpha(0.01f);

+    queueWrite.setLambda(0.01f);

+

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

+    {

+        queueWrite.populate(domainWrite, nIterations);

+        for (unsigned j = 0; j < queueWrite.size(); ++j)

         {

-            burn_in = gaps::random::uniform(0,1);

+            switch (queueWrite[j].type)

+            {

+                case 'B':

+                    queueWrite.acceptBirth();

+                    queueWrite[j].atom1->mass = 3.f;

+                    break;

+                case 'D':