@@ -222,7 +222,7 @@ setMethod("celda_CG",

         verbose = TRUE) {

         # Convert to sparse matrix

-        x <- methods::as(x, "dgCMatrix")

+        x <- methods::as(x, "CsparseMatrix")

         ls <- list()

         ls[[useAssay]] <- x

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

 #'  Rows represent features and columns represent cells. Alternatively,

 #'  any matrix-like object that can be coerced to a sparse matrix of class

 #'  "dgCMatrix" can be directly used as input. The matrix will automatically be

-#'  converted to a \linkS4class{SingleCellExperiment} object. 

+#'  converted to a \linkS4class{SingleCellExperiment} object.

 #' @param useAssay A string specifying the name of the

 #'  \link{assay} slot to use. Default "counts".

 #' @param altExpName The name for the \link{altExp} slot

@@ -223,7 +223,7 @@ setMethod("celda_CG",

         # Convert to sparse matrix

         x <- methods::as(x, "dgCMatrix")

-      

+

         ls <- list()

         ls[[useAssay]] <- x

         sce <- SingleCellExperiment::SingleCellExperiment(assays = ls)

@@ -222,7 +222,7 @@ setMethod("celda_CG",

         verbose = TRUE) {

         # Convert to sparse matrix

-        x <- as(x, "dgCMatrix")

+        x <- methods::as(x, "dgCMatrix")

         ls <- list()

         ls[[useAssay]] <- x

@@ -6,11 +6,12 @@

 #'  it exists. Otherwise, the \code{useAssay}

 #'  \link{assay} slot in \code{x} will be used if

 #'  \code{x} is a \linkS4class{SingleCellExperiment} object.

-#' @param x A numeric \link{matrix} of counts or a

-#'  \linkS4class{SingleCellExperiment}

-#'  with the matrix located in the \link{assay}

-#'  slot under \code{useAssay} in \code{altExp(x, altExpName)}.

-#'  Rows represent features and columns represent cells.

+#' @param x A \linkS4class{SingleCellExperiment}

+#'  with the matrix located in the assay slot under \code{useAssay}.

+#'  Rows represent features and columns represent cells. Alternatively,

+#'  any matrix-like object that can be coerced to a sparse matrix of class

+#'  "dgCMatrix" can be directly used as input. The matrix will automatically be

+#'  converted to a \linkS4class{SingleCellExperiment} object. 

 #' @param useAssay A string specifying the name of the

 #'  \link{assay} slot to use. Default "counts".

 #' @param altExpName The name for the \link{altExp} slot

@@ -194,7 +195,7 @@ setMethod("celda_CG",

 #'     nchains = 1)

 #' @export

 setMethod("celda_CG",

-    signature(x = "matrix"),

+    signature(x = "ANY"),

     function(x,

         useAssay = "counts",

         altExpName = "featureSubset",

@@ -220,6 +221,9 @@ setMethod("celda_CG",

         logfile = NULL,

         verbose = TRUE) {

+        # Convert to sparse matrix

+        x <- as(x, "dgCMatrix")

+      

         ls <- list()

         ls[[useAssay]] <- x

         sce <- SingleCellExperiment::SingleCellExperiment(assays = ls)

@@ -943,8 +943,8 @@ setMethod("celda_CG",

     counts <- .processCounts(counts)

     K <- S4Vectors::metadata(sce)$celda_parameters$K

-    z <- SummarizedExperiment::colData(sce)$celda_cell_cluster

-    y <- SummarizedExperiment::rowData(sce)$celda_feature_module

+    z <- as.integer(SummarizedExperiment::colData(sce)$celda_cell_cluster)

+    y <- as.integer(SummarizedExperiment::rowData(sce)$celda_feature_module)

     L <- S4Vectors::metadata(sce)$celda_parameters$L

     alpha <- S4Vectors::metadata(sce)$celda_parameters$alpha

     beta <- S4Vectors::metadata(sce)$celda_parameters$beta

@@ -942,15 +942,29 @@ setMethod("celda_CG",

     counts <- SummarizedExperiment::assay(sce, i = useAssay)

     counts <- .processCounts(counts)

+    K <- S4Vectors::metadata(sce)$celda_parameters$K

+    z <- SummarizedExperiment::colData(sce)$celda_cell_cluster

+    y <- SummarizedExperiment::rowData(sce)$celda_feature_module

+    L <- S4Vectors::metadata(sce)$celda_parameters$L

+    alpha <- S4Vectors::metadata(sce)$celda_parameters$alpha

+    beta <- S4Vectors::metadata(sce)$celda_parameters$beta

+

+    delta <- S4Vectors::metadata(sce)$celda_parameters$delta

+    gamma <- S4Vectors::metadata(sce)$celda_parameters$gamma

+    sampleLabel <-

+        SummarizedExperiment::colData(sce)$celda_sample_label

+    cNames <- colnames(sce)

+    rNames <- rownames(sce)

+    sNames <- S4Vectors::metadata(sce)$celda_parameters$sampleLevels

+

     ## Checking if maxCells and minClusterSize will work

     if (!is.null(maxCells)) {

         if ((maxCells < ncol(counts)) &

-                (maxCells / minClusterSize <

-                        S4Vectors::metadata(sce)$celda_parameters$K)) {

+                (maxCells / minClusterSize < K)) {

             stop("Cannot distribute ",

                 maxCells,

                 " cells among ",

-                S4Vectors::metadata(sce)$celda_parameters$K,

+                K,

                 " clusters while maintaining a minumum of ",

                 minClusterSize,

                 " cells per cluster. Try increasing 'maxCells' or",

@@ -960,7 +974,21 @@ setMethod("celda_CG",

         maxCells <- ncol(counts)

     }

-    fm <- factorizeMatrix(x = sce, useAssay = useAssay, type = "counts")

+    fm <- .factorizeMatrixCG(

+        counts = counts,

+        K = K,

+        z = z,

+        y = y,

+        L = L,

+        alpha = alpha,

+        beta = beta,

+        delta = delta,

+        gamma = gamma,

+        sampleLabel = sampleLabel,

+        cNames = cNames,

+        rNames = rNames,

+        sNames = sNames,

+        type = "counts")

     modulesToUse <- seq(nrow(fm$counts$cell))

     if (!is.null(modules)) {

         if (!all(modules %in% modulesToUse)) {

@@ -976,8 +1004,7 @@ setMethod("celda_CG",

     zInclude <- rep(TRUE, ncol(counts))

     if (totalCellsToRemove > 0) {

-        zTa <- tabulate(SummarizedExperiment::colData(sce)$celda_cell_cluster,

-            S4Vectors::metadata(sce)$celda_parameters$K)

+        zTa <- tabulate(z, K)

         ## Number of cells that can be sampled from each cluster without

         ## going below the minimum threshold

@@ -995,11 +1022,7 @@ setMethod("celda_CG",

         ## Perform sampling for each cluster

         for (i in which(clusterNToSample > 0)) {

-            zInclude[sample(

-                which(SummarizedExperiment::colData(sce)$celda_cell_cluster ==

-                        i),

-                clusterNToSample[i]

-            )] <- FALSE

+            zInclude[sample(which(z == i), clusterNToSample[i])] <- FALSE

         }

     }

     cellIx <- which(zInclude)

@@ -68,7 +68,6 @@

 #' @param logfile Character. Messages will be redirected to a file named

 #'  `logfile`. If NULL, messages will be printed to stdout.  Default NULL.

 #' @param verbose Logical. Whether to print log messages. Default TRUE.

-#' @param ... Ignored. Placeholder to prevent check warning.

 #' @return A \linkS4class{SingleCellExperiment} object. Function

 #'  parameter settings are stored in \link{metadata}

 #'  \code{"celda_parameters"} in \link{altExp} slot.

@@ -82,7 +81,31 @@

 #'  values of K/L and multiple chains in parallel.

 #' @import Rcpp RcppEigen

 #' @export

-setGeneric("celda_CG", function(x, ...) {

+setGeneric("celda_CG",

+    function(x,

+        useAssay = "counts",

+        altExpName = "featureSubset",

+        sampleLabel = NULL,

+        K,

+        L,

+        alpha = 1,

+        beta = 1,

+        delta = 1,

+        gamma = 1,

+        algorithm = c("EM", "Gibbs"),

+        stopIter = 10,

+        maxIter = 200,

+        splitOnIter = 10,

+        splitOnLast = TRUE,

+        seed = 12345,

+        nchains = 3,

+        zInitialize = c("split", "random", "predefined"),

+        yInitialize = c("split", "random", "predefined"),

+        countChecksum = NULL,

+        zInit = NULL,

+        yInit = NULL,

+        logfile = NULL,

+        verbose = TRUE) {

     standardGeneric("celda_CG")})

@@ -937,7 +937,7 @@ setMethod("celda_CG",

         maxCells <- ncol(counts)

     }

-    fm <- .factorizeMatrixCelda_CG(sce, useAssay, type = "counts")

+    fm <- factorizeMatrix(x = sce, useAssay = useAssay, type = "counts")

     modulesToUse <- seq(nrow(fm$counts$cell))

     if (!is.null(modules)) {

         if (!all(modules %in% modulesToUse)) {

@@ -1041,11 +1041,11 @@ setMethod("celda_CG",

     SummarizedExperiment::colData(sce)["colnames"] <-

         celdaCGMod@names$column

     SummarizedExperiment::colData(sce)["celda_sample_label"] <-

-        celdaCGMod@sampleLabel

+        as.factor(celdaCGMod@sampleLabel)

     SummarizedExperiment::colData(sce)["celda_cell_cluster"] <-

-        celdaClusters(celdaCGMod)$z

+        as.factor(celdaClusters(celdaCGMod)$z)

     SummarizedExperiment::rowData(sce)["celda_feature_module"] <-

-        celdaClusters(celdaCGMod)$y

+        as.factor(celdaClusters(celdaCGMod)$y)

     return(sce)

 }

@@ -379,7 +379,7 @@ setMethod("celda_CG",

   startTime <- Sys.time()

-  #counts <- .processCounts(counts)

+  counts <- .processCounts(counts)

   if (is.null(countChecksum)) {

     countChecksum <- .createCountChecksum(counts)

   }

@@ -917,7 +917,7 @@ setMethod("celda_CG",

     transformationFun) {

     counts <- SummarizedExperiment::assay(sce, i = useAssay)

-    #counts <- .processCounts(counts)

+    counts <- .processCounts(counts)

     ## Checking if maxCells and minClusterSize will work

     if (!is.null(maxCells)) {

@@ -871,6 +871,7 @@ setMethod("celda_CG",

 # @param y Numeric vector. Denotes feature module labels.

 # @param K Integer. Number of cell populations.

 # @param L Integer. Number of feature modules.

+#' @importFrom Matrix colSums rowSums

 .cCGDecomposeCounts <- function(counts, s, z, y, K, L) {

   nS <- length(unique(s))

   mCPByS <- matrix(as.integer(table(factor(z, levels = seq(K)), s)),

@@ -880,14 +881,9 @@ setMethod("celda_CG",

   nTSByC <- .rowSumByGroup(counts, group = y, L = L)

   nGByCP <- .colSumByGroup(counts, group = z, K = K)

   nTSByCP <- .colSumByGroup(nTSByC, group = z, K = K)

-  

-  if (inherits(counts, "dgCMatrix")) {

-    nByC <- Matrix::colSums(counts)

-    nByG <- Matrix::rowSums(counts)

-  } else {

-    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

-    nByC <- .colSums(counts, nrow(counts), ncol(counts))

-  }

+

+  nByC <- colSums(counts)

+  nByG <- rowSums(counts)

   nByTS <- .rowSumByGroup(matrix(nByG, ncol = 1), group = y, L = L)

   nCP <- .colSums(nTSByCP, nrow(nTSByCP), ncol(nTSByCP))

   nGByTS <- tabulate(y, L) + 1 ## Add pseudogene to each module

@@ -379,7 +379,7 @@ setMethod("celda_CG",

   startTime <- Sys.time()

-  counts <- .processCounts(counts)

+  #counts <- .processCounts(counts)

   if (is.null(countChecksum)) {

     countChecksum <- .createCountChecksum(counts)

   }

@@ -554,20 +554,7 @@ setMethod("celda_CG",

       mCPByS <- nextZ$mCPByS

       nTSByCP <- nextZ$nGByCP

       nCP <- nextZ$nCP

-      

-      # Also need to recalculate nGByCP based on new label

-      # This could be done by '.cCReDecomposeCounts', however that also 

-      # calculates additional variables, so just the relevant code for nGByCP

-      # is here.

-      if (inherits(counts, "matrix") & is.integer(counts)) {

-        nGByCP <- .colSumByGroupChange(counts, nGByCP, z, previousZ, K)

-      } else if (inherits(counts, "matrix") & is.numeric(counts)) {

-        nGByCP <- .colSumByGroupChangeNumeric(counts, nGByCP, z, previousZ, K)

-      } else if (inherits(counts, "dgCMatrix")) {

-        nGByCP <- colSumByGroupChangeSparse(counts, nGByCP, group = z,

-                                            pgroup = previousZ)

-      }

-      

+      nGByCP <- .colSumByGroupChange(counts, nGByCP, nextZ$z, z, K)

       z <- nextZ$z

       ## Perform split on i-th iteration defined by splitOnIter

@@ -642,20 +629,7 @@ setMethod("celda_CG",

         nTSByCP <- res$nTSByCP

         nByTS <- res$nByTS

         nGByTS <- res$nGByTS

-        

-        # Also need to recalculate nTSByC based on new label

-        # This could be done by '.cGReDecomposeCounts', however that also 

-        # calculates additional variables, so just the relevant code for nTSByC

-        # is here.

-        if (inherits(counts, "matrix") & is.integer(counts)) {

-          nTSByC <- .rowSumByGroupChange(counts, nTSByC, y, previousY, L)

-        } else if (inherits(counts, "matrix") & is.numeric(counts)) {

-          nTSByC <- .rowSumByGroupChangeNumeric(counts, nTSByC, y, previousY, L)

-        } else if (inherits(counts, "dgCMatrix")) {

-          nTSByC <- rowSumByGroupChangeSparse(counts, nTSByC, y, previousY)

-        } else {

-          stop("'counts' must be an integer, numeric, or dgCMatrix matrix.")

-        }

+        nTSByC <- .rowSumByGroup(counts, group = y, L = L)

       }

       if (K > 2 & iter != maxIter &

@@ -902,30 +876,19 @@ setMethod("celda_CG",

   mCPByS <- matrix(as.integer(table(factor(z, levels = seq(K)), s)),

     ncol = nS

   )

-  if (inherits(counts, "matrix") & is.integer(counts)) {

-    nTSByC <- .rowSumByGroup(counts, group = y, L = L)

-    nGByCP <- .colSumByGroup(counts, group = z, K = K)

-    nTSByCP <- .colSumByGroup(nTSByC, group = z, K = K)

-    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

-    nByC <- .colSums(counts, nrow(counts), ncol(counts))

-    nByTS <- .rowSumByGroup(matrix(nByG, ncol = 1), group = y, L = L)

-  } else if (inherits(counts, "matrix") & is.numeric(counts)) {

-    nTSByC <- .rowSumByGroupNumeric(counts, group = y, L = L)

-    nGByCP <- .colSumByGroupNumeric(counts, group = z, K = K)

-    nTSByCP <- .colSumByGroupNumeric(nTSByC, group = z, K = K)

-    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

-    nByC <- .colSums(counts, nrow(counts), ncol(counts))

-    nByTS <- .rowSumByGroupNumeric(matrix(nByG, ncol = 1), group = y, L = L)

-  } else if (inherits(counts, "dgCMatrix")) {

-    nTSByC <- rowSumByGroupSparse(counts, group = y)

-    nGByCP <- .colSumByGroupSparse(counts, group = z)

-    nByTS <- .rowSumByGroupNumeric(matrix(nByG, ncol = 1), group = y, L = L)

-    nTSByCP <- colSumByGroupSparse(nTSByC, group = z)

+

+  nTSByC <- .rowSumByGroup(counts, group = y, L = L)

+  nGByCP <- .colSumByGroup(counts, group = z, K = K)

+  nTSByCP <- .colSumByGroup(nTSByC, group = z, K = K)

+  

+  if (inherits(counts, "dgCMatrix")) {

     nByC <- Matrix::colSums(counts)

     nByG <- Matrix::rowSums(counts)

   } else {

-    stop("'counts' must be an integer, numeric, or dgCMatrix matrix.")

+    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

+    nByC <- .colSums(counts, nrow(counts), ncol(counts))

   }

+  nByTS <- .rowSumByGroup(matrix(nByG, ncol = 1), group = y, L = L)

   nCP <- .colSums(nTSByCP, nrow(nTSByCP), ncol(nTSByCP))

   nGByTS <- tabulate(y, L) + 1 ## Add pseudogene to each module

   nG <- nrow(counts)

@@ -554,7 +554,20 @@ setMethod("celda_CG",

       mCPByS <- nextZ$mCPByS

       nTSByCP <- nextZ$nGByCP

       nCP <- nextZ$nCP

-      nGByCP <- .colSumByGroupChange(counts, nGByCP, nextZ$z, z, K)

+      

+      # Also need to recalculate nGByCP based on new label

+      # This could be done by '.cCReDecomposeCounts', however that also 

+      # calculates additional variables, so just the relevant code for nGByCP

+      # is here.

+      if (inherits(counts, "matrix") & is.integer(counts)) {

+        nGByCP <- .colSumByGroupChange(counts, nGByCP, z, previousZ, K)

+      } else if (inherits(counts, "matrix") & is.numeric(counts)) {

+        nGByCP <- .colSumByGroupChangeNumeric(counts, nGByCP, z, previousZ, K)

+      } else if (inherits(counts, "dgCMatrix")) {

+        nGByCP <- colSumByGroupChangeSparse(counts, nGByCP, group = z,

+                                            pgroup = previousZ)

+      }

+      

       z <- nextZ$z

       ## Perform split on i-th iteration defined by splitOnIter

@@ -629,7 +642,20 @@ setMethod("celda_CG",

         nTSByCP <- res$nTSByCP

         nByTS <- res$nByTS

         nGByTS <- res$nGByTS

-        nTSByC <- .rowSumByGroup(counts, group = y, L = L)

+        

+        # Also need to recalculate nTSByC based on new label

+        # This could be done by '.cGReDecomposeCounts', however that also 

+        # calculates additional variables, so just the relevant code for nTSByC

+        # is here.

+        if (inherits(counts, "matrix") & is.integer(counts)) {

+          nTSByC <- .rowSumByGroupChange(counts, nTSByC, y, previousY, L)

+        } else if (inherits(counts, "matrix") & is.numeric(counts)) {

+          nTSByC <- .rowSumByGroupChangeNumeric(counts, nTSByC, y, previousY, L)

+        } else if (inherits(counts, "dgCMatrix")) {

+          nTSByC <- rowSumByGroupChangeSparse(counts, nTSByC, y, previousY)

+        } else {

+          stop("'counts' must be an integer, numeric, or dgCMatrix matrix.")

+        }

       }

       if (K > 2 & iter != maxIter &

@@ -876,17 +902,32 @@ setMethod("celda_CG",

   mCPByS <- matrix(as.integer(table(factor(z, levels = seq(K)), s)),

     ncol = nS

   )

-  nTSByC <- .rowSumByGroup(counts, group = y, L = L)

-  nTSByCP <- .colSumByGroup(nTSByC, group = z, K = K)

-  nCP <- as.integer(colSums(nTSByCP))

-  nByG <- as.integer(rowSums(counts))

-  nByC <- as.integer(colSums(counts))

-  nByTS <- as.integer(.rowSumByGroup(matrix(nByG, ncol = 1),

-    group = y, L = L

-  ))

+  if (inherits(counts, "matrix") & is.integer(counts)) {

+    nTSByC <- .rowSumByGroup(counts, group = y, L = L)

+    nGByCP <- .colSumByGroup(counts, group = z, K = K)

+    nTSByCP <- .colSumByGroup(nTSByC, group = z, K = K)

+    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

+    nByC <- .colSums(counts, nrow(counts), ncol(counts))

+    nByTS <- .rowSumByGroup(matrix(nByG, ncol = 1), group = y, L = L)

+  } else if (inherits(counts, "matrix") & is.numeric(counts)) {

+    nTSByC <- .rowSumByGroupNumeric(counts, group = y, L = L)

+    nGByCP <- .colSumByGroupNumeric(counts, group = z, K = K)

+    nTSByCP <- .colSumByGroupNumeric(nTSByC, group = z, K = K)

+    nByG <- .rowSums(counts, nrow(counts), ncol(counts))

+    nByC <- .colSums(counts, nrow(counts), ncol(counts))

+    nByTS <- .rowSumByGroupNumeric(matrix(nByG, ncol = 1), group = y, L = L)

+  } else if (inherits(counts, "dgCMatrix")) {

+    nTSByC <- rowSumByGroupSparse(counts, group = y)

+    nGByCP <- .colSumByGroupSparse(counts, group = z)

+    nByTS <- .rowSumByGroupNumeric(matrix(nByG, ncol = 1), group = y, L = L)

+    nTSByCP <- colSumByGroupSparse(nTSByC, group = z)

+    nByC <- Matrix::colSums(counts)

+    nByG <- Matrix::rowSums(counts)

+  } else {

+    stop("'counts' must be an integer, numeric, or dgCMatrix matrix.")

+  }

+  nCP <- .colSums(nTSByCP, nrow(nTSByCP), ncol(nTSByCP))

   nGByTS <- tabulate(y, L) + 1 ## Add pseudogene to each module

-  nGByCP <- .colSumByGroup(counts, group = z, K = K)

-

   nG <- nrow(counts)

   nM <- ncol(counts)

@@ -917,7 +958,7 @@ setMethod("celda_CG",

     transformationFun) {

     counts <- SummarizedExperiment::assay(sce, i = useAssay)

-    counts <- .processCounts(counts)

+    #counts <- .processCounts(counts)

     ## Checking if maxCells and minClusterSize will work

     if (!is.null(maxCells)) {

@@ -576,7 +576,7 @@ setMethod("celda_CG",

       if (L > 2 & iter != maxIter &

         (((numIterWithoutImprovement == stopIter &

-          !all(tempLl > ll)) & isTRUE(splitOnLast)) |

+          !all(tempLl >= ll)) & isTRUE(splitOnLast)) |

           (splitOnIter > 0 & iter %% splitOnIter == 0 &

             isTRUE(doGeneSplit)))) {

         .logMessages(date(),

@@ -62,7 +62,7 @@

 #' @param zInit Integer vector. Sets initial starting values of z. 'zInit'

 #'  is only used when `zInitialize = 'predfined'`. Default NULL.

 #' @param yInit Integer vector. Sets initial starting values of y.

-#'  'yInit' is only be used when \code{yInitialize = "random"}. Default NULL.

+#'  'yInit' is only be used when `yInitialize = "predefined"`. Default NULL.

 #' @param countChecksum Character. An MD5 checksum for the counts matrix.

 #'  Default NULL.

 #' @param logfile Character. Messages will be redirected to a file named

@@ -51,20 +51,18 @@

 #' @param nchains Integer. Number of random cluster initializations. Default 3.

 #' @param zInitialize Chararacter. One of 'random', 'split', or 'predefined'.

 #'  With 'random', cells are randomly assigned to a populations. With 'split',

-#'  cells will be split into sqrt(K) populations and then each popluation will

+#'  cells will be split into sqrt(K) populations and then each population will

 #'  be subsequently split into another sqrt(K) populations. With 'predefined',

 #'  values in \code{zInit} will be used to initialize \code{z}. Default 'split'.

-#' @param yInitialize Chararacter. One of 'random', 'split', or 'predefined'.

+#' @param yInitialize Character. One of 'random', 'split', or 'predefined'.

 #'  With 'random', features are randomly assigned to a modules. With 'split',

 #'  features will be split into sqrt(L) modules and then each module will be

 #'  subsequently split into another sqrt(L) modules. With 'predefined', values

 #'  in \code{yInit} will be used to initialize \code{y}. Default 'split'.

-#' @param zInit Integer vector. Sets initial starting values of z. If NULL,

-#'  starting values for each cell will be randomly sampled from 1:K. 'zInit'

-#'  can only be used when \code{initialize = "random"}. Default NULL.

-#' @param yInit Integer vector. Sets initial starting values of y. If NULL,

-#'  starting values for each feature will be randomly sampled from 1:L.

-#'  'yInit' can only be used when \code{initialize = "random"}. Default NULL.

+#' @param zInit Integer vector. Sets initial starting values of z. 'zInit'

+#'  is only used when `zInitialize = 'predfined'`. Default NULL.

+#' @param yInit Integer vector. Sets initial starting values of y.

+#'  'yInit' is only be used when \code{yInitialize = "random"}. Default NULL.

 #' @param countChecksum Character. An MD5 checksum for the counts matrix.

 #'  Default NULL.

 #' @param logfile Character. Messages will be redirected to a file named

@@ -909,33 +909,6 @@ setMethod("celda_CG",

 }

-.reorderCeldaCG <- function(counts, res) {

-    # Reorder K

-    if (params(res)$K > 2 & isTRUE(length(unique(celdaClusters(res)$z)) > 1)) {

-        res@clusters$z <- as.integer(as.factor(celdaClusters(res)$z))

-        fm <- factorizeMatrix(counts, res, type = "posterior")

-        uniqueZ <- sort(unique(celdaClusters(res)$z))

-        d <- .cosineDist(fm$posterior$cellPopulation[, uniqueZ])

-        h <- stats::hclust(d, method = "complete")

-

-        res <- .recodeClusterZ(res, from = h$order, to = seq(length(h$order)))

-    }

-

-    # Reorder L

-    if (params(res)$L > 2 & isTRUE(length(unique(celdaClusters(res)$y)) > 1)) {

-        res@clusters$y <- as.integer(as.factor(celdaClusters(res)$y))

-        fm <- factorizeMatrix(counts, res, type = "posterior")

-        uniqueY <- sort(unique(celdaClusters(res)$y))

-        cs <- prop.table(t(fm$posterior$cellPopulation[uniqueY, ]), 2)

-        d <- .cosineDist(cs)

-        h <- stats::hclust(d, method = "complete")

-

-        res <- .recodeClusterY(res, from = h$order, to = seq(length(h$order)))

-    }

-    return(res)

-}

-

-

 .prepareCountsForDimReductionCeldaCG <- function(sce,

     useAssay,

     maxCells,

@@ -1,19 +1,19 @@

 #' @title Cell and feature clustering with Celda

 #' @description Clusters the rows and columns of a count matrix containing

 #'  single-cell data into L modules and K subpopulations, respectively. The

-#'  \code{useAssay} \link[SummarizedExperiment]{assay} slot in

-#'  \code{altExpName} \link[SingleCellExperiment]{altExp} slot will be used if

+#'  \code{useAssay} \link{assay} slot in

+#'  \code{altExpName} \link{altExp} slot will be used if

 #'  it exists. Otherwise, the \code{useAssay}

-#'  \link[SummarizedExperiment]{assay} slot in \code{x} will be used if

+#'  \link{assay} slot in \code{x} will be used if

 #'  \code{x} is a \linkS4class{SingleCellExperiment} object.

 #' @param x A numeric \link{matrix} of counts or a

 #'  \linkS4class{SingleCellExperiment}

-#'  with the matrix located in the \link[SummarizedExperiment]{assay}

+#'  with the matrix located in the \link{assay}

 #'  slot under \code{useAssay} in \code{altExp(x, altExpName)}.

 #'  Rows represent features and columns represent cells.

 #' @param useAssay A string specifying the name of the

-#'  \link[SummarizedExperiment]{assay} slot to use. Default "counts".

-#' @param altExpName The name for the \link[SingleCellExperiment]{altExp} slot

+#'  \link{assay} slot to use. Default "counts".

+#' @param altExpName The name for the \link{altExp} slot

 #'  to use. Default "featureSubset".

 #' @param sampleLabel Vector or factor. Denotes the sample label for each cell

 #'  (column) in the count matrix.

@@ -35,11 +35,12 @@

 #'  likelihood to stop inference. Default 10.

 #' @param maxIter Integer. Maximum number of iterations of Gibbs sampling to

 #'  perform. Default 200.

-#' @param splitOnIter Integer. On every `splitOnIter` iteration, a heuristic

+#' @param splitOnIter Integer. On every \code{splitOnIter} iteration,

+#'  a heuristic

 #'  will be applied to determine if a cell population or feature module should

 #'  be reassigned and another cell population or feature module should be split

 #'  into two clusters. To disable splitting, set to -1. Default 10.

-#' @param splitOnLast Integer. After `stopIter` iterations have been

+#' @param splitOnLast Integer. After \code{stopIter} iterations have been

 #'  performed without improvement, a heuristic will be applied to determine if

 #'  a cell population or feature module should be reassigned and another cell

 #'  population or feature module should be split into two clusters. If a split

@@ -52,32 +53,32 @@

 #'  With 'random', cells are randomly assigned to a populations. With 'split',

 #'  cells will be split into sqrt(K) populations and then each popluation will

 #'  be subsequently split into another sqrt(K) populations. With 'predefined',

-#'  values in `zInit` will be used to initialize `z`. Default 'split'.

+#'  values in \code{zInit} will be used to initialize \code{z}. Default 'split'.

 #' @param yInitialize Chararacter. One of 'random', 'split', or 'predefined'.

 #'  With 'random', features are randomly assigned to a modules. With 'split',

 #'  features will be split into sqrt(L) modules and then each module will be

 #'  subsequently split into another sqrt(L) modules. With 'predefined', values

-#'  in `yInit` will be used to initialize `y`. Default 'split'.

+#'  in \code{yInit} will be used to initialize \code{y}. Default 'split'.

 #' @param zInit Integer vector. Sets initial starting values of z. If NULL,

 #'  starting values for each cell will be randomly sampled from 1:K. 'zInit'

-#'  can only be used when `initialize' = 'random'`. Default NULL.

+#'  can only be used when \code{initialize = "random"}. Default NULL.

 #' @param yInit Integer vector. Sets initial starting values of y. If NULL,

 #'  starting values for each feature will be randomly sampled from 1:L.

-#'  'yInit' can only be used when `initialize = 'random'`. Default NULL.

-#' @param countChecksum Character. An MD5 checksum for the `counts` matrix.

+#'  'yInit' can only be used when \code{initialize = "random"}. Default NULL.

+#' @param countChecksum Character. An MD5 checksum for the counts matrix.

 #'  Default NULL.

 #' @param logfile Character. Messages will be redirected to a file named

 #'  `logfile`. If NULL, messages will be printed to stdout.  Default NULL.

 #' @param verbose Logical. Whether to print log messages. Default TRUE.

 #' @param ... Ignored. Placeholder to prevent check warning.

 #' @return A \linkS4class{SingleCellExperiment} object. Function

-#'  parameter settings are stored in \link[S4Vectors]{metadata}

-#'  \code{"celda_parameters"} in \link[SingleCellExperiment]{altExp} slot.

-#'  In \link[SingleCellExperiment]{altExp} slot,

+#'  parameter settings are stored in \link{metadata}

+#'  \code{"celda_parameters"} in \link{altExp} slot.

+#'  In \link{altExp} slot,

 #'  columns \code{celda_sample_label} and \code{celda_cell_cluster} in

-#'  \link[SummarizedExperiment]{colData} contain sample labels and celda cell

+#'  \link{colData} contain sample labels and celda cell

 #'  population clusters. Column \code{celda_feature_module} in

-#'  \link[SummarizedExperiment]{rowData} contains feature modules.

+#'  \link{rowData} contains feature modules.

 #' @seealso \link{celda_G} for feature clustering and \link{celda_C} for

 #'  clustering cells. \link{celdaGridSearch} can be used to run multiple

 #'  values of K/L and multiple chains in parallel.

@@ -69,6 +69,7 @@

 #' @param logfile Character. Messages will be redirected to a file named

 #'  `logfile`. If NULL, messages will be printed to stdout.  Default NULL.

 #' @param verbose Logical. Whether to print log messages. Default TRUE.

+#' @param ... Ignored. Placeholder to prevent check warning.

 #' @return A \linkS4class{SingleCellExperiment} object. Function

 #'  parameter settings are stored in \link[S4Vectors]{metadata}

 #'  \code{"celda_parameters"} in \link[SingleCellExperiment]{altExp} slot.

@@ -81,7 +81,6 @@

 #'  clustering cells. \link{celdaGridSearch} can be used to run multiple

 #'  values of K/L and multiple chains in parallel.

 #' @import Rcpp RcppEigen

-#' @rawNamespace import(gridExtra, except = c(combine))

 #' @export

 setGeneric("celda_CG", function(x, ...) {

     standardGeneric("celda_CG")})

@@ -1,13 +1,20 @@

 #' @title Cell and feature clustering with Celda

 #' @description Clusters the rows and columns of a count matrix containing

-#'  single-cell data into L modules and K subpopulations, respectively.

+#'  single-cell data into L modules and K subpopulations, respectively. The

+#'  \code{useAssay} \link[SummarizedExperiment]{assay} slot in

+#'  \code{altExpName} \link[SingleCellExperiment]{altExp} slot will be used if

+#'  it exists. Otherwise, the \code{useAssay}

+#'  \link[SummarizedExperiment]{assay} slot in \code{x} will be used if

+#'  \code{x} is a \linkS4class{SingleCellExperiment} object.

 #' @param x A numeric \link{matrix} of counts or a

 #'  \linkS4class{SingleCellExperiment}

-#'  with the matrix located in the assay slot under \code{useAssay}.

+#'  with the matrix located in the \link[SummarizedExperiment]{assay}

+#'  slot under \code{useAssay} in \code{altExp(x, altExpName)}.

 #'  Rows represent features and columns represent cells.

-#' @param useAssay A string specifying which \link[SummarizedExperiment]{assay}

-#'  slot to use if \code{x} is a

-#'  \linkS4class{SingleCellExperiment} object. Default "counts".

+#' @param useAssay A string specifying the name of the

+#'  \link[SummarizedExperiment]{assay} slot to use. Default "counts".

+#' @param altExpName The name for the \link[SingleCellExperiment]{altExp} slot

+#'  to use. Default "featureSubset".

 #' @param sampleLabel Vector or factor. Denotes the sample label for each cell

 #'  (column) in the count matrix.

 #' @param K Integer. Number of cell populations.

@@ -62,23 +69,17 @@

 #' @param logfile Character. Messages will be redirected to a file named

 #'  `logfile`. If NULL, messages will be printed to stdout.  Default NULL.

 #' @param verbose Logical. Whether to print log messages. Default TRUE.

-#' @return A \link[SingleCellExperiment]{SingleCellExperiment} object. Function

-#'  parameter settings are stored in the \link[S4Vectors]{metadata}

-#'  \code{"celda_parameters"} slot.

-#'  Columns \code{celda_sample_label} and \code{celda_cell_cluster} in

+#' @return A \linkS4class{SingleCellExperiment} object. Function

+#'  parameter settings are stored in \link[S4Vectors]{metadata}

+#'  \code{"celda_parameters"} in \link[SingleCellExperiment]{altExp} slot.

+#'  In \link[SingleCellExperiment]{altExp} slot,

+#'  columns \code{celda_sample_label} and \code{celda_cell_cluster} in

 #'  \link[SummarizedExperiment]{colData} contain sample labels and celda cell

 #'  population clusters. Column \code{celda_feature_module} in

 #'  \link[SummarizedExperiment]{rowData} contains feature modules.

 #' @seealso \link{celda_G} for feature clustering and \link{celda_C} for

 #'  clustering cells. \link{celdaGridSearch} can be used to run multiple

 #'  values of K/L and multiple chains in parallel.

-#' @examples

-#' data(celdaCGSim)

-#' sce <- celda_CG(celdaCGSim$counts,

-#'     K = celdaCGSim$K,

-#'     L = celdaCGSim$L,

-#'     sampleLabel = celdaCGSim$sampleLabel,

-#'     nchains = 1)

 #' @import Rcpp RcppEigen

 #' @rawNamespace import(gridExtra, except = c(combine))

 #' @export

@@ -92,6 +93,7 @@ setMethod("celda_CG",

     signature(x = "SingleCellExperiment"),

     function(x,

         useAssay = "counts",

+        altExpName = "featureSubset",

         sampleLabel = NULL,

         K,

         L,

@@ -115,12 +117,24 @@ setMethod("celda_CG",

         verbose = TRUE) {

         xClass <- "SingleCellExperiment"

-        counts <- SummarizedExperiment::assay(x, i = useAssay)

-        sce <- .celdaCGWithSeed(counts = counts,

+        if (!altExpName %in% SingleCellExperiment::altExpNames(x)) {

+            stop(altExpName, " not in 'altExpNames(x)'. Run ",

+                "selectFeatures(x) first!")

+        }

+

+        altExp <- SingleCellExperiment::altExp(x, altExpName)

+

+        if (!useAssay %in% SummarizedExperiment::assayNames(altExp)) {

+            stop(useAssay, " not in assayNames(altExp(x, altExpName))")

+        }

+

+        counts <- SummarizedExperiment::assay(altExp, i = useAssay)

+

+        altExp <- .celdaCGWithSeed(counts = counts,

             xClass = xClass,

             useAssay = useAssay,

-            sce = x,

+            sce = altExp,

             sampleLabel = sampleLabel,

             K = K,

             L = L,

@@ -142,16 +156,26 @@ setMethod("celda_CG",

             yInit = yInit,

             logfile = logfile,

             verbose = verbose)

-        return(sce)

+        SingleCellExperiment::altExp(x, altExpName) <- altExp

+        return(x)

     }

 )

 #' @rdname celda_CG

+#' @examples

+#' data(celdaCGSim)

+#' sce <- celda_CG(celdaCGSim$counts,

+#'     K = celdaCGSim$K,

+#'     L = celdaCGSim$L,

+#'     sampleLabel = celdaCGSim$sampleLabel,

+#'     nchains = 1)

 #' @export

 setMethod("celda_CG",

     signature(x = "matrix"),

     function(x,

+        useAssay = "counts",

+        altExpName = "featureSubset",

         sampleLabel = NULL,

         K,

         L,

@@ -174,14 +198,16 @@ setMethod("celda_CG",

         logfile = NULL,

         verbose = TRUE) {

+        ls <- list()

+        ls[[useAssay]] <- x

+        sce <- SingleCellExperiment::SingleCellExperiment(assays = ls)

+        SingleCellExperiment::altExp(sce, altExpName) <- sce

         xClass <- "matrix"

-        useAssay <- NULL

-        sce <- SingleCellExperiment::SingleCellExperiment(

-            assays = list(counts = x))

-        sce <- .celdaCGWithSeed(counts = x,

+

+        altExp <- .celdaCGWithSeed(counts = x,

             xClass = xClass,

             useAssay = useAssay,

-            sce = sce,

+            sce = SingleCellExperiment::altExp(sce, altExpName),

             sampleLabel = sampleLabel,

             K = K,

             L = L,

@@ -203,6 +229,7 @@ setMethod("celda_CG",

             yInit = yInit,

             logfile = logfile,

             verbose = verbose)

+        SingleCellExperiment::altExp(sce, altExpName) <- altExp

         return(sce)

     }

 )

@@ -938,9 +965,7 @@ setMethod("celda_CG",

         maxCells <- ncol(counts)

     }

-    fm <- factorizeMatrix(sce,

-        useAssay,

-        type = "counts")

+    fm <- .factorizeMatrixCelda_CG(sce, useAssay, type = "counts")

     modulesToUse <- seq(nrow(fm$counts$cell))

     if (!is.null(modules)) {

         if (!all(modules %in% modulesToUse)) {

@@ -956,7 +981,7 @@ setMethod("celda_CG",

     zInclude <- rep(TRUE, ncol(counts))

     if (totalCellsToRemove > 0) {

-        zTa <- tabulate(celdaClusters(sce),

+        zTa <- tabulate(SummarizedExperiment::colData(sce)$celda_cell_cluster,

             S4Vectors::metadata(sce)$celda_parameters$K)

         ## Number of cells that can be sampled from each cluster without

@@ -976,7 +1001,8 @@ setMethod("celda_CG",

         ## Perform sampling for each cluster

         for (i in which(clusterNToSample > 0)) {

             zInclude[sample(

-                which(celdaClusters(sce) == i),

+                which(SummarizedExperiment::colData(sce)$celda_cell_cluster ==

+                        i),

                 clusterNToSample[i]

             )] <- FALSE

         }

@@ -912,7 +912,10 @@ setMethod("celda_CG",

     useAssay,

     maxCells,

     minClusterSize,

-    modules) {

+    modules,

+    normalize,

+    scaleFactor,

+    transformationFun) {

     counts <- SummarizedExperiment::assay(sce, i = useAssay)

     counts <- .processCounts(counts)

@@ -981,9 +984,9 @@ setMethod("celda_CG",

     cellIx <- which(zInclude)

     norm <- t(normalizeCounts(fm$counts$cell[modulesToUse, cellIx],

-        normalize = "proportion",

-        transformationFun = sqrt

-    ))

+        normalize = normalize,

+        scaleFactor = scaleFactor,

+        transformationFun = transformationFun))

     return(list(norm = norm, cellIx = cellIx))

 }