@@ -95,210 +95,125 @@ bool gaps::algo::isColZero(const ColMatrix &mat, unsigned col)

     return gaps::algo::sum(mat.getCol(col)) == 0;

 }

-/*

-// horribly slow, don't call often

-void gaps::algo::matrixMultiplication(TwoWayMatrix &C, const ColMatrix &A,

-const RowMatrix &B)

-{

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

-    {

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

-        {

-            float sum = 0.0;

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

-            {

-                sum += A(i,k) * B(k,j);

-            }

-            C.set(i, j, sum);

-        }

-    }

-}

-

-static float deltaLL_comp(unsigned size, const float *D, const float *S,

-const float *AP, const float *other, float delta)

+AlphaParameters gaps::algo::alphaParameters(unsigned size, const float *D,

+const float *S, const float *AP, const float *mat)

 {

-    const gaps::simd::packedFloat pDelta = delta, two = 2.f;

-    gaps::simd::packedFloat d, pOther, pD, pAP, pS, partialSum = 0.f;

+    gaps::simd::packedFloat ratio, pMat, pD, pAP, pS;

+    gaps::simd::packedFloat partialS = 0.f, partialSU = 0.f;

     gaps::simd::Index i = 0;

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

     {   

-        pOther.load(other + i);

+        pMat.load(mat + i);

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        d = pDelta * pOther;

-        partialSum += (d * (two * (pD - pAP) - d)) / (two * pS * pS);

+        ratio = pMat / pS;

+        partialS += ratio * ratio;

+        partialSU += ratio * (pD - pAP) / pS;

     }

-    float fd, delLL = partialSum.scalar();

+    float fratio, s = partialS.scalar(), su = partialSU.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fd = delta * other[j];

-        delLL += (fd * (2.f * (D[j] - AP[j]) - fd)) / (2.f * S[j] * S[j]);

+        fratio = mat[j] / S[j];

+        s += fratio * fratio;

+        su += fratio * (D[j] - AP[j]) / S[j];

     }

-    return delLL;

+    return AlphaParameters(s,su);

 }

-static float deltaLL_comp(unsigned size, const float *D, const float *S,

-const float *AP, const float *other1, float delta1, const float *other2,

-float delta2)

+AlphaParameters gaps::algo::alphaParameters(unsigned size, const float *D,

+const float *S, const float *AP, const float *mat1, const float *mat2)

 {

-    const gaps::simd::packedFloat pDelta1 = delta1, pDelta2 = delta2, two = 2.f;

-    gaps::simd::packedFloat d, pOther1, pOther2, pD, pAP, pS, partialSum = 0.f;

+    gaps::simd::packedFloat ratio, pMat1, pMat2, pD, pAP, pS;

+    gaps::simd::packedFloat partialS = 0.f, partialSU = 0.f;

     gaps::simd::Index i = 0;

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

     {   

-        pOther1.load(other1 + i);

-        pOther2.load(other2 + i);

+        pMat1.load(mat1 + i);

+        pMat2.load(mat2 + i);

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        d = pDelta1 * pOther1 + pDelta2 * pOther2;

-        partialSum += (d * (two * (pD - pAP) - d)) / (two * pS * pS);

+        ratio = (pMat1 - pMat2) / pS;

+        partialS += ratio * ratio;

+        partialSU += ratio * (pD - pAP) / pS;

     }

-    float fd, delLL = partialSum.scalar();

+    float fratio, s = partialS.scalar(), su = partialSU.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fd = delta1 * other1[j] + delta2 * other2[j];

-        delLL += (fd * (2.f * (D[j] - AP[j]) - fd)) / (2.f * S[j] * S[j]);

-    }

-    return delLL;

-}

-

-float gaps::algo::deltaLL(const MatrixChange &ch, const TwoWayMatrix &D,

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

-const TwoWayMatrix &AP)

-{

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

-    {

-        return deltaLL_comp(D.nCol(), D.rowPtr(ch.row1), S.rowPtr(ch.row1),

-            AP.rowPtr(ch.row1), P.rowPtr(ch.col1), ch.delta1,

-            P.rowPtr(ch.col2), ch.delta2);

-    }

-    else if (ch.label == 'A') // single change, or two independent changes

-    {

-        float d1 = 0.f, d2 = 0.f;

-        d1 = deltaLL_comp(D.nCol(), D.rowPtr(ch.row1), S.rowPtr(ch.row1),

-            AP.rowPtr(ch.row1), P.rowPtr(ch.col1), ch.delta1);

-        if (ch.nChanges == 2)

-        {

-            d2 = deltaLL_comp(D.nCol(), D.rowPtr(ch.row2), S.rowPtr(ch.row2),

-                AP.rowPtr(ch.row2), P.rowPtr(ch.col2), ch.delta2);

-        }

-        return d1 + d2;

-    }

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

-    {

-        return deltaLL_comp(D.nRow(), D.colPtr(ch.col1), S.colPtr(ch.col1),

-            AP.colPtr(ch.col1), A.colPtr(ch.row1), ch.delta1,

-            A.colPtr(ch.row2), ch.delta2);

-    }

-    else // single change, or two independent changes

-    {

-        float d1 = 0.f, d2 = 0.f;

-        d1 = deltaLL_comp(D.nRow(), D.colPtr(ch.col1), S.colPtr(ch.col1),

-            AP.colPtr(ch.col1), A.colPtr(ch.row1), ch.delta1);

-        if (ch.nChanges == 2)

-        {

-            d2 = deltaLL_comp(D.nRow(), D.colPtr(ch.col2), S.colPtr(ch.col2),

-                AP.colPtr(ch.col2), A.colPtr(ch.row2), ch.delta2);

-        }

-        return d1 + d2;

+        fratio = (mat1[j] - mat2[j]) / S[j];

+        s += fratio * fratio;

+        su += fratio * (D[j] - AP[j]) / S[j];

     }

+    return AlphaParameters(s,su);

 }

-// single change

-static AlphaParameters alphaParameters_comp(unsigned size, const float *D,

-const float *S, const float *AP, const float *other)

+float gaps::algo::deltaLL(unsigned size, const float *D, const float *S,

+const float *AP, const float *mat, float delta)

 {

-    gaps::simd::packedFloat ratio, pOther, pD, pAP, pS;

-    gaps::simd::packedFloat partialS = 0.f, partialSU = 0.f;

+    const gaps::simd::packedFloat pDelta = delta, two = 2.f;

+    gaps::simd::packedFloat d, pMat, pD, pAP, pS, partialSum = 0.f;

     gaps::simd::Index i = 0;

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

     {   

-        pOther.load(other + i);

+        pMat.load(mat + i);

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        ratio = pOther / pS;

-        partialS += ratio * ratio;

-        partialSU += ratio * (pD - pAP) / pS;

+        d = pDelta * pMat;

+        partialSum += (d * (two * (pD - pAP) - d)) / (two * pS * pS);

     }

-    float fratio, s = partialS.scalar(), su = partialSU.scalar();

+    float fd, delLL = partialSum.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fratio = other[j] / S[j];

-        s += fratio * fratio;

-        su += fratio * (D[j] - AP[j]) / S[j];

+        fd = delta * mat[j];

+        delLL += (fd * (2.f * (D[j] - AP[j]) - fd)) / (2.f * S[j] * S[j]);

     }

-    return AlphaParameters(s,su);

+    return delLL;

 }

-// two dependent changes

-static AlphaParameters alphaParameters_comp(unsigned size, const float *D,

-const float *S, const float *AP, const float *other1, const float *other2)

+float gaps::algo::deltaLL(unsigned size, const float *D, const float *S,

+const float *AP, const float *mat1, float delta1, const float *mat2,

+float delta2)

 {

-    gaps::simd::packedFloat ratio, pOther1, pOther2, pD, pAP, pS;

-    gaps::simd::packedFloat partialS = 0.f, partialSU = 0.f;

+    const gaps::simd::packedFloat pDelta1 = delta1, pDelta2 = delta2, two = 2.f;

+    gaps::simd::packedFloat d, pMat1, pMat2, pD, pAP, pS, partialSum = 0.f;

     gaps::simd::Index i = 0;

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

     {   

-        pOther1.load(other1 + i);

-        pOther2.load(other2 + i);

+        pMat1.load(mat1 + i);

+        pMat2.load(mat2 + i);

         pD.load(D + i);

         pAP.load(AP + i);

         pS.load(S + i);

-        ratio = (pOther1 - pOther2) / pS;

-        partialS += ratio * ratio;

-        partialSU += ratio * (pD - pAP) / pS;

+        d = pDelta1 * pMat1 + pDelta2 * pMat2;

+        partialSum += (d * (two * (pD - pAP) - d)) / (two * pS * pS);

     }

-    float fratio, s = partialS.scalar(), su = partialSU.scalar();

+    float fd, delLL = partialSum.scalar();

     for (unsigned j = i.value(); j < size; ++j)

     {

-        fratio = (other1[j] - other2[j]) / S[j];

-        s += fratio * fratio;

-        su += fratio * (D[j] - AP[j]) / S[j];

+        fd = delta1 * mat1[j] + delta2 * mat2[j];

+        delLL += (fd * (2.f * (D[j] - AP[j]) - fd)) / (2.f * S[j] * S[j]);

     }

-    return AlphaParameters(s,su);

+    return delLL;

 }

-// should these always be positive? could explain ordering of atoms in exchange

-AlphaParameters gaps::algo::alphaParameters(const MatrixChange &ch,

-const TwoWayMatrix &D, const TwoWayMatrix &S, const ColMatrix &A,

-const RowMatrix &P, const TwoWayMatrix &AP)

+/*

+// horribly slow, don't call often

+void gaps::algo::matrixMultiplication(TwoWayMatrix &C, const ColMatrix &A,

+const RowMatrix &B)

 {

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

-    {

-        return alphaParameters_comp(D.nCol(), D.rowPtr(ch.row1), S.rowPtr(ch.row1),

-            AP.rowPtr(ch.row1), P.rowPtr(ch.col1), P.rowPtr(ch.col2));

-    }

-    else if (ch.label == 'A') // single change, or two independent changes

-    {

-        AlphaParameters a1(0.f, 0.f), a2(0.f, 0.f);

-        a1 = alphaParameters_comp(D.nCol(), D.rowPtr(ch.row1), S.rowPtr(ch.row1),

-            AP.rowPtr(ch.row1), P.rowPtr(ch.col1));

-        if (ch.nChanges == 2)

-        {

-            a2 = alphaParameters_comp(D.nCol(), D.rowPtr(ch.row2), S.rowPtr(ch.row2),

-            AP.rowPtr(ch.row2), P.rowPtr(ch.col2));

-        }

-        return a1 + a2;

-    }

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

-    {

-        return alphaParameters_comp(D.nRow(), D.colPtr(ch.col1), S.colPtr(ch.col1),

-            AP.colPtr(ch.col1), A.colPtr(ch.row1), A.colPtr(ch.row2));

-    }

-    else // single change, or two independent changes

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

     {

-        AlphaParameters a1(0.f, 0.f), a2(0.f, 0.f);

-        a1 = alphaParameters_comp(D.nRow(), D.colPtr(ch.col1), S.colPtr(ch.col1),

-            AP.colPtr(ch.col1), A.colPtr(ch.row1));

-        if (ch.nChanges == 2)

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

         {

-            a2 = alphaParameters_comp(D.nRow(), D.colPtr(ch.col2), S.colPtr(ch.col2),

-            AP.colPtr(ch.col2), A.colPtr(ch.row2));

+            float sum = 0.0;

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

+            {

+                sum += A(i,k) * B(k,j);

+            }

+            C.set(i, j, sum);

         }

-        return a1 + a2;

     }

 }

-*/

