@@ -72,7 +72,7 @@ intersectRows <- function(..., subset.row=NULL, keep.all=FALSE) {

             stop("only character 'subset.row' is allowed when '...' have different rownames")

         }

         if (!keep.all) {

-            all.batches[[i]] <- lapply(all.batches, function(x) x[subset.row,,drop=FALSE])

+            all.batches <- lapply(all.batches, function(x) x[subset.row,,drop=FALSE])

         }

     }

@@ -66,11 +66,12 @@ quickCorrect <- function(...,

     assay.type="counts", 

     PARAM=FastMnnParam(), 

     multi.norm.args=list(),

-    precomputed.var=NULL,

+    precomputed=NULL,

     model.var.args=list(),

     hvg.args=list(n=5000))

 {

     all.batches <- intersectRows(...)

+    single.batch <- length(all.batches)==1L

     # Perform multibatchNorm.

     all.batches <- do.call(multiBatchNorm, c(

@@ -80,9 +81,9 @@ quickCorrect <- function(...,

     ))

     # Perform HVG calling within each batch.

-    if (is.null(precomputed.var)) {

-        if (length(all.batches) == 1) {

-            dec <- do.call(scran::modelGeneVar, c(list(all.batches[[1]], block=batch), model.var.args))

+    if (is.null(precomputed)) {

+        if (single.batch) { 

+            dec <- do.call(scran::modelGeneVar, c(list(all.batches, block=batch), model.var.args))

         } else {

             sub.dec <- vector("list", length(all.batches))

             for (i in seq_along(all.batches)) {

@@ -91,14 +92,17 @@ quickCorrect <- function(...,

             dec <- do.call(scran::combineVar, sub.dec)

         }

     } else {

-        if (length(precomputed.var)==length(all.batches)) {

-            stop("'length(precomputed.var)' is not the same as the number of objects in '...'")

-        }

-        if (length(all.batches) == 1) {

-            dec <- precomputed.var[[1]]

+        if (single.batch) {

+            if (length(precomputed)!=1L){ 

+                stop("'length(precomputed)' is not the same as the number of objects in '...'")

+            }

+            dec <- precomputed[[1]]

         } else {

+            if (length(precomputed)!=length(all.batches)) {

+                stop("'length(precomputed)' is not the same as the number of objects in '...'")

+            }

             universe <- rownames(all.batches[[1]])

-            sub.dec <- lapply(precomputed.var, function(x) x[universe,,drop=FALSE])

+            sub.dec <- lapply(precomputed, function(x) x[universe,,drop=FALSE])

             dec <- do.call(scran::combineVar, sub.dec)

         }

     }

@@ -12,7 +12,7 @@ quickCorrect(

   assay.type = "counts",

   PARAM = FastMnnParam(),

   multi.norm.args = list(),

-  precomputed.var = NULL,

+  precomputed = NULL,

   model.var.args = list(),

   hvg.args = list(n = 5000)

 )

@@ -45,14 +45,14 @@ and \linkS4class{RegressParam} will dispatch to \code{\link{regressBatches}}.}

 \item{multi.norm.args}{Named list of further arguments to pass to \code{\link{multiBatchNorm}}.}

+\item{precomputed}{List of \link{DataFrame}s containing precomputed variance modelling results.

+This should be a list of the same length as the number of entries in \code{...},

+and each should have the same row names as the corresponding entry of \code{...}.}

+

 \item{model.var.args}{Named list of further arguments to pass to \code{\link[scran]{modelGeneVar}}.}

 \item{hvg.args}{Named list of further arguments to pass to \code{\link[scran]{getTopHVGs}}.

 By default, we take the top 5000 genes with the highest variances.}

-

-\item{precomputed}{List of \link{DataFrame}s containing precomputed variance modelling results.

-This should be a list of the same length as the number of entries in \code{...},

-and each should have the same row names as the corresponding entry of \code{...}.}

 }

 \value{

 A list containing:

new file mode 100644

@@ -0,0 +1,52 @@

+# This tests the various quickCorrect functions.

+# library(testthat); library(batchelor); source("test-quick-correct.R")

+

+set.seed(100)

+d1 <- matrix(rnbinom(50000, mu=10, size=1), ncol=100)

+sce1 <- SingleCellExperiment(list(counts=d1))

+sizeFactors(sce1) <- runif(ncol(d1))

+rownames(sce1) <- paste0("GENE", 1:500)

+

+d2 <- matrix(rnbinom(20000, mu=50, size=1), ncol=40)

+sce2 <- SingleCellExperiment(list(counts=d2))

+sizeFactors(sce2) <- runif(ncol(d2))

+rownames(sce2) <- paste0("GENE", 201:700)

+

+set.seed(1000)

+output <- quickCorrect(sce1, sce2)

+universe <- intersect(rownames(sce1), rownames(sce2))

+

+test_that("quickCorrect works as expected", {

+    expect_identical(rownames(output$corrected), universe)

+

+    # Same results.

+    normed <- multiBatchNorm(sce1[universe,], sce2[universe,])

+    dec1 <- scran::modelGeneVar(normed[[1]])

+    dec2 <- scran::modelGeneVar(normed[[2]])

+

+    set.seed(1000)

+    pre <- quickCorrect(sce1, sce2, precomputed=list(dec1, dec2))

+    expect_equal(reducedDim(output$corrected), reducedDim(pre$corrected))

+

+    expect_error(quickCorrect(sce1, sce2, precomputed=list(dec2)), "not the same")

+})

+

+test_that("quickCorrect works with a single object", {

+    com <- cbind(sce1[universe,], sce2[universe,])

+    b <- rep(1:2, c(ncol(sce1), ncol(sce2)))

+

+    set.seed(1000)

+    single <- quickCorrect(com, batch=b)

+    expect_equal(reducedDim(output$corrected), reducedDim(single$corrected))

+

+    # Same results.

+    normed <- multiBatchNorm(com, batch=b)

+    dec <- scran::modelGeneVar(normed, block=b)

+

+    set.seed(1000)

+    pre <- quickCorrect(com, batch=b, precomputed=list(dec))

+    expect_equal(reducedDim(output$corrected), reducedDim(pre$corrected))

+

+    expect_error(quickCorrect(com, batch=b, precomputed=list(dec, dec)), "not the same")

+})

+