@@ -93,40 +93,40 @@ Atom* AtomicDomain::front()

     return &(mAtoms.front());

 }

-Atom* AtomicDomain::randomAtom()

+Atom* AtomicDomain::randomAtom(GapsRng *rng)

 {

     GAPS_ASSERT(size() > 0);

     GAPS_ASSERT(isSorted(mAtoms));

-    unsigned index = mRng.uniform32(0, mAtoms.size() - 1);

+    unsigned index = rng->uniform32(0, mAtoms.size() - 1);

     return &(mAtoms[index]);

 }

-AtomNeighborhood AtomicDomain::randomAtomWithNeighbors()

+AtomNeighborhood AtomicDomain::randomAtomWithNeighbors(GapsRng *rng)

 {

     GAPS_ASSERT(size() > 0);

-    unsigned index = mRng.uniform32(0, mAtoms.size() - 1);

+    unsigned index = rng->uniform32(0, mAtoms.size() - 1);

     Atom* left = (index == 0) ? NULL : &(mAtoms[index - 1]);

     Atom* right = (index == mAtoms.size() - 1) ? NULL : &(mAtoms[index + 1]);

     return AtomNeighborhood(left, &(mAtoms[index]), right);

 }

-AtomNeighborhood AtomicDomain::randomAtomWithRightNeighbor()

+AtomNeighborhood AtomicDomain::randomAtomWithRightNeighbor(GapsRng *rng)

 {

     GAPS_ASSERT(size() > 0);

-    unsigned index = mRng.uniform32(0, mAtoms.size() - 1);

+    unsigned index = rng->uniform32(0, mAtoms.size() - 1);

     Atom* right = (index == mAtoms.size() - 1) ? NULL : &(mAtoms[index + 1]);

     return AtomNeighborhood(NULL, &(mAtoms[index]), right);

 }

-uint64_t AtomicDomain::randomFreePosition() const

+uint64_t AtomicDomain::randomFreePosition(GapsRng *rng) const

 {

-    uint64_t pos = mRng.uniform64(0, mDomainLength);

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

     while (vecContains(mAtoms, pos))

     {

-        pos = mRng.uniform64(0, mDomainLength);

+        pos = rng->uniform64(0, mDomainLength);

     } 

     return pos;

 }

@@ -155,7 +155,7 @@ void AtomicDomain::insert(uint64_t pos, float mass)

 Archive& operator<<(Archive &ar, AtomicDomain &domain)

 {

-    ar << domain.mDomainLength << domain.mRng << domain.mAtoms.size();

+    ar << domain.mDomainLength << domain.mAtoms.size();

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

     {

@@ -168,7 +168,7 @@ Archive& operator>>(Archive &ar, AtomicDomain &domain)

 {

     Atom temp;

     uint64_t size = 0;

-    ar >> domain.mDomainLength >> domain.mRng >> size;

+    ar >> domain.mDomainLength >> size;

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

     {

         ar >> temp;

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

     // access atoms

     Atom* front();

-    Atom* randomAtom();

-    AtomNeighborhood randomAtomWithNeighbors();

-    AtomNeighborhood randomAtomWithRightNeighbor();

+    Atom* randomAtom(GapsRng *rng);

+    AtomNeighborhood randomAtomWithNeighbors(GapsRng *rng);

+    AtomNeighborhood randomAtomWithRightNeighbor(GapsRng *rng);

-    uint64_t randomFreePosition() const;

+    uint64_t randomFreePosition(GapsRng *rng) const;

     uint64_t size() const;

     void erase(uint64_t pos);

@@ -63,9 +63,6 @@ private:

     // domain storage, sorted vector

     std::vector<Atom> mAtoms;

-

-    // random number generator

-    mutable GapsRng mRng;

 };

 #endif

\ No newline at end of file

@@ -62,7 +62,6 @@ unsigned getNumPatterns(const Rcpp::List &allParams)

     {

         std::string file(Rcpp::as<std::string>(allParams["checkpointInFile"]));

         Archive ar(file, ARCHIVE_READ);

-        GapsRng::load(ar);

         ar >> nPatterns;

         ar.close();

     }

@@ -100,7 +99,6 @@ const Rcpp::Nullable<Rcpp::NumericMatrix> &fixedMatrix, bool isMaster)

 {

     // calculate essential parameters needed for constructing GapsRunner

     const Rcpp::S4 &gapsParams(allParams["gaps"]);

-    GapsRng::setSeed(gapsParams.slot("seed"));

     unsigned nPatterns = getNumPatterns(allParams); // TODO clarify this sets the checkpoint seed as well

     bool printThreads = !processDistributedParameters(allParams).first;

     bool partitionRows = processDistributedParameters(allParams).second;

@@ -108,7 +106,7 @@ const Rcpp::Nullable<Rcpp::NumericMatrix> &fixedMatrix, bool isMaster)

     // construct GapsRunner

     GapsRunner runner(data, allParams["transposeData"], nPatterns,

-        partitionRows, cIndices);

+        partitionRows, cIndices, gapsParams.slot("seed"));

     // set uncertainty

     if (!isNull(uncertainty))

@@ -122,7 +120,6 @@ const Rcpp::Nullable<Rcpp::NumericMatrix> &fixedMatrix, bool isMaster)

     {

         std::string file(Rcpp::as<std::string>(allParams["checkpointInFile"]));

         Archive ar(file, ARCHIVE_READ);

-        GapsRng::load(ar);

         ar >> runner;

         ar.close();

     }