\ No newline at end of file

+*/

@@ -26,6 +26,8 @@ namespace gaps

 {

 namespace algo

 {

+    const float epsilon = 1.0e-5f;

+

     // vector algorithms    

     unsigned whichMin(const Vector &vec);

     float sum(const Vector &vec);

@@ -50,7 +52,7 @@ namespace algo

         const GenericMatrix &meanMat, unsigned nUpdates);

     // specific matrix algorithms

-    bool isRowZero(const RowMatrix &mat, unsigned row);

+    bool isRowZero(const RowMatrix &mat, unsigned row); // TODO take pointer

     bool isColZero(const ColMatrix &mat, unsigned col);

     //void matrixMultiplication(TwoWayMatrix &C, const ColMatrix &A,

     //    const RowMatrix &B);

@@ -60,15 +62,19 @@ namespace algo

     float loglikelihood(const Matrix &D, const Matrix &S,

         const Matrix &AP);

-    // change in likelihood

-    //float deltaLL(const MatrixChange &ch, const TwoWayMatrix &D,

-    //    const TwoWayMatrix &S, const ColMatrix &A,

-    //    const RowMatrix &P, const TwoWayMatrix &AP);

+    AlphaParameters alphaParameters(unsigned size, const float *D,

+        const float *S, const float *AP, const float *mat);

+

+    AlphaParameters alphaParameters(unsigned size, const float *D,

+        const float *S, const float *AP, const float *mat1, const float *mat2);

+

+    float deltaLL(unsigned size, const float *D, const float *S,

+        const float *AP, const float *mat, float delta);

+

+    float deltaLL(unsigned size, const float *D, const float *S,

+        const float *AP, const float *mat1, float delta1, const float *mat2,

+        float delta2);

-    // alpha parameters used in exchange and gibbsMass calculation

-    //AlphaParameters alphaParameters(const MatrixChange &ch,

-    //    const TwoWayMatrix &D, const TwoWayMatrix &S, const ColMatrix &A,

-    //    const RowMatrix &P, const TwoWayMatrix &AP);*/

 } // namespace algo

 } // namespace gaps

