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

 Package: CoGAPS

-Version: 3.3.11

+Version: 3.3.21

 Date: 2018-04-24

 Title: Coordinated Gene Activity in Pattern Sets

 Author: Thomas Sherman, Wai-shing Lee, Conor Kelton, Ondrej Maxian, Jacob Carey,

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

-# CoGAPS Version: 3.3.11

+# CoGAPS Version: 3.3.21

 [![Bioc](https://bioconductor.org/images/logo_bioconductor.gif)](https://bioconductor.org/packages/CoGAPS)

 [![downloads](https://bioconductor.org/shields/downloads/CancerInSilico.svg)](https://bioconductor.org/packages/CoGAPS)

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

 #! /bin/sh

 # Guess values for system-dependent variables and create Makefiles.

-# Generated by GNU Autoconf 2.69 for CoGAPS 3.3.2.

+# Generated by GNU Autoconf 2.69 for CoGAPS 3.3.11.

 #

 #

 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.

@@ -577,8 +577,8 @@ MAKEFLAGS=

 # Identity of this package.

 PACKAGE_NAME='CoGAPS'

 PACKAGE_TARNAME='cogaps'

-PACKAGE_VERSION='3.3.2'

-PACKAGE_STRING='CoGAPS 3.3.2'

+PACKAGE_VERSION='3.3.11'

+PACKAGE_STRING='CoGAPS 3.3.11'

 PACKAGE_BUGREPORT=''

 PACKAGE_URL=''

@@ -696,6 +696,7 @@ enable_option_checking

 enable_silent_rules

 enable_dependency_tracking

 enable_debug

+enable_internal_tests

 enable_warnings

 enable_simd

 enable_openmp

@@ -1262,7 +1263,7 @@ if test "$ac_init_help" = "long"; then

   # Omit some internal or obsolete options to make the list less imposing.

   # This message is too long to be a string in the A/UX 3.1 sh.

   cat <<_ACEOF

-\`configure' configures CoGAPS 3.3.2 to adapt to many kinds of systems.

+\`configure' configures CoGAPS 3.3.11 to adapt to many kinds of systems.

 Usage: $0 [OPTION]... [VAR=VALUE]...

@@ -1333,7 +1334,7 @@ fi

 if test -n "$ac_init_help"; then

   case $ac_init_help in

-     short | recursive ) echo "Configuration of CoGAPS 3.3.2:";;

+     short | recursive ) echo "Configuration of CoGAPS 3.3.11:";;

    esac

   cat <<\_ACEOF

@@ -1348,6 +1349,7 @@ Optional Features:

   --disable-dependency-tracking

                           speeds up one-time build

   --enable-debug          build debug version of CoGAPS

+  --enable-internal-tests allow for testing private data

   --enable-warnings       compile CoGAPS with warning messages

   --enable-simd           specify simd instruction set (sse, avx)

   --enable-openmp         compile with openMP support if available

@@ -1430,7 +1432,7 @@ fi

 test -n "$ac_init_help" && exit $ac_status

 if $ac_init_version; then

   cat <<\_ACEOF

-CoGAPS configure 3.3.2

+CoGAPS configure 3.3.11

 generated by GNU Autoconf 2.69

 Copyright (C) 2012 Free Software Foundation, Inc.

@@ -1873,7 +1875,7 @@ cat >config.log <<_ACEOF

 This file contains any messages produced by compilers while

 running configure, to aid debugging if configure makes a mistake.

-It was created by CoGAPS $as_me 3.3.2, which was

+It was created by CoGAPS $as_me 3.3.11, which was

 generated by GNU Autoconf 2.69.  Invocation command line was

   $ $0 $@

@@ -2736,7 +2738,7 @@ fi

 # Define the identity of the package.

  PACKAGE='cogaps'

- VERSION='3.3.2'

+ VERSION='3.3.11'

 cat >>confdefs.h <<_ACEOF

@@ -4069,6 +4071,15 @@ else

 fi

+# Check if running internal tests

+# Check whether --enable-internal-tests was given.

+if test "${enable_internal_tests+set}" = set; then :

+  enableval=$enable_internal_tests; internal_tests=yes

+else

+  internal_tests=no

+fi

+

+

 # Check if compiler warnings should be turned on

 # Check whether --enable-warnings was given.

 if test "${enable_warnings+set}" = set; then :

@@ -5140,7 +5151,6 @@ else

 fi

-if test "x$use_openmp" != "xno" ; then

 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OpenMP flag of C++ compiler" >&5

@@ -5207,6 +5217,7 @@ $as_echo "#define HAVE_OPENMP 1" >>confdefs.h

 fi

+if test "x$use_openmp" != "xno" ; then

     GAPS_CXX_FLAGS+=" $OPENMP_CXXFLAGS "

     GAPS_LIBS+=" $OPENMP_CXXFLAGS "

 fi

@@ -6841,6 +6852,12 @@ if test "x$build_debug" = "xyes" ; then

     GAPS_CPP_FLAGS+=" -DGAPS_DEBUG "

 fi

+# set compile flags for internal tests

+if test "x$internal_tests" = "xyes" ; then

+    echo "Enabling Internal Tests"

+    GAPS_CPP_FLAGS+=" -DGAPS_INTERNAL_TESTS "

+fi

+

 # set compile flags if warnings enabled

 if test "x$warnings" = "xyes" ; then

     if test "x$ax_cv_cxx_compiler_vendor" = "xgnu" || test "x$ax_cv_cxx_compiler_vendor" = "xclang"; then

@@ -7472,7 +7489,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1

 # report actual input values of CONFIG_FILES etc. instead of their

 # values after options handling.

 ac_log="

-This file was extended by CoGAPS $as_me 3.3.2, which was

+This file was extended by CoGAPS $as_me 3.3.11, which was

 generated by GNU Autoconf 2.69.  Invocation command line was

   CONFIG_FILES    = $CONFIG_FILES

@@ -7529,7 +7546,7 @@ _ACEOF

 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1

 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"

 ac_cs_version="\\

-CoGAPS config.status 3.3.2

+CoGAPS config.status 3.3.11

 configured by $0, generated by GNU Autoconf 2.69,

   with options \\"\$ac_cs_config\\"

@@ -14,6 +14,10 @@ AC_PROG_CXX

 AC_ARG_ENABLE(debug, [AC_HELP_STRING([--enable-debug],

     [build debug version of CoGAPS])], [build_debug=yes], [build_debug=no])

+# Check if running internal tests

+AC_ARG_ENABLE(internal-tests, [AC_HELP_STRING([--enable-internal-tests],

+    [allow for testing private data])], [internal_tests=yes], [internal_tests=no])

+

 # Check if compiler warnings should be turned on

 AC_ARG_ENABLE(warnings, [AC_HELP_STRING([--enable-warnings],

     [compile CoGAPS with warning messages])], [warnings=yes], [warnings=no])

@@ -54,6 +58,12 @@ if test "x$build_debug" = "xyes" ; then

     GAPS_CPP_FLAGS+=" -DGAPS_DEBUG "

 fi

+# set compile flags for internal tests

+if test "x$internal_tests" = "xyes" ; then

+    echo "Enabling Internal Tests"

+    GAPS_CPP_FLAGS+=" -DGAPS_INTERNAL_TESTS "

+fi

+

 # set compile flags if warnings enabled

 if test "x$warnings" = "xyes" ; then

     if test "x$ax_cv_cxx_compiler_vendor" = "xgnu" || test "x$ax_cv_cxx_compiler_vendor" = "xclang"; then

@@ -2,8 +2,7 @@

 #define __COGAPS_ARCHIVE_H__

 #include <fstream>

-

-#include <boost/random/mersenne_twister.hpp>

+#include <stdint.h>

 // flags for opening an archive

 #define ARCHIVE_READ  std::ios::in

@@ -53,7 +52,6 @@ public:

     friend Archive& operator<<(Archive &ar, int64_t val)  { return writeToArchive(ar, val); }

     friend Archive& operator<<(Archive &ar, float val)    { return writeToArchive(ar, val); }

     friend Archive& operator<<(Archive &ar, double val)   { return writeToArchive(ar, val); }

-    friend Archive& operator<<(Archive &ar, boost::random::mt11213b val) { return writeToArchive(ar, val); }

     friend Archive& operator>>(Archive &ar, char &val)     { return readFromArchive(ar, val); }

     friend Archive& operator>>(Archive &ar, bool &val)     { return readFromArchive(ar, val); }

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

     friend Archive& operator>>(Archive &ar, int64_t &val)  { return readFromArchive(ar, val); }

     friend Archive& operator>>(Archive &ar, float &val)    { return readFromArchive(ar, val); }

     friend Archive& operator>>(Archive &ar, double &val)   { return readFromArchive(ar, val); }

-    friend Archive& operator>>(Archive &ar, boost::random::mt11213b &val) { return readFromArchive(ar, val); }

 };

 #endif // __COGAPS_ARCHIVE_H__

@@ -3,87 +3,6 @@

 #include <vector>

-// should only ever use this when copying a default constructed bucket

-// in the vector of buckets used in the allocator

-/*AtomBucket& AtomBucket::operator=(const AtomBucket& other)

-{

-    GAPS_ASSERT(other.mSize == 0);

-    GAPS_ASSERT(other.mPrev == NULL);

-    GAPS_ASSERT(other.mNext == NULL);

-    GAPS_ASSERT(other.mOverflow == NULL);

-

-    mSize = 0;

-    mPrev = NULL;

-    mNext = NULL;

-    mOverflow = NULL;

-}*/

-

-/////////////////////// ALLOCATOR FOR OVERFLOW BUCKETS /////////////////////////

-

-static const unsigned poolsize = 1024;

-

-class AtomBucketPool

-{

-public:

-

-    AtomBucketPool()

-        : mPool(std::vector<AtomBucket>(poolsize, AtomBucket())), mCurrent(0)

-    {}

-

-    AtomBucket* create()

-    {

-        return &(mPool[mCurrent++]);

-    }

-

-    bool depleted()

-    {

-        return mCurrent == poolsize;

-    }

-

-private:

-

-    std::vector<AtomBucket> mPool;

-    unsigned mCurrent;

-};

-

-class AtomBucketAllocator

-{

-public:

-

-    AtomBucketAllocator()

-    {

-        mAllPools.push_back(new AtomBucketPool());

-    }

-

-    ~AtomBucketAllocator()

-    {

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

-        {

-            delete mAllPools[i];

-        }

-    }

-

-    AtomBucket* create()

-    {

-        if (mAllPools.back()->depleted())

-        {

-            mAllPools.push_back(new AtomBucketPool());

-        }

-        return mAllPools.back()->create();

-    }

-

-private:

-

-    std::vector<AtomBucketPool*> mAllPools;

-};

-

-static AtomBucket* createAtomBucket()

-{

-    //static AtomBucketAllocator allocator;

-    //return allocator.create();

-    return new AtomBucket();

-}

-

 ////////////////////////////////// ATOM ////////////////////////////////////////

 Atom::Atom() : pos(0), mass(0.f) {}

@@ -125,583 +44,71 @@ bool AtomNeighborhood::hasRight()

     return right != NULL;

 }

-/////////////////////////////// ATOM BUCKET ////////////////////////////////////

-

-// note much of this code is unrolled intentionally so that the most frequent

-// cases are fast

-

-AtomBucket::AtomBucket()

-    : mSize(0), mOverflow(NULL), mPrev(NULL), mNext(NULL)

-{}

-

-unsigned AtomBucket::size() const

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-

-    return mOverflow == NULL ? mSize : mSize + mOverflow->size();

-}

-

-bool AtomBucket::isEmpty() const

-{

-    return mSize == 0;

-}

-

-bool AtomBucket::contains(uint64_t pos) const

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(pos > 0);

-

-    if (mOverflow != NULL && !mOverflow->isEmpty() && pos > mBucket[1].pos)

-    {

-        return mOverflow->contains(pos);

-    }

-    else

-    {

-        switch (mSize)

-        {

-            case 0:

-                return false;

-            case 1:

-                return mBucket[0].pos == pos;

-            case 2:

-                return mBucket[0].pos == pos || mBucket[1].pos == pos;

-        }

-    }

-}

-

-Atom* AtomBucket::operator[](unsigned index)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(index < size());

-

-    if (index > 1) // must be overflowed

-    {

-        return mOverflow->operator[](index - 2);

-    }

-    return &(mBucket[index]);

-}

-

-void AtomBucket::insert(uint64_t pos, float mass)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(pos > 0);

-

-    if (mSize == 0)

-    {

-        mBucket[0] = Atom(pos, mass);

-        ++mSize;

-    }

-    else if (mSize == 1)

-    {

-        if (pos < mBucket[0].pos)

-        {

-            mBucket[1] = mBucket[0];

-            mBucket[0] = Atom(pos, mass);

-        }

-        else

-        {

-            mBucket[1] = Atom(pos, mass);

-        }

-        ++mSize;

-    }

-    else

-    {

-        // check if we need to allocate the overflow bucket

-        if (mOverflow == NULL)

-        {

-            mOverflow = createAtomBucket();

-            mOverflow->mPrev = this;

-            mOverflow->mNext = mNext;

-        }

-        else if (mOverflow->isEmpty())

-        {

-            mOverflow->mPrev = this;

-            mOverflow->mNext = mNext;

-        }

-

-        // push correct atom into overflow bucket

-        if (pos > mBucket[1].pos)

-        {

-            return mOverflow->insert(pos, mass);

-        }

-        mOverflow->insert(mBucket[1].pos, mBucket[1].mass);

-

-        // if inserting in this bucket, find correct position

-        if (pos < mBucket[0].pos)

-        {

-            mBucket[1] = mBucket[0];

-            mBucket[0] = Atom(pos, mass);

-        }

-        else

-        {

-            mBucket[1] = Atom(pos, mass);

-        }

-    }

-}

-

-// assumes pos is contained in this chain

-void AtomBucket::erase(uint64_t pos)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(pos > 0);

-    GAPS_ASSERT(mSize > 0);

-    GAPS_ASSERT(contains(pos));

-

-    if (mSize == 1)

-    {

-        connectAdjacent();

-        mSize = 0;

-    }

-    else if (mSize == 2)

-    {

-        // check if this position is in overflow bucket    

-        if (pos > mBucket[1].pos)

-        {

-            return mOverflow->erase(pos);

-        }

-

-        // shift top position down if needed

-        if (mBucket[0].pos == pos)

-        {

-            mBucket[0] = mBucket[1];

-        }

-        

-        // pull first atom from overflow if it's there

-        if (mOverflow != NULL && !mOverflow->isEmpty())

-        {

-            mBucket[1] = *(mOverflow->front());

-            mOverflow->eraseFront();

-        }

-        else // just delete atom at last position

-        {

-            --mSize;

-        }

-    }

-}

-

-void AtomBucket::eraseFront()

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-

-    GAPS_ASSERT(mSize > 0);

-

-    if (mSize == 1)

-    {

-        connectAdjacent();

-        mSize = 0;

-    }

-    else if (mSize == 2)

-    {

-        mBucket[0] = mBucket[1];

-        

-        // pull first atom from overflow if it's there

-        if (mOverflow != NULL && !mOverflow->isEmpty())

-        {

-            mBucket[1] = *(mOverflow->front());

-            mOverflow->eraseFront();

-        }

-        else

-        {

-            --mSize;

-        }

-    }

-}

-

-AtomNeighborhood AtomBucket::getNeighbors(unsigned index)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(index < size());

-

-    return AtomNeighborhood(getLeft(index), this->operator[](index), getRight(index));

-}

-

-AtomNeighborhood AtomBucket::getRightNeighbor(unsigned index)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(index < size());

-

-    return AtomNeighborhood(NULL, this->operator[](index), getRight(index));

-}

-

-// needs to propogate through overflow so that the last overflow will know

-// where the next bucket is

-void AtomBucket::setRightAdjacentBucket(AtomBucket *bucket)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-

-    mNext = bucket;

-    if (mOverflow != NULL && !mOverflow->isEmpty())

-    {

-        mOverflow->setRightAdjacentBucket(bucket);

-    }

-}

-

-void AtomBucket::setLeftAdjacentBucket(AtomBucket *bucket)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(bucket == NULL || !bucket->isEmpty());

-

-    mPrev = bucket;

-}

-

-void AtomBucket::connectAdjacent()

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-

-    // be careful when connecting overflow buckets

-    if (mNext != NULL && (mPrev == NULL || mPrev->mOverflow != this))

-    {

-        mNext->setLeftAdjacentBucket(mPrev);

-    }

-    if (mPrev != NULL)

-    {

-        mPrev->setRightAdjacentBucket(mNext);

-    }

-

-    mNext = NULL;

-    mPrev = NULL;

-}

-

-Atom* AtomBucket::front()

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(mSize > 0);

-    GAPS_ASSERT(mBucket[0].pos > 0);

-

-    return &(mBucket[0]);

-}

-

-Atom* AtomBucket::back()

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(mSize > 0);

-

-    if (mOverflow == NULL || (mOverflow != NULL && mOverflow->isEmpty()))

-    {

-        return &(mBucket[mSize - 1]);

-    }

-    return mOverflow->back();

-}

-

-Atom* AtomBucket::getLeft(unsigned index)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(mSize > 0);

-    GAPS_ASSERT(index < size());

-

-    if (index == 0)

-    {

-        GAPS_ASSERT(mPrev == NULL || mPrev->mOverflow != this);

-        return mPrev != NULL ? mPrev->back() : NULL; // mPrev can't be overflow here

-    }

-    else if (index < 3)

-    {

-        return &(mBucket[index - 1]);

-    }

-    else

-    {

-        GAPS_ASSERT(mOverflow != NULL);

-        return mOverflow->getLeft(index - 2);

-    }    

-}

-

-Atom* AtomBucket::getRight(unsigned index)

-{

-    GAPS_ASSERT(mPrev == NULL || !mPrev->isEmpty());

-    GAPS_ASSERT(mNext == NULL || !mNext->isEmpty());

-    GAPS_ASSERT(mSize > 0);

-    GAPS_ASSERT(index < size());

-

-    if (index == mSize - 1) // this is last atom in bucket

-    {

-        if (mOverflow != NULL && !mOverflow->isEmpty())

-        {

-            return mOverflow->front();

-        }

-        return mNext != NULL ? mNext->front() : NULL;

-    }        

-    else if (index == 0)

-    {

-        GAPS_ASSERT(mBucket[1].pos > 0);

-        return &(mBucket[1]);

-    }

-    else

-    {

-        mOverflow->getRight(index - 2);

-    }

-}

-

-Archive& operator<<(Archive &ar, AtomBucket &b)

-{

-    bool hasOverflow = (b.mOverflow != NULL);

-    ar << b.mBucket[0] << b.mBucket[1] << b.mSize << hasOverflow;

-

-    if (hasOverflow)

-    {

-        ar << *b.mOverflow;

-    }

-    return ar;

-}

-

-Archive& operator>>(Archive& ar, AtomBucket &b)

-{

-    bool hasOverflow = false;

-    ar >> b.mBucket[0] >> b.mBucket[1] >> b.mSize >> hasOverflow;

-

-    if (hasOverflow)

-    {

-        b.mOverflow = createAtomBucket();

-        ar >> *b.mOverflow;

-    }

-    return ar;

-}

-

-////////////////////////////// ATOM HASH MAP ///////////////////////////////////

-

-AtomHashMap::AtomHashMap(unsigned expectedNumAtoms)

-    :

-mExpectedNumAtoms(expectedNumAtoms), mLongestBucketSize(0), mSize(0),

-mHashMap(std::vector<AtomBucket>(expectedNumAtoms, AtomBucket()))

-{}

-

-void AtomHashMap::setTotalLength(uint64_t length)

-{

-    GAPS_ASSERT(length % mExpectedNumAtoms == 0);

-    mTotalLength = length;

-    mBucketLength = mTotalLength / mExpectedNumAtoms;

-}

-

-// pos ranges from 1 to mTotalLength

-unsigned AtomHashMap::hash(uint64_t pos) const

-{

-    return pos / mBucketLength;

-}

-

-Atom* AtomHashMap::front()

-{

-    return mHashMap[*(mFullBuckets.begin())].front();

-}

-    

-HashMapIndex AtomHashMap::getRandomIndex() const

-{

-    GAPS_ASSERT(mSize > 0);

-    while (true)

-    {

-        unsigned bucket = hash(mRng.uniform64(0, mTotalLength - 1));

-        if (!mHashMap[bucket].isEmpty())

-        {

-            unsigned pos = mRng.uniform32(0, mLongestBucketSize - 1);

-            if (pos < mHashMap[bucket].size())

-            {

-                return HashMapIndex(bucket, pos);

-            }

-        }

-    }

-}

-

-Atom* AtomHashMap::randomAtom()

-{

-    HashMapIndex ndx = getRandomIndex();

-    return mHashMap[ndx.bucket][ndx.index];

-}

-

-AtomNeighborhood AtomHashMap::randomAtomWithNeighbors()

-{

-    HashMapIndex ndx = getRandomIndex();

-    return mHashMap[ndx.bucket].getNeighbors(ndx.index);

-}

-

-AtomNeighborhood AtomHashMap::randomAtomWithRightNeighbor()

-{

-    HashMapIndex ndx = getRandomIndex();

-    return mHashMap[ndx.bucket].getRightNeighbor(ndx.index);

-}

-

-bool AtomHashMap::contains(uint64_t pos) const

-{

-    unsigned index = hash(pos);

-    return !(mHashMap[index].isEmpty()) && mHashMap[index].contains(pos);

-}

-

-unsigned AtomHashMap::size() const

-{

-    return mSize;

-}

-

-// usually O(1), might be O(logN)

-void AtomHashMap::insert(uint64_t pos, float mass)

-{

-    // hash position once

-    unsigned index = hash(pos);

-

-    // if inserting into an empty bucket, mark bucket as non-empty

-    // and connect adjacent buckets O(logN)

-    if (mHashMap[index].isEmpty())

-    {

-        mHashMap[index].insert(pos, mass);

-        GAPS_ASSERT(mHashMap[index].contains(pos));

-        std::set<unsigned>::iterator it = mFullBuckets.insert(index).first;

-        if (it != mFullBuckets.begin())

-        {

-            --it;

-            mHashMap[index].setLeftAdjacentBucket(&mHashMap[*it]);

-            mHashMap[*it].setRightAdjacentBucket(&mHashMap[index]);

-            ++it;

-        }

-        if (++it != mFullBuckets.end())

-        {

-            mHashMap[index].setRightAdjacentBucket(&mHashMap[*it]);

-            mHashMap[*it].setLeftAdjacentBucket(&mHashMap[index]);

-        }

-    }

-    else

-    {

-        mHashMap[index].insert(pos, mass);

-        GAPS_ASSERT(mHashMap[index].contains(pos));

-    }

-    GAPS_ASSERT(mHashMap[index].contains(pos));

-

-    // insert atom

-    ++mSize;

-

-    // check if this is now the longest bucket

-    if (mHashMap[index].size() > mLongestBucketSize)

-    {

-        mWhichLongestBucket = index;

-        ++mLongestBucketSize;

-    }

-}

-

-// usually O(1), sometimes O(logN), rarely O(N)

-void AtomHashMap::erase(uint64_t pos)

-{

-    // erase atom

-    unsigned index = hash(pos);

-    GAPS_ASSERT(!mHashMap[index].isEmpty());

-    GAPS_ASSERT(mHashMap[index].contains(pos));

-    --mSize;

-    

-    // mark bucket as empty if this was the last atom O(logN)

-    mHashMap[index].erase(pos);

-    if (mHashMap[index].isEmpty())

-    {

-        mFullBuckets.erase(index);

-    }

-    GAPS_ASSERT(!mHashMap[index].contains(pos));

-

-    // if this atom was in the largest bucket, find the new largest bucket O(N)

-    if (index == mWhichLongestBucket)

-    {

-        --mLongestBucketSize;

-        std::set<unsigned>::iterator it = mFullBuckets.begin();

-        for (; it != mFullBuckets.end(); ++it)

-        {

-            if (mHashMap[*it].size() > mLongestBucketSize)

-            {

-                mLongestBucketSize = mHashMap[*it].size();

-                mWhichLongestBucket = *it;

-            }

-        }

-    }

-}

+////////////////////////////// ATOMIC DOMAIN ///////////////////////////////////

-void AtomHashMap::move(uint64_t src, uint64_t dest, float mass)

+AtomicDomain::AtomicDomain(unsigned nBins)

 {

-    unsigned srcHash = hash(src);

-    unsigned destHash = hash(dest);

-    if (srcHash != destHash)

-    {

-        erase(src);

-        insert(dest, mass);

-    }

+    uint64_t binLength = std::numeric_limits<uint64_t>::max() / nBins;

+    mDomainLength = binLength * nBins;

 }

-Archive& operator<<(Archive& ar, AtomHashMap &h)

+Atom* AtomicDomain::front()

 {

-    ar << h.mExpectedNumAtoms << h.mBucketLength << h.mTotalLength <<

-        h.mWhichLongestBucket << h.mLongestBucketSize << h.mSize;

-

-    ar << h.mFullBuckets.size();

-    std::set<unsigned>::iterator it = h.mFullBuckets.begin();

-    for (; it != h.mFullBuckets.end(); ++it)

-    {

-        ar << *it << h.mHashMap[*it];

-    }

-    return ar;

+    GAPS_ASSERT(size() > 0);

+    return &(mAtoms.front());

 }

-Archive& operator>>(Archive& ar, AtomHashMap &h)

+Atom* AtomicDomain::randomAtom()

 {

-    ar >> h.mExpectedNumAtoms >> h.mBucketLength >> h.mTotalLength >>

-        h.mWhichLongestBucket >> h.mLongestBucketSize >> h.mSize;

-

-    unsigned nBuckets = 0;

-    ar >> nBuckets;

-

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

-    {

-        unsigned thisBucket = 0;

-        ar >> thisBucket;

-        h.mFullBuckets.insert(thisBucket);

-        ar >> h.mHashMap[thisBucket];

-    }

-    return ar;

+    GAPS_ASSERT(size() > 0);

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

+    return &(mAtoms[index]);

 }

-////////////////////////////// ATOMIC DOMAIN ///////////////////////////////////

-

-AtomicDomain::AtomicDomain(unsigned nBins) : mAtoms(nBins)

+AtomNeighborhood AtomicDomain::randomAtomWithNeighbors()

 {

-    uint64_t binLength = std::numeric_limits<uint64_t>::max() / nBins;

-    mDomainLength = binLength * nBins;

-    mAtoms.setTotalLength(mDomainLength);

+    GAPS_ASSERT(size() > 0);

+    unsigned index = mRng.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);

 }

-void AtomicDomain::setDomainSize(uint64_t size)

+AtomNeighborhood AtomicDomain::randomAtomWithRightNeighbor()

 {

-    // do nothing

+    GAPS_ASSERT(size() > 0);

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

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

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

 }

-Atom* AtomicDomain::front()

+static bool compareAtomLower(const Atom &lhs, uint64_t pos)

 {

-    return mAtoms.front();

+    return lhs.pos < pos;

 }

-Atom* AtomicDomain::randomAtom()

+static bool compareAtomUpper(uint64_t pos, const Atom &lhs)

 {