@@ -2,6 +2,10 @@ language: r

 cache: packages

 matrix:

+  fast_finish: true

+  allow_failures:

+    - stage: Linting

+    - stage: Code Formatting

   include:

     - stage: Bioconductor Release Testing

       r: bioc-release

@@ -10,6 +14,12 @@ matrix:

     - stage: Test Running in Debug Mode

       install: R -e 'devtools::install_deps(dep = T, configure.args = c(debugMode = " --enable-debug " ))'

       script: R -f inst/scripts/debugRuns.R

+    - stage: Valgrind Analysis

+      script: R -d valgrind -e 'library(CoGAPS); data(GIST); CoGAPS(GIST.matrix, nIterations=1000, outputFrequency=250)'

+    - stage: Linting

+      script: echo "linting not implemented"

+    - stage: Code Formatting

+      script: echo "formatting not implemented"

 notifications:

   slack: fertiglab:LZeNoaS7BnLfqP6XuHiDYdts

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

+#include "GapsParameters.h"

+#include "GapsResult.h"

 #include "GapsRunner.h"

+#include "data_structures/Matrix.h"

+#include "file_parser/FileParser.h"

+#include "math/Random.h"

 #include "utils/GlobalConfig.h"

 #include <Rcpp.h>

@@ -1,5 +1,7 @@

 #include "GapsParameters.h"

+#include "utils/Archive.h"

 #include "utils/GapsPrint.h"