@@ -5,11 +5,6 @@

 #include <stdint.h>

 #include <utility>

-unsigned AtomicDomain::size() const

-{

-    return mAtoms.size();

-}

-

 // O(1)

 Atom AtomicDomain::front() const

 {

@@ -19,8 +14,10 @@ Atom AtomicDomain::front() const

 // O(1)

 Atom AtomicDomain::randomAtom() const

 {

-    GAPS_ASSERT(!mAtoms.empty());

+    GAPS_ASSERT(mAtoms.size() > 0);

     uint64_t num = gaps::random::uniform64(0, mAtoms.size() - 1);

+    GAPS_ASSERT(num >= 0);

+    GAPS_ASSERT(num < mAtoms.size());

     return mAtoms[num];

 }

@@ -35,10 +32,57 @@ uint64_t AtomicDomain::randomFreePosition() const

     return pos;

 }

+// O(1)

+uint64_t AtomicDomain::size() const

+{

+    return mAtoms.size();

+}

+

+// O(1)

+Atom& AtomicDomain::left(const Atom &atom)

+{

+    GAPS_ASSERT(hasLeft(atom));

+    return mAtoms[atom.leftNdx - 1];

+}

+

+// O(1)

+Atom& AtomicDomain::right(const Atom &atom)

+{

+    GAPS_ASSERT(hasRight(atom));

+    return mAtoms[atom.rightNdx - 1];

+}

