test

Author: fspecque

R/bbknn.R

@@ -203,7 +203,7 @@ bbknnIntegration <- function(
       Matrix::t(x = scaled.mat)
     ),
     obs = reticulate::r_to_py(x = groups[, groups.name, drop = FALSE]),
-    var = reticulate::r_to_py(x = features)
+    var = r_to_py(data.frame(features = features))
   )
   adata$X = adata$X$toarray()
   adata$obsm["X_pca"] = reticulate::r_to_py(x = X_pca)

R/scANVI.R

@@ -258,7 +258,7 @@ scANVIIntegration <- function(
       t( GetAssayData(object, layer = layer)[features ,] )
     ),
     obs = r_to_py(groups),
-    var = r_to_py(features)
+    var = r_to_py(data.frame(features = features))
   )
   # ValueError raised if unlabeled_category = NULL/None => use unlikely cell label)
   labels.null <- labels.null %||% "Gloubi-boulga"

R/scVI.R

@@ -203,7 +203,7 @@ scVIIntegration <- function(
       t( GetAssayData(object, layer = layer)[features ,] )
     ),
     obs = r_to_py(groups),
-    var = r_to_py(features)
+    var = r_to_py(data.frame(features = features))
   )
 
   args.call <- c(list(adata = adata, labels_key = r_to_py(labels.name),

R/trVAE.R

@@ -309,7 +309,7 @@ trVAEIntegration <- function(
       Matrix::t( GetAssayData(object, layer = layer)[features, ] )
     ),
     obs = reticulate::r_to_py(groups[, c(groups.name, surgery.name), drop = FALSE]),
-    var = reticulate::r_to_py(features)
+    var = r_to_py(data.frame(features = features))
   )
 
   adata <- sca$dataset$remove_sparsity(adata)

R/utils.R

@@ -185,34 +185,6 @@ symmetrize.pmin.sparse <- function(i, j, x, height) {
 
 }
 
-#' Normalise a matrix using L2 norm
-#'
-#' @description
-#' Normalise the rows or columns of a matrix using L2 norm
-#'
-#' @param mat a matrix (sparse or dense)
-#' @param MARGIN one of 1 or 2, corresponding to normalisation per rows and
-#' columns respectively
-#'
-#' @return the matrix with normalised rows or columns
-#'
-#' @importFrom rlang abort
-#' @importFrom Matrix rowSums colSums
-#' @note
-#' Adapted from \href{https://github.com/satijalab/seurat/blob/1549dcb3075eaeac01c925c4b4bb73c73450fc50/R/utilities.R#L1941-L1956}{Seurat:::L2Norm}
-#' @export
-
-NormaliseL2 <- function(mat, MARGIN = 1) {
-  marSums <- switch (MARGIN,
-                     `1` = rowSums,
-                     `2` = colSums,
-                     NULL
-  ) %||% abort(paste(sQuote(MARGIN), "is not a correct value for 'MARGIN'.",
-                     "Possible values are 1 (rows) or 2 (columns)"))
-  mat.norm <- sweep(mat, MARGIN = MARGIN, STATS = sqrt(marSums(mat^2)), FUN = `/`)
-  mat.norm[!is.finite(mat.norm)] <- 0
-  return(mat.norm)
-}
 ################################################################################
 ################################     NN cut     ################################
 #' Remove excessive number of neighbours in a knn graph
@@ -364,7 +336,7 @@ setMethod(".cut.knn", "Neighbor",
             return(object)
           })
 
-#' Very similar to .cut.knn.Matrix, but doesn't contruct the trimmed knn network
+#' Very similar to .cut.knn.Matrix, but doesn't construct the trimmed knn network
 #' @description
 #' Requires that all cells have at least k.max neighbors
 #'