+#include "file_parser/FileParser.h"

 void GapsParameters::print() const

 {

@@ -2,11 +2,13 @@

 #define __COGAPS_GAPS_PARAMETERS_H__

 #include "data_structures/Matrix.h"

-#include "file_parser/FileParser.h"

+#include <stdint.h>

 #include <string>

 #include <vector>

+class Archive;

+

 enum PumpThreshold

 {

     PUMP_UNIQUE=1,

@@ -16,23 +18,17 @@ enum PumpThreshold

 struct GapsParameters

 {

 public:

-

     template <class DataType>

     explicit GapsParameters(const DataType &data, bool t_transposeData=false,

         bool t_subsetData=false, bool t_subsetGenes=false,

         const std::vector<unsigned> &t_dataIndicesSubset=std::vector<unsigned>());

-

     void print() const;

     Matrix fixedPatterns;

-

     std::vector<unsigned> dataIndicesSubset;

-    

     std::string checkpointFile;

     std::string checkpointOutFile;

-

     uint32_t seed;

-

     unsigned nGenes;

     unsigned nSamples;

     unsigned nPatterns;

@@ -40,14 +36,11 @@ public:

     unsigned maxThreads;

     unsigned outputFrequency;

     unsigned checkpointInterval;

-

     float alphaA;

     float alphaP;

     float maxGibbsMassA;

     float maxGibbsMassP;

-

     PumpThreshold pumpThreshold;

-

     bool useFixedPatterns;

     bool subsetData;

     bool useCheckPoint;

@@ -59,13 +52,10 @@ public:

     bool useSparseOptimization;

     bool takePumpSamples;

     bool asynchronousUpdates;

-

     char whichMatrixFixed;

     unsigned workerID;

     bool runningDistributed;

-

 private:

-

     void calculateDataDimensions(const std::string &file);

     void calculateDataDimensions(const Matrix &mat);

 };

@@ -113,4 +103,4 @@ asynchronousUpdates(true)

     calculateDataDimensions(data);

 }

-#endif

\ No newline at end of file

+#endif // __COGAPS_GAPS_PARAMETERS_H__

\ No newline at end of file

@@ -18,21 +18,7 @@ Psd(stat.Psd()), meanChiSq(0.f), seed(0), chisqHistory(stat.chisqHistory()),

 atomHistoryA(stat.atomHistory('A')), atomHistoryP(stat.atomHistory('P'))

 {}

-void GapsResult::writeToFile(const std::string &fullPath)

-{

-    std::size_t pos = fullPath.find_last_of('.');

-    std::string base = fullPath.substr(0, pos);

-

-    switch (FileParser::fileType(fullPath))

-    {

-        case GAPS_CSV: return writeCsv(base);

-        case GAPS_TSV: return writeTsv(base);

-        case GAPS_GCT: return writeGct(base);

-        default : GAPS_ERROR("Invalid File Type");

-    }

-}

-

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

+void GapsResult::writeToFile(const std::string &path)

 {

     unsigned nPatterns = Amean.nCol();

     std::string label("_" + to_string(nPatterns) + "_");

@@ -40,24 +26,4 @@ void GapsResult::writeCsv(const std::string &path)

     FileParser::writeToCsv(path + label + "Pmean.csv", Pmean);

     FileParser::writeToCsv(path + label + "Asd.csv", Asd);

     FileParser::writeToCsv(path + label + "Psd.csv", Psd);

-}

-

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

-{

-    unsigned nPatterns = Amean.nCol();

-    std::string label("_" + to_string(nPatterns) + "_");

-    FileParser::writeToCsv(path + label + "Amean.tsv", Amean);

-    FileParser::writeToCsv(path + label + "Pmean.tsv", Pmean);

-    FileParser::writeToCsv(path + label + "Asd.tsv", Asd);

-    FileParser::writeToCsv(path + label + "Psd.tsv", Psd);

-}

-

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

-{

-    unsigned nPatterns = Amean.nCol();

-    std::string label("_" + to_string(nPatterns) + "_");

-    FileParser::writeToCsv(path + label + "Amean.gct", Amean);

-    FileParser::writeToCsv(path + label + "Pmean.gct", Pmean);

-    FileParser::writeToCsv(path + label + "Asd.gct", Asd);

-    FileParser::writeToCsv(path + label + "Psd.gct", Psd);

 }

\ No newline at end of file

@@ -1,39 +1,34 @@

 #ifndef __COGAPS_GAPS_RESULT__

 #define __COGAPS_GAPS_RESULT__

-#include "GapsStatistics.h"

 #include "data_structures/Matrix.h"

 #include <stdint.h>

 #include <string>

+#include <vector>

+

+class GapsStatistics;

 struct GapsResult

 {

+    explicit GapsResult(const GapsStatistics &stat);

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

+

     Matrix Amean;

     Matrix Asd;

     Matrix Pmean;

     Matrix Psd;

     Matrix pumpMatrix;

     Matrix meanPatternAssignment;

-

     std::vector<float> chisqHistory;

     std::vector<unsigned> atomHistoryA;

     std::vector<unsigned> atomHistoryP;

-

     uint64_t totalUpdates;

     uint32_t seed;

     unsigned totalRunningTime;

-

     float meanChiSq;

     float averageQueueLengthA;

     float averageQueueLengthP;

-

-    explicit GapsResult(const GapsStatistics &stat);

-

-    void writeToFile(const std::string &fullPath);

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

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

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

 };

 #endif // __COGAPS_GAPS_RESULT__

\ No newline at end of file

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

 #include "GapsRunner.h"

-

+#include "GapsResult.h"

+#include "GapsParameters.h"

+#include "GapsStatistics.h"

+#include "math/Random.h"

 #include "utils/Archive.h"

+#include "utils/GlobalConfig.h"

 #include "gibbs_sampler/AsynchronousGibbsSampler.h"

 #include "gibbs_sampler/SingleThreadedGibbsSampler.h"

 #include "gibbs_sampler/DenseNormalModel.h"

@@ -39,7 +43,7 @@ struct GapsTime

     unsigned hours;

     unsigned minutes;

     unsigned seconds;

-    GapsTime(unsigned totalSeconds)

+    explicit GapsTime(unsigned totalSeconds)

     {

         hours = totalSeconds / 3600;

         totalSeconds -= hours * 3600;

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

 #ifndef __COGAPS_GAPS_RUNNER_H__

 #define __COGAPS_GAPS_RUNNER_H__

-#include "GapsResult.h"

-#include "GapsParameters.h"

-#include "data_structures/Matrix.h"

-#include "math/Random.h"

+class GapsResult;

+class Matrix;

+class GapsParameters;

+class GapsRandomState;

+

+#include <string>

 // these two functions are the top-level functions exposed to the C++

 // code that is being wrapped by any given language

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

 #include "GapsStatistics.h"

+#include "utils/Archive.h"

 #include "math/Math.h"

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

@@ -1,63 +1,50 @@

 #ifndef __COGAPS_GAPS_STATISTICS_H__

 #define __COGAPS_GAPS_STATISTICS_H__

-#include "GapsParameters.h"

 #include "gibbs_sampler/DenseNormalModel.h"

 #include "gibbs_sampler/SparseNormalModel.h"

 #include "math/Math.h"

 #include "math/MatrixMath.h"

 #include "math/VectorMath.h"

 #include "data_structures/Matrix.h"

+#include "utils/GapsAssert.h"

+

+class Archive;

 #define GAPS_SQ(x) ((x) * (x))

 class GapsStatistics

 {

 public:

-

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

-

     template <class DataModel>

     void update(const DataModel &AModel, const DataModel &PModel);

-

     template <class DataModel>

     void updatePump(const DataModel &AModel);

-

     Matrix Amean() const;

     Matrix Pmean() const;

     Matrix Asd() const;

     Matrix Psd() const;

-

     Matrix pumpMatrix() const;

     Matrix meanPattern() const;

-

     void addChiSq(float chisq);

     void addAtomCount(unsigned atomA, unsigned atomP);

-

     std::vector<float> chisqHistory() const;

     std::vector<unsigned> atomHistory(char m) const;

-    

     float meanChiSq(const DenseNormalModel &model) const;

     float meanChiSq(const SparseNormalModel &model) const;

-

-    // serialization

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

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

-

 private:

-

     Matrix mAMeanMatrix;

     Matrix mAStdMatrix;

     Matrix mPMeanMatrix;

     Matrix mPStdMatrix;

     Matrix mPumpMatrix;

-   

     std::vector<float> mChisqHistory;

     std::vector<unsigned> mAtomHistoryA;

     std::vector<unsigned> mAtomHistoryP;

-

     PumpThreshold mPumpThreshold;

-

     unsigned mStatUpdates;

     unsigned mNumPatterns;

     unsigned mPumpUpdates;

@@ -68,7 +55,6 @@ inline void pumpMatrixUniqueThreshold(const FactorMatrix &AMatrix, Matrix *statM

 {

     GAPS_ASSERT(statMatrix->nRow() == AMatrix.nRow());

     GAPS_ASSERT(statMatrix->nCol() == AMatrix.nCol());

-

     std::vector<float> maxValues(AMatrix.nRow(), 0.f);

     std::vector<unsigned> maxIndices(AMatrix.nRow(), 0);

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

@@ -82,10 +68,9 @@ inline void pumpMatrixUniqueThreshold(const FactorMatrix &AMatrix, Matrix *statM

             }

         }

     }

-

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

     {

-        statMatrix->operator()(i,maxIndices[i])++;

+        statMatrix->operator()(i, maxIndices[i])++;

     }

 }

@@ -95,11 +80,9 @@ inline void pumpMatrixCutThreshold(const FactorMatrix &AMatrix, Matrix *statMatr

 {

     GAPS_ASSERT(statMatrix->nRow() == AMatrix.nRow());

     GAPS_ASSERT(statMatrix->nCol() == AMatrix.nCol());

-

-    // we need to access data in columns due to matrix data layout

     std::vector<float> maxValues(AMatrix.nRow(), 0.f);

     std::vector<unsigned> maxIndices(AMatrix.nRow(), 0);

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

+    for (unsigned j = 0; j < AMatrix.nCol(); ++j) // col-major ordering

     {

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

         {

@@ -110,7 +93,6 @@ inline void pumpMatrixCutThreshold(const FactorMatrix &AMatrix, Matrix *statMatr

             }

         }

     }

-

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

     {

         statMatrix->operator()(i,maxIndices[i])++;

@@ -131,29 +113,26 @@ void GapsStatistics::updatePump(const DataModel &AModel)

     }

 }

+// TODO is there precision loss? use double?

 template <class DataModel>

 void GapsStatistics::update(const DataModel &AModel, const DataModel &PModel)

 {

     GAPS_ASSERT(mNumPatterns == AModel.mMatrix.nCol());

     GAPS_ASSERT(mNumPatterns == PModel.mMatrix.nCol());

-

-    // precision loss? use double?

     ++mStatUpdates;

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

     {

         float norm = gaps::max(PModel.mMatrix.getCol(j));

-        norm = norm == 0.f ? 1.f : norm;

-        GAPS_ASSERT(norm > 0.f);

-

+        norm = (norm == 0.f) ? 1.f : norm;

         Vector quot(PModel.mMatrix.getCol(j) / norm);

-        GAPS_ASSERT(gaps::min(quot) >= 0.f);

         mPMeanMatrix.getCol(j) += quot;

         mPStdMatrix.getCol(j) += gaps::elementSq(quot);

-

         Vector prod(AModel.mMatrix.getCol(j) * norm);

-        GAPS_ASSERT(gaps::min(prod) >= 0.f);

         mAMeanMatrix.getCol(j) += prod;

         mAStdMatrix.getCol(j) += gaps::elementSq(prod);

+        GAPS_ASSERT(norm > 0.f);

+        GAPS_ASSERT(gaps::min(quot) >= 0.f);

+        GAPS_ASSERT(gaps::min(prod) >= 0.f);

     }

 }

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

 #include "Atom.h"

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

+

+#include <cstddef>

+

+AtomNeighborhood::AtomNeighborhood()

+    : center(NULL), left(NULL), right(NULL)

+{}

+

+AtomNeighborhood::AtomNeighborhood(Atom *l, Atom *c, Atom *r)

+    : center(c), left(l), right(r)

+{}

+

+bool AtomNeighborhood::hasLeft() const

+{

+    return left != NULL;

+}

+

+bool AtomNeighborhood::hasRight() const

+{

+    return right != NULL;

+}

 Atom::Atom(uint64_t p, float m)

     : mPos(p), mIterator(), mLeftIndex(-1), mRightIndex(-1), mIndex(-1), mMass(m)

@@ -1,9 +1,8 @@

 #ifndef __COGAPS_ATOM_H__

 #define __COGAPS_ATOM_H__

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

-

 struct Atom;

+class Archive;

 class AtomicDomain;

 // this is the map used internally by the atomic domain

@@ -12,44 +11,34 @@ typedef MutableMap<uint64_t, unsigned> AtomMapType;

 struct AtomNeighborhood

 {

+    AtomNeighborhood();

+    AtomNeighborhood(Atom *l, Atom *c, Atom *r);

+    bool hasLeft() const;

+    bool hasRight() const;

+

     Atom* center;

     Atom* left;

     Atom* right;

-

-    AtomNeighborhood() : center(NULL), left(NULL), right(NULL) {}

-    AtomNeighborhood(Atom *l, Atom *c, Atom *r)

-        : center(c), left(l), right(r)

-    {}

-

-    bool hasLeft() const { return left != NULL; }

-    bool hasRight() const { return right != NULL; }

 };

 struct Atom

 {

 public:

-

     Atom(uint64_t p, float m);

-

     uint64_t pos() const;

     float mass() const;

     void updateMass(float newMass);

-

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

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

-

 private:

-

     // only the atomic domain can change the position of an atom, since it is

     // responsible for keeping them ordered

     friend class AtomicDomain;

     void updatePos(uint64_t newPos);

-

     void setLeftIndex(int index);

     void setRightIndex(int index);

     void setIndex(int index);

     void setIterator(AtomMapType::iterator it);    

-

     bool hasLeft() const;

     bool hasRight() const;

     int leftIndex() const;

@@ -57,15 +46,12 @@ private:

     int index() const;

     AtomMapType::iterator iterator() const;

-    uint64_t mPos;

     AtomMapType::iterator mIterator; // iterator to position in map

-

-    // storing the index allows vector lookup once found in map

-    int mLeftIndex;

-    int mRightIndex;

-    int mIndex;

-

-    float mMass;

+    uint64_t mPos; // position of the atom

+    int mLeftIndex; // index of left neighbor

+    int mRightIndex; // index of right neighbor

+    int mIndex; // storing the index allows vector lookup once found in map

+    float mMass; // mass of the atom

 };

 #endif // __COGAPS_ATOM_H__

\ No newline at end of file

@@ -1,5 +1,7 @@

 #include "AtomicDomain.h"

 #include "../utils/GapsAssert.h"

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

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

 #include <algorithm>

 #include <limits>

@@ -39,7 +41,7 @@ AtomNeighborhood AtomicDomain::randomAtomWithNeighbors(GapsRng *rng)

 uint64_t AtomicDomain::randomFreePosition(GapsRng *rng) const

 {

     uint64_t pos = rng->uniform64(1, mDomainLength);

-    while (mAtomMap.count(pos))

+    while (mAtomMap.count(pos) != 0u)

     {

         pos = rng->uniform64(1, mDomainLength);

     }

@@ -97,9 +99,13 @@ void AtomicDomain::erase(Atom *atom)

         mAtoms[index].setIndex(index);

         mAtoms[index].iterator()->second = index;

         if (leftIndex >= 0)

+        {

             mAtoms[leftIndex].setRightIndex(index);

+        }

         if (rightIndex >= 0)

+        {

             mAtoms[rightIndex].setLeftIndex(index);

+        }

     }

     mAtoms.pop_back();

 }

@@ -1,54 +1,44 @@

 #ifndef __COGAPS_ATOMIC_DOMAIN_H__

 #define __COGAPS_ATOMIC_DOMAIN_H__

-#include "../data_structures/HashSets.h"

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

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

 #include "Atom.h"

 #include <vector>

+#include <cstddef>

-// needed for friend declarations

 template <class StoragePolicy>

 class SingleThreadedGibbsSampler;

+class Archive;

+class GapsRng;

+

 class AtomicDomain

 {

 public:

-

-    AtomicDomain(uint64_t nBins);

-

-    // access atoms

+    explicit AtomicDomain(uint64_t nBins);

     Atom* front();

     Atom* randomAtom(GapsRng *rng);

     AtomNeighborhood randomAtomWithNeighbors(GapsRng *rng);

-

     uint64_t randomFreePosition(GapsRng *rng) const;

     uint64_t size() const;

-

-    // serialization

     friend Archive& operator<<(Archive &ar, const AtomicDomain &domain);

     friend Archive& operator>>(Archive &ar, AtomicDomain &domain);

-   

 private:

-

-    template <class StoragePolicy>

-    friend class SingleThreadedGibbsSampler;

-

     // both insert and erase will invalidate pointers to atoms and neither

     // of these functions should be considered thread-safe in any way. This

     // class can provide increased performance when thread-safety and 

     // concurrency is not needed. Friend classes are declared here as a way

     // to enforce this contract between classes.

+    template <class StoragePolicy>

+    friend class SingleThreadedGibbsSampler;

+

     Atom* insert(uint64_t pos, float mass);

     void erase(Atom *atom);

     void move(Atom *atom, uint64_t newPos);

     AtomMapType mAtomMap; // sorted, used when inserting atoms to find neighbors

     std::vector<Atom> mAtoms; // unsorted, used for reads

-

-    // size of atomic domain to ensure all bins are equal length

-    uint64_t mDomainLength;

+    uint64_t mDomainLength; // size of atomic domain to ensure all bins are equal length

 };

 #endif // __COGAPS_ATOMIC_DOMAIN_H__

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

 #include "ConcurrentAtom.h"

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

+

+#include <cstddef>

+

+ConcurrentAtomNeighborhood::ConcurrentAtomNeighborhood()

+    : center(NULL), left(NULL), right(NULL)

+{}

+

+ConcurrentAtomNeighborhood::ConcurrentAtomNeighborhood(ConcurrentAtom *l, ConcurrentAtom *c, ConcurrentAtom *r)

+    : center(c), left(l), right(r)

+{}

+    

+bool ConcurrentAtomNeighborhood::hasLeft() const

+{

+    return left != NULL;

+}

+

+bool ConcurrentAtomNeighborhood::hasRight() const

+{

+    return right != NULL;

+}

 ConcurrentAtom::ConcurrentAtom(uint64_t p, float m)

     : mPos(p), mLeft(NULL), mRight(NULL), mIterator(), mIndex(0), mMass(m)

@@ -44,14 +65,14 @@ void ConcurrentAtom::updatePos(uint64_t newPos)

     mPos = newPos;

 }

-void ConcurrentAtom::setLeft(ConcurrentAtom* ConcurrentAtom)

+void ConcurrentAtom::setLeft(ConcurrentAtom* atom)

 {

-    mLeft = ConcurrentAtom;

+    mLeft = atom;

 }

-void ConcurrentAtom::setRight(ConcurrentAtom* ConcurrentAtom)

+void ConcurrentAtom::setRight(ConcurrentAtom* atom)

 {

-    mRight = ConcurrentAtom;

+    mRight = atom;

 }

 void ConcurrentAtom::setIndex(unsigned index)

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

 #ifndef __COGAPS_CONCURRENT_ATOM_H__

 #define __COGAPS_CONCURRENT_ATOM_H__

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

-

 struct ConcurrentAtom;

 class ConcurrentAtomicDomain;

+class Archive;

 // this is the map used internally by the atomic domain

 #include "../data_structures/MutableMap.h"

@@ -12,44 +11,33 @@ typedef MutableMap<uint64_t, ConcurrentAtom*> ConcurrentAtomMapType;

 struct ConcurrentAtomNeighborhood

 {

+    ConcurrentAtomNeighborhood();

+    ConcurrentAtomNeighborhood(ConcurrentAtom *l, ConcurrentAtom *c, ConcurrentAtom *r);

+    bool hasLeft() const;

+    bool hasRight() const;

     ConcurrentAtom *center;

     ConcurrentAtom *left;

     ConcurrentAtom *right;

-

-    ConcurrentAtomNeighborhood() : center(NULL), left(NULL), right(NULL) {}

-    ConcurrentAtomNeighborhood(ConcurrentAtom *l, ConcurrentAtom *c, ConcurrentAtom *r)

-        : center(c), left(l), right(r)

-    {}

-

-    bool hasLeft() const { return left != NULL; }

-    bool hasRight() const { return right != NULL; }

 };

 struct ConcurrentAtom

 {

 public:

-

     ConcurrentAtom(uint64_t p, float m);

-

     uint64_t pos() const;

     float mass() const;

     void updateMass(float newMass);

-

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

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

-

-//private:

-

+//private: // TODO

     // only the atomic domain can change the position of an atom, since it is

     // responsible for keeping them ordered

     friend class ConcurrentAtomicDomain;

     void updatePos(uint64_t newPos);

-

     void setLeft(ConcurrentAtom *atom);

     void setRight(ConcurrentAtom *atom);

     void setIndex(unsigned index);

     void setIterator(ConcurrentAtomMapType::iterator it);    

-

     bool hasLeft() const;

     bool hasRight() const;

     ConcurrentAtom* left() const;

@@ -58,12 +46,9 @@ public:

     ConcurrentAtomMapType::iterator iterator() const;

     uint64_t mPos;

-

     ConcurrentAtom *mLeft;

     ConcurrentAtom *mRight;

-

     ConcurrentAtomMapType::iterator mIterator; // iterator to position in map

-

     unsigned mIndex; // storing the index allows vector lookup once found in map

     float mMass;

 };

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

 #include "ConcurrentAtomicDomain.h"

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

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

 #include "../utils/GapsAssert.h"

 #include <algorithm>

@@ -1,47 +1,36 @@

 #ifndef __COGAPS_CONCURRENT_ATOMIC_DOMAIN_H__

 #define __COGAPS_CONCURRENT_ATOMIC_DOMAIN_H__

-#include "../data_structures/HashSets.h"

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

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

 #include "ConcurrentAtom.h"

 #include <vector>

-// needed for friend declarations

-template <class StoragePolicy>

-class AsynchronousGibbsSampler;

 template <class StoragePolicy>

 class SingleThreadedGibbsSampler;

+

+struct ConcurrentAtom;

+class Archive;

+class GapsRng;

 class ProposalQueue;

 class ConcurrentAtomicDomain

 {

 public:

-

-    ConcurrentAtomicDomain(uint64_t nBins);

-

-    // access atoms

+    explicit ConcurrentAtomicDomain(uint64_t nBins);

     ConcurrentAtom* front();

     const ConcurrentAtom* front() const;

     ConcurrentAtom* randomAtom(GapsRng *rng);

     ConcurrentAtomNeighborhood randomAtomWithNeighbors(GapsRng *rng);

-

     uint64_t randomFreePosition(GapsRng *rng) const;

     uint64_t size() const;

-

     void cacheErase(ConcurrentAtom *atom); // OpenMP thread safe

     void move(ConcurrentAtom *atom, uint64_t newPos); // OpenMP thread safe

     void flushEraseCache();

-

-    // serialization

     friend Archive& operator<<(Archive &ar, const ConcurrentAtomicDomain &domain);

     friend Archive& operator>>(Archive &ar, ConcurrentAtomicDomain &domain);

-

 #ifdef GAPS_DEBUG

     bool isSorted() const;

 #endif

-   

 private:

     // only these classes can call the non-thread safe insert and erase functions

@@ -54,11 +43,9 @@ private:

     void erase(ConcurrentAtom *atom);

     ConcurrentAtomMapType mAtomMap; // sorted, used when inserting atoms to find neighbors

-    std::vector<ConcurrentAtom*> mAtoms; // unsorted, used for reads

+    std::vector<ConcurrentAtom*> mAtoms; // unsorted, used for random selection of atoms

     std::vector<ConcurrentAtom*> mEraseCache;

-

-    // size of atomic domain to ensure all bins are equal length

-    uint64_t mDomainLength;

+    uint64_t mDomainLength; // size of atomic domain to ensure all bins are equal length

 };

 #endif // __COGAPS_CONCURRENT_ATOMIC_DOMAIN_H__

@@ -1,6 +1,8 @@

 #include "ProposalQueue.h"

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

 #include "../math/Math.h"

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

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

 #include "../utils/GapsAssert.h"

 #include <limits>

@@ -1,95 +1,75 @@

 #ifndef __COGAPS_PROPOSAL_QUEUE_H__

 #define __COGAPS_PROPOSAL_QUEUE_H__

-#include "ConcurrentAtomicDomain.h"

-#include "../data_structures/HashSets.h"

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

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

+#include "../data_structures/HashSets.h"

 #include <cstddef>

 #include <stdint.h>

 #include <vector>

+struct ConcurrentAtom;

+class Archive;

+class ConcurrentAtomicDomain;

+

 struct AtomicProposal

 {

+    AtomicProposal(char t, GapsRandomState *randState);

+

     mutable GapsRng rng; // used for consistency no matter number of threads 

- 

     uint64_t pos; // used for move

     ConcurrentAtom *atom1; // used for birth/death/move/exchange

     ConcurrentAtom *atom2; // used for exchange

-

     uint32_t r1; // row of atom1

     uint32_t c1; // col of atom1

     uint32_t r2; // row of pos (move) or atom2 (exchange)

     uint32_t c2; // col of pos (move) or atom2 (exchange)

-

     char type; // birth (B), death (D), move (M), exchange (E)

-

-    AtomicProposal(char t, GapsRandomState *randState);

 };

 class ProposalQueue

 {

 public:

-

-    // initialize