+

+// O(1)

+const Atom& AtomicDomain::left(const Atom &atom) const

+{

+    GAPS_ASSERT(hasLeft(atom));

+    return mAtoms[atom.leftNdx - 1];

+}

+

+// O(1)

+const Atom& AtomicDomain::right(const Atom &atom) const

+{

+    GAPS_ASSERT(hasRight(atom));

+    return mAtoms[atom.rightNdx - 1];

+}

+

+// O(1)

+bool AtomicDomain::hasLeft(const Atom &atom) const

+{

+    return atom.leftNdx != 0;

+}

+

+// O(1)

+bool AtomicDomain::hasRight(const Atom &atom) const

+{

+    return atom.rightNdx != 0;

+}

+

 // O(logN)

 void AtomicDomain::insert(uint64_t pos, float mass)

 {

     // insert position into map

+    GAPS_ASSERT(mAtomPositions.find(pos) == mAtomPositions.end());

     std::map<uint64_t, uint64_t>::iterator iter, iterLeft, iterRight;

     iter = mAtomPositions.insert(std::pair<uint64_t, uint64_t>(pos, mAtoms.size())).first;

     iterLeft = iter;

@@ -49,53 +93,106 @@ void AtomicDomain::insert(uint64_t pos, float mass)

     if (iter != mAtomPositions.begin())

     {

         --iterLeft;

-        atom.left = &(mAtoms[iterLeft->second]);

+        atom.leftNdx = iterLeft->second + 1;

     }

     if (++iter != mAtomPositions.end())

     {

         ++iterRight;

-        atom.right = &(mAtoms[iterRight->second]);

+        atom.rightNdx = iterRight->second + 1;

     } 

     // add atom to vector

+    GAPS_ASSERT(atom.rightNdx <= size());

+    GAPS_ASSERT(atom.leftNdx <= size());

     mAtoms.push_back(atom);

     mUsedPositions.insert(pos);

+    GAPS_ASSERT(mAtoms.size() == mAtomPositions.size());

+    GAPS_ASSERT(mAtoms.size() == mUsedPositions.size());

+}

+

+void AtomicDomain::swap(uint64_t i1, uint64_t i2)

+{

+    if (i1 != i2)

+    {

+        // store the atom in position 1

+        Atom temp1 = mAtoms[i1];

+        Atom temp2 = mAtoms[i2];

+

+        // switch atoms

+        mAtoms[i1] = temp2;

+        mAtoms[i2] = temp1;

+

+        // update neighbors

+        if (hasLeft(temp1))

+        {

+            GAPS_ASSERT(i2 + 1 <= size());

+            left(temp1).rightNdx = i2 + 1;

+        }

+        if (hasRight(temp1))

+        {

+            GAPS_ASSERT(i2 + 1 <= size());

+            right(temp1).leftNdx = i2 + 1;

+        }

+        if (hasLeft(temp2))

+        {

+            GAPS_ASSERT(i1 + 1 <= size());

+            left(temp2).rightNdx = i1 + 1;

+        }

+        if (hasRight(temp2))

+        {

+            GAPS_ASSERT(i1 + 1 <= size());

+            right(temp2).leftNdx = i1 + 1;

+        }

+

+        // update atom positions

+        mAtomPositions.erase(mAtoms[i1].pos);

+        mAtomPositions.erase(mAtoms[i2].pos);

+        mAtomPositions.insert(std::pair<uint64_t, uint64_t>(mAtoms[i1].pos,

+            i1));

+        mAtomPositions.insert(std::pair<uint64_t, uint64_t>(mAtoms[i2].pos,

+            i2));

+    }

 }

 // O(logN)

