@@ -34,7 +34,7 @@ Imports:

 Suggests:

     testthat,

     lintr

-LinkingTo: Rcpp, BH, RcppArmadillo

+LinkingTo: Rcpp, BH

 License: GPL (==2)

 biocViews: GeneExpression, Transcription, GeneSetEnrichment,

     DifferentialExpression, Bayesian, Clustering, TimeCourse, RNASeq, Microarray,

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

 # Generated by using Rcpp::compileAttributes() -> do not edit by hand

 # Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

-cogaps <- function(DMatrix, SMatrix, ABins, PBins, Config, ConfigNums, seed = -1L, messages = FALSE, singleCellRNASeq = FALSE) {

-    .Call('_CoGAPS_cogaps', PACKAGE = 'CoGAPS', DMatrix, SMatrix, ABins, PBins, Config, ConfigNums, seed, messages, singleCellRNASeq)

+cogaps <- function(DMatrix, SMatrix, nFactor, alphaA, alphaP, nEquil, nEquilCool, nSample, maxGibbsMassA, maxGibbsMassP, seed = -1L, messages = FALSE, singleCellRNASeq = FALSE) {

+    .Call('_CoGAPS_cogaps', PACKAGE = 'CoGAPS', DMatrix, SMatrix, nFactor, alphaA, alphaP, nEquil, nEquilCool, nSample, maxGibbsMassA, maxGibbsMassP, seed, messages, singleCellRNASeq)

 }

 run_catch_unit_tests <- function() {

@@ -64,123 +64,10 @@ gapsRun <- function(D, S, ABins = data.frame(), PBins = data.frame(),

                     alphaP = 0.01, nMaxP = 100000, max_gibbmass_paraP = 100.0,

                     seed=-1, messages=TRUE, singleCellRNASeq=FALSE)

 {

-  #Begin data type error checking code

-  charDataErrors = c(!is.character(simulation_id), !is.character(fixedDomain))

-  charCheck = c("simulation_id", "fixedDomain")

-

-  boolDataErrors = c(!is.logical(output_atomic), !is.logical(fixedBinProbs), !is.logical(sampleSnapshots))

-  boolCheck = c("output_atomic", "fixedBinProbs", "sampleSnapshots")

-

-  numericDataErrors = c(!is.numeric(nFactor), !is.numeric(nEquil), !is.numeric(nSample), !is.numeric(nOutR), !is.numeric(numSnapshots),

-                        !is.numeric(alphaA), !is.numeric(nMaxA), !is.numeric(max_gibbmass_paraA), !is.numeric(alphaP),

-                        !is.numeric(nMaxP), !is.numeric(max_gibbmass_paraP))

-  numericCheck = c("nFactor", "nEquil", "nSample", "nOutR", "numSnapshots", "alphaA", "nMaxA",

-                   "max_gibbmass_paraA", "alphaP",    "nMaxP", "max_gibbmass_paraP")

-

-  dataFrameErrors = c(!is.data.frame(D), !is.data.frame(S), !is.data.frame(ABins), !is.data.frame(PBins))

-  dataFrameCheck = c("D", "S", "ABins", "PBins")

-

-  matrixErrors = c(!is.matrix(D), !is.matrix(S), !is.matrix(ABins), !is.matrix(PBins))

-

-  if(any(charDataErrors))

-  {

-    #Check which of these is not a string

-    for(i in 1:length(charDataErrors))

-    {

-      if(charDataErrors[i] == TRUE)

-      {

-        stop(paste("Error in gapsRun: Argument",charCheck[i],"is of the incorrect type. Please see documentation for details."))

-      }

-    }

-  }

-

-  if(any(boolDataErrors))

-  {

-    #Check which of these is not a boolean

-    for(i in 1:length(boolDataErrors))

-    {

-      if(boolDataErrors[i] == TRUE)

-      {

-        stop(paste("Error in gapsRun: Argument",boolCheck[i],"is of the incorrect type. Please see documentation for details."))

-      }

-    }

-  }

-

-  if(any(numericDataErrors))

-  {

-    #Check which of these is not an integer/double

-    for(i in 1:length(numericDataErrors))

-    {

-      if(numericDataErrors[i] == TRUE)

-      {

-        stop(paste("Error in gapsRun: Argument",numericCheck[i],"is of the incorrect type. Please see documentation for details."))

-

-      }

-    }

-  }

-

-  #At least one of A, P, ABins, or PBins is not a matrix or data.frame

-  if(any((dataFrameErrors[1] && matrixErrors[1]), (dataFrameErrors[2] && matrixErrors[2]), (dataFrameErrors[3] && matrixErrors[3]), (dataFrameErrors[4] && matrixErrors[4])))

-  {

-    for(i in 1:length(dataFrameCheck))

-    {

-      if((dataFrameErrors[i] && matrixErrors[i]) == TRUE)

-      {

-        stop(paste("Error in gapsRun: Argument",dataFrameCheck[i],"is not a matrix or data.frame. Please see documentation for details."))

-

-      }

-    }

-  }

-

   #Floor the parameters that are integers to prevent allowing doubles.

   nFactor = floor(nFactor)

   nEquil = floor(nEquil)

   nSample = floor(nSample)

-  nOutR = floor(nOutR)

-  numSnapshots = floor(numSnapshots)

-  nMaxA = floor(nMaxA)

-  nMaxP = floor(nMaxP)

-

-

-  # pass all settings to C++ within a list

-  #    if (is.null(P)) {

-  Config = c(simulation_id, output_atomic, fixedBinProbs, fixedDomain, sampleSnapshots);

-

-  ConfigNums = c(nFactor, nEquil, nSample, nOutR, alphaA, nMaxA, max_gibbmass_paraA,

-                 alphaP, nMaxP, max_gibbmass_paraP, numSnapshots);

-

-  #Begin logic error checking code

-

-  #Check for negative or zero arguments

-  if(any(ConfigNums <= 0))

-  {

-    stop("Error in gapsRun: Numeric Arguments must be strictly positive.")

-  }

-

-  #Check for nonsensical inputs (such as numSnapshots < nEquil or nSample)

-  if((numSnapshots > nEquil) || (numSnapshots > nSample))

-  {

-    stop("Error in gapsRun: Cannot have more snapshots of A and P than equilibration and/or sampling iterations.")

-  }

-

-  if((nOutR > nEquil) || (nOutR > nSample))

-  {

-    stop("Error in gapsRun: Cannot have more output steps than equilibration and/or sampling iterations.")

-  }

-

-  if(nFactor > (ncol(D)))

-  {

-    warning("Warning in gapsRun: Number of requested patterns greater than columns of Data Matrix.")

-  }

-

-  #        P <- as.data.frame(matrix(nrow=1,c(1,1,1))) # make something to pass

-  #    } else {

-  #        Config = c(nFactor, simulation_id, nEquil, nSample, nOutR,

-  #        output_atomic, alphaA, nMaxA, max_gibbmass_paraA, lambdaA_scale_factor,

-  #        alphaP, nMaxP, max_gibbmass_paraP, lambdaP_scale_factor, 1)

-

-  #   }

-

   geneNames = rownames(D);

   sampleNames = colnames(D);

@@ -193,45 +80,45 @@ gapsRun <- function(D, S, ABins = data.frame(), PBins = data.frame(),

   }

   # call to C++ Rcpp code

-  cogapResult = cogaps(D, S, ABins, PBins, Config, ConfigNums, seed, messages,

-    singleCellRNASeq);

+  cogapResult = cogaps(as.matrix(D), as.matrix(S), nFactor, alphaA, alphaP, nEquil, 10, nSample, max_gibbmass_paraA,

+    max_gibbmass_paraP, seed, messages, singleCellRNASeq)

   # convert returned files to matrices to simplify visualization and processing

-  cogapResult$Amean = as.matrix(cogapResult$Amean);

-  cogapResult$Asd = as.matrix(cogapResult$Asd);

-  cogapResult$Pmean = as.matrix(cogapResult$Pmean);

-  cogapResult$Psd = as.matrix(cogapResult$Psd);

-

-  # label matrices

-  colnames(cogapResult$Amean) = patternNames;

-  rownames(cogapResult$Amean) = geneNames;

-  colnames(cogapResult$Asd) = patternNames;

-  rownames(cogapResult$Asd) = geneNames;

-  colnames(cogapResult$Pmean) = sampleNames;

-  rownames(cogapResult$Pmean) = patternNames;

-  colnames(cogapResult$Psd) = sampleNames;

-  rownames(cogapResult$Psd) = patternNames;

-

-  # calculate chi-squared of mean, this should be smaller than individual

-  # chi-squared sample values if sampling is good

-  calcChiSq = c(0);

-  MMatrix = (cogapResult$Amean %*% cogapResult$Pmean);

-

-

-  for(i in 1:(nrow(MMatrix)))

-  {

-    for(j in 1:(ncol(MMatrix)))

-    {

-      calcChiSq = (calcChiSq) + ((D[i,j] - MMatrix[i,j])/(S[i,j]))^(2);

-    }

-  }

-

-  cogapResult = c(cogapResult, calcChiSq);

-

-  names(cogapResult)[13] = "meanChi2";

-

-  if (messages)

-    message(paste("Chi-Squared of Mean:",calcChiSq))

+  #cogapResult$Amean = as.matrix(cogapResult$Amean);

+  #cogapResult$Asd = as.matrix(cogapResult$Asd);

+  #cogapResult$Pmean = as.matrix(cogapResult$Pmean);

+  #cogapResult$Psd = as.matrix(cogapResult$Psd);

+#

+  ## label matrices

+  #colnames(cogapResult$Amean) = patternNames;

+  #rownames(cogapResult$Amean) = geneNames;

+  #colnames(cogapResult$Asd) = patternNames;

+  #rownames(cogapResult$Asd) = geneNames;

+  #colnames(cogapResult$Pmean) = sampleNames;

+  #rownames(cogapResult$Pmean) = patternNames;

+  #colnames(cogapResult$Psd) = sampleNames;

+  #rownames(cogapResult$Psd) = patternNames;

+#

+  ## calculate chi-squared of mean, this should be smaller than individual

+  ## chi-squared sample values if sampling is good

+  #calcChiSq = c(0);

+  #MMatrix = (cogapResult$Amean %*% cogapResult$Pmean);

+#

+#

+  #for(i in 1:(nrow(MMatrix)))

+  #{

+  #  for(j in 1:(ncol(MMatrix)))

+  #  {

+  #    calcChiSq = (calcChiSq) + ((D[i,j] - MMatrix[i,j])/(S[i,j]))^(2);

+  #  }

+  #}

+#

+  #cogapResult = c(cogapResult, calcChiSq);

+#

+  #names(cogapResult)[13] = "meanChi2";

+#

+  #if (messages)

+  #  message(paste("Chi-Squared of Mean:",calcChiSq))

   return(cogapResult);

 }

new file mode 100644

@@ -0,0 +1,164 @@

+#include "Algorithms.h"

+#include "Matrix.h"

+

+#include <algorithm>

+

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

+

+matrix_data_t gaps::algo::mean(const TwoWayMatrix &mat)

+{

+    return gaps::algo::sum(mat) / (mat.nRow() * mat.nCol());

+}

+

+matrix_data_t gaps::algo::sum(const Vector &vec)

+{

+    matrix_data_t sum = 0.0;

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

+    {

+        sum += vec(i);

+    }

+    return sum;

+}

+

+matrix_data_t gaps::algo::sum(const TwoWayMatrix &mat)

+{

+    matrix_data_t sum = 0.0;

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

+    {

+        sum += gaps::algo::sum(mat.getRow(r));

+    }

+    return sum;

+}

+

+matrix_data_t gaps::algo::nonZeroMean(const TwoWayMatrix &mat)

+{

+    matrix_data_t sum = 0.0;

+    unsigned int nNonZeros = 0;

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

+    {

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

+        {

+            if (mat(r,c) != 0.0)

+            {

+                nNonZeros++;

+                sum += mat(r,c);

+            }

+        }

+    }

+    return sum / nNonZeros;

+}

+

+bool gaps::algo::isRowZero(const RowMatrix &mat, unsigned row)

+{

+    return gaps::algo::sum(mat.getRow(row)) == 0;

+}

+    

+bool gaps::algo::isColZero(const ColMatrix &mat, unsigned col)

+{

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

+}

+

+static double deltaLL_A(unsigned row, unsigned col, double delta,

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

+const RowMatrix &P, const TwoWayMatrix &AP)

+{

+    double numer = 0.0, denom = 0.0, delLL = 0.0;

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

+    {

+        numer = 2 * delta * (D(row,j) - AP(row,j)) * P(col,j) - GAPS_SQ(delta * P(col,j));

+        denom = 2 * GAPS_SQ(S(row,j));

+        delLL += numer / denom;

+    }

+    return delLL;

+}

+

+static double deltaLL_P(unsigned row, unsigned col, double delta,

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

+const RowMatrix &P, const TwoWayMatrix &AP)

+{

+    double numer = 0.0, denom = 0.0, delLL = 0.0;

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

+    {

+        numer = 2 * delta * (D(i,col) - AP(i,col)) * A(i,row) - GAPS_SQ(delta * A(i,row));

+        denom = 2 * GAPS_SQ(S(i,col));

+        delLL += numer / denom;

+    }

+    return delLL;

+}

+

+double gaps::algo::deltaLL(const MatrixChange &ch, const TwoWayMatrix &D,

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

+const TwoWayMatrix &AP)

+{

+    if (ch.nChanges == 1 && ch.label == 'A')

+    {

+        return deltaLL_A(ch.row1, ch.col1, ch.delta1, D, S, A, P, AP);

+    }

+    else if (ch.nChanges == 1 && ch.label == 'P')

+    {

+        return deltaLL_P(ch.row1, ch.col1, ch.delta1, D, S, A, P, AP);

+    }

+    else if (ch.nChanges == 2 && ch.label == 'A')

+    {

+        return deltaLL_A(ch.row1, ch.col1, ch.delta1, D, S, A, P, AP)

+            + deltaLL_A(ch.row2, ch.col2, ch.delta2, D, S, A, P, AP);

+    }

+    else

+    {

+        return deltaLL_P(ch.row1, ch.col1, ch.delta1, D, S, A, P, AP)

+            + deltaLL_P(ch.row2, ch.col2, ch.delta2, D, S, A, P, AP);

+    }

+}

+

+static AlphaParameters alphaParameters_A(unsigned row, unsigned col,

+const TwoWayMatrix &D, const TwoWayMatrix &S, const RowMatrix &P,

+const TwoWayMatrix &AP)

+{

+    double s = 0.0, su = 0.0, ratio = 0.0;

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

+    {

+        ratio = P(col,j) / S(row,j);

+        s += GAPS_SQ(ratio);

+        su += P(col,j) * (D(row,j) - AP(row,j)) / GAPS_SQ(S(row,j));

+    }

+    return AlphaParameters(s, su);

+}

+

+static AlphaParameters alphaParameters_P(unsigned row, unsigned col,

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

+const TwoWayMatrix &AP)

+{

+    double s = 0.0, su = 0.0, ratio = 0.0;

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

+    {

+        ratio = A(i,row) / S(i,col);

+        s += GAPS_SQ(ratio);

+        su += A(i,row) * (D(i,col) - AP(i,col)) / GAPS_SQ(S(i,col));

+    }

+    return AlphaParameters(s, su);

+}

+

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

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

+const RowMatrix &P, const TwoWayMatrix &AP)

+{

+    if (ch.nChanges == 1 && ch.label == 'A')

+    {

+        return alphaParameters_A(ch.row1, ch.col1, D, S, P, AP);

+    }

+    else if (ch.nChanges == 1 && ch.label == 'P')

+    {

+        return alphaParameters_P(ch.row1, ch.col1, D, S, A, AP);

+    }

+    else if (ch.nChanges == 2 && ch.label == 'A')

+    {

+        return alphaParameters_A(ch.row1, ch.col1, D, S, P, AP)

+            + alphaParameters_A(ch.row2, ch.col2, D, S, P, AP);

+    }

+    else

+    {

+        return alphaParameters_P(ch.row1, ch.col1, D, S, A, AP)

+            + alphaParameters_P(ch.row2, ch.col2, D, S, A, AP);

+    }

+}

+

new file mode 100644

@@ -0,0 +1,46 @@

+#ifndef __COGAPS_ALGORITHMS_H__

+#define __COGAPS_ALGORITHMS_H__

+

+#include "Matrix.h"

+

+struct AlphaParameters

+{

+    double s;

+    double su;

+    

+    AlphaParameters(double inS, double inSU)

+        : s(inS), su(inSU)

+    {}

+

+    AlphaParameters& operator+(const AlphaParameters &other)

+    {

+        s += other.s;

+        su -= other.su; // weird

+        return *this;

+    }

+};

+

+namespace gaps

+{

+

+namespace algo

+{

+    matrix_data_t sum(const Vector &vec);

+    matrix_data_t sum(const TwoWayMatrix &mat);

+    matrix_data_t mean(const TwoWayMatrix &mat);

+    matrix_data_t nonZeroMean(const TwoWayMatrix &mat);

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

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

+

+    double deltaLL(const MatrixChange &ch, const TwoWayMatrix &D,

+        const TwoWayMatrix &S, const ColMatrix &A,

+        const RowMatrix &P, const TwoWayMatrix &AP);

+

+    AlphaParameters alphaParameters(const MatrixChange &ch,

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

+        const RowMatrix &P, const TwoWayMatrix &AP);

+}

+

+}

+

+#endif

\ No newline at end of file

@@ -14,11 +14,13 @@

 #define EPSILON 1E-10

-AtomicSupport::AtomicSupport(uint64_t nrow, uint64_t ncol)

-    : mNumRows(nrow), mNumCols(ncol), mNumBins(nrow * ncol),

-      mNumAtoms(0), mTotalMass(0.0),

-      mMaxNumAtoms(std::numeric_limits<uint64_t>::max()),

-      mBinSize(std::numeric_limits<uint64_t>::max() / (nrow * ncol))

+AtomicSupport::AtomicSupport(char label, uint64_t nrow, uint64_t ncol,

+double alpha, double lambda)

+    :

+mNumRows(nrow), mNumCols(ncol), mNumBins(nrow * ncol),

+mNumAtoms(0), mTotalMass(0.0), mLabel(label), mAlpha(alpha), 

+mMaxNumAtoms(std::numeric_limits<uint64_t>::max()), mLambda(lambda),

+mBinSize(std::numeric_limits<uint64_t>::max() / (nrow * ncol))

 {}

 uint64_t AtomicSupport::getRow(uint64_t pos) const

@@ -55,14 +57,14 @@ AtomicProposal AtomicSupport::proposeDeath() const

 {

     uint64_t location = randomAtomPosition();

     uint64_t mass = mAtomicDomain.at(location);

-    return AtomicProposal('D', location, -mass);

+    return AtomicProposal(mLabel, 'D', location, -mass);

 }

 AtomicProposal AtomicSupport::proposeBirth() const

 {

     uint64_t location = randomFreePosition();

     uint64_t mass = gaps::random::exponential(mLambda);

-    return AtomicProposal('B', location, mass);

+    return AtomicProposal(mLabel, 'B', location, mass);

 }

 // move atom between adjacent atoms

@@ -82,7 +84,7 @@ AtomicProposal AtomicSupport::proposeMove() const

     uint64_t newLocation = gaps::random::uniform64(left, right);

-    return AtomicProposal('M', location, -mass, newLocation, mass);

+    return AtomicProposal(mLabel, 'M', location, -mass, newLocation, mass);

 }

 // exchange with adjacent atom to the right

