Binary files a/data/GIST.RData and b/data/GIST.RData differ

Binary files a/data/SimpSim.RData and b/data/SimpSim.RData differ

@@ -27,7 +27,7 @@ const PatternGibbsSampler &PSampler)

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

         mAMeanMatrix.getCol(j) += prod;

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

+        mAStdMatrix.getCol(j) += gaps::algo::elementSq(prod); // precision loss? use double?

     }

 }

@@ -525,20 +525,20 @@ float m2, unsigned r1, unsigned c1, unsigned r2, unsigned c2)

         float pUpper = gaps::random::p_gamma(m1 + m2, 2.f, 1.f / mLambda);

         float newMass = gaps::random::inverseGammaSample(0.f, pUpper, 2.f, 1.f / mLambda);

-        // swapping only effects alpha parameters - only effects gibbs

-        // flips the sign of alpha parameters (only su)

-        // flips sign in gibbs mass

-        // can we swap after gibbsMass calculation?

-        if ((m1 > m2 && m1 > newMass) || (m2 > m1 && m2 < newMass))

-        {

-            std::swap(r1, r2);

-            std::swap(c1, c2);

-            std::swap(p1, p2);

-            std::swap(m1, m2);

-        }

-

         if (impl()->canUseGibbs(r1, c1, r2, c2))

         {

+            // swapping only effects alpha parameters - only effects gibbs

+            // flips the sign of alpha parameters (only su)

+            // flips sign in gibbs mass

+            // can we swap after gibbsMass calculation?

+            if ((m1 > m2 && m1 > newMass) || (m2 > m1 && m2 < newMass))

+            {

+                std::swap(r1, r2);

+                std::swap(c1, c2);

+                std::swap(p1, p2);

+                std::swap(m1, m2);

+            }

+

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

             std::pair<float, bool> gMass = gibbsMass(alpha, m1, m2);

             if (gMass.second)

@@ -549,9 +549,9 @@ float m2, unsigned r1, unsigned c1, unsigned r2, unsigned c2)

             }

         }

-        // use metropolis hastings otherwise

         float delta = m1 > m2 ? newMass - m1 : m2 - newMass; // change larger mass

-        float pOldMass = m1 + delta > m2 - delta ? m1 : m2;

+        float pOldMass = 2 * newMass > m1 + m2 ? gaps::max(m1, m2) : gaps::min(m1, m2);

+    

         float pNew = gaps::random::d_gamma(newMass, 2.f, 1.f / mLambda);

         float pOld = gaps::random::d_gamma(pOldMass, 2.f, 1.f / mLambda);