-void AtomicDomain::erase(uint64_t pos)

+// erase directly from position map

+// swap with last atom in vector, pop off the back

+void AtomicDomain::erase(uint64_t pos, bool display)

 {

     // get vector index of this atom and erase it

+    GAPS_ASSERT(mAtomPositions.find(pos) != mAtomPositions.end());

     uint64_t index = mAtomPositions.at(pos);

-    mAtomPositions.erase(pos);

-    // update key of object about to be moved (last one doesn't need to move)

-    if (index < mAtoms.size() - 1)

-    {

-        mAtomPositions.erase(mAtoms.back().pos);

-        mAtomPositions.insert(std::pair<uint64_t, uint64_t>(mAtoms.back().pos,

-            index));

-    }

+    // move atom to back

+    swap(index, mAtoms.size() - 1);

-    // update neighbors

-    if (mAtoms[index].left)

+    // connect neighbors of atom to be deleted

+    if (hasLeft(mAtoms.back()))

     {

-        mAtoms[index].left->right = mAtoms[index].right;

+        left(mAtoms.back()).rightNdx = mAtoms.back().rightNdx;

     }

-    if (mAtoms[index].right)

+    if (hasRight(mAtoms.back()))

     {

-        mAtoms[index].right->left = mAtoms[index].left;

+        right(mAtoms.back()).leftNdx = mAtoms.back().leftNdx;

     }

     // delete atom from vector in O(1)

-    mAtoms[index] = mAtoms.back();

+    GAPS_ASSERT(mAtomPositions.at(pos) == mAtoms.size() - 1);

+    mAtomPositions.erase(pos);

     mAtoms.pop_back();

     mUsedPositions.erase(pos);

+    GAPS_ASSERT(mAtoms.size() == mAtomPositions.size());

+    GAPS_ASSERT(mAtoms.size() == mUsedPositions.size());

 }

 // O(logN)

 void AtomicDomain::updateMass(uint64_t pos, float newMass)

 {

-    uint64_t index = mAtomPositions.at(pos);

-    mAtoms[index].mass = newMass;

+    GAPS_ASSERT(mAtomPositions.find(pos) != mAtomPositions.end());

+    mAtoms[mAtomPositions.at(pos)].mass = newMass;

 }

+

+void AtomicDomain::test(uint64_t pos) const

+{

+    GAPS_ASSERT(mAtomPositions.find(pos) != mAtomPositions.end());

+}

\ No newline at end of file

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

-#ifndef __GAPS_ATOMIC_DOMAIN_H__

-#define __GAPS_ATOMIC_DOMAIN_H__

+#ifndef __COGAPS_ATOMIC_DOMAIN_H__

+#define __COGAPS_ATOMIC_DOMAIN_H__

 #include "Archive.h"

@@ -9,16 +9,27 @@

 #include <vector>

 #include <map>

+class AtomicDomain;

+

+// Want the neighbors to be pointers, but can't use pointers since vector

+// is resized, shifted integers allow for 0 to be "null" and 1 to be the