@@ -111,8 +113,8 @@ AtomicProposal AtomicSupport::proposeExchange() const

     // preserve total mass

     return mass1 > mass2 ?

-        AtomicProposal('E', pos1, newMass - mass1, pos2, mass1 - newMass)

-        : AtomicProposal('E', pos1, mass2 - newMass, pos2, newMass - mass2);

+        AtomicProposal(mLabel, 'E', pos1, newMass - mass1, pos2, mass1 - newMass)

+        : AtomicProposal(mLabel, 'E', pos1, mass2 - newMass, pos2, newMass - mass2);

 }

 void AtomicSupport::updateAtomMass(uint64_t pos, double delta)

@@ -180,13 +182,12 @@ MatrixChange AtomicSupport::getMatrixChange(const AtomicProposal &prop) const

 {

     if (prop.nChanges > 1)

     {

-        return MatrixChange(prop.type, getRow(prop.pos1), getCol(prop.pos1),

-            prop.delta1, getRow(prop.pos2), getCol(prop.pos2), prop.delta2);

+        return MatrixChange(prop.label, getRow(prop.pos1), getCol(prop.pos1), prop.delta1,

+            getRow(prop.pos2), getCol(prop.pos2), prop.delta2);

     }

     else

     {   

-        return MatrixChange(prop.type, getRow(prop.pos1), getCol(prop.pos1),

-            prop.delta1);

+        return MatrixChange(prop.label, getRow(prop.pos1), getCol(prop.pos1), prop.delta1);

     }

 }