@@ -120,14 +120,15 @@ template<class GenericMatrix>

 GenericMatrix gaps::algo::computeStdDev(const GenericMatrix &stdMat,

 const GenericMatrix &meanMat, unsigned nUpdates)

 {

+    GAPS_ASSERT(nUpdates > 1);

     GenericMatrix retMat(stdMat.nRow(), stdMat.nCol());

-    float meanTerm = 0.f;

     for (unsigned r = 0; r < retMat.nRow(); ++r)

     {

         for (unsigned c = 0; c < retMat.nCol(); ++c)

         {

-            meanTerm = meanMat(r,c) * meanMat(r,c) / static_cast<float>(nUpdates);

-            retMat(r,c) = std::sqrt((stdMat(r,c) - meanTerm) / (static_cast<float>(nUpdates) - 1.f));

+            float meanTerm = meanMat(r,c) * meanMat(r,c) / static_cast<float>(nUpdates);

+            float numer = gaps::max(0.f, stdMat(r,c) - meanTerm);

+            retMat(r,c) = std::sqrt(numer / (static_cast<float>(nUpdates) - 1.f));

         }

     }

     return retMat;

@@ -105,8 +105,6 @@ public:

     void load(const float *ptr) { mData = LOAD_PACKED(ptr); }

     void store(float *ptr) { STORE_PACKED(ptr, mData); }

-// RTTI may be expensive

-

 #if defined( __GAPS_AVX__ )

     float scalar()

     {

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

 context("CoGAPS")

+no_na_in_result <- function(gapsResult)

+{

+    sum(is.na(gapsResult@featureLoadings)) +

+        sum(is.na(gapsResult@featureStdDev)) +

+        sum(is.na(gapsResult@sampleFactors)) +

+        sum(is.na(gapsResult@sampleStdDev)) == 0

+}

+

 test_that("Valid Top-Level CoGAPS Calls",

 {

     data(GIST)

@@ -19,6 +27,7 @@ test_that("Valid Top-Level CoGAPS Calls",

     res[[3]] <- CoGAPS(gistCsvPath, nIterations=100, outputFrequency=50, seed=1)

     res[[4]] <- CoGAPS(gistTsvPath, nIterations=100, outputFrequency=50, seed=1)

     res[[5]] <- CoGAPS(gistMtxPath, nIterations=100, outputFrequency=50, seed=1)

+    expect_true(all(sapply(res, no_na_in_result)))

     expect_equal(nrow(res[[1]]@featureLoadings), 1363)

     expect_equal(ncol(res[[1]]@featureLoadings), 7)

@@ -41,6 +50,7 @@ test_that("Valid Top-Level CoGAPS Calls",

         outputFrequency=50, seed=1)

     res[[5]] <- CoGAPS(gistMtxPath, transposeData=TRUE, nIterations=100,

         outputFrequency=50, seed=1)

+    expect_true(all(sapply(res, no_na_in_result)))

     expect_equal(nrow(res[[1]]@featureLoadings), 9)

     expect_equal(ncol(res[[1]]@featureLoadings), 7)

@@ -52,30 +62,42 @@ test_that("Valid Top-Level CoGAPS Calls",

         res[[i]]@sampleFactors == res[[i+1]]@sampleFactors)))

     # passing uncertainty

-    expect_error(CoGAPS(testDataFrame, uncertainty=as.matrix(GIST.uncertainty),

+    expect_error(res <- CoGAPS(testDataFrame, uncertainty=as.matrix(GIST.uncertainty),

         nIterations=100, outputFrequency=50, seed=1), NA)    

+    expect_true(no_na_in_result(res))

     # multiple threads

-    expect_error(CoGAPS(testDataFrame, nIterations=100, outputFrequency=50,

-        seed=1, nThreads=2), NA)

-    expect_error(CoGAPS(testDataFrame, nIterations=100, outputFrequency=50,

-        seed=1, nThreads=6), NA)

-    expect_error(CoGAPS(testDataFrame, nIterations=100, outputFrequency=50,

-        seed=1, nThreads=12), NA)

+    expect_error(res <- CoGAPS(testDataFrame, nIterations=100,

+        outputFrequency=50, seed=1, nThreads=2), NA)

+    expect_true(no_na_in_result(res))

+

+    expect_error(res <- CoGAPS(testDataFrame, nIterations=100,

+        outputFrequency=50, seed=1, nThreads=6), NA)

+    expect_true(no_na_in_result(res))

+

+    expect_error(res <- CoGAPS(testDataFrame, nIterations=100,

+        outputFrequency=50, seed=1, nThreads=12), NA)

+    expect_true(no_na_in_result(res))

     # genome-wide CoGAPS 

-    expect_error(CoGAPS(testDataFrame, nIterations=100, outputFrequency=50,

-        seed=1, distributed="genome-wide"), NA)

-    expect_error(CoGAPS(gistTsvPath, nIterations=100, outputFrequency=50,

-        seed=1, distributed="genome-wide"), NA)

+    expect_error(res <- CoGAPS(testDataFrame, nIterations=100,

+        outputFrequency=50, seed=1, distributed="genome-wide"), NA)

+    expect_true(no_na_in_result(res))

+

+    expect_error(res <- CoGAPS(gistTsvPath, nIterations=100,

+        outputFrequency=50, seed=1, distributed="genome-wide"), NA)

+    expect_true(no_na_in_result(res))

     # single-cell CoGAPS

-    expect_error(CoGAPS(testDataFrame, nIterations=100, outputFrequency=50,

-        seed=1, distributed="single-cell", singleCell=TRUE,

+    expect_error(res <- CoGAPS(testDataFrame, nIterations=100,

+        outputFrequency=50, seed=1, distributed="single-cell", singleCell=TRUE,

         transposeData=TRUE), NA)

-    expect_error(CoGAPS(gistTsvPath, nIterations=100, outputFrequency=50,

-        seed=1, distributed="single-cell", singleCell=TRUE,

+    expect_true(no_na_in_result(res))

+

+    expect_error(res <- CoGAPS(gistTsvPath, nIterations=100,

+        outputFrequency=50, seed=1, distributed="single-cell", singleCell=TRUE,

         transposeData=TRUE), NA)

+    expect_true(no_na_in_result(res))

 })

 #test_that("Invalid Top-Level CoGAPS Calls",