@@ -137,7 +134,6 @@ const Rcpp::Nullable<Rcpp::NumericMatrix> &fixedMatrix, bool isMaster)

         }

         // set parameters that would be saved in the checkpoint

-        runner.recordSeed(gapsParams.slot("seed"));

         runner.setMaxIterations(gapsParams.slot("nIterations"));

         runner.setSparsity(gapsParams.slot("alphaA"),

             gapsParams.slot("alphaP"), gapsParams.slot("singleCell"));

@@ -1,8 +1,10 @@

 #include "GapsRunner.h"

+#include "math/Algorithms.h"

 #include "math/Random.h"

 #include "math/SIMD.h"

 #include "utils/GapsAssert.h"

 #include "utils/GapsPrint.h"

+#include "utils/GlobalConfig.h"

 #ifdef __GAPS_R_BUILD__

 #include <Rcpp.h>

@@ -25,11 +27,6 @@ void GapsRunner::setFixedMatrix(char which, const Matrix &mat)

     }

 }

-void GapsRunner::recordSeed(uint32_t seed)

-{

-    mSeed = seed;

-}

-

 uint32_t GapsRunner::getSeed() const

 {

     return mSeed;

@@ -245,7 +242,6 @@ void GapsRunner::createCheckpoint()

         // create checkpoint file

         Archive ar(mCheckpointOutFile, ARCHIVE_WRITE);

-        GapsRng::save(ar);

         ar << mNumPatterns << mSeed << mASampler << mPSampler << mStatistics

             << mFixedMatrix << mMaxIterations << mPhase << mCurrentIteration

             << mNumUpdatesA << mNumUpdatesP << mRng;

@@ -263,5 +259,12 @@ Archive& operator>>(Archive &ar, GapsRunner &gr)

         >> gr.mStatistics >> gr.mFixedMatrix >> gr.mMaxIterations >> gr.mPhase

         >> gr.mCurrentIteration >> gr.mNumUpdatesA >> gr.mNumUpdatesP

         >> gr.mRng;

+

+    gr.mASampler.sync(gr.mPSampler);

+    gr.mPSampler.sync(gr.mASampler);

+

+    gr.mASampler.recalculateAPMatrix();

+    gr.mPSampler.recalculateAPMatrix();

+

     return ar;

 }

@@ -52,7 +52,8 @@ public:

     template <class DataType>

     GapsRunner(const DataType &data, bool transposeData, unsigned nPatterns,

-        bool partitionRows, const std::vector<unsigned> &indices);

+        bool partitionRows, const std::vector<unsigned> &indices,

+        uint32_t seed);

     template <class DataType>

     void setUncertainty(const DataType &unc, bool transposeData,

@@ -60,7 +61,6 @@ public:

     void setFixedMatrix(char which, const Matrix &mat);

-    void recordSeed(uint32_t seed);

     uint32_t getSeed() const;

     void setMaxIterations(unsigned nIterations);

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

 // problem with passing file parser - need to read it twice

 template <class DataType>

 GapsRunner::GapsRunner(const DataType &data, bool transposeData,

-unsigned nPatterns, bool partitionRows, const std::vector<unsigned> &indices)

+unsigned nPatterns, bool partitionRows, const std::vector<unsigned> &indices,

+uint32_t seed)

     :

 mASampler(data, !transposeData, nPatterns,!partitionRows, indices),

 mPSampler(data, transposeData, nPatterns, partitionRows, indices),