@@ -11,6 +11,7 @@

 struct AtomicProposal

 {

+    char label;

     char type;

     unsigned nChanges;

@@ -20,12 +21,12 @@ struct AtomicProposal

     uint64_t pos2;

     double delta2;

-    AtomicProposal(char t, uint64_t p1, double m1)

-        : type(t), nChanges(1), pos1(p1), delta1(m1), pos2(0), delta2(0.0)

+    AtomicProposal(char l, char t, uint64_t p1, double m1)

+        : label(l), type(t), nChanges(1), pos1(p1), delta1(m1), pos2(0), delta2(0.0)

     {}

-    AtomicProposal(char t, uint64_t p1, double m1, uint64_t p2, double m2)

-        : type(t), nChanges(2), pos1(p1), delta1(m1), pos2(p2), delta2(m2)

+    AtomicProposal(char l, char t, uint64_t p1, double m1, uint64_t p2, double m2)

+        : label(l), type(t), nChanges(2), pos1(p1), delta1(m1), pos2(p2), delta2(m2)

     {}

 };

@@ -33,6 +34,9 @@ class AtomicSupport

 {

 private:

+    // label of this atomic domain (A/P)

+    char mLabel;

+

     // storage of the atomic domain

     std::map<uint64_t, double> mAtomicDomain;

     uint64_t mNumAtoms;

@@ -47,10 +51,10 @@ private:

     uint64_t mNumBins;

     uint64_t mBinSize;

-    // average number of atoms per bin

+    // average number of atoms per bin (must be > 0)

     double mAlpha;

-    // expected magnitude of each atom

+    // expected magnitude of each atom (must be > 0)

     double mLambda;     

     // convert atomic position to row/col of the matrix

@@ -73,7 +77,8 @@ private:

 public:

     // constructor

-    AtomicSupport(uint64_t nrow, uint64_t ncol);

+    AtomicSupport(char label, uint64_t nrow, uint64_t ncol, double alpha=1.0,

+        double lambda=1.0);

     // create and accept a proposal

     AtomicProposal makeProposal() const;

@@ -95,9 +100,6 @@ public:

     void setAlpha(double alpha) {mAlpha = alpha;}

     void setLambda(double lambda) {mLambda = lambda;}

     void setMaxNumAtoms(uint64_t max) {mMaxNumAtoms = max;}

-

-    // TODO remove support for this

-    std::map<uint64_t, double> getDomain() {return mAtomicDomain;}

 };

 #endif

