@@ -20,7 +20,7 @@ TEST_CASE("Test SparseIterator.h - One Dimensional")

         v.insert(7, 8.f);

         v.insert(9, 10.f);

-        TemplatedSparseIterator<1> it(v);

+        SparseIterator<1> it(v);

         REQUIRE(get<1>(it) == 1.f);

         it.next();

         REQUIRE(get<1>(it) == 5.f);

@@ -51,7 +51,7 @@ TEST_CASE("Test SparseIterator.h - One Dimensional")

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

         {

             float colSum = 0.f;

-            TemplatedSparseIterator<1> it(mat.getCol(j));

+            SparseIterator<1> it(mat.getCol(j));

             while (!it.atEnd())

             {

                 colSum += get<1>(it);

@@ -79,7 +79,7 @@ TEST_CASE("Test SparseIterator.h - Two Dimensional")

         hv.add(6, 5.f);

         hv.add(7, 6.f);

-        TemplatedSparseIterator<2> it(sv, hv);

+        SparseIterator<2> it(sv, hv);

         REQUIRE(get<1>(it) == 5.f);

         REQUIRE(get<2>(it) == 3.f);

         it.next();

@@ -107,7 +107,7 @@ TEST_CASE("Test SparseIterator.h - Two Dimensional")

         hv.add(8, 9.f);

         hv.add(75, 76.f);

-        TemplatedSparseIterator<2> it(sv, hv);

+        SparseIterator<2> it(sv, hv);

         REQUIRE(get<1>(it) == 75.f);

         REQUIRE(get<2>(it) == 76.f);

         it.next();

@@ -170,7 +170,7 @@ TEST_CASE("Test SparseIterator.h - Two Dimensional")

         // calculate dot product

         float sdot = 0.f, ddot = 0.f;

-        TemplatedSparseIterator<2> it(sv, hv);

+        SparseIterator<2> it(sv, hv);

         unsigned i = 0;

         while (!it.atEnd())

         {

@@ -218,7 +218,7 @@ TEST_CASE("Test SparseIterator.h - Two Dimensional")

             for (unsigned j2 = j1; j2 < ref.nCol(); ++j2)

             {

                 float dot = 0.f;

-                TemplatedSparseIterator<2> it(sMat.getCol(j1), hMat.getCol(j2));

+                SparseIterator<2> it(sMat.getCol(j1), hMat.getCol(j2));

                 while (!it.atEnd())

                 {

                     dot += get<1>(it) * get<2>(it);

@@ -265,7 +265,7 @@ TEST_CASE("Test SparseIterator.h - Three Dimensional")

         hv2.add(8, 7.f);

         hv2.add(9, 8.f);

-        TemplatedSparseIterator<3> it(sv, hv1, hv2);

+        SparseIterator<3> it(sv, hv1, hv2);

         REQUIRE(get<1>(it) == 5.f); // 4

         REQUIRE(get<2>(it) == 3.f);

         REQUIRE(get<3>(it) == 6.f);

@@ -301,7 +301,7 @@ TEST_CASE("Test SparseIterator.h - Three Dimensional")

                 for (unsigned j3 = j2; j3 < ref.nCol(); ++j3)

                 {

                     float prod = 0.f;

-                    TemplatedSparseIterator<3> it(sMat.getCol(j1), hMat.getCol(j2),

+                    SparseIterator<3> it(sMat.getCol(j1), hMat.getCol(j2),

                         hMat.getCol(j3));

                     while (!it.atEnd())

                     {

@@ -23,7 +23,7 @@ public:

     friend class SparseIteratorThree;

     template <unsigned N>

-    friend class TemplatedSparseIterator;

+    friend class SparseIterator;

     explicit HybridVector(unsigned size);

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

@@ -53,59 +53,59 @@ void gotoNextCommon(Iter &it)

 }

 template<>

-float get<1>(const TemplatedSparseIterator<1> &it)

+float get<1>(const SparseIterator<1> &it)

 {

     return it.mSparse.at(it.mSparseIndex);

 }

 template<>

-float get<1>(const TemplatedSparseIterator<2> &it)

+float get<1>(const SparseIterator<2> &it)

 {

     return it.mSparse.at(it.mSparseIndex);

 }

 template<>

-float get<1>(const TemplatedSparseIterator<3> &it)

+float get<1>(const SparseIterator<3> &it)

 {

     return it.mSparse.at(it.mSparseIndex);

 }

 template<>

-float get<2>(const TemplatedSparseIterator<2> &it)

+float get<2>(const SparseIterator<2> &it)

 {

     return it.mHybrid[64 * it.mBigIndex + it.mSmallIndex];

 }

 template<>

-float get<2>(const TemplatedSparseIterator<3> &it)

+float get<2>(const SparseIterator<3> &it)

 {

     return it.mHybrid_1[64 * it.mBigIndex + it.mSmallIndex];

 }

 template<>

-float get<3>(const TemplatedSparseIterator<3> &it)

+float get<3>(const SparseIterator<3> &it)

 {

     return it.mHybrid_2[64 * it.mBigIndex + it.mSmallIndex];

 }

-TemplatedSparseIterator<1>::TemplatedSparseIterator(const SparseVector &v)

+SparseIterator<1>::SparseIterator(const SparseVector &v)

 :

 mSparse(v),

 mSparseIndex(0)

 {}

-bool TemplatedSparseIterator<1>::atEnd() const

+bool SparseIterator<1>::atEnd() const

 {

     return mSparseIndex == mSparse.nElements();

 }

-void TemplatedSparseIterator<1>::next()

+void SparseIterator<1>::next()

 {

     ++mSparseIndex;

 }

-TemplatedSparseIterator<2>::TemplatedSparseIterator(const SparseVector &v, const HybridVector &h)

+SparseIterator<2>::SparseIterator(const SparseVector &v, const HybridVector &h)

     :

 mSparse(v),

 mHybrid(h),

@@ -124,33 +124,33 @@ mAtEnd(false)

     mSparseIndex -= 1; // next puts us at position 1, this resets to 0

 }

-bool TemplatedSparseIterator<2>::atEnd() const

+bool SparseIterator<2>::atEnd() const

 {

     return mAtEnd;

 }

-void TemplatedSparseIterator<2>::next()

+void SparseIterator<2>::next()

 {

     gotoNextCommon(*this);

 }

-void TemplatedSparseIterator<2>::calculateCommonFlags()

+void SparseIterator<2>::calculateCommonFlags()

 {

     mCommonFlags = mSparseFlags & mHybridFlags;

 }

-void TemplatedSparseIterator<2>::getFlags()

+void SparseIterator<2>::getFlags()

 {

     mSparseFlags = mSparse.mIndexBitFlags[mBigIndex];

     mHybridFlags = mHybrid.mIndexBitFlags[mBigIndex];

 }

-unsigned TemplatedSparseIterator<2>::getIndex() const

+unsigned SparseIterator<2>::getIndex() const

 {

     return 64 * mBigIndex + mSmallIndex;

 }

-TemplatedSparseIterator<3>::TemplatedSparseIterator(const SparseVector &v,

+SparseIterator<3>::SparseIterator(const SparseVector &v,

 const HybridVector &h1, const HybridVector &h2)

     :

 mSparse(v),

@@ -173,211 +173,29 @@ mAtEnd(false)

     mSparseIndex -= 1;

 }

-bool TemplatedSparseIterator<3>::atEnd() const

+bool SparseIterator<3>::atEnd() const

 {

     return mAtEnd;

 }

-void TemplatedSparseIterator<3>::next()

+void SparseIterator<3>::next()

 {

     gotoNextCommon(*this);

 }

-void TemplatedSparseIterator<3>::calculateCommonFlags()

+void SparseIterator<3>::calculateCommonFlags()

 {

     mCommonFlags = mSparseFlags & mHybridFlags_1 & mHybridFlags_2;

 }

-void TemplatedSparseIterator<3>::getFlags()

+void SparseIterator<3>::getFlags()

 {

     mSparseFlags = mSparse.mIndexBitFlags[mBigIndex];

     mHybridFlags_1 = mHybrid_1.mIndexBitFlags[mBigIndex];

     mHybridFlags_2 = mHybrid_2.mIndexBitFlags[mBigIndex];

 }

-unsigned TemplatedSparseIterator<3>::getIndex() const

-{

-    return 64 * mBigIndex + mSmallIndex;

-}

-

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-

-SparseIterator::SparseIterator(const SparseVector &v)

-    :

-mSparse(v),

-mSparseIndex(0)

-{}

-

-bool SparseIterator::atEnd() const

-{

-    return mSparseIndex == mSparse.mData.size();

-}

-

-void SparseIterator::next()

-{

-    ++mSparseIndex;

-}

-

-float SparseIterator::getValue() const

-{

-    return mSparse.mData[mSparseIndex];

-}

-

-SparseIteratorTwo::SparseIteratorTwo(const SparseVector &v1, const HybridVector &v2)

-    :

-mSparse(v1),

-mHybrid(v2),

-mFlags_1(mSparse.mIndexBitFlags[0]),

-mFlags_2(mHybrid.mIndexBitFlags[0]),

-mCommon(mFlags_1 & mFlags_2),

-mTotalIndices(mSparse.mIndexBitFlags.size()),

-mBigIndex(0),

-mSmallIndex(0),

-mSparseIndex(0),

-mAtEnd(false)

-{   

-    GAPS_ASSERT(v1.size() == v2.size());

-

-    next();

-    mSparseIndex -= 1; // next puts us at position 1, this resets to 0

-}

-

-bool SparseIteratorTwo::atEnd() const

-{

-    return mAtEnd;

-}

-

-void SparseIteratorTwo::next()

-{

-    // get the common indices in this chunk

-    mCommon = mFlags_1 & mFlags_2;

-

-    // if nothing common in this chunk, find a chunk that has common indices

-    while (!mCommon)

-    {

-        // first count how many sparse indices we are skipping

-        mSparseIndex += __builtin_popcountll(mFlags_1);

-        

-        // advance to next chunk

-        if (++mBigIndex == mTotalIndices)

-        {   

-            mAtEnd = true;

-            return;

-        }

-

-        // update the flags

-        mFlags_1 = mSparse.mIndexBitFlags[mBigIndex];

-        mFlags_2 = mHybrid.mIndexBitFlags[mBigIndex];

-        mCommon = mFlags_1 & mFlags_2;

-    }

-

-    // must have at least one common value, this is our index

-    mSmallIndex = __builtin_ffsll(mCommon) - 1;

-

-    // find the number of skipped entries in the sparse vector

-    mSparseIndex += 1 + countLowerBits(mFlags_1, mSmallIndex);

-

-    // clear out all skipped indices and the current index from the bitflags

-    mFlags_1 = clearLowerBits(mFlags_1, mSmallIndex);

-}

-

-float SparseIteratorTwo::getValue_1() const

-{

-    return mSparse.mData[mSparseIndex];

-}

-

-float SparseIteratorTwo::getValue_2() const

-{

-    return mHybrid[64 * mBigIndex + mSmallIndex];

-}

-

-unsigned SparseIteratorTwo::getIndex() const

-{

-    return 64 * mBigIndex + mSmallIndex;

-}

-

-SparseIteratorThree::SparseIteratorThree(const SparseVector &v1,

-const HybridVector &v2, const HybridVector &v3)

-    :

-mSparse(v1),

-mHybrid_1(v2),

-mHybrid_2(v3),

-mFlags_1(mSparse.mIndexBitFlags[0]),

-mFlags_2(mHybrid_1.mIndexBitFlags[0]),

-mFlags_3(mHybrid_2.mIndexBitFlags[0]),

-mCommon(mFlags_1 & mFlags_2 & mFlags_3),

-mTotalIndices(mSparse.mIndexBitFlags.size()),

-mBigIndex(0),

-mSmallIndex(0),

-mSparseIndex(0),

-mAtEnd(false)

-{   

-    GAPS_ASSERT(v1.size() == v2.size());

-    GAPS_ASSERT(v2.size() == v3.size());

-

-    next();

-    mSparseIndex -= 1;

-}

-

-bool SparseIteratorThree::atEnd() const

-{

-    return mAtEnd;

-}

-

-void SparseIteratorThree::next()

-{

-    // get the common indices in this chunk

-    mCommon = mFlags_1 & mFlags_2 & mFlags_3;

-

-    // if nothing common in this chunk, find a chunk that has common indices

-    while (!mCommon)

-    {

-        // first count how many sparse indices we are skipping

-        mSparseIndex += __builtin_popcountll(mFlags_1);

-

-        // advance to next chunk

-        if (++mBigIndex == mTotalIndices)

-        {   

-            mAtEnd = true;

-            return;

-        }

-

-        // update the flags

-        mFlags_1 = mSparse.mIndexBitFlags[mBigIndex];

-        mFlags_2 = mHybrid_1.mIndexBitFlags[mBigIndex];

-        mFlags_3 = mHybrid_2.mIndexBitFlags[mBigIndex];

-        mCommon = mFlags_1 & mFlags_2 & mFlags_3;

-    }

-

-    // must have at least one common value, this is our index

-    mSmallIndex = __builtin_ffsll(mCommon) - 1;

-

-    // find the number of skipped entries in the sparse vector

-    mSparseIndex += 1 + countLowerBits(mFlags_1, mSmallIndex);

-

-    // clear out all skipped indices and the current index from the bitflags

-    mFlags_1 = clearLowerBits(mFlags_1, mSmallIndex);

-}

-

-float SparseIteratorThree::getValue_1() const

-{

-    return mSparse.mData[mSparseIndex];

-}

-

-float SparseIteratorThree::getValue_2() const

-{

-    return mHybrid_1[64 * mBigIndex + mSmallIndex];

-}

-

-float SparseIteratorThree::getValue_3() const

-{

-    return mHybrid_2[64 * mBigIndex + mSmallIndex];

-}

-

-unsigned SparseIteratorThree::getIndex() const

+unsigned SparseIterator<3>::getIndex() const

 {

     return 64 * mBigIndex + mSmallIndex;

 }

@@ -9,36 +9,36 @@ float get(const Iter &it);

 // only allow this class to constructed with N=1,2,3

 template <unsigned N>

-class TemplatedSparseIterator

+class SparseIterator

 {

 private:

-    TemplatedSparseIterator() {}

+    SparseIterator() {}

 };

 template<>

-class TemplatedSparseIterator<1>

+class SparseIterator<1>

 {

 public:

-    TemplatedSparseIterator(const SparseVector &v);

+    SparseIterator(const SparseVector &v);

     bool atEnd() const;

     void next();

 private:

-    friend float get<1>(const TemplatedSparseIterator<1> &it);

+    friend float get<1>(const SparseIterator<1> &it);

     const SparseVector &mSparse;

     unsigned mSparseIndex;

 };

 template<>

-class TemplatedSparseIterator<2>

+class SparseIterator<2>

 {

 public:

-    TemplatedSparseIterator(const SparseVector &v, const HybridVector &h);

+    SparseIterator(const SparseVector &v, const HybridVector &h);

     bool atEnd() const;

     void next();

@@ -51,8 +51,8 @@ private:

     template <class Iter>

     friend void gotoNextCommon(Iter &it);

-    friend float get<1>(const TemplatedSparseIterator<2> &it);

-    friend float get<2>(const TemplatedSparseIterator<2> &it);

+    friend float get<1>(const SparseIterator<2> &it);

+    friend float get<2>(const SparseIterator<2> &it);

     const SparseVector &mSparse;  

     const HybridVector &mHybrid;

@@ -69,11 +69,11 @@ private:

 };

 template<>

-class TemplatedSparseIterator<3>

+class SparseIterator<3>

 {

 public:

-    TemplatedSparseIterator(const SparseVector &v, const HybridVector &h1,

+    SparseIterator(const SparseVector &v, const HybridVector &h1,

     const HybridVector &h2);

     bool atEnd() const;

@@ -87,9 +87,9 @@ private:

     template <class Iter>

     friend void gotoNextCommon(Iter &it);

-    friend float get<1>(const TemplatedSparseIterator<3> &it);

-    friend float get<2>(const TemplatedSparseIterator<3> &it);

-    friend float get<3>(const TemplatedSparseIterator<3> &it);

+    friend float get<1>(const SparseIterator<3> &it);

+    friend float get<2>(const SparseIterator<3> &it);

+    friend float get<3>(const SparseIterator<3> &it);

     const SparseVector &mSparse;  

     const HybridVector &mHybrid_1;

@@ -107,91 +107,4 @@ private:

     bool mAtEnd;

 };

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-////////////////////////////////////////////////////////////////////////////////

-

-class SparseIterator

-{

-public:

-

-    SparseIterator(const SparseVector &v);

-

-    bool atEnd() const;

-    void next();

-    float getValue() const;

-

-private:

-

-    const SparseVector &mSparse;

-    unsigned mSparseIndex;

-};

-

-class SparseIteratorTwo

-{

-public:

-

-    SparseIteratorTwo(const SparseVector &v1, const HybridVector &v2);

-

-    bool atEnd() const;

-    void next();

-

-    float getValue_1() const;

-    float getValue_2() const;

-    unsigned getIndex() const;

-

-#ifndef GAPS_INTERNAL_TESTS

-private:

-#endif

-

-    const SparseVector &mSparse;

-    const HybridVector &mHybrid;

-

-    uint64_t mFlags_1;

-    uint64_t mFlags_2;

-    uint64_t mCommon;

-

-    unsigned mTotalIndices;

-    unsigned mBigIndex;

-    unsigned mSmallIndex;

-    unsigned mSparseIndex;

-

-    bool mAtEnd;

-};

-

-class SparseIteratorThree

-{

-public:

-

-    SparseIteratorThree(const SparseVector &v1, const HybridVector &v2,

-    const HybridVector &v3);

-

-    bool atEnd() const;

-    void next();

-

-    float getValue_1() const;

-    float getValue_2() const;

-    float getValue_3() const;

-    unsigned getIndex() const;

-

-private:

-

-    const SparseVector &mSparse;

-    const HybridVector &mHybrid_1;

-    const HybridVector &mHybrid_2;

-   

-    uint64_t mFlags_1;

-    uint64_t mFlags_2;

-    uint64_t mFlags_3;

-    uint64_t mCommon;

-

-    unsigned mTotalIndices;

-    unsigned mBigIndex;

-    unsigned mSmallIndex;

-    unsigned mSparseIndex;

-

-    bool mAtEnd;

-};

-

 #endif // __COGAPS_SPARSE_ITERATOR_H__

\ No newline at end of file

@@ -12,12 +12,8 @@ class SparseVector

 {

 public:

-    friend class SparseIterator;

-    friend class SparseIteratorTwo;

-    friend class SparseIteratorThree;

-

     template <unsigned N>

-    friend class TemplatedSparseIterator;

+    friend class SparseIterator;

     friend class SparseMatrix; // for inserting values

@@ -56,7 +56,7 @@ AlphaParameters SparseGibbsSampler::alphaParameters(unsigned row, unsigned col)

     float s = mZ1[col];

     float s_mu = -1.f * gaps::dot(mMatrix.getRow(row), mZ2.getCol(col));

-    TemplatedSparseIterator<2> it(mDMatrix.getCol(row), mOtherMatrix->getCol(col));

+    SparseIterator<2> it(mDMatrix.getCol(row), mOtherMatrix->getCol(col));

     while (!it.atEnd())

     {

         s += (get<2>(it) * get<2>(it)) / (get<1>(it) * get<1>(it))

@@ -79,7 +79,7 @@ unsigned r2, unsigned c2)

         AlphaParameters a2 = alphaParameters(r2, c2);

         float s = -2.f * mBeta * mZ2(c1,c2) + a1.s + a2.s;

-        TemplatedSparseIterator<3> it(mDMatrix.getCol(r1), mOtherMatrix->getCol(c1),

+        SparseIterator<3> it(mDMatrix.getCol(r1), mOtherMatrix->getCol(c1),

             mOtherMatrix->getCol(c2));

         while (!it.atEnd())

         {

@@ -100,7 +100,7 @@ unsigned col, float ch)

     float s_mu = -1.f * gaps::dot(mMatrix.getRow(row), mZ2.getCol(col));

     s_mu -= ch * mZ2(col,col);

-    TemplatedSparseIterator<2> it(mDMatrix.getCol(row), mOtherMatrix->getCol(col));

+    SparseIterator<2> it(mDMatrix.getCol(row), mOtherMatrix->getCol(col));

     while (!it.atEnd())

     {

         s += (get<2>(it) * get<2>(it))

@@ -72,10 +72,10 @@ mBeta(100.f)

     // check data for values less than 1

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

     {

-        SparseIterator it(mDMatrix.getCol(j));

+        SparseIterator<1> it(mDMatrix.getCol(j));

         while (!it.atEnd())

         {

-            if (it.getValue() < 1.f)

+            if (get<1>(it) < 1.f)

             {

                 gaps_printf("\nError: Non-zero values less than 1 detected\n");

                 gaps_printf("\n       Not allowed when useSparseOptimization is enabled\n");

@@ -48,10 +48,10 @@ float gaps::sum(const SparseMatrix &mat)

     float sum = 0.f;

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

     {

-        SparseIterator it(mat.getCol(j));

+        SparseIterator<1> it(mat.getCol(j));

         while (!it.atEnd())

         {

-            sum += it.getValue();

+            sum += get<1>(it);

             it.next();

         }

     }

@@ -92,10 +92,10 @@ float gaps::nonZeroMean(const SparseMatrix &mat)

     unsigned nNonZeroes = 0;

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

     {

-        SparseIterator it(mat.getCol(j));

+        SparseIterator<1> it(mat.getCol(j));

         while (!it.atEnd())

         {

-            sum += it.getValue();

+            sum += get<1>(it);

             ++nNonZeroes;

             it.next();

         }

@@ -4,10 +4,19 @@

 static float dot_helper(const float *v1, const float *v2, unsigned size)

 {

-    float dot = 0.f;

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

+    gaps::simd::PackedFloat partialDot(0.f), p1, p2;

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

+    for (; i <= size - gaps::simd::Index::increment(); ++i)

     {

-        dot += v1[i] * v2[i];

+        p1.load(v1 + i);

+        p2.load(v2 + i);

+        partialDot += p1 * p2;

+    }

+

+    float dot = partialDot.scalar();

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

+    {

+        dot += v1[j] * v2[j];

     }

     return dot;

 }