@@ -90,10 +91,14 @@ mStatistics(mPSampler.dataRows(), mPSampler.dataCols(), nPatterns),

 mFixedMatrix('N'), mMaxIterations(1000), mMaxThreads(1), mPrintMessages(true),

 mOutputFrequency(500), mCheckpointOutFile("gaps_checkpoint.out"),

 mCheckpointInterval(0), mPhase('C'), mCurrentIteration(0),

-mNumPatterns(nPatterns), mSeed(0), mNumUpdatesA(0), mNumUpdatesP(0)

+mNumPatterns(nPatterns), mSeed(seed), mNumUpdatesA(0), mNumUpdatesP(0),

+mRng(seed)

 {

     mASampler.sync(mPSampler);

     mPSampler.sync(mASampler);

+

+    mASampler.setSeed(mRng.uniform64());

+    mPSampler.setSeed(mRng.uniform64());

 }

 template <class DataType>

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

 #include "GibbsSampler.h"

+#include "math/Algorithms.h"

 #include "math/SIMD.h"

 static float getDeltaLL(AlphaParameters alpha, float mass)

 {

-    return mass * (alpha.su - alpha.s * mass / 2.f);

+    return mass * (alpha.s_mu - alpha.s * mass / 2.f);

 }

 unsigned GibbsSampler::dataRows() const

@@ -43,6 +44,11 @@ void GibbsSampler::setMatrix(const Matrix &mat)

     mMatrix = mat;

 }

+void GibbsSampler::setSeed(uint64_t seed)

+{

+    mSeeder.seed(seed);

+}

+

 float GibbsSampler::chi2() const

 {   

     return 2.f * gaps::algo::loglikelihood(mDMatrix, mSMatrix, mAPMatrix);

@@ -53,6 +59,11 @@ uint64_t GibbsSampler::nAtoms() const

     return mDomain.size();

 }

+void GibbsSampler::recalculateAPMatrix()

+{

+    mAPMatrix = gaps::algo::matrixMultiplication(*mOtherMatrix, mMatrix);

+}