new file mode 100644

@@ -0,0 +1,66 @@

+#include "GibbsSampler.h"

+

+#include <Rcpp.h>

+#include <ctime>

+

+void runGibbsSampler(GibbsSampler &sampler, unsigned iterations,

+    bool updateTemp=false);

+

+// [[Rcpp::export]]

+Rcpp::List cogaps(Rcpp::NumericMatrix DMatrix, Rcpp::NumericMatrix SMatrix,

+unsigned nFactor, double alphaA, double alphaP, unsigned nEquil,

+unsigned nEquilCool, unsigned nSample, double maxGibbsMassA,

+double maxGibbsMassP, int seed=-1, bool messages=false, bool singleCellRNASeq=false)

+{

+    // set seed

+    uint32_t seedUsed = seed >= 0 ? static_cast<uint32_t>(seed)

+        : static_cast<uint32_t>(std::time(0));

+    gaps::random::setSeed(seedUsed);

+

+    // create the gibbs sampler

+    GibbsSampler sampler(DMatrix, SMatrix, nFactor, alphaA, alphaP,

+        maxGibbsMassA, maxGibbsMassP, singleCellRNASeq);

+

+    // run the sampler for each phase of the algorithm

+    runGibbsSampler(sampler, nEquil, true);

+    runGibbsSampler(sampler, nEquilCool);

+    runGibbsSampler(sampler, nSample);

+

+    //Just leave the snapshots as empty lists

+    return Rcpp::List::create(Rcpp::Named("randSeed") = seedUsed,

+                              Rcpp::Named("numAtomA") = sampler.totalNumAtoms('A'));

+}