+// first index. AtomicDomain is responsible for managing this correctly.

 struct Atom

 {

+//private:    

+public:

+

+    friend AtomicDomain;

+    uint64_t leftNdx; // shift these up 1, 0 == no neighbor

+    uint64_t rightNdx;

+

+public:    

+

     uint64_t pos;

     float mass;

-    Atom* left;

-    Atom* right;

-    

     Atom(uint64_t p, float m)

-        : pos(p), mass(m), left(NULL), right(NULL)

+        : pos(p), mass(m), leftNdx(0), rightNdx(0)

     {}

     bool operator==(const Atom &other) const

@@ -45,12 +56,21 @@ public:

     Atom front() const;

     Atom randomAtom() const;

     uint64_t randomFreePosition() const;

-    unsigned size() const;

+    uint64_t size() const;

+

+    Atom& left(const Atom &atom);

+    Atom& right(const Atom &atom);

+    const Atom& left(const Atom &atom) const;

+    const Atom& right(const Atom &atom) const;

+    bool hasLeft(const Atom &atom) const;

+    bool hasRight(const Atom &atom) const;

     // modify domain

     void insert(uint64_t pos, float mass);

-    void erase(uint64_t pos);

+    void swap(uint64_t i1, uint64_t i2);

+    void erase(uint64_t pos, bool display=false);

     void updateMass(uint64_t pos, float newMass);

+    void test(uint64_t pos) const;

     // serialization

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

@@ -29,7 +29,7 @@ const std::string &cptFile, unsigned pumpThreshold, unsigned nPumpSamples)

     // create internal state from parameters and run from there

     GapsRunner runner(D, S, nFactor, nEquil, nEquilCool, nSample,

-        nOutputs, nSnapshots, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seed,

+        nOutputs, nSnapshots, alphaA, alphaP, maxGibbmassA, maxGibbmassP, seedUsed,

         messages, singleCellRNASeq,  checkpointInterval, cptFile,

         whichMatrixFixed, FP);

     return runner.run();

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

-#ifndef __GAPS_ASSERT_H__

-#define __GAPS_ASSERT_H__

+#ifndef __COGAPS_GAPS_ASSERT_H__

+#define __COGAPS_GAPS_ASSERT_H__

 #ifdef GAPS_DEBUG

     #define GAPS_ASSERT(cond)                                           \

@@ -10,8 +10,19 @@

                 std::exit(0);                                           \

             }                                                           \

         } while(0)

+

+    #define GAPS_ASSERT_MSG(cond, msg)                                  \

+        do {                                                            \

+            if (!(cond))                                                \

+            {                                                           \

+                Rcpp::Rcout << "assert failed " << __FILE__ << " " <<   \

+                    __LINE__ << " , " << msg << '\n';                   \

+                std::exit(0);                                           \

+            }                                                           \

+        } while(0)

 #else

     #define GAPS_ASSERT(cond) ((void)sizeof(cond))

+    #define GAPS_ASSERT_MSG(cond, msg) ((void)sizeof(cond))

 #endif 

 #endif

\ No newline at end of file

@@ -40,6 +40,9 @@ mStatistics(D.nrow(), D.ncol(), nFactor)

    //    >> mPrintMessages >> mCurrentIter >> mPhase >> mSeed

    //    >> mCheckpointInterval >> mCheckpointFile >> mNumUpdatesA

    //    >> mNumUpdatesP >> mASampler >> mPSampler >> mStatistics;

+

+    mASampler.sync(mPSampler);

+    mPSampler.sync(mASampler);

 }

 // execute the steps of the algorithm, return list to R