+

 void GibbsSampler::sync(const GibbsSampler &sampler)

 {

     mOtherMatrix = &(sampler.mMatrix);

@@ -61,25 +72,27 @@ void GibbsSampler::sync(const GibbsSampler &sampler)

 void GibbsSampler::update(unsigned nSteps, unsigned nCores)

 {

+    uint64_t seed = mSeeder.next();

     for (unsigned n = 0; n < nSteps; ++n)

     {

-        makeAndProcessProposal();

+        GapsRng rng(seed, n);

+        makeAndProcessProposal(&rng);

     }

 }

-void GibbsSampler::makeAndProcessProposal()

+void GibbsSampler::makeAndProcessProposal(GapsRng *rng)

 {

     if (mDomain.size() < 2)

     {

-        return birth();

+        return birth(rng);

     }

-    float u1 = mPropRng.uniform();

+    float u1 = rng->uniform();

     if (u1 < 0.5f)

     {

-        return mPropRng.uniform() < deathProb(mDomain.size()) ? death() : birth();

+        return rng->uniform() < deathProb(mDomain.size()) ? death(rng) : birth(rng);

     }

-    return (u1 < 0.75f) ? move() : exchange();

+    return (u1 < 0.75f) ? move(rng) : exchange(rng);

 }

 float GibbsSampler::deathProb(uint64_t nAtoms) const

@@ -92,17 +105,16 @@ float GibbsSampler::deathProb(uint64_t nAtoms) const

 // add an atom at a random position, calculate mass either with an

 // exponential distribution or with the gibbs mass distribution

-void GibbsSampler::birth()

+void GibbsSampler::birth(GapsRng *rng)

 {

-    uint64_t pos = mDomain.randomFreePosition();

+    uint64_t pos = mDomain.randomFreePosition(rng);

     unsigned row = getRow(pos);

     unsigned col = getCol(pos);

-    GapsRng rng;

     // calculate proposed mass

     float mass = canUseGibbs(col)

-        ? gibbsMass(alphaParameters(row, col), &rng).value()

-        : rng.exponential(mLambda);

+        ? gibbsMass(alphaParameters(row, col), rng).value()

+        : rng->exponential(mLambda);

     // accept mass as long as it's non-zero

     if (mass >= gaps::epsilon)

@@ -115,32 +127,31 @@ void GibbsSampler::birth()

 // automatically accept death, attempt a rebirth at the same position, using

 // the original mass or the gibbs mass distribution

-void GibbsSampler::death()

+void GibbsSampler::death(GapsRng *rng)

 {

     // get random atom

-    Atom* atom = mDomain.randomAtom();

+    Atom* atom = mDomain.randomAtom(rng);

     unsigned row = getRow(atom->pos);

     unsigned col = getCol(atom->pos);

-    GapsRng rng;

     // calculate alpha parameters assuming atom dies

     AlphaParameters alpha = alphaParametersWithChange(row, col, -atom->mass);

     float rebirthMass = atom->mass;

-    bool useSame = true;

+    bool useOriginalMass = true;

     if (canUseGibbs(col))

     {

-        OptionalFloat gMass = gibbsMass(alpha, &rng);

+        OptionalFloat gMass = gibbsMass(alpha, rng);

         if (gMass.hasValue())

         {

             rebirthMass = gMass.value();

-            useSame = false;

+            useOriginalMass = false;

         }

     }

     // accept/reject rebirth

-    if (std::log(rng.uniform()) < getDeltaLL(alpha, rebirthMass) * mAnnealingTemp)

+    if (std::log(rng->uniform()) < getDeltaLL(alpha, rebirthMass) * mAnnealingTemp)

     {

-        if (!useSame)

+        if (!useOriginalMass)

         {

             safelyChangeMatrix(row, col, rebirthMass - atom->mass);

             atom->mass = rebirthMass;

@@ -154,12 +165,12 @@ void GibbsSampler::death()

 }

 // move mass from src to dest in the atomic domain

-void GibbsSampler::move()

+void GibbsSampler::move(GapsRng *rng)

 {

-    AtomNeighborhood hood = mDomain.randomAtomWithNeighbors();

+    AtomNeighborhood hood = mDomain.randomAtomWithNeighbors(rng);

     uint64_t lbound = hood.hasLeft() ? hood.left->pos : 0;

     uint64_t rbound = hood.hasRight() ? hood.right->pos : mDomainLength;

-    uint64_t newLocation = mPropRng.uniform64(lbound + 1, rbound - 1);

+    uint64_t newLocation = rng->uniform64(lbound + 1, rbound - 1);

     unsigned r1 = getRow(hood.center->pos);

     unsigned c1 = getCol(hood.center->pos);

@@ -168,9 +179,8 @@ void GibbsSampler::move()

     if (r1 != r2 || c1 != c2)

     {

-        GapsRng rng;

         AlphaParameters alpha = alphaParameters(r1, c1, r2, c2);

-        if (std::log(rng.uniform()) < getDeltaLL(alpha, -hood.center->mass) * mAnnealingTemp)

+        if (std::log(rng->uniform()) < getDeltaLL(alpha, -hood.center->mass) * mAnnealingTemp)

         {

             hood.center->pos = newLocation;

             safelyChangeMatrix(r1, c1, -hood.center->mass);

@@ -187,9 +197,9 @@ void GibbsSampler::move()

 // exchange some amount of mass between two positions, note it is possible

 // for one of the atoms to be deleted if it's mass becomes too small after

 // the exchange

-void GibbsSampler::exchange()

+void GibbsSampler::exchange(GapsRng *rng)

 {

-    AtomNeighborhood hood = mDomain.randomAtomWithRightNeighbor();

+    AtomNeighborhood hood = mDomain.randomAtomWithRightNeighbor(rng);

     Atom* a1 = hood.center;

     Atom* a2 = hood.hasRight() ? hood.right : mDomain.front();

@@ -200,11 +210,10 @@ void GibbsSampler::exchange()

     if (r1 != r2 || c1 != c2)

     {

-        GapsRng rng;

         AlphaParameters alpha = alphaParameters(r1, c1, r2, c2);

         if (canUseGibbs(c1, c2))

         {

-            OptionalFloat gMass = gibbsMass(alpha, a1->mass, a2->mass, &rng);

+            OptionalFloat gMass = gibbsMass(alpha, a1->mass, a2->mass, rng);

             if (gMass.hasValue())

             {

                 acceptExchange(a1, a2, gMass.value(), r1, c1, r2, c2);

@@ -212,7 +221,7 @@ void GibbsSampler::exchange()

             }

         }

-        float newMass = rng.truncGammaUpper(a1->mass + a2->mass, 2.f, 1.f / mLambda);

+        float newMass = rng->truncGammaUpper(a1->mass + a2->mass, 2.f, 1.f / mLambda);

         // change larger mass

         float delta = a1->mass > a2->mass ? newMass - a1->mass : a2->mass - newMass;

@@ -225,7 +234,7 @@ void GibbsSampler::exchange()

         float deltaLL = getDeltaLL(alpha, delta);

         float priorLL = (pNew == 0.f) ? 1.f : pOld / pNew;

-        if (priorLL == 0.f || std::log(rng.uniform() * priorLL) < deltaLL * mAnnealingTemp)

+        if (priorLL == 0.f || std::log(rng->uniform() * priorLL) < deltaLL * mAnnealingTemp)

         {

             acceptExchange(a1, a2, delta, r1, c1, r2, c2);

             return;

@@ -261,11 +270,11 @@ OptionalFloat GibbsSampler::gibbsMass(AlphaParameters alpha,

 GapsRng *rng)

 {        

     alpha.s *= mAnnealingTemp;

-    alpha.su *= mAnnealingTemp;

+    alpha.s_mu *= mAnnealingTemp;

     if (alpha.s > gaps::epsilon)

     {

-        float mean = (alpha.su - mLambda) / alpha.s;

+        float mean = (alpha.s_mu - mLambda) / alpha.s;

         float sd = 1.f / std::sqrt(alpha.s);

         float pLower = gaps::p_norm(0.f, mean, sd);

@@ -286,11 +295,11 @@ OptionalFloat GibbsSampler::gibbsMass(AlphaParameters alpha,

 float m1, float m2, GapsRng *rng)

 {

     alpha.s *= mAnnealingTemp;

-    alpha.su *= mAnnealingTemp;

+    alpha.s_mu *= mAnnealingTemp;

     if (alpha.s > gaps::epsilon)

     {

-        float mean = alpha.su / alpha.s; // lambda cancels out

+        float mean = alpha.s_mu / alpha.s; // lambda cancels out

         float sd = 1.f / std::sqrt(alpha.s);

         float pLower = gaps::p_norm(-m1, mean, sd);

         float pUpper = gaps::p_norm(m2, mean, sd);

@@ -319,9 +328,9 @@ void GibbsSampler::updateAPMatrix(unsigned row, unsigned col, float delta)

     float *ap = mAPMatrix.colPtr(row);

     unsigned size = mAPMatrix.nRow();

-    gaps::simd::packedFloat pOther, pAP;

+    gaps::simd::PackedFloat pOther, pAP;

     gaps::simd::Index i(0);

-    gaps::simd::packedFloat pDelta(delta);

+    gaps::simd::PackedFloat pDelta(delta);

     for (; i <= size - i.increment(); ++i)

     {

         pOther.load(other + i);

@@ -27,10 +27,12 @@ public:

     void setMaxGibbsMass(float max);

     void setAnnealingTemp(float temp);

     void setMatrix(const Matrix &mat);

+    void setSeed(uint64_t seed);

     float chi2() const;

     uint64_t nAtoms() const;

+    void recalculateAPMatrix();

     void sync(const GibbsSampler &sampler);

     void update(unsigned nSteps, unsigned nCores);

@@ -53,9 +55,10 @@ private:

     ColMatrix mMatrix; // genes by patterns for A, samples by patterns for P

     const ColMatrix *mOtherMatrix; // pointer to P if this is A, and vice versa

-    GapsRng mPropRng;

     AtomicDomain mDomain; // data structure providing access to atoms

+    Xoroshiro128plus mSeeder; // used to generate seeds for individual proposals

+

     float mAlpha;

     float mLambda;

     float mMaxGibbsMass;

@@ -66,13 +69,13 @@ private:

     uint64_t mBinSize;

     uint64_t mDomainLength;

-    void makeAndProcessProposal();

+    void makeAndProcessProposal(GapsRng *rng);

     float deathProb(uint64_t nAtoms) const;

-    void birth();

-    void death();

-    void move();

-    void exchange();

+    void birth(GapsRng *rng);

+    void death(GapsRng *rng);

+    void move(GapsRng *rng);

+    void exchange(GapsRng *rng);

     void acceptExchange(Atom *a1, Atom *a2, float d1, unsigned r1,

         unsigned c1, unsigned r2, unsigned c2);

@@ -18,7 +18,6 @@ OBJECTS =   AtomicDomain.o \

             file_parser/TsvParser.o \

             file_parser/MtxParser.o \

             math/Algorithms.o \

-            math/Math.o \

             math/Random.o \

             cpp_tests/testAlgorithms.o \

             cpp_tests/testAtomicDomain.o \

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

 #include "catch.h"

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

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

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

 #define TEST_APPROX(x) Approx(x).epsilon(0.001)

@@ -2,16 +2,10 @@

 #define __COGAPS_EFFICIENT_SETS_H__

 #include <vector>

-

 #include <stdint.h>

 class IntFixedHashSet

 {

-private:

-

-    std::vector<uint64_t> mSet;

-    uint64_t mCurrentKey;

-

 public:

     IntFixedHashSet() : mCurrentKey(1) {}

@@ -20,6 +14,11 @@ public:

     void clear() {++mCurrentKey;}

     bool contains(unsigned n) {return mSet[n] == mCurrentKey;}

     void insert(unsigned n) {mSet[n] = mCurrentKey;}

+

+private:

+

+    std::vector<uint64_t> mSet;

+    uint64_t mCurrentKey;

 };

 // TODO have sorted vector with at least some % of holes

@@ -27,10 +26,6 @@ public:

 // when shift happens, should be minimal

 class IntDenseOrderedSet

 {

-private:

-

-    std::vector<uint64_t> mVec;

-

 public:

     void insert(uint64_t p) {mVec.push_back(p);}

@@ -48,6 +43,10 @@ public:

         }

         return true;

     }

+

+private:

+

+    std::vector<uint64_t> mVec;

 };

-#endif

\ No newline at end of file

+#endif // __COGAPS_EFFICIENT_SETS_H__

\ No newline at end of file

@@ -4,7 +4,8 @@

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

 ColMatrix::ColMatrix(unsigned nrow, unsigned ncol)

-: mNumRows(nrow), mNumCols(ncol)

+    :

+mNumRows(nrow), mNumCols(ncol)

 {

     allocate();

 }

@@ -1,21 +1,49 @@

 #include "Vector.h"

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

+

+Vector::Vector(unsigned size)

+    : mValues(aligned_vector(size, 0.f))

+{}

+

 Vector::Vector(const std::vector<float> &v) : mValues(v.size())

 {

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

+    unsigned sz = v.size();

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

     {

         mValues[i] = v[i];

     }

 }

-void Vector::concat(const Vector& vec)

+unsigned Vector::size() const

+{

+    return mValues.size();

+}

+

+float* Vector::ptr()

+{

+    return &mValues[0];

+}

+

+const float* Vector::ptr() const

 {

-    mValues.insert(mValues.end(), vec.mValues.begin(), vec.mValues.end());

+    return &mValues[0];

+}

+

+float& Vector::operator[](unsigned i)

+{

+    return mValues[i];

+}

+

+float Vector::operator[](unsigned i) const

+{

+    return mValues[i];

 }

 void Vector::operator+=(const Vector &vec)

 {

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

+    unsigned sz = size();

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

     {

         mValues[i] += vec[i];

     }

@@ -23,7 +51,8 @@ void Vector::operator+=(const Vector &vec)

 Vector Vector::operator-(Vector v) const

 {

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

+    unsigned sz = size();

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

     {

         v[i] = mValues[i] - v[i];

     }

@@ -46,7 +75,8 @@ Vector Vector::operator/(float val) const

 void Vector::operator*=(float val)

 {

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

+    unsigned sz = size();

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

     {

         mValues[i] *= val;

     }

@@ -54,7 +84,8 @@ void Vector::operator*=(float val)

 void Vector::operator/=(float val)

 {

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

+    unsigned sz = size();

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

     {

         mValues[i] /= val;

     }

@@ -62,7 +93,9 @@ void Vector::operator/=(float val)

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

 {

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

+    unsigned sz = vec.size();

+    ar << sz;

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

     {

         ar << vec[i];

     }

@@ -71,7 +104,11 @@ Archive& operator<<(Archive &ar, Vector &vec)

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

 {

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

+    unsigned sz = 0;

+    ar >> sz;

+    GAPS_ASSERT(sz == vec.size());

+

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

     {

         ar >> vec.mValues[i];

     }

@@ -12,22 +12,18 @@ typedef std::vector<float, bal::aligned_allocator<float,32> > aligned_vector;

 class Vector

 {

-private:

-

-    aligned_vector mValues;

-

 public:

-    explicit Vector(unsigned size) : mValues(aligned_vector(size, 0.f)) {}

+    explicit Vector(unsigned size);

     explicit Vector(const std::vector<float> &v);

-    unsigned size() const {return mValues.size();}

+    unsigned size() const;

-    float* ptr() {return &mValues[0];}

-    const float* ptr() const {return &mValues[0];}

+    float* ptr();

+    const float* ptr() const;

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

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

+    float& operator[](unsigned i);

+    float operator[](unsigned i) const;

     void operator+=(const Vector &vec);

     Vector operator-(Vector v) const;

@@ -37,10 +33,12 @@ public:

     void operator*=(float val);

     void operator/=(float val);

-    void concat(const Vector& vec);

-

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

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

+

+private:

+

+    aligned_vector mValues;

 };

-#endif

\ No newline at end of file

+#endif // __COGAPS_VECTOR_H__

\ No newline at end of file

@@ -5,151 +5,236 @@

 #include <algorithm>

-ColMatrix gaps::algo::pmax(const ColMatrix &mat, float factor)

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

+

+////////////////////////////// AlphaParameters /////////////////////////////////

+

+AlphaParameters::AlphaParameters(float inS, float inS_mu)

+    : s(inS), s_mu(inS_mu) 

+{}

+

+AlphaParameters AlphaParameters::operator+(const AlphaParameters &other) const

 {

-    ColMatrix temp(mat.nRow(), mat.nCol());

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

-    {

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

-        {

-            temp(i,j) = gaps::max(mat(i,j) * factor, factor);

-        }

-    }

-    return temp;

+    return AlphaParameters(s + other.s, s_mu - other.s_mu); // not a typo

 }

-float gaps::algo::sum(const ColMatrix &mat, bool transposeOrder)

+void AlphaParameters::operator*=(float v)

 {

-    float sum = 0.f;

-    unsigned outer = transposeOrder ? mat.nCol() : mat.nRow();

-    unsigned inner = transposeOrder ? mat.nRow() : mat.nCol();

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

+    s *= v;

+    s_mu *= v;

+}

+

+//////////////////////////////// Algorithms ////////////////////////////////////

+

+float gaps::min(float a, float b)

+{

+    return a < b ? a : b;

+}

+

+unsigned gaps::min(unsigned a, unsigned b)

+{

+    return a < b ? a : b;

+}

+

+uint64_t gaps::min(uint64_t a, uint64_t b)

+{

+    return a < b ? a : b;

+}

+

+float gaps::max(float a, float b)

+{

+    return a < b ? b : a;

+}

+

+unsigned gaps::max(unsigned a, unsigned b)

+{

+    return a < b ? b : a;

+}

+

+uint64_t gaps::max(uint64_t a, uint64_t b)

+{

+    return a < b ? b : a;

+}

+

+bool gaps::algo::isVectorZero(const float *vec, unsigned size)

+{

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

     {

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

+        if (vec[i] != 0.f)

         {

-            sum += transposeOrder ? mat(j,i) : mat(i,j);

+            return false;

         }

     }

-    return sum;

+    return true;

 }

-float gaps::algo::mean(const ColMatrix &mat, bool transposeOrder)

+Vector gaps::algo::elementSq(Vector vec)

 {

-    return gaps::algo::sum(mat, transposeOrder) / (mat.nRow() * mat.nCol());

+    unsigned sz = vec.size();

+

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

+    {

+        vec[i] *= vec[i];

+    }

+    return vec;

 }

-void gaps::algo::copyTranspose(ColMatrix *dest, const ColMatrix &src)

+float gaps::algo::max(const Vector &vec)

 {

-    GAPS_ASSERT(dest->nRow() == src.nCol());

-    GAPS_ASSERT(dest->nCol() == src.nRow());

+    unsigned sz = vec.size();

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

+    float max = vec[0];

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

     {

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

-        {

-            dest->operator()(j,i) = src(i,j); // TODO test which order is better

-        }

+        max = gaps::max(max, vec[i]);

     }

+    return max;

 }

 float gaps::algo::sum(const Vector &vec)

 {

+    unsigned sz = vec.size();

+

     float sum = 0.f;

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

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

     {

         sum += vec[i];

     }

     return sum;

 }

-float gaps::algo::min(const Vector &vec)

+float gaps::algo::sum(const ColMatrix &mat)

 {

-    float min = vec[0];