+

+void runGibbsSampler(GibbsSampler &sampler, unsigned iterations, bool updateTemp)

+{

+    unsigned nIterA = 10;

+    unsigned nIterP = 10;

+        

+    double tempDenom = (double)iterations / 2.0;

+

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

+    {

+        if (updateTemp)

+        {

+            sampler.setAnnealingTemp(std::min((i + 1) / tempDenom, 1.0));

+        }

+

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

+        {

+            sampler.update('A');

+        }

+

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

+        {

+            sampler.update('P');

+        }

+

+        double tempChiSq = sampler.chi2();

+        uint64_t numAtomsA = sampler.totalNumAtoms('A');

+        uint64_t numAtomsP = sampler.totalNumAtoms('P');

+

+        nIterA = gaps::random::poisson(std::max(numAtomsA, (uint64_t)10));

+        nIterP = gaps::random::poisson(std::max(numAtomsP, (uint64_t)10));

+    }

+

+}

\ No newline at end of file

deleted file mode 100644

@@ -1,397 +0,0 @@

-// cogapsR.cpp

-

-// =============================================================================

-// This is the main code for Cogaps. (7th Sep, 2013)

-// This file also works as an interface to R via Rcpp (24th July, 2014)

-// =============================================================================

-

-#include <iostream>       // for use with standard I/O