@@ -554,7 +526,7 @@ setMethod("GetNeighborsPerBatch", c("Seurat", "data.frame"),
 #' @usage NULL
 setMethod("GetNeighborsPerBatch", "Graph",
   function(object, batch.var, count.self) {
-    knnmat <- as.dgcmatrix(object > 0)
+    knnmat <- as.dgcmatrix(as(object > 0, 'dsparseMatrix'))
     GetNeighborsPerBatch(object = knnmat, batch.var = batch.var,
                          count.self = count.self)
 })
@@ -753,17 +725,48 @@ n_zeros_mat <- function(mat) {
 #' @noRd
 choose_matrix_format <- function(mat) {
   max_int_32bit <- 2^31 - 1
-  if (all(c(ncol(mat), nrow(mat)) <= max_int_32bit)) { # should always be TRUE
+  if (all(c(ncol(mat), nrow(mat)) <= max_int_32bit) & length(mat) > 0) { # should always be TRUE
     n_0s <- n_zeros_mat(mat = mat)
-    if ( (n_0s > max_int_32bit) | (n_0s/length(mat) < .35) ) {
+    n_not0s <- length(mat) - n_0s
+    if ( (n_not0s > max_int_32bit) | (n_0s/length(mat) < .35) ) {
       mat <- as.matrix(mat)
     } else {
-      as.dgcmatrix(mat)
+      mat <- as.dgcmatrix(mat)
     }
   }
   return(mat)
 }
 
+################################################################################
+###########################    Seurat extensions    ############################
+#' Normalise a matrix using L2 norm
+#'
+#' @description
+#' Normalise the rows or columns of a matrix using L2 norm
+#'
+#' @param mat a matrix (sparse or dense)
+#' @param MARGIN one of 1 or 2, corresponding to normalisation per rows and
+#' columns respectively
+#'
+#' @return the matrix with normalised rows or columns
+#'
+#' @importFrom rlang abort
+#' @importFrom Matrix rowSums colSums
+#' @note
+#' Adapted from \href{https://github.com/satijalab/seurat/blob/1549dcb3075eaeac01c925c4b4bb73c73450fc50/R/utilities.R#L1941-L1956}{Seurat:::L2Norm}
+#' @export
+
+NormaliseL2 <- function(mat, MARGIN = 1) {
+  marSums <- switch (MARGIN,
+                     `1` = rowSums,
+                     `2` = colSums,
+                     NULL
+  ) %||% abort(paste(sQuote(MARGIN), "is not a correct value for 'MARGIN'.",
+                     "Possible values are 1 (rows) or 2 (columns)"))
+  mat.norm <- sweep(mat, MARGIN = MARGIN, STATS = sqrt(marSums(mat^2)), FUN = `/`)
+  mat.norm[!is.finite(mat.norm)] <- 0
+  return(mat.norm)
+}
 
 # Creates data.frame with cell group assignments for integration
 # uses SCT models if SCTAssay and layers otherwise
@@ -801,3 +804,8 @@ CreateIntegrationGroups <- function(object, layers, scale.layer) {
   return(groups)
 }
 ############
+
+#' @method as.Graph Graph
+as.Graph.Graph <- function(x, ...) {
+  return(x)
+}

pkgdown/_pkgdown.yml

@@ -1,4 +1,4 @@
-url: https://cbib.github.io/Seurat-Integrate/
+url: https://fspecque.github.io/test/
 template:
   bootstrap: 5
   math-rendering: mathjax

src/RcppExports.cpp

@@ -35,12 +35,12 @@ BEGIN_RCPP
 END_RCPP
 }
 // n_zeros_sparse_mat
-int64_t n_zeros_sparse_mat(const arma::sp_mat& mat);
+int64_t n_zeros_sparse_mat(arma::sp_mat& mat);
 RcppExport SEXP _SeuratIntegrate_n_zeros_sparse_mat(SEXP matSEXP) {
 BEGIN_RCPP
     Rcpp::RObject rcpp_result_gen;
     Rcpp::RNGScope rcpp_rngScope_gen;
-    Rcpp::traits::input_parameter< const arma::sp_mat& >::type mat(matSEXP);
+    Rcpp::traits::input_parameter< arma::sp_mat& >::type mat(matSEXP);
     rcpp_result_gen = Rcpp::wrap(n_zeros_sparse_mat(mat));
     return rcpp_result_gen;
 END_RCPP

src/n_zeros_matrix.cpp

@@ -8,8 +8,8 @@ int64_t n_zeros_dense_mat(const arma::mat &mat) {
 }
 
 // [[Rcpp::export]]
-int64_t n_zeros_sparse_mat(const arma::sp_mat &mat) {
-  int64_t count = mat.n_elem - mat.n_nonzero;
+int64_t n_zeros_sparse_mat(arma::sp_mat &mat) {
+  int64_t count = mat.clean(0).n_elem - mat.n_nonzero;
   return count;
 }