@@ -95,6 +98,7 @@ void GapsRunner::runBurnPhase()

 {

     for (; mCurrentIter < mEquilIter; ++mCurrentIter)

     {

+        Rcpp::checkUserInterrupt();

         makeCheckpointIfNeeded();

         float temp = ((float)mCurrentIter + 2.f) / ((float)mEquilIter / 2.f);

         mASampler.setAnnealingTemp(std::min(1.f,temp));

@@ -109,6 +113,7 @@ void GapsRunner::runCoolPhase()

 {

     for (; mCurrentIter < mCoolIter; ++mCurrentIter)

     {

+        Rcpp::checkUserInterrupt();

         makeCheckpointIfNeeded();

         updateSampler();

     }

@@ -118,6 +123,7 @@ void GapsRunner::runSampPhase()

 {

     for (; mCurrentIter < mSampleIter; ++mCurrentIter)

     {

+        Rcpp::checkUserInterrupt();

         makeCheckpointIfNeeded();

         updateSampler();

         mStatistics.update(mASampler, mPSampler);

@@ -150,7 +156,7 @@ void GapsRunner::displayStatus(const std::string &type, unsigned nIterTotal)

 {

     if ((mCurrentIter + 1) % mNumOutputs == 0 && mPrintMessages)

     {

-        Rprintf("%s %d of %d, Atoms:%d(%d) Chi2 = %.2f\n", type.c_str(),

+        Rprintf("%s %d of %d, Atoms:%lu(%lu) Chi2 = %.2f\n", type.c_str(),

             mCurrentIter + 1, nIterTotal, mASampler.nAtoms(),

             mPSampler.nAtoms(), mASampler.chi2());

     }

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

 public:

+    // construct from parameters

     GapsRunner(const Rcpp::NumericMatrix &D, const Rcpp::NumericMatrix &S,

         unsigned nFactor, unsigned nEquil, unsigned nCool, unsigned nSample,

         unsigned nOutputs, unsigned nSnapshots, float alphaA, float alphaP,

         float maxGibbsMassA, float maxGibbsMassP, uint32_t seed, bool messages,

         bool singleCellRNASeq, unsigned cptInterval, const std::string &cptFile,

         char whichMatrixFixed, const Rcpp::NumericMatrix &FP);

-

+    

+    // construct from checkpoint file

     GapsRunner(const Rcpp::NumericMatrix &D, const Rcpp::NumericMatrix &S,

         unsigned nFactor, unsigned nEquil, unsigned nSample,

         const std::string &cptFile);

@@ -15,16 +15,16 @@ const PatternGibbsSampler &PSampler)

     Vector normVec(mNumPatterns);

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

     {

-        //normVec[j] = gaps::algo::sum(PSampler.mPMatrix.getRow(j));

-        //normVec[j] = normVec[j] == 0 ? 1.f : normVec[j];

+        normVec[j] = gaps::algo::sum(PSampler.mMatrix.getRow(j));

+        normVec[j] = normVec[j] == 0 ? 1.f : normVec[j];

-        //Vector quot(PSampler.mPMatrix.getRow(j) / normVec[j]);

-        //mPMeanMatrix.getRow(j) += quot;

-        //mPStdMatrix.getRow(j) += gaps::algo::elementSq(quot);

+        Vector quot(PSampler.mMatrix.getRow(j) / normVec[j]);

+        mPMeanMatrix.getRow(j) += quot;

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

-        //Vector prod(ASampler.mAMatrix.getCol(j) * normVec[j]);

-        //mAMeanMatrix.getCol(j) += prod;

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

+        Vector prod(ASampler.mMatrix.getCol(j) * normVec[j]);

+        mAMeanMatrix.getCol(j) += prod;

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

     }

 }

@@ -36,7 +36,7 @@ bool AmplitudeGibbsSampler::canUseGibbs(unsigned r1, unsigned c1, unsigned r2, u

 void AmplitudeGibbsSampler::sync(PatternGibbsSampler &sampler)

 {

-    mOtherMatrix = &sampler.mMatrix;

+    mOtherMatrix = &(sampler.mMatrix);

     mAPMatrix = sampler.mAPMatrix;

 }

@@ -44,7 +44,50 @@ void AmplitudeGibbsSampler::updateAPMatrix(unsigned row, unsigned col, float del

 {

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

     {

-        mAPMatrix(row,j) += delta * (*mOtherMatrix)(j,col);

+        mAPMatrix(row,j) += delta * (*mOtherMatrix)(col,j);

+    }

+}

+

+AlphaParameters AmplitudeGibbsSampler::alphaParameters(unsigned row, unsigned col)

+{

+    return gaps::algo::alphaParameters(mDMatrix.nCol(), mDMatrix.rowPtr(row),

+        mSMatrix.rowPtr(row), mAPMatrix.rowPtr(row), mOtherMatrix->rowPtr(col));

+}

+

+AlphaParameters AmplitudeGibbsSampler::alphaParameters(unsigned r1, unsigned c1,

+unsigned r2, unsigned c2)

+{

+    if (r1 == r2)

+    {

+        return gaps::algo::alphaParameters(mDMatrix.nCol(), mDMatrix.rowPtr(r1),

+            mSMatrix.rowPtr(r1), mAPMatrix.rowPtr(r1), mOtherMatrix->rowPtr(c1),

+            mOtherMatrix->rowPtr(c2));

+    }

+    else

+    {

+        return alphaParameters(r1, c1) + alphaParameters(r2, c2);

+    }

+}

+

+float AmplitudeGibbsSampler::computeDeltaLL(unsigned row, unsigned col, float mass)

+{

+    return gaps::algo::deltaLL(mDMatrix.nCol(), mDMatrix.rowPtr(row),

+        mSMatrix.rowPtr(row), mAPMatrix.rowPtr(row), mOtherMatrix->rowPtr(col),

+        mass);

+}

+

+float AmplitudeGibbsSampler::computeDeltaLL(unsigned r1, unsigned c1, float m1,

+unsigned r2, unsigned c2, float m2)

+{

+    if (r1 == r2)

+    {

+        return gaps::algo::deltaLL(mDMatrix.nCol(), mDMatrix.rowPtr(r1),

+            mSMatrix.rowPtr(r1), mAPMatrix.rowPtr(r1), mOtherMatrix->rowPtr(c1),

+            m1, mOtherMatrix->rowPtr(c2), m2);

+    }

+    else

+    {

+        return computeDeltaLL(r1, c1, m1) + computeDeltaLL(r2, c2, m2);

     }

 }

@@ -84,7 +127,7 @@ bool PatternGibbsSampler::canUseGibbs(unsigned r1, unsigned c1, unsigned r2, uns

 void PatternGibbsSampler::sync(AmplitudeGibbsSampler &sampler)

 {

-    mOtherMatrix = &sampler.mMatrix;

+    mOtherMatrix = &(sampler.mMatrix);

     mAPMatrix = sampler.mAPMatrix;

 }

@@ -94,4 +137,47 @@ void PatternGibbsSampler::updateAPMatrix(unsigned row, unsigned col, float delta

     {

         mAPMatrix(i,col) += delta * (*mOtherMatrix)(i,row);

     }

+}

+

+AlphaParameters PatternGibbsSampler::alphaParameters(unsigned row, unsigned col)

+{

+    return gaps::algo::alphaParameters(mDMatrix.nRow(), mDMatrix.colPtr(col),

+        mSMatrix.colPtr(col), mAPMatrix.colPtr(col), mOtherMatrix->colPtr(row));

+}

+

+AlphaParameters PatternGibbsSampler::alphaParameters(unsigned r1, unsigned c1,

+unsigned r2, unsigned c2)

+{

+    if (c1 == c2)

+    {

+        return gaps::algo::alphaParameters(mDMatrix.nRow(), mDMatrix.colPtr(c1),

+            mSMatrix.colPtr(c1), mAPMatrix.colPtr(c1), mOtherMatrix->colPtr(r1),

+            mOtherMatrix->colPtr(r2));

+    }

+    else

+    {

+        return alphaParameters(r1, c1) + alphaParameters(r2, c2);

+    }

+}

+

+float PatternGibbsSampler::computeDeltaLL(unsigned row, unsigned col, float mass)

+{

+    return gaps::algo::deltaLL(mDMatrix.nRow(), mDMatrix.colPtr(col),

+        mSMatrix.colPtr(col), mAPMatrix.colPtr(col), mOtherMatrix->colPtr(row),

+        mass);

+}

+

+float PatternGibbsSampler::computeDeltaLL(unsigned r1, unsigned c1, float m1,

+unsigned r2, unsigned c2, float m2)

+{

+    if (c1 == c2)

+    {

+        return gaps::algo::deltaLL(mDMatrix.nRow(), mDMatrix.colPtr(c1),

+            mSMatrix.colPtr(c1), mAPMatrix.colPtr(c1), mOtherMatrix->colPtr(r1),

+            m1, mOtherMatrix->colPtr(r2), m2);

+    }

+    else

+    {

+        return computeDeltaLL(r1, c1, m1) + computeDeltaLL(r2, c2, m2);

+    }

 }

\ No newline at end of file

@@ -24,6 +24,7 @@ class GibbsSampler

 private:

     friend T; // prevent incorrect inheritance - only T can construct

+    friend GapsStatistics;

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

         unsigned nrow, unsigned ncol, float alpha);

@@ -50,11 +51,20 @@ protected:

     T* impl();

     void processProposal(const AtomicProposal &prop);

-    void birth(uint64_t pos);

-    void death(uint64_t pos, float mass);

-    void move(uint64_t src, float mass, uint64_t dest);

-    void exchange(uint64_t p1, float mass1, uint64_t p2, float mass2);

-    float gibbsMass(unsigned row, unsigned col);

+    void birth(uint64_t pos, unsigned row, unsigned col);

+    void death(uint64_t pos, float mass, unsigned row, unsigned col);

+    void move(uint64_t src, float mass, uint64_t dest, unsigned r1, unsigned c1,

+        unsigned r2, unsigned c2);

+    void exchange(uint64_t p1, float mass1, uint64_t p2, float mass2,

+        unsigned r1, unsigned c1, unsigned r2, unsigned c2);

+    float gibbsMass(unsigned row, unsigned col, float mass);

+    float gibbsMass(unsigned r1, unsigned c1, float m1, unsigned r2,

+        unsigned c2, float m2);

+    void addMass(uint64_t pos, float mass, unsigned row, unsigned col);

+    void removeMass(uint64_t pos, float mass, unsigned row, unsigned col);

+    void acceptExchange(uint64_t p1, float m1, float d1, uint64_t p2, float m2,

+        float d2, unsigned r1, unsigned c1, unsigned r2, unsigned c2);

+    bool updateAtomMass(uint64_t pos, float newMass);

 public:

@@ -62,11 +72,7 @@ public:

     void setAnnealingTemp(float temp);

     float chi2() const;

-    float nAtoms() const;