-#include <string>         // for string processing

-#include <fstream>        // for output to files

-#include <limits>         // for extracting numerical limits of C++

-#include <ctime>

-

-

-// ------ incorporated to use Cogaps_options ------------

-#include <vector>

-#include <iomanip>

-#include <boost/algorithm/string.hpp>

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

-#include "Random.h"   // for incorporating a random number generator.

-#include <RcppArmadillo.h>

-#include "Matrix.h"  // for incorporating a Matrix class

-#include "AtomicSupport.h"  // for incorporating an Atomic class

-#include "GAPSNorm.h"  // for incorporating calculation of statistics in cogaps.

-#include "GibbsSampler.h" // for incorporating the GibbsSampler which

-// does all the atomic space to matrix conversion

-// and sampling actions.

-

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

-

-//namespace bpo = boost::program_options;

-using namespace std;

-using std::vector;

-

-// [[Rcpp::export]]

-Rcpp::List cogaps(Rcpp::NumericMatrix DMatrix, Rcpp::NumericMatrix SMatrix,

-Rcpp::NumericMatrix ABins, Rcpp::NumericMatrix PBins,

-Rcpp::CharacterVector Config, Rcpp::NumericVector ConfigNums, int seed=-1, 

-bool messages=false, bool singleCellRNASeq=false)

-{

-    // set seed

-    uint32_t seedUsed = seed >= 0 ? static_cast<uint32_t>(seed)

-        : static_cast<uint32_t>(std::time(0));

-    gaps::random::setSeed(seedUsed);

-

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

-    // ===========================================================================

-    // Part 1) Initialization:

-    // In this section, we read in the system parameters from the paremter file

-    // parameter.txt, and matrices D and S from datafile.txt.

-    // Then we initialize A and P in both their atomic domains and

-    // matrix forms.

-    // ===========================================================================

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

-//CK CODE FOR CHANGING R VARIABLES OF THE CONFIG FILE INTO C VARIABLES

-//THIS REPLACES COGAPS_PROGAM_OPTIONS

-    string temp;

-    double tempNumInput;

-    tempNumInput = (ConfigNums[1]);

-    unsigned long nEquil = (tempNumInput);

-    //For equilibration

-    tempNumInput = (ConfigNums[2]);

-    unsigned long nSample = (tempNumInput);

-    // For Sampling

-    tempNumInput = (ConfigNums[3]);

-    unsigned long nObsR = tempNumInput;

-    //How many times we output the Chi-Sq

-    tempNumInput = (ConfigNums[0]);

-    unsigned int nFactor = tempNumInput;

-//Number of patterns

-    tempNumInput = (ConfigNums[4]);

-    double alphaA = tempNumInput;

-//scale parameter A

-    tempNumInput = (ConfigNums[7]);

-    double alphaP = tempNumInput;

-    //scale parameter P

-    tempNumInput = (ConfigNums[5]);

-    double nMaxA = tempNumInput;

-    //max atoms in A domain

-    tempNumInput = (ConfigNums[8]);

-    double nMaxP = tempNumInput;

-    //max atoms in P domain

-    string simulation_id = Rcpp::as<string>(Config[0]);

-    //Variable to name optional output files

-    tempNumInput = (ConfigNums[6]);

-    double max_gibbsmass_paraA = tempNumInput;

-//max atom mass in A domain

-    tempNumInput = (ConfigNums[9]);

-    double max_gibbsmass_paraP = tempNumInput;

-    //max atom mass in P domain

-    //Lambda Scale Factors removed and made to be constant. Can be hard coded from GibbsSampler.cpp

-    temp = Rcpp::as<string>(Config[1]);

-    bool Q_output_atomic;

-

-    if (temp == "TRUE" || temp == "true") {

-        Q_output_atomic = true;    // whether to output the atomic space info to a file specified by simulation ID

-

-    } else {

-        Q_output_atomic = false;

-    }

-

-    temp = Rcpp::as<string>(Config[2]);

-    bool fixBinProbs;

-

-    if (temp == "TRUE" || temp == "true") {

-        fixBinProbs = true;    // whether we are allowing variable bin sizes.

-

-    } else {

-        fixBinProbs = false;

-    }

-

-    temp = Rcpp::as<string>(Config[3]); //The Domain to allow variable bin sizes for (A, P, Both or Neither)

-    string fixedDomainStr = temp;

-    temp = Rcpp::as<string>(Config[4]); //Whether or not to run snapshots

-    bool SampleSnapshots;

-

-    if (temp == "TRUE" || temp == "true") {

-        SampleSnapshots = true;

-

-    } else {

-        SampleSnapshots = false;

-    }

-

-    tempNumInput = (ConfigNums[10]); //The number of snapshots saved during the Sampling (nSample/numSnapshots) increments

-    int numSnapshots = tempNumInput;

-    //Code to make the D and S matrices read from R into C++ vectors to make into Elana's Matrix Objects in Matrix.cpp

-    //Now also allows for variable bin sizes to be created

-    //Code to establish the sizes and initialize the C++ vectors to pass

-

-    //--------------------END CREATING D and S C++ VECTORS

-    // Parameters or structures to be calculated or constructed:

-    unsigned long nIterA = 10;    // initial inner loop iterations for A

-    unsigned long nIterP = 10;    // initial inner loop iterations for P

-    unsigned long atomicSize = 0; // number of atomic points

-

-    // Initialize the GibbsSampler.

-    GibbsSampler GibbsSamp(DMatrix, SMatrix, nFactor, alphaA, alphaP);

-

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

-    // Based on the information of D, construct and initialize for A and P both

-    // the matrices and atomic spaces.

-    //GibbsSamp.init_AMatrix_and_PMatrix(); // initialize A and P matrices

-    //This Section now is to handle the many possibilities for Variable Bin Sizes (Priors)

-    //A for variable A bins, P for variable P Bins, B for both and N for regular uniform bin sizes

-    char fixedDomain = fixedDomainStr[0];

-

-    // ===========================================================================

-    // Part 2) Equilibration:

-    // In this section, we let the system eqilibrate with nEquil outer loop

-    // iterations. Within each outer loop iteration, A is iterated nIterA times

-    // and P is iterated nIterP times. After equilibration, we update nIterA and

-    // nIterP according to the expected number of atoms in the atomic spaces

-    // of A and P respectively.

-    // ===========================================================================

-    double chi2;

-    double tempChiSq;

-    double tempAtomA;

-    double tempAtomP;

-    int outCount = 0;

-    int numOutputs = nObsR;                  //R'S OUTPUT CONTROL

-    int totalChiSize = nSample + nEquil;

-    Rcpp::NumericVector chiVect(totalChiSize); //INITIALIZE THE VECTOR HOLDING THE CHISQUARE.

-    Rcpp::NumericVector nAEquil(nEquil);       //INITIALIZE THE VECTOR HOLDING THE ATOMS FOR EACH MATRIX FOR EACH EQUIL/SAMP

-    Rcpp::NumericVector nASamp(nSample);

-    Rcpp::NumericVector nPEquil(nEquil);

-    Rcpp::NumericVector nPSamp(nSample);

-

-    for (unsigned long ext_iter = 1; ext_iter <= nEquil; ++ext_iter)

-    {

-        GibbsSamp.set_AnnealingTemperature();

-

-        for (unsigned long iterA = 1; iterA <= nIterA; ++iterA)

-        {

-            GibbsSamp.update('A');

-        }

-

-        for (unsigned long iterP = 1; iterP <= nIterP; ++iterP)

-        {

-            GibbsSamp.update('P');

-        }

-

-        //Finds the current ChiSq and places it into the vector to be returned to R (and output on occasion)

-        tempChiSq = GibbsSamp.get_sysChi2();

-        chiVect[(ext_iter) - 1] = tempChiSq;

-        // ----------- output computing info ---------

-        tempAtomA = GibbsSamp.getTotNumAtoms('A');

-        tempAtomP = GibbsSamp.getTotNumAtoms('P');

-        nAEquil[outCount] = tempAtomA;

-        nPEquil[outCount] = tempAtomP;

-        outCount++;

-

-        if (ext_iter % numOutputs == 0 && messages)

-        {

-            Rcpp::Rcout << "Equil:" << ext_iter << " of " << nEquil <<

-                        ", Atoms:" << tempAtomA << "("

-                        << tempAtomP << ")" <<

-                        "  Chi2 = " << tempChiSq << endl;

-        }

-

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

-        // re-calculate nIterA and nIterP to the expected number of atoms

-        nIterA = (unsigned long) Random::poisson(max((double) GibbsSamp.getTotNumAtoms('A'), 10.));

-        nIterP = (unsigned long) Random::poisson(max((double) GibbsSamp.getTotNumAtoms('P'), 10.));

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

-    }  // end of for-block for equilibration

-

-    // ===========================================================================

-    // Part 2.5) Equilibration Settling:

-    // Allow the Equilibration to settle for 10% of the set Equilibrations

-    // ===========================================================================

-    int nEquilCool = floor(.1 * nEquil);

-

-    for (unsigned long ext_iter = 1; ext_iter <= nEquilCool; ++ext_iter)