} (character versus factor).\nSee \\code{vignette(\"types\")} for an overview of common\ntype abbreviations.\n}\n\nPrinting can be tweaked for a one-off call by calling \\code{print()} explicitly\nand setting arguments like \\code{n} and \\code{width}. More persistent control is\navailable by setting the options described in \\link[pillar:pillar_options]{pillar::pillar_options}.\nSee also \\code{vignette(\"digits\")} for a comparison to base options,\nand \\code{vignette(\"numbers\")} that showcases \\code{\\link[tibble:num]{num()}} and \\code{\\link[tibble:char]{char()}}\nfor creating columns with custom formatting options.\n\nAs of tibble 3.1.0, printing is handled entirely by the \\pkg{pillar} package.\nIf you implement a package that extends tibble,\nthe printed output can be customized in various ways.\nSee \\code{vignette(\"extending\", package = \"pillar\")} for details,\nand \\link[pillar:pillar_options]{pillar::pillar_options} for options that control the display in the console.\n}\n\\examples{\ndata(pbmc_small)\nprint(pbmc_small)\n\n}\n"
},
{
"path": "man/fragments/intro.Rmd",
"content": "\n**Brings Seurat to the tidyverse!**\n\nwebsite: [stemangiola.github.io/tidyseurat/](https://stemangiola.github.io/tidyseurat/)\n\nPlease also have a look at\n\n- [tidyseurat](https://stemangiola.github.io/tidyseurat/) for tidy single-cell RNA sequencing analysis\n- [tidySummarizedExperiment](https://tidyomics.github.io/tidySummarizedExperiment/) for tidy bulk RNA sequencing analysis\n- [tidybulk](https://tidyomics.github.io/tidybulk/) for tidy bulk RNA-seq analysis\n- [tidygate](https://github.com/stemangiola/tidygate/) for adding custom gate information to your tibble\n- [tidyHeatmap](https://stemangiola.github.io/tidyHeatmap/) for heatmaps produced with tidy principles\n\n\n```{r, echo=FALSE, include=FALSE, }\nlibrary(knitr)\nknitr::opts_chunk$set(warning = FALSE, message = FALSE)\n```\n\n\n\n# Introduction\n\ntidyseurat provides a bridge between the Seurat single-cell package [@butler2018integrating; @stuart2019comprehensive] and the tidyverse [@wickham2019welcome]. It creates an invisible layer that enables viewing the\nSeurat object as a tidyverse tibble, and provides Seurat-compatible *dplyr*, *tidyr*, *ggplot* and *plotly* functions.\n\n\n## Functions/utilities available\n\nSeurat-compatible Functions | Description\n------------ | -------------\n`all` | \n\ntidyverse Packages | Description\n------------ | -------------\n`dplyr` | All `dplyr` APIs like for any tibble\n`tidyr` | All `tidyr` APIs like for any tibble\n`ggplot2` | `ggplot` like for any tibble\n`plotly` | `plot_ly` like for any tibble\n\nUtilities | Description\n------------ | -------------\n`tidy` | Add `tidyseurat` invisible layer over a Seurat object\n`as_tibble` | Convert cell-wise information to a `tbl_df`\n`join_features` | Add feature-wise information, returns a `tbl_df`\n`aggregate_cells`| Aggregate cell gene-transcription abundance as pseudobulk tissue |\n\n## Installation\n\nFrom CRAN\n```{r eval=FALSE}\ninstall.packages(\"tidyseurat\")\n```\n\nFrom Github (development)\n```{r, eval=FALSE}\ndevtools::install_github(\"stemangiola/tidyseurat\")\n```\n\n```{r}\nlibrary(dplyr)\nlibrary(tidyr)\nlibrary(purrr)\nlibrary(magrittr)\nlibrary(ggplot2)\nlibrary(Seurat)\nlibrary(tidyseurat)\n```\n\n\n## Create `tidyseurat`, the best of both worlds!\n\nThis is a seurat object but it is evaluated as tibble. So it is fully compatible both with Seurat and tidyverse APIs.\n\n```{r}\npbmc_small = SeuratObject::pbmc_small\n```\n\n**It looks like a tibble**\n\n```{r}\npbmc_small\n```\n\n**But it is a Seurat object after all**\n\n```{r}\npbmc_small@assays\n```\n\n# Preliminary plots\n\nSet colours and theme for plots.\n\n```{r}\n# Use colourblind-friendly colours\nfriendly_cols <- c(\"#88CCEE\", \"#CC6677\", \"#DDCC77\", \"#117733\", \"#332288\", \"#AA4499\", \"#44AA99\", \"#999933\", \"#882255\", \"#661100\", \"#6699CC\")\n\n# Set theme\nmy_theme <-\n list(\n scale_fill_manual(values = friendly_cols),\n scale_color_manual(values = friendly_cols),\n theme_bw() +\n theme(\n panel.border = element_blank(),\n axis.line = element_line(),\n panel.grid.major = element_line(size = 0.2),\n panel.grid.minor = element_line(size = 0.1),\n text = element_text(size = 12),\n legend.position = \"bottom\",\n aspect.ratio = 1,\n strip.background = element_blank(),\n axis.title.x = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10)),\n axis.title.y = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10))\n )\n )\n```\n\nWe can treat `pbmc_small` effectively as a normal tibble for plotting.\n\nHere we plot number of features per cell.\n\n```{r plot1}\npbmc_small %>%\n ggplot(aes(nFeature_RNA, fill = groups)) +\n geom_histogram() +\n my_theme\n```\n\nHere we plot total features per cell.\n\n```{r plot2}\npbmc_small %>%\n ggplot(aes(groups, nCount_RNA, fill = groups)) +\n geom_boxplot(outlier.shape = NA) +\n geom_jitter(width = 0.1) +\n my_theme\n```\n\nHere we plot abundance of two features for each group.\n\n```{r}\npbmc_small %>%\n join_features(features = c(\"HLA-DRA\", \"LYZ\"), shape = \"long\") %>%\n ggplot(aes(groups, .abundance_RNA + 1, fill = groups)) +\n geom_boxplot(outlier.shape = NA) +\n geom_jitter(aes(size = nCount_RNA), alpha = 0.5, width = 0.2) +\n scale_y_log10() +\n my_theme\n```\n\n# Preprocess the dataset\n\nAlso you can treat the object as Seurat object and proceed with data processing.\n\n```{r preprocess}\npbmc_small_pca <-\n pbmc_small %>%\n SCTransform(verbose = FALSE) %>%\n FindVariableFeatures(verbose = FALSE) %>%\n RunPCA(verbose = FALSE)\n\npbmc_small_pca\n```\n\n\nIf a tool is not included in the tidyseurat collection, we can use `as_tibble` to permanently convert `tidyseurat` into tibble.\n\n```{r pc_plot}\npbmc_small_pca %>%\n as_tibble() %>%\n select(contains(\"PC\"), everything()) %>%\n GGally::ggpairs(columns = 1:5, ggplot2::aes(colour = groups)) +\n my_theme\n```\n\n# Identify clusters\n\nWe proceed with cluster identification with Seurat.\n\n```{r cluster}\npbmc_small_cluster <-\n pbmc_small_pca %>%\n FindNeighbors(verbose = FALSE) %>%\n FindClusters(method = \"igraph\", verbose = FALSE)\n\npbmc_small_cluster\n```\n\nNow we can interrogate the object as if it was a regular tibble data frame.\n\n```{r cluster count}\npbmc_small_cluster %>%\n count(groups, seurat_clusters)\n```\n\nWe can identify cluster markers using Seurat.\n\n\n\n`r if (packageVersion(\"Seurat\") >= package_version(\"4.0.0\")) {\"\"}`\n\n\n\n`r if (packageVersion(\"Seurat\") < package_version(\"4.0.0\")) {\"\"}`\n\n# Reduce dimensions\n\nWe can calculate the first 3 UMAP dimensions using the Seurat framework.\n\n```{r umap, eval=FALSE}\npbmc_small_UMAP <-\n pbmc_small_cluster %>%\n RunUMAP(reduction = \"pca\", dims = 1:15, n.components = 3L)\n```\n\nAnd we can plot them using 3D plot using plotly.\n\n```{r umap plot, eval=FALSE}\npbmc_small_UMAP %>%\n plot_ly(\n x = ~`UMAP_1`,\n y = ~`UMAP_2`,\n z = ~`UMAP_3`,\n color = ~seurat_clusters,\n colors = friendly_cols[1:4]\n )\n```\n\n\n\n## Cell type prediction\n\nWe can infer cell type identities using *SingleR* [@aran2019reference] and manipulate the output using tidyverse.\n\n```{r eval=FALSE}\n# Get cell type reference data\nblueprint <- celldex::BlueprintEncodeData()\n\n# Infer cell identities\ncell_type_df <-\n GetAssayData(pbmc_small_UMAP, slot = 'counts', assay = \"SCT\") %>%\n log1p() %>%\n Matrix::Matrix(sparse = TRUE) %>%\n SingleR::SingleR(\n ref = blueprint,\n labels = blueprint$label.main,\n method = \"single\"\n ) %>%\n as.data.frame() %>%\n as_tibble(rownames = \"cell\") %>%\n select(cell, first.labels)\n```\n\n```{r, eval=FALSE}\n# Join UMAP and cell type info\npbmc_small_cell_type <-\n pbmc_small_UMAP %>%\n left_join(cell_type_df, by = \"cell\")\n\n# Reorder columns\npbmc_small_cell_type %>%\n select(cell, first.labels, everything())\n```\n\nWe can easily summarise the results. For example, we can see how cell type classification overlaps with cluster classification.\n\n```{r, eval=FALSE}\npbmc_small_cell_type %>%\n count(seurat_clusters, first.labels)\n```\n\nWe can easily reshape the data for building information-rich faceted plots.\n\n```{r eval=FALSE}\npbmc_small_cell_type %>%\n\n # Reshape and add classifier column\n pivot_longer(\n cols = c(seurat_clusters, first.labels),\n names_to = \"classifier\", values_to = \"label\"\n ) %>%\n\n # UMAP plots for cell type and cluster\n ggplot(aes(UMAP_1, UMAP_2, color = label)) +\n geom_point() +\n facet_wrap(~classifier) +\n my_theme\n```\n\nWe can easily plot gene correlation per cell category, adding multi-layer annotations.\n\n```{r eval=FALSE}\npbmc_small_cell_type %>%\n\n # Add some mitochondrial abundance values\n mutate(mitochondrial = rnorm(n())) %>%\n\n # Plot correlation\n join_features(features = c(\"CST3\", \"LYZ\"), shape = \"wide\") %>%\n ggplot(aes(CST3 + 1, LYZ + 1, color = groups, size = mitochondrial)) +\n geom_point() +\n facet_wrap(~first.labels, scales = \"free\") +\n scale_x_log10() +\n scale_y_log10() +\n my_theme\n```\n\n# Nested analyses\n\nA powerful tool we can use with tidyseurat is `nest`. We can easily perform independent analyses on subsets of the dataset. First we classify cell types in lymphoid and myeloid; then, nest based on the new classification\n\n```{r eval=FALSE}\npbmc_small_nested <-\n pbmc_small_cell_type %>%\n filter(first.labels != \"Erythrocytes\") %>%\n mutate(cell_class = if_else(`first.labels` %in% c(\"Macrophages\", \"Monocytes\"), \"myeloid\", \"lymphoid\")) %>%\n nest(data = -cell_class)\n\npbmc_small_nested\n```\n\nNow we can independently for the lymphoid and myeloid subsets (i) find variable features, (ii) reduce dimensions, and (iii) cluster using both tidyverse and Seurat seamlessly.\n\n```{r eval=FALSE}\npbmc_small_nested_reanalysed <-\n pbmc_small_nested %>%\n mutate(data = map(\n data, ~ .x %>%\n FindVariableFeatures(verbose = FALSE) %>%\n RunPCA(npcs = 10, verbose = FALSE) %>%\n FindNeighbors(verbose = FALSE) %>%\n FindClusters(method = \"igraph\", verbose = FALSE) %>%\n RunUMAP(reduction = \"pca\", dims = 1:10, n.components = 3L, verbose = FALSE)\n ))\n\npbmc_small_nested_reanalysed\n```\n\nNow we can unnest and plot the new classification.\n\n```{r eval=FALSE}\npbmc_small_nested_reanalysed %>%\n\n # Convert to tibble otherwise Seurat drops reduced dimensions when unifying data sets.\n mutate(data = map(data, ~ .x %>% as_tibble())) %>%\n unnest(data) %>%\n\n # Define unique clusters\n unite(\"cluster\", c(cell_class, seurat_clusters), remove = FALSE) %>%\n\n # Plotting\n ggplot(aes(UMAP_1, UMAP_2, color = cluster)) +\n geom_point() +\n facet_wrap(~cell_class) +\n my_theme\n```\n\n# Aggregating cells \n\nSometimes, it is necessary to aggregate the gene-transcript abundance from a group of cells into a single value. For example, when comparing groups of cells across different samples with fixed-effect models.\n\nIn tidyseurat, cell aggregation can be achieved using the `aggregate_cells` function.\n \n \n```{r, eval=FALSE}\npbmc_small %>%\n aggregate_cells(groups, assays = \"RNA\")\n```\n\n "
},
{
"path": "man/full_join.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{full_join}\n\\alias{full_join}\n\\alias{full_join.Seurat}\n\\title{Mutating joins}\n\\usage{\n\\method{full_join}{Seurat}(x, y, by = NULL, copy = FALSE, suffix = c(\".x\", \".y\"), ...)\n}\n\\arguments{\n\\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or\nlazy data frames (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{by}{A join specification created with \\code{\\link[dplyr:join_by]{join_by()}}, or a character\nvector of variables to join by.\n\nIf \\code{NULL}, the default, \\verb{*_join()} will perform a natural join, using all\nvariables in common across \\code{x} and \\code{y}. A message lists the variables so\nthat you can check they're correct; suppress the message by supplying \\code{by}\nexplicitly.\n\nTo join on different variables between \\code{x} and \\code{y}, use a \\code{\\link[dplyr:join_by]{join_by()}}\nspecification. For example, \\code{join_by(a == b)} will match \\code{x$a} to \\code{y$b}.\n\nTo join by multiple variables, use a \\code{\\link[dplyr:join_by]{join_by()}} specification with\nmultiple expressions. For example, \\code{join_by(a == b, c == d)} will match\n\\code{x$a} to \\code{y$b} and \\code{x$c} to \\code{y$d}. If the column names are the same between\n\\code{x} and \\code{y}, you can shorten this by listing only the variable names, like\n\\code{join_by(a, c)}.\n\n\\code{\\link[dplyr:join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap\njoins. See the documentation at \\link[dplyr:join_by]{?join_by} for details on\nthese types of joins.\n\nFor simple equality joins, you can alternatively specify a character vector\nof variable names to join by. For example, \\code{by = c(\"a\", \"b\")} joins \\code{x$a}\nto \\code{y$a} and \\code{x$b} to \\code{y$b}. If variable names differ between \\code{x} and \\code{y},\nuse a named character vector like \\code{by = c(\"x_a\" = \"y_a\", \"x_b\" = \"y_b\")}.\n\nTo perform a cross-join, generating all combinations of \\code{x} and \\code{y}, see\n\\code{\\link[dplyr:cross_join]{cross_join()}}.}\n\n\\item{copy}{If \\code{x} and \\code{y} are not from the same data source,\nand \\code{copy} is \\code{TRUE}, then \\code{y} will be copied into the\nsame src as \\code{x}. This allows you to join tables across srcs, but\nit is a potentially expensive operation so you must opt into it.}\n\n\\item{suffix}{If there are non-joined duplicate variables in \\code{x} and\n\\code{y}, these suffixes will be added to the output to disambiguate them.\nShould be a character vector of length 2.}\n\n\\item{...}{Other parameters passed onto methods.}\n}\n\\value{\nAn object of the same type as \\code{x} (including the same groups). The order of\nthe rows and columns of \\code{x} is preserved as much as possible. The output has\nthe following properties:\n\\itemize{\n\\item The rows are affect by the join type.\n\\itemize{\n\\item \\code{inner_join()} returns matched \\code{x} rows.\n\\item \\code{left_join()} returns all \\code{x} rows.\n\\item \\code{right_join()} returns matched of \\code{x} rows, followed by unmatched \\code{y} rows.\n\\item \\code{full_join()} returns all \\code{x} rows, followed by unmatched \\code{y} rows.\n}\n\\item Output columns include all columns from \\code{x} and all non-key columns from\n\\code{y}. If \\code{keep = TRUE}, the key columns from \\code{y} are included as well.\n\\item If non-key columns in \\code{x} and \\code{y} have the same name, \\code{suffix}es are added\nto disambiguate. If \\code{keep = TRUE} and key columns in \\code{x} and \\code{y} have\nthe same name, \\code{suffix}es are added to disambiguate these as well.\n\\item If \\code{keep = FALSE}, output columns included in \\code{by} are coerced to their\ncommon type between \\code{x} and \\code{y}.\n}\n}\n\\description{\nMutating joins add columns from \\code{y} to \\code{x}, matching observations based on\nthe keys. There are four mutating joins: the inner join, and the three outer\njoins.\n\\subsection{Inner join}{\n\nAn \\code{inner_join()} only keeps observations from \\code{x} that have a matching key\nin \\code{y}.\n\nThe most important property of an inner join is that unmatched rows in either\ninput are not included in the result. This means that generally inner joins\nare not appropriate in most analyses, because it is too easy to lose\nobservations.\n}\n\n\\subsection{Outer joins}{\n\nThe three outer joins keep observations that appear in at least one of the\ndata frames:\n\\itemize{\n\\item A \\code{left_join()} keeps all observations in \\code{x}.\n\\item A \\code{right_join()} keeps all observations in \\code{y}.\n\\item A \\code{full_join()} keeps all observations in \\code{x} and \\code{y}.\n}\n}\n}\n\\section{Many-to-many relationships}{\n\n\n\nBy default, dplyr guards against many-to-many relationships in equality joins\nby throwing a warning. These occur when both of the following are true:\n\\itemize{\n\\item A row in \\code{x} matches multiple rows in \\code{y}.\n\\item A row in \\code{y} matches multiple rows in \\code{x}.\n}\n\nThis is typically surprising, as most joins involve a relationship of\none-to-one, one-to-many, or many-to-one, and is often the result of an\nimproperly specified join. Many-to-many relationships are particularly\nproblematic because they can result in a Cartesian explosion of the number of\nrows returned from the join.\n\nIf a many-to-many relationship is expected, silence this warning by\nexplicitly setting \\code{relationship = \"many-to-many\"}.\n\nIn production code, it is best to preemptively set \\code{relationship} to whatever\nrelationship you expect to exist between the keys of \\code{x} and \\code{y}, as this\nforces an error to occur immediately if the data doesn't align with your\nexpectations.\n\nInequality joins typically result in many-to-many relationships by nature, so\nthey don't warn on them by default, but you should still take extra care when\nspecifying an inequality join, because they also have the capability to\nreturn a large number of rows.\n\nRolling joins don't warn on many-to-many relationships either, but many\nrolling joins follow a many-to-one relationship, so it is often useful to\nset \\code{relationship = \"many-to-one\"} to enforce this.\n\nNote that in SQL, most database providers won't let you specify a\nmany-to-many relationship between two tables, instead requiring that you\ncreate a third \\emph{junction table} that results in two one-to-many relationships\ninstead.\n\n}\n\n\\section{Methods}{\n\n\nThese functions are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{inner_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"inner_join\")}.\n\\item \\code{left_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"left_join\")}.\n\\item \\code{right_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"right_join\")}.\n\\item \\code{full_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"full_join\")}.\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\ntt <- pbmc_small\ntt |> full_join(tibble::tibble(groups=\"g1\", other=1:4))\n\n}\n\\seealso{\nOther joins: \n\\code{\\link[dplyr]{cross_join}()},\n\\code{\\link[dplyr]{filter-joins}},\n\\code{\\link[dplyr]{nest_join}()}\n}\n"
},
{
"path": "man/get_abundance_sc_long.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/utilities.R\n\\name{get_abundance_sc_long}\n\\alias{get_abundance_sc_long}\n\\title{get abundance long}\n\\usage{\nget_abundance_sc_long(\n .data,\n features = NULL,\n all = FALSE,\n exclude_zeros = FALSE,\n assay = Assays(.data),\n slot = \"data\"\n)\n}\n\\arguments{\n\\item{.data}{A tidyseurat}\n\n\\item{features}{A character}\n\n\\item{all}{A boolean}\n\n\\item{exclude_zeros}{A boolean}\n\n\\item{assay}{assay name to extract feature abundance}\n\n\\item{slot}{slot in the assay, e.g. `data` and `scale.data`}\n}\n\\value{\nA Seurat object\n}\n\\description{\nget abundance long\n}\n\\examples{\ndata(pbmc_small)\npbmc_small \\%>\\%\n get_abundance_sc_long(features=c(\"HLA-DRA\", \"LYZ\"))\n\n}\n\\keyword{internal}\n"
},
{
"path": "man/get_abundance_sc_wide.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/utilities.R\n\\name{get_abundance_sc_wide}\n\\alias{get_abundance_sc_wide}\n\\title{get abundance wide}\n\\usage{\nget_abundance_sc_wide(\n .data,\n features = NULL,\n all = FALSE,\n assay = .data@active.assay,\n slot = \"data\",\n prefix = \"\"\n)\n}\n\\arguments{\n\\item{.data}{A tidyseurat}\n\n\\item{features}{A character}\n\n\\item{all}{A boolean}\n\n\\item{assay}{assay name to extract feature abundance}\n\n\\item{slot}{slot in the assay, e.g. `data` and `scale.data`}\n\n\\item{prefix}{prefix for the feature names}\n}\n\\value{\nA Seurat object\n}\n\\description{\nget abundance wide\n}\n\\examples{\ndata(pbmc_small)\npbmc_small \\%>\\%\n get_abundance_sc_wide(features=c(\"HLA-DRA\", \"LYZ\"))\n\n}\n\\keyword{internal}\n"
},
{
"path": "man/ggplot.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/ggplot2_methods.R\n\\name{ggplot}\n\\alias{ggplot}\n\\alias{ggplot.Seurat}\n\\title{Create a new \\code{ggplot} from a \\code{tidyseurat}}\n\\usage{\n\\method{ggplot}{Seurat}(data = NULL, mapping = aes(), ..., environment = parent.frame())\n}\n\\arguments{\n\\item{data}{Default dataset to use for plot. If not already a data.frame,\nwill be converted to one by \\code{\\link[ggplot2:fortify]{fortify()}}. If not specified,\nmust be supplied in each layer added to the plot.}\n\n\\item{mapping}{Default list of aesthetic mappings to use for plot.\nIf not specified, must be supplied in each layer added to the plot.}\n\n\\item{...}{Other arguments passed on to methods. Not currently used.}\n\n\\item{environment}{\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}} Used prior to tidy\nevaluation.}\n}\n\\value{\n`ggplot`\n}\n\\description{\n\\code{ggplot()} initializes a ggplot object. It can be used to\ndeclare the input data frame for a graphic and to specify the\nset of aesthetic mappings for the plot, intended to be common throughout all\nsubsequent layers unless specifically overridden.\n}\n\\details{\n\\code{ggplot()} is used to construct the initial plot object,\nand is almost always followed by a plus sign (\\code{+}) to add\ncomponents to the plot.\n\nThere are three common patterns used to invoke \\code{ggplot()}:\n\\itemize{\n\\item \\verb{ggplot(data = df, mapping = aes(x, y, other aesthetics))}\n\\item \\code{ggplot(data = df)}\n\\item \\code{ggplot()}\n}\n\nThe first pattern is recommended if all layers use the same\ndata and the same set of aesthetics, although this method\ncan also be used when adding a layer using data from another\ndata frame.\n\nThe second pattern specifies the default data frame to use\nfor the plot, but no aesthetics are defined up front. This\nis useful when one data frame is used predominantly for the\nplot, but the aesthetics vary from one layer to another.\n\nThe third pattern initializes a skeleton \\code{ggplot} object, which\nis fleshed out as layers are added. This is useful when\nmultiple data frames are used to produce different layers, as\nis often the case in complex graphics.\n\nThe \\verb{data =} and \\verb{mapping =} specifications in the arguments are optional\n(and are often omitted in practice), so long as the data and the mapping\nvalues are passed into the function in the right order. In the examples\nbelow, however, they are left in place for clarity.\n}\n\\examples{\nlibrary(ggplot2)\ndata(pbmc_small)\npbmc_small |> \n ggplot(aes(groups, nCount_RNA)) +\n geom_boxplot()\n\n}\n\\seealso{\nThe \\href{https://ggplot2-book.org/getting-started}{first steps chapter} of the online ggplot2 book.\n}\n"
},
{
"path": "man/glimpse.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tibble_methods.R\n\\name{glimpse}\n\\alias{glimpse}\n\\alias{glimpse.tidyseurat}\n\\title{Get a glimpse of your data}\n\\usage{\n\\method{glimpse}{tidyseurat}(x, width = NULL, ...)\n}\n\\arguments{\n\\item{x}{An object to glimpse at.}\n\n\\item{width}{Width of output: defaults to the setting of the\n\\code{width} \\link[pillar:pillar_options]{option} (if finite)\nor the width of the console.}\n\n\\item{...}{Unused, for extensibility.}\n}\n\\value{\nx original x is (invisibly) returned, allowing \\code{glimpse()} to be\nused within a data pipe line.\n}\n\\description{\n\\code{glimpse()} is like a transposed version of \\code{print()}:\ncolumns run down the page, and data runs across.\nThis makes it possible to see every column in a data frame.\nIt's a little like \\code{\\link[=str]{str()}} applied to a data frame\nbut it tries to show you as much data as possible.\n(And it always shows the underlying data, even when applied\nto a remote data source.)\n\nSee \\code{\\link[pillar:format_glimpse]{format_glimpse()}} for details on the formatting.\n}\n\\section{S3 methods}{\n\n\n\\code{glimpse} is an S3 generic with a customised method for \\code{tbl}s and\n\\code{data.frames}, and a default method that calls \\code{\\link[=str]{str()}}.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> glimpse()\n\n}\n"
},
{
"path": "man/group_by.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{group_by}\n\\alias{group_by}\n\\alias{group_by.Seurat}\n\\title{Group by one or more variables}\n\\usage{\n\\method{group_by}{Seurat}(.data, ..., .add = FALSE, .drop = group_by_drop_default(.data))\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{<\\code{\\link[rlang:args_data_masking]{data-masking}}> In \\code{group_by()},\nvariables or computations to group by. Computations are always done on the\nungrouped data frame. To perform computations on the grouped data, you need\nto use a separate \\code{mutate()} step before the \\code{group_by()}.\nComputations are not allowed in \\code{nest_by()}.\nIn \\code{ungroup()}, variables to remove from the grouping.}\n\n\\item{.add}{When \\code{FALSE}, the default, \\code{group_by()} will\noverride existing groups. To add to the existing groups, use\n\\code{.add = TRUE}.}\n\n\\item{.drop}{Drop groups formed by factor levels that don't appear in the\ndata? The default is \\code{TRUE} except when \\code{.data} has been previously\ngrouped with \\code{.drop = FALSE}. See \\code{\\link[dplyr:group_by_drop_default]{group_by_drop_default()}} for details.}\n}\n\\value{\nA grouped data frame with class \\code{\\link[dplyr]{grouped_df}},\nunless the combination of \\code{...} and \\code{add} yields a empty set of\ngrouping columns, in which case a tibble will be returned.\n}\n\\description{\nMost data operations are done on groups defined by variables.\n\\code{group_by()} takes an existing tbl and converts it into a grouped tbl\nwhere operations are performed \"by group\". \\code{ungroup()} removes grouping.\n}\n\\section{Methods}{\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{group_by()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"group_by\")}.\n\\item \\code{ungroup()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"ungroup\")}.\n}\n\n}\n\n\\section{Ordering}{\n\n\nCurrently, \\code{group_by()} internally orders the groups in ascending order. This\nresults in ordered output from functions that aggregate groups, such as\n\\code{\\link[dplyr:summarise]{summarise()}}.\n\nWhen used as grouping columns, character vectors are ordered in the C locale\nfor performance and reproducibility across R sessions. If the resulting\nordering of your grouped operation matters and is dependent on the locale,\nyou should follow up the grouped operation with an explicit call to\n\\code{\\link[dplyr:arrange]{arrange()}} and set the \\code{.locale} argument. For example:\n\n\\if{html}{\\out{}}\\preformatted{data |>\n group_by(chr) |>\n summarise(avg = mean(x)) |>\n arrange(chr, .locale = \"en\")\n}\\if{html}{\\out{
}}\n\nThis is often useful as a preliminary step before generating content intended\nfor humans, such as an HTML table.\n\\subsection{Legacy behavior}{\n\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}\n\nPrior to dplyr 1.1.0, character vector grouping columns were ordered in the\nsystem locale. Setting the global option \\code{dplyr.legacy_locale} to \\code{TRUE}\nretains this legacy behavior, but this has been deprecated. Update existing\ncode to explicitly call \\code{arrange(.locale = )} instead. Run\n\\code{Sys.getlocale(\"LC_COLLATE\")} to determine your system locale, and compare\nthat against the list in \\code{\\link[stringi:stri_locale_list]{stringi::stri_locale_list()}} to find an appropriate\nvalue for \\code{.locale}, i.e. for American English, \\code{\"en_US\"}.\n}\n\n}\n\n\\examples{\ndata(\"pbmc_small\")\npbmc_small |> group_by(groups)\n\n}\n\\seealso{\nOther grouping functions: \n\\code{\\link[dplyr]{group_map}()},\n\\code{\\link[dplyr]{group_nest}()},\n\\code{\\link[dplyr]{group_split}()},\n\\code{\\link[dplyr]{group_trim}()}\n}\n"
},
{
"path": "man/group_split.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{group_split}\n\\alias{group_split}\n\\alias{group_split.Seurat}\n\\title{Split data frame by groups}\n\\usage{\n\\method{group_split}{Seurat}(.tbl, ..., .keep = TRUE)\n}\n\\arguments{\n\\item{.tbl}{A tbl.}\n\n\\item{...}{If \\code{.tbl} is an ungrouped data frame, a grouping specification,\nforwarded to \\code{\\link[dplyr:group_by]{group_by()}}.}\n\n\\item{.keep}{Should the grouping columns be kept?}\n}\n\\value{\nA list of tibbles. Each tibble contains the rows of \\code{.tbl} for the\nassociated group and all the columns, including the grouping variables.\nNote that this returns a \\link[vctrs:list_of]{list_of} which is slightly\nstricter than a simple list but is useful for representing lists where\nevery element has the same type.\n}\n\\description{\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\\strong{[Experimental]}}\n\n\\code{\\link[dplyr:group_split]{group_split()}} works like \\code{\\link[base:split]{base::split()}} but:\n\\itemize{\n\\item It uses the grouping structure from \\code{\\link[dplyr:group_by]{group_by()}} and therefore is subject\nto the data mask\n\\item It does not name the elements of the list based on the grouping as this\nonly works well for a single character grouping variable. Instead,\nuse \\code{\\link[dplyr:group_keys]{group_keys()}} to access a data frame that defines the groups.\n}\n\n\\code{group_split()} is primarily designed to work with grouped data frames.\nYou can pass \\code{...} to group and split an ungrouped data frame, but this\nis generally not very useful as you want have easy access to the group\nmetadata.\n}\n\\section{Lifecycle}{\n\n\n\\code{group_split()} is not stable because you can achieve very similar results by\nmanipulating the nested column returned from\n\\code{\\link[tidyr:nest]{tidyr::nest(.by =)}}. That also retains the group keys all\nwithin a single data structure. \\code{group_split()} may be deprecated in the\nfuture.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> group_split(groups)\n\n}\n\\seealso{\nOther grouping functions: \n\\code{\\link[dplyr]{group_by}()},\n\\code{\\link[dplyr]{group_map}()},\n\\code{\\link[dplyr]{group_nest}()},\n\\code{\\link[dplyr]{group_trim}()}\n}\n"
},
{
"path": "man/inner_join.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{inner_join}\n\\alias{inner_join}\n\\alias{inner_join.Seurat}\n\\title{Mutating joins}\n\\usage{\n\\method{inner_join}{Seurat}(x, y, by = NULL, copy = FALSE, suffix = c(\".x\", \".y\"), ...)\n}\n\\arguments{\n\\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or\nlazy data frames (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{by}{A join specification created with \\code{\\link[dplyr:join_by]{join_by()}}, or a character\nvector of variables to join by.\n\nIf \\code{NULL}, the default, \\verb{*_join()} will perform a natural join, using all\nvariables in common across \\code{x} and \\code{y}. A message lists the variables so\nthat you can check they're correct; suppress the message by supplying \\code{by}\nexplicitly.\n\nTo join on different variables between \\code{x} and \\code{y}, use a \\code{\\link[dplyr:join_by]{join_by()}}\nspecification. For example, \\code{join_by(a == b)} will match \\code{x$a} to \\code{y$b}.\n\nTo join by multiple variables, use a \\code{\\link[dplyr:join_by]{join_by()}} specification with\nmultiple expressions. For example, \\code{join_by(a == b, c == d)} will match\n\\code{x$a} to \\code{y$b} and \\code{x$c} to \\code{y$d}. If the column names are the same between\n\\code{x} and \\code{y}, you can shorten this by listing only the variable names, like\n\\code{join_by(a, c)}.\n\n\\code{\\link[dplyr:join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap\njoins. See the documentation at \\link[dplyr:join_by]{?join_by} for details on\nthese types of joins.\n\nFor simple equality joins, you can alternatively specify a character vector\nof variable names to join by. For example, \\code{by = c(\"a\", \"b\")} joins \\code{x$a}\nto \\code{y$a} and \\code{x$b} to \\code{y$b}. If variable names differ between \\code{x} and \\code{y},\nuse a named character vector like \\code{by = c(\"x_a\" = \"y_a\", \"x_b\" = \"y_b\")}.\n\nTo perform a cross-join, generating all combinations of \\code{x} and \\code{y}, see\n\\code{\\link[dplyr:cross_join]{cross_join()}}.}\n\n\\item{copy}{If \\code{x} and \\code{y} are not from the same data source,\nand \\code{copy} is \\code{TRUE}, then \\code{y} will be copied into the\nsame src as \\code{x}. This allows you to join tables across srcs, but\nit is a potentially expensive operation so you must opt into it.}\n\n\\item{suffix}{If there are non-joined duplicate variables in \\code{x} and\n\\code{y}, these suffixes will be added to the output to disambiguate them.\nShould be a character vector of length 2.}\n\n\\item{...}{Other parameters passed onto methods.}\n}\n\\value{\nAn object of the same type as \\code{x} (including the same groups). The order of\nthe rows and columns of \\code{x} is preserved as much as possible. The output has\nthe following properties:\n\\itemize{\n\\item The rows are affect by the join type.\n\\itemize{\n\\item \\code{inner_join()} returns matched \\code{x} rows.\n\\item \\code{left_join()} returns all \\code{x} rows.\n\\item \\code{right_join()} returns matched of \\code{x} rows, followed by unmatched \\code{y} rows.\n\\item \\code{full_join()} returns all \\code{x} rows, followed by unmatched \\code{y} rows.\n}\n\\item Output columns include all columns from \\code{x} and all non-key columns from\n\\code{y}. If \\code{keep = TRUE}, the key columns from \\code{y} are included as well.\n\\item If non-key columns in \\code{x} and \\code{y} have the same name, \\code{suffix}es are added\nto disambiguate. If \\code{keep = TRUE} and key columns in \\code{x} and \\code{y} have\nthe same name, \\code{suffix}es are added to disambiguate these as well.\n\\item If \\code{keep = FALSE}, output columns included in \\code{by} are coerced to their\ncommon type between \\code{x} and \\code{y}.\n}\n}\n\\description{\nMutating joins add columns from \\code{y} to \\code{x}, matching observations based on\nthe keys. There are four mutating joins: the inner join, and the three outer\njoins.\n\\subsection{Inner join}{\n\nAn \\code{inner_join()} only keeps observations from \\code{x} that have a matching key\nin \\code{y}.\n\nThe most important property of an inner join is that unmatched rows in either\ninput are not included in the result. This means that generally inner joins\nare not appropriate in most analyses, because it is too easy to lose\nobservations.\n}\n\n\\subsection{Outer joins}{\n\nThe three outer joins keep observations that appear in at least one of the\ndata frames:\n\\itemize{\n\\item A \\code{left_join()} keeps all observations in \\code{x}.\n\\item A \\code{right_join()} keeps all observations in \\code{y}.\n\\item A \\code{full_join()} keeps all observations in \\code{x} and \\code{y}.\n}\n}\n}\n\\section{Many-to-many relationships}{\n\n\n\nBy default, dplyr guards against many-to-many relationships in equality joins\nby throwing a warning. These occur when both of the following are true:\n\\itemize{\n\\item A row in \\code{x} matches multiple rows in \\code{y}.\n\\item A row in \\code{y} matches multiple rows in \\code{x}.\n}\n\nThis is typically surprising, as most joins involve a relationship of\none-to-one, one-to-many, or many-to-one, and is often the result of an\nimproperly specified join. Many-to-many relationships are particularly\nproblematic because they can result in a Cartesian explosion of the number of\nrows returned from the join.\n\nIf a many-to-many relationship is expected, silence this warning by\nexplicitly setting \\code{relationship = \"many-to-many\"}.\n\nIn production code, it is best to preemptively set \\code{relationship} to whatever\nrelationship you expect to exist between the keys of \\code{x} and \\code{y}, as this\nforces an error to occur immediately if the data doesn't align with your\nexpectations.\n\nInequality joins typically result in many-to-many relationships by nature, so\nthey don't warn on them by default, but you should still take extra care when\nspecifying an inequality join, because they also have the capability to\nreturn a large number of rows.\n\nRolling joins don't warn on many-to-many relationships either, but many\nrolling joins follow a many-to-one relationship, so it is often useful to\nset \\code{relationship = \"many-to-one\"} to enforce this.\n\nNote that in SQL, most database providers won't let you specify a\nmany-to-many relationship between two tables, instead requiring that you\ncreate a third \\emph{junction table} that results in two one-to-many relationships\ninstead.\n\n}\n\n\\section{Methods}{\n\n\nThese functions are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{inner_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"inner_join\")}.\n\\item \\code{left_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"left_join\")}.\n\\item \\code{right_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"right_join\")}.\n\\item \\code{full_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"full_join\")}.\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\ntt <- pbmc_small\ntt |> inner_join(tt |> \n distinct(groups) |> \n mutate(new_column=1:2) |> \n slice(1))\n\n}\n\\seealso{\nOther joins: \n\\code{\\link[dplyr]{cross_join}()},\n\\code{\\link[dplyr]{filter-joins}},\n\\code{\\link[dplyr]{nest_join}()}\n}\n"
},
{
"path": "man/join_features.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/methods.R\n\\name{join_features}\n\\alias{join_features}\n\\alias{join_features,Seurat-method}\n\\title{join_features}\n\\usage{\n\\S4method{join_features}{Seurat}(\n .data,\n features = NULL,\n all = FALSE,\n exclude_zeros = FALSE,\n shape = \"wide\",\n assay = NULL,\n slot = \"data\",\n ...\n)\n}\n\\arguments{\n\\item{.data}{A tidyseurat object}\n\n\\item{features}{A vector of feature identifiers to join}\n\n\\item{all}{If TRUE return all}\n\n\\item{exclude_zeros}{If TRUE exclude zero values}\n\n\\item{shape}{Format of the returned table \"long\" or \"wide\"}\n\n\\item{assay}{assay name to extract feature abundance}\n\n\\item{slot}{slot name to extract feature abundance}\n\n\\item{...}{Parameters to pass to join wide, i.e. assay name to extract feature abundance from and gene prefix, for shape=\"wide\"}\n}\n\\value{\nA `tidyseurat` object\n containing information for the specified features.\n}\n\\description{\njoin_features() extracts and joins information for specific\n features\n}\n\\details{\nThis function extracts information for specified features and\n returns the information in either long or wide format.\n}\n\\examples{\ndata(pbmc_small)\npbmc_small \\%>\\% join_features(\n features=c(\"HLA-DRA\", \"LYZ\"))\n\n}\n"
},
{
"path": "man/join_transcripts.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/methods_DEPRECATED.R\n\\name{join_transcripts}\n\\alias{join_transcripts}\n\\title{(DEPRECATED) Extract and join information for transcripts.}\n\\usage{\njoin_transcripts(\n .data,\n transcripts = NULL,\n all = FALSE,\n exclude_zeros = FALSE,\n shape = \"wide\",\n ...\n)\n}\n\\arguments{\n\\item{.data}{A tidyseurat object}\n\n\\item{transcripts}{A vector of transcript identifiers to join}\n\n\\item{all}{If TRUE return all}\n\n\\item{exclude_zeros}{If TRUE exclude zero values}\n\n\\item{shape}{Format of the returned table \"long\" or \"wide\"}\n\n\\item{...}{Parameters to pass to join wide, i.e. assay name to extract transcript abundance from}\n}\n\\value{\nA `tbl` containing the information.for the specified transcripts\n}\n\\description{\njoin_transcripts() extracts and joins information for specified transcripts\n}\n\\details{\nDEPRECATED, please use join_features()\n}\n\\examples{\n\nprint(\"DEPRECATED\")\n\n\n}\n"
},
{
"path": "man/left_join.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{left_join}\n\\alias{left_join}\n\\alias{left_join.Seurat}\n\\title{Mutating joins}\n\\usage{\n\\method{left_join}{Seurat}(x, y, by = NULL, copy = FALSE, suffix = c(\".x\", \".y\"), ...)\n}\n\\arguments{\n\\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or\nlazy data frames (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{by}{A join specification created with \\code{\\link[dplyr:join_by]{join_by()}}, or a character\nvector of variables to join by.\n\nIf \\code{NULL}, the default, \\verb{*_join()} will perform a natural join, using all\nvariables in common across \\code{x} and \\code{y}. A message lists the variables so\nthat you can check they're correct; suppress the message by supplying \\code{by}\nexplicitly.\n\nTo join on different variables between \\code{x} and \\code{y}, use a \\code{\\link[dplyr:join_by]{join_by()}}\nspecification. For example, \\code{join_by(a == b)} will match \\code{x$a} to \\code{y$b}.\n\nTo join by multiple variables, use a \\code{\\link[dplyr:join_by]{join_by()}} specification with\nmultiple expressions. For example, \\code{join_by(a == b, c == d)} will match\n\\code{x$a} to \\code{y$b} and \\code{x$c} to \\code{y$d}. If the column names are the same between\n\\code{x} and \\code{y}, you can shorten this by listing only the variable names, like\n\\code{join_by(a, c)}.\n\n\\code{\\link[dplyr:join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap\njoins. See the documentation at \\link[dplyr:join_by]{?join_by} for details on\nthese types of joins.\n\nFor simple equality joins, you can alternatively specify a character vector\nof variable names to join by. For example, \\code{by = c(\"a\", \"b\")} joins \\code{x$a}\nto \\code{y$a} and \\code{x$b} to \\code{y$b}. If variable names differ between \\code{x} and \\code{y},\nuse a named character vector like \\code{by = c(\"x_a\" = \"y_a\", \"x_b\" = \"y_b\")}.\n\nTo perform a cross-join, generating all combinations of \\code{x} and \\code{y}, see\n\\code{\\link[dplyr:cross_join]{cross_join()}}.}\n\n\\item{copy}{If \\code{x} and \\code{y} are not from the same data source,\nand \\code{copy} is \\code{TRUE}, then \\code{y} will be copied into the\nsame src as \\code{x}. This allows you to join tables across srcs, but\nit is a potentially expensive operation so you must opt into it.}\n\n\\item{suffix}{If there are non-joined duplicate variables in \\code{x} and\n\\code{y}, these suffixes will be added to the output to disambiguate them.\nShould be a character vector of length 2.}\n\n\\item{...}{Other parameters passed onto methods.}\n}\n\\value{\nAn object of the same type as \\code{x} (including the same groups). The order of\nthe rows and columns of \\code{x} is preserved as much as possible. The output has\nthe following properties:\n\\itemize{\n\\item The rows are affect by the join type.\n\\itemize{\n\\item \\code{inner_join()} returns matched \\code{x} rows.\n\\item \\code{left_join()} returns all \\code{x} rows.\n\\item \\code{right_join()} returns matched of \\code{x} rows, followed by unmatched \\code{y} rows.\n\\item \\code{full_join()} returns all \\code{x} rows, followed by unmatched \\code{y} rows.\n}\n\\item Output columns include all columns from \\code{x} and all non-key columns from\n\\code{y}. If \\code{keep = TRUE}, the key columns from \\code{y} are included as well.\n\\item If non-key columns in \\code{x} and \\code{y} have the same name, \\code{suffix}es are added\nto disambiguate. If \\code{keep = TRUE} and key columns in \\code{x} and \\code{y} have\nthe same name, \\code{suffix}es are added to disambiguate these as well.\n\\item If \\code{keep = FALSE}, output columns included in \\code{by} are coerced to their\ncommon type between \\code{x} and \\code{y}.\n}\n}\n\\description{\nMutating joins add columns from \\code{y} to \\code{x}, matching observations based on\nthe keys. There are four mutating joins: the inner join, and the three outer\njoins.\n\\subsection{Inner join}{\n\nAn \\code{inner_join()} only keeps observations from \\code{x} that have a matching key\nin \\code{y}.\n\nThe most important property of an inner join is that unmatched rows in either\ninput are not included in the result. This means that generally inner joins\nare not appropriate in most analyses, because it is too easy to lose\nobservations.\n}\n\n\\subsection{Outer joins}{\n\nThe three outer joins keep observations that appear in at least one of the\ndata frames:\n\\itemize{\n\\item A \\code{left_join()} keeps all observations in \\code{x}.\n\\item A \\code{right_join()} keeps all observations in \\code{y}.\n\\item A \\code{full_join()} keeps all observations in \\code{x} and \\code{y}.\n}\n}\n}\n\\section{Many-to-many relationships}{\n\n\n\nBy default, dplyr guards against many-to-many relationships in equality joins\nby throwing a warning. These occur when both of the following are true:\n\\itemize{\n\\item A row in \\code{x} matches multiple rows in \\code{y}.\n\\item A row in \\code{y} matches multiple rows in \\code{x}.\n}\n\nThis is typically surprising, as most joins involve a relationship of\none-to-one, one-to-many, or many-to-one, and is often the result of an\nimproperly specified join. Many-to-many relationships are particularly\nproblematic because they can result in a Cartesian explosion of the number of\nrows returned from the join.\n\nIf a many-to-many relationship is expected, silence this warning by\nexplicitly setting \\code{relationship = \"many-to-many\"}.\n\nIn production code, it is best to preemptively set \\code{relationship} to whatever\nrelationship you expect to exist between the keys of \\code{x} and \\code{y}, as this\nforces an error to occur immediately if the data doesn't align with your\nexpectations.\n\nInequality joins typically result in many-to-many relationships by nature, so\nthey don't warn on them by default, but you should still take extra care when\nspecifying an inequality join, because they also have the capability to\nreturn a large number of rows.\n\nRolling joins don't warn on many-to-many relationships either, but many\nrolling joins follow a many-to-one relationship, so it is often useful to\nset \\code{relationship = \"many-to-one\"} to enforce this.\n\nNote that in SQL, most database providers won't let you specify a\nmany-to-many relationship between two tables, instead requiring that you\ncreate a third \\emph{junction table} that results in two one-to-many relationships\ninstead.\n\n}\n\n\\section{Methods}{\n\n\nThese functions are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{inner_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"inner_join\")}.\n\\item \\code{left_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"left_join\")}.\n\\item \\code{right_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"right_join\")}.\n\\item \\code{full_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"full_join\")}.\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\ntt <- pbmc_small\ntt |> left_join(tt |> \n distinct(groups) |> \n mutate(new_column=1:2))\n\n}\n\\seealso{\nOther joins: \n\\code{\\link[dplyr]{cross_join}()},\n\\code{\\link[dplyr]{filter-joins}},\n\\code{\\link[dplyr]{nest_join}()}\n}\n"
},
{
"path": "man/mutate.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{mutate}\n\\alias{mutate}\n\\alias{mutate.Seurat}\n\\title{Create, modify, and delete columns}\n\\usage{\n\\method{mutate}{Seurat}(.data, ...)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{<\\code{\\link[rlang:args_data_masking]{data-masking}}> Name-value pairs.\nThe name gives the name of the column in the output.\n\nThe value can be:\n\\itemize{\n\\item A vector of length 1, which will be recycled to the correct length.\n\\item A vector the same length as the current group (or the whole data frame\nif ungrouped).\n\\item \\code{NULL}, to remove the column.\n\\item A data frame or tibble, to create multiple columns in the output.\n}}\n}\n\\value{\nAn object of the same type as \\code{.data}. The output has the following\nproperties:\n\\itemize{\n\\item Columns from \\code{.data} will be preserved according to the \\code{.keep} argument.\n\\item Existing columns that are modified by \\code{...} will always be returned in\ntheir original location.\n\\item New columns created through \\code{...} will be placed according to the\n\\code{.before} and \\code{.after} arguments.\n\\item The number of rows is not affected.\n\\item Columns given the value \\code{NULL} will be removed.\n\\item Groups will be recomputed if a grouping variable is mutated.\n\\item Data frame attributes are preserved.\n}\n}\n\\description{\n\\code{mutate()} creates new columns that are functions of existing variables.\nIt can also modify (if the name is the same as an existing\ncolumn) and delete columns (by setting their value to \\code{NULL}).\n}\n\\section{Useful mutate functions}{\n\n\n\\itemize{\n\\item \\code{\\link{+}}, \\code{\\link{-}}, \\code{\\link[=log]{log()}}, etc., for their usual mathematical meanings\n\\item \\code{\\link[dplyr:lead]{lead()}}, \\code{\\link[dplyr:lag]{lag()}}\n\\item \\code{\\link[dplyr:dense_rank]{dense_rank()}}, \\code{\\link[dplyr:min_rank]{min_rank()}}, \\code{\\link[dplyr:percent_rank]{percent_rank()}}, \\code{\\link[dplyr:row_number]{row_number()}},\n\\code{\\link[dplyr:cume_dist]{cume_dist()}}, \\code{\\link[dplyr:ntile]{ntile()}}\n\\item \\code{\\link[=cumsum]{cumsum()}}, \\code{\\link[dplyr:cummean]{cummean()}}, \\code{\\link[=cummin]{cummin()}}, \\code{\\link[=cummax]{cummax()}}, \\code{\\link[dplyr:cumany]{cumany()}}, \\code{\\link[dplyr:cumall]{cumall()}}\n\\item \\code{\\link[dplyr:na_if]{na_if()}}, \\code{\\link[dplyr:coalesce]{coalesce()}}\n\\item \\code{\\link[dplyr:if_else]{if_else()}}, \\code{\\link[dplyr:recode]{recode()}}, \\code{\\link[dplyr:case_when]{case_when()}}\n}\n\n}\n\n\\section{Grouped tibbles}{\n\n\n\nBecause mutating expressions are computed within groups, they may\nyield different results on grouped tibbles. This will be the case\nas soon as an aggregating, lagging, or ranking function is\ninvolved. Compare this ungrouped mutate:\n\n\\if{html}{\\out{}}\\preformatted{starwars |>\n select(name, mass, species) |>\n mutate(mass_norm = mass / mean(mass, na.rm = TRUE))\n}\\if{html}{\\out{
}}\n\nWith the grouped equivalent:\n\n\\if{html}{\\out{}}\\preformatted{starwars |>\n select(name, mass, species) |>\n group_by(species) |>\n mutate(mass_norm = mass / mean(mass, na.rm = TRUE))\n}\\if{html}{\\out{
}}\n\nThe former normalises \\code{mass} by the global average whereas the\nlatter normalises by the averages within species levels.\n\n}\n\n\\section{Methods}{\n\n\nThis function is a \\strong{generic}, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"mutate\")}.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> mutate(nFeature_RNA=1)\n\n}\n\\seealso{\nOther single table verbs: \n\\code{\\link{arrange}()},\n\\code{\\link{rename}()},\n\\code{\\link{slice}()},\n\\code{\\link{summarise}()}\n}\n\\concept{single table verbs}\n"
},
{
"path": "man/nest.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tidyr_methods.R\n\\name{nest}\n\\alias{nest}\n\\alias{nest.Seurat}\n\\title{Nest rows into a list-column of data frames}\n\\usage{\n\\method{nest}{Seurat}(.data, ..., .names_sep = NULL)\n}\n\\arguments{\n\\item{.data}{A data frame.}\n\n\\item{...}{<\\code{\\link[tidyr:tidyr_tidy_select]{tidy-select}}> Columns to nest; these will\nappear in the inner data frames.\n\nSpecified using name-variable pairs of the form\n\\code{new_col = c(col1, col2, col3)}. The right hand side can be any valid\ntidyselect expression.\n\nIf not supplied, then \\code{...} is derived as all columns \\emph{not} selected by\n\\code{.by}, and will use the column name from \\code{.key}.\n\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}:\npreviously you could write \\code{df |> nest(x, y, z)}.\nConvert to \\code{df |> nest(data = c(x, y, z))}.}\n\n\\item{.names_sep}{If \\code{NULL}, the default, the inner names will come from\nthe former outer names. If a string, the new inner names will use the\nouter names with \\code{names_sep} automatically stripped. This makes\n\\code{names_sep} roughly symmetric between nesting and unnesting.}\n}\n\\value{\n`tidyseurat_nested`\n}\n\\description{\nNesting creates a list-column of data frames; unnesting flattens it back out\ninto regular columns. Nesting is implicitly a summarising operation: you\nget one row for each group defined by the non-nested columns. This is useful\nin conjunction with other summaries that work with whole datasets, most\nnotably models.\n\nLearn more in \\code{vignette(\"nest\")}.\n}\n\\details{\nIf neither \\code{...} nor \\code{.by} are supplied, \\code{nest()} will nest all variables,\nand will use the column name supplied through \\code{.key}.\n}\n\\section{New syntax}{\n\n\ntidyr 1.0.0 introduced a new syntax for \\code{nest()} and \\code{unnest()} that's\ndesigned to be more similar to other functions. Converting to the new syntax\nshould be straightforward (guided by the message you'll receive) but if\nyou just need to run an old analysis, you can easily revert to the previous\nbehaviour using \\code{\\link[tidyr:nest_legacy]{nest_legacy()}} and \\code{\\link[tidyr:unnest_legacy]{unnest_legacy()}} as follows:\n\n\\if{html}{\\out{}}\\preformatted{library(tidyr)\nnest <- nest_legacy\nunnest <- unnest_legacy\n}\\if{html}{\\out{
}}\n\n}\n\n\\section{Grouped data frames}{\n\n\n\\code{df |> nest(data = c(x, y))} specifies the columns to be nested; i.e. the\ncolumns that will appear in the inner data frame. \\code{df |> nest(.by = c(x, y))} specifies the columns to nest \\emph{by}; i.e. the columns that will remain in\nthe outer data frame. An alternative way to achieve the latter is to \\code{nest()}\na grouped data frame created by \\code{\\link[dplyr:group_by]{dplyr::group_by()}}. The grouping variables\nremain in the outer data frame and the others are nested. The result\npreserves the grouping of the input.\n\nVariables supplied to \\code{nest()} will override grouping variables so that\n\\code{df |> group_by(x, y) |> nest(data = !z)} will be equivalent to\n\\code{df |> nest(data = !z)}.\n\nYou can't supply \\code{.by} with a grouped data frame, as the groups already\nrepresent what you are nesting by.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> \n nest(data=-groups) |> \n unnest(data)\n\n}\n"
},
{
"path": "man/pbmc_small_nested_interactions.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/data.R\n\\docType{data}\n\\name{pbmc_small_nested_interactions}\n\\alias{pbmc_small_nested_interactions}\n\\title{Intercellular ligand-receptor interactions for \n38 ligands from a single cell RNA-seq cluster.}\n\\format{\nA `tibble` containing 100 rows and 9 columns.\n Cells are a subsample of the PBMC dataset of 2,700 single cells. \n Cell interactions were identified with `SingleCellSignalR`.\n\\describe{\n \\item{sample}{sample identifier}\n \\item{ligand}{cluster and ligand identifier}\n \\item{receptor}{cluster and receptor identifier}\n \\item{ligand.name}{ligand name}\n \\item{receptor.name}{receptor name}\n \\item{origin}{cluster containing ligand}\n \\item{destination}{cluster containing receptor}\n \\item{interaction.type}{type of interation, paracrine or autocrine}\n \\item{LRscore}{interaction score}\n}\n}\n\\source{\n\\url{https://satijalab.org/seurat/v3.1/pbmc3k_tutorial.html}\n}\n\\usage{\ndata(pbmc_small_nested_interactions)\n}\n\\value{\n`tibble`\n}\n\\description{\nA dataset containing ligand-receptor interactions within a sample.\nThere are 38 ligands from a single cell cluster versus 35 receptors \nin 6 other clusters.\n}\n\\keyword{datasets}\n"
},
{
"path": "man/pipe.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/utils-pipe.R\n\\name{\\%>\\%}\n\\alias{\\%>\\%}\n\\title{Pipe operator}\n\\usage{\nlhs \\%>\\% rhs\n}\n\\value{\nvoid\n}\n\\description{\nSee \\code{magrittr::\\link[magrittr:pipe]{\\%>\\%}} for details.\n}\n\\examples{\ndata(pbmc_small)\npbmc_small \\%>\\% print()\n}\n\\keyword{internal}\n"
},
{
"path": "man/pivot_longer.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tidyr_methods.R\n\\name{pivot_longer}\n\\alias{pivot_longer}\n\\alias{pivot_longer.Seurat}\n\\title{Pivot data from wide to long}\n\\usage{\n\\method{pivot_longer}{Seurat}(\n data,\n cols,\n names_to = \"name\",\n names_prefix = NULL,\n names_sep = NULL,\n names_pattern = NULL,\n names_ptypes = NULL,\n names_transform = NULL,\n names_repair = \"check_unique\",\n values_to = \"value\",\n values_drop_na = FALSE,\n values_ptypes = NULL,\n values_transform = NULL,\n ...\n)\n}\n\\arguments{\n\\item{data}{A data frame to pivot.}\n\n\\item{cols}{<\\code{\\link[tidyr:tidyr_tidy_select]{tidy-select}}> Columns to pivot into\nlonger format.}\n\n\\item{names_to}{A character vector specifying the new column or columns to\ncreate from the information stored in the column names of \\code{data} specified\nby \\code{cols}.\n\\itemize{\n\\item If length 0, or if \\code{NULL} is supplied, no columns will be created.\n\\item If length 1, a single column will be created which will contain the\ncolumn names specified by \\code{cols}.\n\\item If length >1, multiple columns will be created. In this case, one of\n\\code{names_sep} or \\code{names_pattern} must be supplied to specify how the\ncolumn names should be split. There are also two additional character\nvalues you can take advantage of:\n\\itemize{\n\\item \\code{NA} will discard the corresponding component of the column name.\n\\item \\code{\".value\"} indicates that the corresponding component of the column\nname defines the name of the output column containing the cell values,\noverriding \\code{values_to} entirely.\n}\n}}\n\n\\item{names_prefix}{A regular expression used to remove matching text\nfrom the start of each variable name.}\n\n\\item{names_sep, names_pattern}{If \\code{names_to} contains multiple values,\nthese arguments control how the column name is broken up.\n\n\\code{names_sep} takes the same specification as \\code{\\link[tidyr:separate]{separate()}}, and can either\nbe a numeric vector (specifying positions to break on), or a single string\n(specifying a regular expression to split on).\n\n\\code{names_pattern} takes the same specification as \\code{\\link[tidyr:extract]{extract()}}, a regular\nexpression containing matching groups (\\verb{()}).\n\nIf these arguments do not give you enough control, use\n\\code{pivot_longer_spec()} to create a spec object and process manually as\nneeded.}\n\n\\item{names_ptypes, values_ptypes}{Optionally, a list of column name-prototype\npairs. Alternatively, a single empty prototype can be supplied, which will\nbe applied to all columns. A prototype (or ptype for short) is a\nzero-length vector (like \\code{integer()} or \\code{numeric()}) that defines the type,\nclass, and attributes of a vector. Use these arguments if you want to\nconfirm that the created columns are the types that you expect. Note that\nif you want to change (instead of confirm) the types of specific columns,\nyou should use \\code{names_transform} or \\code{values_transform} instead.}\n\n\\item{names_transform, values_transform}{Optionally, a list of column\nname-function pairs. Alternatively, a single function can be supplied,\nwhich will be applied to all columns. Use these arguments if you need to\nchange the types of specific columns. For example, \\code{names_transform = list(week = as.integer)} would convert a character variable called \\code{week}\nto an integer.\n\nIf not specified, the type of the columns generated from \\code{names_to} will\nbe character, and the type of the variables generated from \\code{values_to}\nwill be the common type of the input columns used to generate them.}\n\n\\item{names_repair}{What happens if the output has invalid column names?\nThe default, \\code{\"check_unique\"} is to error if the columns are duplicated.\nUse \\code{\"minimal\"} to allow duplicates in the output, or \\code{\"unique\"} to\nde-duplicated by adding numeric suffixes. See \\code{\\link[vctrs:vec_as_names]{vctrs::vec_as_names()}}\nfor more options.}\n\n\\item{values_to}{A string specifying the name of the column to create\nfrom the data stored in cell values. If \\code{names_to} is a character\ncontaining the special \\code{.value} sentinel, this value will be ignored,\nand the name of the value column will be derived from part of the\nexisting column names.}\n\n\\item{values_drop_na}{If \\code{TRUE}, will drop rows that contain only \\code{NA}s\nin the \\code{values_to} column. This effectively converts explicit missing values\nto implicit missing values, and should generally be used only when missing\nvalues in \\code{data} were created by its structure.}\n\n\\item{...}{Additional arguments passed on to methods.}\n}\n\\value{\n`tidyseurat`\n}\n\\description{\n\\code{pivot_longer()} \"lengthens\" data, increasing the number of rows and\ndecreasing the number of columns. The inverse transformation is\n\\code{\\link[tidyr:pivot_wider]{pivot_wider()}}\n\nLearn more in \\code{vignette(\"pivot\")}.\n}\n\\details{\n\\code{pivot_longer()} is an updated approach to \\code{\\link[tidyr:gather]{gather()}}, designed to be both\nsimpler to use and to handle more use cases. We recommend you use\n\\code{pivot_longer()} for new code; \\code{gather()} isn't going away but is no longer\nunder active development.\n}\n\\examples{\ndata(pbmc_small)\npbmc_small |> pivot_longer(\n cols=c(orig.ident, groups),\n names_to=\"name\", values_to=\"value\")\n\n}\n"
},
{
"path": "man/plotly.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/plotly_methods.R\n\\name{plotly}\n\\alias{plotly}\n\\alias{plot_ly}\n\\alias{plot_ly.tbl_df}\n\\alias{plot_ly.Seurat}\n\\title{Initiate a plotly visualization}\n\\usage{\nplot_ly(\n data = data.frame(),\n ...,\n type = NULL,\n name = NULL,\n color = NULL,\n colors = NULL,\n alpha = NULL,\n stroke = NULL,\n strokes = NULL,\n alpha_stroke = 1,\n size = NULL,\n sizes = c(10, 100),\n span = NULL,\n spans = c(1, 20),\n symbol = NULL,\n symbols = NULL,\n linetype = NULL,\n linetypes = NULL,\n split = NULL,\n frame = NULL,\n width = NULL,\n height = NULL,\n source = \"A\"\n)\n\n\\method{plot_ly}{tbl_df}(\n data = data.frame(),\n ...,\n type = NULL,\n name = NULL,\n color = NULL,\n colors = NULL,\n alpha = NULL,\n stroke = NULL,\n strokes = NULL,\n alpha_stroke = 1,\n size = NULL,\n sizes = c(10, 100),\n span = NULL,\n spans = c(1, 20),\n symbol = NULL,\n symbols = NULL,\n linetype = NULL,\n linetypes = NULL,\n split = NULL,\n frame = NULL,\n width = NULL,\n height = NULL,\n source = \"A\"\n)\n\n\\method{plot_ly}{Seurat}(\n data = data.frame(),\n ...,\n type = NULL,\n name = NULL,\n color = NULL,\n colors = NULL,\n alpha = NULL,\n stroke = NULL,\n strokes = NULL,\n alpha_stroke = 1,\n size = NULL,\n sizes = c(10, 100),\n span = NULL,\n spans = c(1, 20),\n symbol = NULL,\n symbols = NULL,\n linetype = NULL,\n linetypes = NULL,\n split = NULL,\n frame = NULL,\n width = NULL,\n height = NULL,\n source = \"A\"\n)\n}\n\\arguments{\n\\item{data}{A data frame (optional) or \\link[crosstalk:SharedData]{crosstalk::SharedData} object.}\n\n\\item{...}{Arguments (i.e., attributes) passed along to the trace \\code{type}.\nSee \\code{\\link[plotly:schema]{schema()}} for a list of acceptable attributes for a given trace \\code{type}\n(by going to \\code{traces} -> \\code{type} -> \\code{attributes}). Note that attributes\nprovided at this level may override other arguments\n(e.g. \\code{plot_ly(x = 1:10, y = 1:10, color = I(\"red\"), marker = list(color = \"blue\"))}).}\n\n\\item{type}{A character string specifying the trace type (e.g. \\code{\"scatter\"}, \\code{\"bar\"}, \\code{\"box\"}, etc).\nIf specified, it \\emph{always} creates a trace, otherwise}\n\n\\item{name}{Values mapped to the trace's name attribute. Since a trace can\nonly have one name, this argument acts very much like \\code{split} in that it\ncreates one trace for every unique value.}\n\n\\item{color}{Values mapped to relevant 'fill-color' attribute(s)\n(e.g. \\href{https://plotly.com/r/reference/#scatter-fillcolor}{fillcolor},\n\\href{https://plotly.com/r/reference/#scatter-marker-color}{marker.color},\n\\href{https://plotly.com/r/reference/#scatter-textfont-color}{textfont.color}, etc.).\nThe mapping from data values to color codes may be controlled using\n\\code{colors} and \\code{alpha}, or avoided altogether via \\code{\\link[=I]{I()}} (e.g., \\code{color = I(\"red\")}).\nAny color understood by \\code{\\link[grDevices:col2rgb]{grDevices::col2rgb()}} may be used in this way.}\n\n\\item{colors}{Either a colorbrewer2.org palette name (e.g. \"YlOrRd\" or \"Blues\"),\nor a vector of colors to interpolate in hexadecimal \"#RRGGBB\" format,\nor a color interpolation function like \\code{colorRamp()}.}\n\n\\item{alpha}{A number between 0 and 1 specifying the alpha channel applied to \\code{color}.\nDefaults to 0.5 when mapping to \\href{https://plotly.com/r/reference/#scatter-fillcolor}{fillcolor} and 1 otherwise.}\n\n\\item{stroke}{Similar to \\code{color}, but values are mapped to relevant 'stroke-color' attribute(s)\n(e.g., \\href{https://plotly.com/r/reference/#scatter-marker-line-color}{marker.line.color}\nand \\href{https://plotly.com/r/reference/#scatter-line-color}{line.color}\nfor filled polygons). If not specified, \\code{stroke} inherits from \\code{color}.}\n\n\\item{strokes}{Similar to \\code{colors}, but controls the \\code{stroke} mapping.}\n\n\\item{alpha_stroke}{Similar to \\code{alpha}, but applied to \\code{stroke}.}\n\n\\item{size}{(Numeric) values mapped to relevant 'fill-size' attribute(s)\n(e.g., \\href{https://plotly.com/r/reference/#scatter-marker-size}{marker.size},\n\\href{https://plotly.com/r/reference/#scatter-textfont-size}{textfont.size},\nand \\href{https://plotly.com/r/reference/#scatter-error_x-width}{error_x.width}).\nThe mapping from data values to symbols may be controlled using\n\\code{sizes}, or avoided altogether via \\code{\\link[=I]{I()}} (e.g., \\code{size = I(30)}).}\n\n\\item{sizes}{A numeric vector of length 2 used to scale \\code{size} to pixels.}\n\n\\item{span}{(Numeric) values mapped to relevant 'stroke-size' attribute(s)\n(e.g.,\n\\href{https://plotly.com/r/reference/#scatter-marker-line-width}{marker.line.width},\n\\href{https://plotly.com/r/reference/#scatter-line-width}{line.width} for filled polygons,\nand \\href{https://plotly.com/r/reference/#scatter-error_x-thickness}{error_x.thickness})\nThe mapping from data values to symbols may be controlled using\n\\code{spans}, or avoided altogether via \\code{\\link[=I]{I()}} (e.g., \\code{span = I(30)}).}\n\n\\item{spans}{A numeric vector of length 2 used to scale \\code{span} to pixels.}\n\n\\item{symbol}{(Discrete) values mapped to \\href{https://plotly.com/r/reference/#scatter-marker-symbol}{marker.symbol}.\nThe mapping from data values to symbols may be controlled using\n\\code{symbols}, or avoided altogether via \\code{\\link[=I]{I()}} (e.g., \\code{symbol = I(\"pentagon\")}).\nAny \\link{pch} value or \\href{https://plotly.com/r/reference/#scatter-marker-symbol}{symbol name} may be used in this way.}\n\n\\item{symbols}{A character vector of \\link{pch} values or \\href{https://plotly.com/r/reference/#scatter-marker-symbol}{symbol names}.}\n\n\\item{linetype}{(Discrete) values mapped to \\href{https://plotly.com/r/reference/#scatter-line-dash}{line.dash}.\nThe mapping from data values to symbols may be controlled using\n\\code{linetypes}, or avoided altogether via \\code{\\link[=I]{I()}} (e.g., \\code{linetype = I(\"dash\")}).\nAny \\code{lty} (see \\link{par}) value or \\href{https://plotly.com/r/reference/#scatter-line-dash}{dash name} may be used in this way.}\n\n\\item{linetypes}{A character vector of \\code{lty} values or \\href{https://plotly.com/r/reference/#scatter-line-dash}{dash names}}\n\n\\item{split}{(Discrete) values used to create multiple traces (one trace per value).}\n\n\\item{frame}{(Discrete) values used to create animation frames.}\n\n\\item{width}{Width in pixels (optional, defaults to automatic sizing).}\n\n\\item{height}{Height in pixels (optional, defaults to automatic sizing).}\n\n\\item{source}{a character string of length 1. Match the value of this string\nwith the source argument in \\code{\\link[plotly:event_data]{event_data()}} to retrieve the\nevent data corresponding to a specific plot (shiny apps can have multiple plots).}\n}\n\\value{\n`plotly`\n}\n\\description{\nThis function maps R objects to \\href{https://plotly.com/javascript/}{plotly.js},\nan (MIT licensed) web-based interactive charting library. It provides\nabstractions for doing common things (e.g. mapping data values to\nfill colors (via \\code{color}) or creating \\link[plotly]{animation}s (via \\code{frame})) and sets\nsome different defaults to make the interface feel more 'R-like'\n(i.e., closer to \\code{\\link[=plot]{plot()}} and \\code{\\link[ggplot2:qplot]{ggplot2::qplot()}}).\n}\n\\details{\nUnless \\code{type} is specified, this function just initiates a plotly\nobject with 'global' attributes that are passed onto downstream uses of\n\\code{\\link[plotly:add_trace]{add_trace()}} (or similar). A \\link{formula} must always be used when\nreferencing column name(s) in \\code{data} (e.g. \\code{plot_ly(mtcars, x = ~wt)}).\nFormulas are optional when supplying values directly, but they do\nhelp inform default axis/scale titles\n(e.g., \\code{plot_ly(x = mtcars$wt)} vs \\code{plot_ly(x = ~mtcars$wt)})\n}\n\\examples{\ndata(pbmc_small)\nplot_ly(pbmc_small)\n\n}\n\\references{\n\\url{https://plotly-r.com/overview.html}\n}\n\\seealso{\n\\itemize{\n\\item For initializing a plotly-geo object: \\code{\\link[plotly:plot_geo]{plot_geo()}}\n\\item For initializing a plotly-mapbox object: \\code{\\link[plotly:plot_mapbox]{plot_mapbox()}}\n\\item For translating a ggplot2 object to a plotly object: \\code{\\link[plotly:ggplotly]{ggplotly()}}\n\\item For modifying any plotly object: \\code{\\link[plotly:layout]{layout()}}, \\code{\\link[plotly:add_trace]{add_trace()}}, \\code{\\link[plotly:style]{style()}}\n\\item For linked brushing: \\code{\\link[plotly:highlight]{highlight()}}\n\\item For arranging multiple plots: \\code{\\link[plotly:subplot]{subplot()}}, \\code{\\link[crosstalk:bscols]{crosstalk::bscols()}}\n\\item For inspecting plotly objects: \\code{\\link[plotly:plotly_json]{plotly_json()}}\n\\item For quick, accurate, and searchable plotly.js reference: \\code{\\link[plotly:schema]{schema()}}\n}\n}\n\\author{\nCarson Sievert\n}\n"
},
{
"path": "man/pull.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{pull}\n\\alias{pull}\n\\alias{pull.Seurat}\n\\title{Extract a single column}\n\\usage{\n\\method{pull}{Seurat}(.data, var = -1, name = NULL, ...)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{var}{A variable specified as:\n\\itemize{\n\\item a literal variable name\n\\item a positive integer, giving the position counting from the left\n\\item a negative integer, giving the position counting from the right.\n}\n\nThe default returns the last column (on the assumption that's the\ncolumn you've created most recently).\n\nThis argument is taken by expression and supports\n\\link[rlang:topic-inject]{quasiquotation} (you can unquote column\nnames and column locations).}\n\n\\item{name}{An optional parameter that specifies the column to be used\nas names for a named vector. Specified in a similar manner as \\code{var}.}\n\n\\item{...}{For use by methods.}\n}\n\\value{\nA vector the same size as \\code{.data}.\n}\n\\description{\n\\code{pull()} is similar to \\code{$}. It's mostly useful because it looks a little\nnicer in pipes, it also works with remote data frames, and it can optionally\nname the output.\n}\n\\section{Methods}{\n\n\nThis function is a \\strong{generic}, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nThe following methods are currently available in loaded packages:\n\\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"pull\")}.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> pull(groups)\n\n}\n"
},
{
"path": "man/quo_names.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/utilities.R\n\\name{quo_names}\n\\alias{quo_names}\n\\title{Convert array of quosure (e.g. c(col_a, col_b)) into character vector}\n\\usage{\nquo_names(v)\n}\n\\arguments{\n\\item{v}{A array of quosures (e.g. c(col_a, col_b))}\n}\n\\value{\nA character vector\n}\n\\description{\nConvert array of quosure (e.g. c(col_a, col_b)) into character vector\n}\n\\keyword{internal}\n"
},
{
"path": "man/rename.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{rename}\n\\alias{rename}\n\\alias{rename.Seurat}\n\\title{Rename columns}\n\\usage{\n\\method{rename}{Seurat}(.data, ...)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{For \\code{rename()}: <\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}> Use\n\\code{new_name = old_name} to rename selected variables.\n\nFor \\code{rename_with()}: additional arguments passed onto \\code{.fn}.}\n}\n\\value{\nAn object of the same type as \\code{.data}. The output has the following\nproperties:\n\\itemize{\n\\item Rows are not affected.\n\\item Column names are changed; column order is preserved.\n\\item Data frame attributes are preserved.\n\\item Groups are updated to reflect new names.\n}\n}\n\\description{\n\\code{rename()} changes the names of individual variables using\n\\code{new_name = old_name} syntax; \\code{rename_with()} renames columns using a\nfunction.\n}\n\\section{Methods}{\n\n\nThis function is a \\strong{generic}, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nThe following methods are currently available in loaded packages:\n\\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"rename\")}.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> rename(s_score=nFeature_RNA)\n\n}\n\\seealso{\nOther single table verbs: \n\\code{\\link{arrange}()},\n\\code{\\link{mutate}()},\n\\code{\\link{slice}()},\n\\code{\\link{summarise}()}\n}\n\\concept{single table verbs}\n"
},
{
"path": "man/return_arguments_of.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/utilities.R\n\\name{return_arguments_of}\n\\alias{return_arguments_of}\n\\title{returns variables from an expression}\n\\usage{\nreturn_arguments_of(expression)\n}\n\\arguments{\n\\item{expression}{an expression}\n}\n\\value{\nlist of symbols\n}\n\\description{\nreturns variables from an expression\n}\n"
},
{
"path": "man/right_join.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{right_join}\n\\alias{right_join}\n\\alias{right_join.Seurat}\n\\title{Mutating joins}\n\\usage{\n\\method{right_join}{Seurat}(x, y, by = NULL, copy = FALSE, suffix = c(\".x\", \".y\"), ...)\n}\n\\arguments{\n\\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or\nlazy data frames (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{by}{A join specification created with \\code{\\link[dplyr:join_by]{join_by()}}, or a character\nvector of variables to join by.\n\nIf \\code{NULL}, the default, \\verb{*_join()} will perform a natural join, using all\nvariables in common across \\code{x} and \\code{y}. A message lists the variables so\nthat you can check they're correct; suppress the message by supplying \\code{by}\nexplicitly.\n\nTo join on different variables between \\code{x} and \\code{y}, use a \\code{\\link[dplyr:join_by]{join_by()}}\nspecification. For example, \\code{join_by(a == b)} will match \\code{x$a} to \\code{y$b}.\n\nTo join by multiple variables, use a \\code{\\link[dplyr:join_by]{join_by()}} specification with\nmultiple expressions. For example, \\code{join_by(a == b, c == d)} will match\n\\code{x$a} to \\code{y$b} and \\code{x$c} to \\code{y$d}. If the column names are the same between\n\\code{x} and \\code{y}, you can shorten this by listing only the variable names, like\n\\code{join_by(a, c)}.\n\n\\code{\\link[dplyr:join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap\njoins. See the documentation at \\link[dplyr:join_by]{?join_by} for details on\nthese types of joins.\n\nFor simple equality joins, you can alternatively specify a character vector\nof variable names to join by. For example, \\code{by = c(\"a\", \"b\")} joins \\code{x$a}\nto \\code{y$a} and \\code{x$b} to \\code{y$b}. If variable names differ between \\code{x} and \\code{y},\nuse a named character vector like \\code{by = c(\"x_a\" = \"y_a\", \"x_b\" = \"y_b\")}.\n\nTo perform a cross-join, generating all combinations of \\code{x} and \\code{y}, see\n\\code{\\link[dplyr:cross_join]{cross_join()}}.}\n\n\\item{copy}{If \\code{x} and \\code{y} are not from the same data source,\nand \\code{copy} is \\code{TRUE}, then \\code{y} will be copied into the\nsame src as \\code{x}. This allows you to join tables across srcs, but\nit is a potentially expensive operation so you must opt into it.}\n\n\\item{suffix}{If there are non-joined duplicate variables in \\code{x} and\n\\code{y}, these suffixes will be added to the output to disambiguate them.\nShould be a character vector of length 2.}\n\n\\item{...}{Other parameters passed onto methods.}\n}\n\\value{\nAn object of the same type as \\code{x} (including the same groups). The order of\nthe rows and columns of \\code{x} is preserved as much as possible. The output has\nthe following properties:\n\\itemize{\n\\item The rows are affect by the join type.\n\\itemize{\n\\item \\code{inner_join()} returns matched \\code{x} rows.\n\\item \\code{left_join()} returns all \\code{x} rows.\n\\item \\code{right_join()} returns matched of \\code{x} rows, followed by unmatched \\code{y} rows.\n\\item \\code{full_join()} returns all \\code{x} rows, followed by unmatched \\code{y} rows.\n}\n\\item Output columns include all columns from \\code{x} and all non-key columns from\n\\code{y}. If \\code{keep = TRUE}, the key columns from \\code{y} are included as well.\n\\item If non-key columns in \\code{x} and \\code{y} have the same name, \\code{suffix}es are added\nto disambiguate. If \\code{keep = TRUE} and key columns in \\code{x} and \\code{y} have\nthe same name, \\code{suffix}es are added to disambiguate these as well.\n\\item If \\code{keep = FALSE}, output columns included in \\code{by} are coerced to their\ncommon type between \\code{x} and \\code{y}.\n}\n}\n\\description{\nMutating joins add columns from \\code{y} to \\code{x}, matching observations based on\nthe keys. There are four mutating joins: the inner join, and the three outer\njoins.\n\\subsection{Inner join}{\n\nAn \\code{inner_join()} only keeps observations from \\code{x} that have a matching key\nin \\code{y}.\n\nThe most important property of an inner join is that unmatched rows in either\ninput are not included in the result. This means that generally inner joins\nare not appropriate in most analyses, because it is too easy to lose\nobservations.\n}\n\n\\subsection{Outer joins}{\n\nThe three outer joins keep observations that appear in at least one of the\ndata frames:\n\\itemize{\n\\item A \\code{left_join()} keeps all observations in \\code{x}.\n\\item A \\code{right_join()} keeps all observations in \\code{y}.\n\\item A \\code{full_join()} keeps all observations in \\code{x} and \\code{y}.\n}\n}\n}\n\\section{Many-to-many relationships}{\n\n\n\nBy default, dplyr guards against many-to-many relationships in equality joins\nby throwing a warning. These occur when both of the following are true:\n\\itemize{\n\\item A row in \\code{x} matches multiple rows in \\code{y}.\n\\item A row in \\code{y} matches multiple rows in \\code{x}.\n}\n\nThis is typically surprising, as most joins involve a relationship of\none-to-one, one-to-many, or many-to-one, and is often the result of an\nimproperly specified join. Many-to-many relationships are particularly\nproblematic because they can result in a Cartesian explosion of the number of\nrows returned from the join.\n\nIf a many-to-many relationship is expected, silence this warning by\nexplicitly setting \\code{relationship = \"many-to-many\"}.\n\nIn production code, it is best to preemptively set \\code{relationship} to whatever\nrelationship you expect to exist between the keys of \\code{x} and \\code{y}, as this\nforces an error to occur immediately if the data doesn't align with your\nexpectations.\n\nInequality joins typically result in many-to-many relationships by nature, so\nthey don't warn on them by default, but you should still take extra care when\nspecifying an inequality join, because they also have the capability to\nreturn a large number of rows.\n\nRolling joins don't warn on many-to-many relationships either, but many\nrolling joins follow a many-to-one relationship, so it is often useful to\nset \\code{relationship = \"many-to-one\"} to enforce this.\n\nNote that in SQL, most database providers won't let you specify a\nmany-to-many relationship between two tables, instead requiring that you\ncreate a third \\emph{junction table} that results in two one-to-many relationships\ninstead.\n\n}\n\n\\section{Methods}{\n\n\nThese functions are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{inner_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"inner_join\")}.\n\\item \\code{left_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"left_join\")}.\n\\item \\code{right_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"right_join\")}.\n\\item \\code{full_join()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"full_join\")}.\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\ntt <- pbmc_small\ntt |> right_join(tt |> \n distinct(groups) |> \n mutate(new_column=1:2) |> \n slice(1))\n\n}\n\\seealso{\nOther joins: \n\\code{\\link[dplyr]{cross_join}()},\n\\code{\\link[dplyr]{filter-joins}},\n\\code{\\link[dplyr]{nest_join}()}\n}\n"
},
{
"path": "man/rowwise.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{rowwise}\n\\alias{rowwise}\n\\alias{rowwise.Seurat}\n\\title{Group input by rows}\n\\usage{\n\\method{rowwise}{Seurat}(data, ...)\n}\n\\arguments{\n\\item{data}{Input data frame.}\n\n\\item{...}{<\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}> Variables to be preserved\nwhen calling \\code{\\link[dplyr:summarise]{summarise()}}. This is typically a set of variables whose\ncombination uniquely identify each row.\n\n\\strong{NB}: unlike \\code{group_by()} you can not create new variables here but\ninstead you can select multiple variables with (e.g.) \\code{everything()}.}\n}\n\\value{\nA row-wise data frame with class \\code{rowwise_df}. Note that a\n\\code{rowwise_df} is implicitly grouped by row, but is not a \\code{grouped_df}.\n}\n\\description{\n\\code{rowwise()} allows you to compute on a data frame a row-at-a-time.\nThis is most useful when a vectorised function doesn't exist.\n\nMost dplyr verbs preserve row-wise grouping. The exception is \\code{\\link[dplyr:summarise]{summarise()}},\nwhich return a \\link[dplyr]{grouped_df}. You can explicitly ungroup with \\code{\\link[dplyr:ungroup]{ungroup()}}\nor \\code{\\link[dplyr:as_tibble]{as_tibble()}}, or convert to a \\link[dplyr]{grouped_df} with \\code{\\link[dplyr:group_by]{group_by()}}.\n}\n\\section{List-columns}{\n\n\nBecause a rowwise has exactly one row per group it offers a small\nconvenience for working with list-columns. Normally, \\code{summarise()} and\n\\code{mutate()} extract a groups worth of data with \\code{[}. But when you index\na list in this way, you get back another list. When you're working with\na \\code{rowwise} tibble, then dplyr will use \\code{[[} instead of \\code{[} to make your\nlife a little easier.\n\n}\n\n\\examples{\n# TODO\n\n}\n\\seealso{\n\\code{\\link[dplyr:nest_by]{nest_by()}} for a convenient way of creating rowwise data frames\nwith nested data.\n}\n"
},
{
"path": "man/sample_n.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{sample_n}\n\\alias{sample_n}\n\\alias{sample_n.Seurat}\n\\alias{sample_frac}\n\\alias{sample_frac.Seurat}\n\\title{Sample n rows from a table}\n\\usage{\n\\method{sample_n}{Seurat}(tbl, size, replace = FALSE, weight = NULL, .env = NULL, ...)\n\n\\method{sample_frac}{Seurat}(tbl, size = 1, replace = FALSE, weight = NULL, .env = NULL, ...)\n}\n\\arguments{\n\\item{tbl}{A data.frame.}\n\n\\item{size}{<\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}>\nFor \\code{sample_n()}, the number of rows to select.\nFor \\code{sample_frac()}, the fraction of rows to select.\nIf \\code{tbl} is grouped, \\code{size} applies to each group.}\n\n\\item{replace}{Sample with or without replacement?}\n\n\\item{weight}{<\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}> Sampling weights.\nThis must evaluate to a vector of non-negative numbers the same length as\nthe input. Weights are automatically standardised to sum to 1.}\n\n\\item{.env}{DEPRECATED.}\n\n\\item{...}{ignored}\n}\n\\description{\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\\strong{[Superseded]}}\n\\code{sample_n()} and \\code{sample_frac()} have been superseded in favour of\n\\code{\\link[dplyr:slice_sample]{slice_sample()}}. While they will not be deprecated in the near future,\nretirement means that we will only perform critical bug fixes, so we recommend\nmoving to the newer alternative.\n\nThese functions were superseded because we realised it was more convenient to\nhave two mutually exclusive arguments to one function, rather than two\nseparate functions. This also made it to clean up a few other smaller\ndesign issues with \\code{sample_n()}/\\code{sample_frac}:\n\\itemize{\n\\item The connection to \\code{slice()} was not obvious.\n\\item The name of the first argument, \\code{tbl}, is inconsistent with other\nsingle table verbs which use \\code{.data}.\n\\item The \\code{size} argument uses tidy evaluation, which is surprising and\nundocumented.\n\\item It was easier to remove the deprecated \\code{.env} argument.\n\\item \\code{...} was in a suboptimal position.\n}\n}\n\\examples{\ndata(pbmc_small)\npbmc_small |> sample_n(50)\npbmc_small |> sample_frac(0.1)\n\n}\n"
},
{
"path": "man/select.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{select}\n\\alias{select}\n\\alias{select.Seurat}\n\\title{Keep or drop columns using their names and types}\n\\usage{\n\\method{select}{Seurat}(.data, ...)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{<\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}> One or more unquoted\nexpressions separated by commas. Variable names can be used as if they\nwere positions in the data frame, so expressions like \\code{x:y} can\nbe used to select a range of variables.}\n}\n\\value{\nAn object of the same type as \\code{.data}. The output has the following\nproperties:\n\\itemize{\n\\item Rows are not affected.\n\\item Output columns are a subset of input columns, potentially with a different\norder. Columns will be renamed if \\code{new_name = old_name} form is used.\n\\item Data frame attributes are preserved.\n\\item Groups are maintained; you can't select off grouping variables.\n}\n}\n\\description{\nSelect (and optionally rename) variables in a data frame, using a concise\nmini-language that makes it easy to refer to variables based on their name\n(e.g. \\code{a:f} selects all columns from \\code{a} on the left to \\code{f} on the\nright) or type (e.g. \\code{where(is.numeric)} selects all numeric columns).\n\\subsection{Overview of selection features}{\n\nTidyverse selections implement a dialect of R where operators make\nit easy to select variables:\n\\itemize{\n\\item \\code{:} for selecting a range of consecutive variables.\n\\item \\code{!} for taking the complement of a set of variables.\n\\item \\code{&} and \\code{|} for selecting the intersection or the union of two\nsets of variables.\n\\item \\code{c()} for combining selections.\n}\n\nIn addition, you can use \\strong{selection helpers}. Some helpers select specific\ncolumns:\n\\itemize{\n\\item \\code{\\link[tidyselect:everything]{everything()}}: Matches all variables.\n\\item \\code{\\link[tidyselect:everything]{last_col()}}: Select last variable, possibly with an offset.\n\\item \\code{\\link[dplyr:group_cols]{group_cols()}}: Select all grouping columns.\n}\n\nOther helpers select variables by matching patterns in their names:\n\\itemize{\n\\item \\code{\\link[tidyselect:starts_with]{starts_with()}}: Starts with a prefix.\n\\item \\code{\\link[tidyselect:starts_with]{ends_with()}}: Ends with a suffix.\n\\item \\code{\\link[tidyselect:starts_with]{contains()}}: Contains a literal string.\n\\item \\code{\\link[tidyselect:starts_with]{matches()}}: Matches a regular expression.\n\\item \\code{\\link[tidyselect:starts_with]{num_range()}}: Matches a numerical range like x01, x02, x03.\n}\n\nOr from variables stored in a character vector:\n\\itemize{\n\\item \\code{\\link[tidyselect:all_of]{all_of()}}: Matches variable names in a character vector. All\nnames must be present, otherwise an out-of-bounds error is\nthrown.\n\\item \\code{\\link[tidyselect:all_of]{any_of()}}: Same as \\code{all_of()}, except that no error is thrown\nfor names that don't exist.\n}\n\nOr using a predicate function:\n\\itemize{\n\\item \\code{\\link[tidyselect:where]{where()}}: Applies a function to all variables and selects those\nfor which the function returns \\code{TRUE}.\n}\n}\n}\n\\section{Methods}{\n\n\nThis function is a \\strong{generic}, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nThe following methods are currently available in loaded packages:\n\\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"select\")}.\n\n}\n\n\\section{Examples}{\n\n\n\nHere we show the usage for the basic selection operators. See the\nspecific help pages to learn about helpers like \\code{\\link[dplyr:starts_with]{starts_with()}}.\n\nThe selection language can be used in functions like\n\\code{dplyr::select()}. Let's first attach\nthe tidyverse:\n\n\\if{html}{\\out{}}\\preformatted{library(tidyverse)\n\n# For better printing\niris <- as_tibble(iris)\n}\\if{html}{\\out{
}}\n\nSelect variables by name:\n\n\\if{html}{\\out{}}\\preformatted{starwars |> select(height)\n#> # A tibble: 87 x 1\n#> height\n#> \n#> 1 172\n#> 2 167\n#> 3 96\n#> 4 202\n#> # i 83 more rows\n\niris |> select(Sepal.Length)\n#> # A tibble: 150 x 1\n#> Sepal.Length\n#> \n#> 1 5.1\n#> 2 4.9\n#> 3 4.7\n#> 4 4.6\n#> # i 146 more rows\n}\\if{html}{\\out{
}}\n\nSelect multiple variables by separating them with commas. Note how\nthe order of columns is determined by the order of inputs:\n\n\\if{html}{\\out{}}\\preformatted{starwars |> select(homeworld, height, mass)\n#> # A tibble: 87 x 3\n#> homeworld height mass\n#> \n#> 1 Tatooine 172 77\n#> 2 Tatooine 167 75\n#> 3 Naboo 96 32\n#> 4 Tatooine 202 136\n#> # i 83 more rows\n\niris |> select(Sepal.Length, Petal.Length)\n#> # A tibble: 150 x 2\n#> Sepal.Length Petal.Length\n#> \n#> 1 5.1 1.4\n#> 2 4.9 1.4\n#> 3 4.7 1.3\n#> 4 4.6 1.5\n#> # i 146 more rows\n}\\if{html}{\\out{
}}\n\nIf you use a named vector to select columns, the output will have\nits columns renamed:\n\n\\if{html}{\\out{}}\\preformatted{selection <- c(\n new_homeworld = \"homeworld\",\n new_height = \"height\",\n new_mass = \"mass\"\n)\nstarwars |> select(all_of(selection))\n#> # A tibble: 87 x 3\n#> new_homeworld new_height new_mass\n#> \n#> 1 Tatooine 172 77\n#> 2 Tatooine 167 75\n#> 3 Naboo 96 32\n#> 4 Tatooine 202 136\n#> # i 83 more rows\n}\\if{html}{\\out{
}}\n\\subsection{Operators:}{\n\nThe \\code{:} operator selects a range of consecutive variables:\n\n\\if{html}{\\out{}}\\preformatted{starwars |> select(name:mass)\n#> # A tibble: 87 x 3\n#> name height mass\n#> \n#> 1 Luke Skywalker 172 77\n#> 2 C-3PO 167 75\n#> 3 R2-D2 96 32\n#> 4 Darth Vader 202 136\n#> # i 83 more rows\n}\\if{html}{\\out{
}}\n\nThe \\code{!} operator negates a selection:\n\n\\if{html}{\\out{}}\\preformatted{starwars |> select(!(name:mass))\n#> # A tibble: 87 x 11\n#> hair_color skin_color eye_color birth_year sex gender homeworld species\n#> \n#> 1 blond fair blue 19 male masculine Tatooine Human \n#> 2 gold yellow 112 none masculine Tatooine Droid \n#> 3 white, blue red 33 none masculine Naboo Droid \n#> 4 none white yellow 41.9 male masculine Tatooine Human \n#> # i 83 more rows\n#> # i 3 more variables: films , vehicles , starships \n\niris |> select(!c(Sepal.Length, Petal.Length))\n#> # A tibble: 150 x 3\n#> Sepal.Width Petal.Width Species\n#> \n#> 1 3.5 0.2 setosa \n#> 2 3 0.2 setosa \n#> 3 3.2 0.2 setosa \n#> 4 3.1 0.2 setosa \n#> # i 146 more rows\n\niris |> select(!ends_with(\"Width\"))\n#> # A tibble: 150 x 3\n#> Sepal.Length Petal.Length Species\n#> \n#> 1 5.1 1.4 setosa \n#> 2 4.9 1.4 setosa \n#> 3 4.7 1.3 setosa \n#> 4 4.6 1.5 setosa \n#> # i 146 more rows\n}\\if{html}{\\out{
}}\n\n\\code{&} and \\code{|} take the intersection or the union of two selections:\n\n\\if{html}{\\out{}}\\preformatted{iris |> select(starts_with(\"Petal\") & ends_with(\"Width\"))\n#> # A tibble: 150 x 1\n#> Petal.Width\n#> \n#> 1 0.2\n#> 2 0.2\n#> 3 0.2\n#> 4 0.2\n#> # i 146 more rows\n\niris |> select(starts_with(\"Petal\") | ends_with(\"Width\"))\n#> # A tibble: 150 x 3\n#> Petal.Length Petal.Width Sepal.Width\n#> \n#> 1 1.4 0.2 3.5\n#> 2 1.4 0.2 3 \n#> 3 1.3 0.2 3.2\n#> 4 1.5 0.2 3.1\n#> # i 146 more rows\n}\\if{html}{\\out{
}}\n\nTo take the difference between two selections, combine the \\code{&} and\n\\code{!} operators:\n\n\\if{html}{\\out{}}\\preformatted{iris |> select(starts_with(\"Petal\") & !ends_with(\"Width\"))\n#> # A tibble: 150 x 1\n#> Petal.Length\n#> \n#> 1 1.4\n#> 2 1.4\n#> 3 1.3\n#> 4 1.5\n#> # i 146 more rows\n}\\if{html}{\\out{
}}\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> select(cell, orig.ident)\n\n}\n\\seealso{\nOther single table verbs: \n\\code{\\link[dplyr]{arrange}()},\n\\code{\\link[dplyr]{filter}()},\n\\code{\\link[dplyr]{mutate}()},\n\\code{\\link[dplyr]{reframe}()},\n\\code{\\link[dplyr]{rename}()},\n\\code{\\link[dplyr]{slice}()},\n\\code{\\link[dplyr]{summarise}()}\n}\n"
},
{
"path": "man/separate.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tidyr_methods.R\n\\name{separate}\n\\alias{separate}\n\\alias{separate.Seurat}\n\\title{Separate a character column into multiple columns with a regular\nexpression or numeric locations}\n\\usage{\n\\method{separate}{Seurat}(\n data,\n col,\n into,\n sep = \"[^[:alnum:]]+\",\n remove = TRUE,\n convert = FALSE,\n extra = \"warn\",\n fill = \"warn\",\n ...\n)\n}\n\\arguments{\n\\item{data}{A data frame.}\n\n\\item{col}{<\\code{\\link[tidyr:tidyr_tidy_select]{tidy-select}}> Column to expand.}\n\n\\item{into}{Names of new variables to create as character vector.\nUse \\code{NA} to omit the variable in the output.}\n\n\\item{sep}{Separator between columns.\n\nIf character, \\code{sep} is interpreted as a regular expression. The default\nvalue is a regular expression that matches any sequence of\nnon-alphanumeric values.\n\nIf numeric, \\code{sep} is interpreted as character positions to split at. Positive\nvalues start at 1 at the far-left of the string; negative value start at -1 at\nthe far-right of the string. The length of \\code{sep} should be one less than\n\\code{into}.}\n\n\\item{remove}{If \\code{TRUE}, remove input column from output data frame.}\n\n\\item{convert}{If \\code{TRUE}, will run \\code{\\link[=type.convert]{type.convert()}} with\n\\code{as.is = TRUE} on new columns. This is useful if the component\ncolumns are integer, numeric or logical.\n\nNB: this will cause string \\code{\"NA\"}s to be converted to \\code{NA}s.}\n\n\\item{extra}{If \\code{sep} is a character vector, this controls what\nhappens when there are too many pieces. There are three valid options:\n\\itemize{\n\\item \\code{\"warn\"} (the default): emit a warning and drop extra values.\n\\item \\code{\"drop\"}: drop any extra values without a warning.\n\\item \\code{\"merge\"}: only splits at most \\code{length(into)} times\n}}\n\n\\item{fill}{If \\code{sep} is a character vector, this controls what\nhappens when there are not enough pieces. There are three valid options:\n\\itemize{\n\\item \\code{\"warn\"} (the default): emit a warning and fill from the right\n\\item \\code{\"right\"}: fill with missing values on the right\n\\item \\code{\"left\"}: fill with missing values on the left\n}}\n\n\\item{...}{Additional arguments passed on to methods.}\n}\n\\value{\n`tidyseurat`\n}\n\\description{\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\\strong{[Superseded]}}\n\n\\code{separate()} has been superseded in favour of \\code{\\link[tidyr:separate_wider_position]{separate_wider_position()}}\nand \\code{\\link[tidyr:separate_wider_delim]{separate_wider_delim()}} because the two functions make the two uses\nmore obvious, the API is more polished, and the handling of problems is\nbetter. Superseded functions will not go away, but will only receive\ncritical bug fixes.\n\nGiven either a regular expression or a vector of character positions,\n\\code{separate()} turns a single character column into multiple columns.\n}\n\\examples{\ndata(pbmc_small)\nun <- pbmc_small |> unite(\"new_col\", c(orig.ident, groups))\nun |> separate(new_col, c(\"orig.ident\", \"groups\"))\n\n}\n\\seealso{\n\\code{\\link[tidyr:unite]{unite()}}, the complement, \\code{\\link[tidyr:extract]{extract()}} which uses regular\nexpression capturing groups.\n}\n"
},
{
"path": "man/slice.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{slice}\n\\alias{slice}\n\\alias{slice.Seurat}\n\\alias{slice_head}\n\\alias{slice_tail}\n\\alias{slice_sample}\n\\alias{slice_min}\n\\alias{slice_max}\n\\alias{slice_sample.Seurat}\n\\alias{slice_head.Seurat}\n\\alias{slice_tail.Seurat}\n\\alias{slice_min.Seurat}\n\\alias{slice_max.Seurat}\n\\title{Subset rows using their positions}\n\\usage{\n\\method{slice}{Seurat}(.data, ..., .by = NULL, .preserve = FALSE)\n\n\\method{slice_sample}{Seurat}(\n .data,\n ...,\n n = NULL,\n prop = NULL,\n by = NULL,\n weight_by = NULL,\n replace = FALSE\n)\n\n\\method{slice_head}{Seurat}(.data, ..., n, prop, by = NULL)\n\n\\method{slice_tail}{Seurat}(.data, ..., n, prop, by = NULL)\n\n\\method{slice_min}{Seurat}(\n .data,\n order_by,\n ...,\n n,\n prop,\n by = NULL,\n with_ties = TRUE,\n na_rm = FALSE\n)\n\n\\method{slice_max}{Seurat}(\n .data,\n order_by,\n ...,\n n,\n prop,\n by = NULL,\n with_ties = TRUE,\n na_rm = FALSE\n)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{For \\code{slice()}: <\\code{\\link[rlang:args_data_masking]{data-masking}}>\nInteger row values.\n\nProvide either positive values to keep, or negative values to drop.\nThe values provided must be either all positive or all negative.\nIndices beyond the number of rows in the input are silently ignored.\n\nFor \\verb{slice_*()}, these arguments are passed on to methods.}\n\n\\item{.by, by}{<\\code{\\link[dplyr:dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to\ngroup by for just this operation, functioning as an alternative to \\code{\\link[dplyr:group_by]{group_by()}}. For\ndetails and examples, see \\link[dplyr:dplyr_by]{?dplyr_by}.}\n\n\\item{.preserve}{Relevant when the \\code{.data} input is grouped. If \\code{.preserve = FALSE} (the default), the grouping structure is recalculated based on the\nresulting data, otherwise the grouping is kept as is.}\n\n\\item{n, prop}{Provide either \\code{n}, the number of rows, or \\code{prop}, the\nproportion of rows to select. If neither are supplied, \\code{n = 1} will be\nused. If \\code{n} is greater than the number of rows in the group\n(or \\code{prop > 1}), the result will be silently truncated to the group size.\n\\code{prop} will be rounded towards zero to generate an integer number of\nrows.\n\nA negative value of \\code{n} or \\code{prop} will be subtracted from the group\nsize. For example, \\code{n = -2} with a group of 5 rows will select 5 - 2 = 3\nrows; \\code{prop = -0.25} with 8 rows will select 8 * (1 - 0.25) = 6 rows.}\n\n\\item{weight_by}{<\\code{\\link[rlang:args_data_masking]{data-masking}}> Sampling\nweights. This must evaluate to a vector of non-negative numbers the same\nlength as the input. Weights are automatically standardised to sum to 1.\nSee the \\code{Details} section for more technical details regarding these\nweights.}\n\n\\item{replace}{Should sampling be performed with (\\code{TRUE}) or without\n(\\code{FALSE}, the default) replacement.}\n\n\\item{order_by}{<\\code{\\link[rlang:args_data_masking]{data-masking}}> Variable or\nfunction of variables to order by. To order by multiple variables, wrap\nthem in a data frame or tibble.}\n\n\\item{with_ties}{Should ties be kept together? The default, \\code{TRUE},\nmay return more rows than you request. Use \\code{FALSE} to ignore ties,\nand return the first \\code{n} rows.}\n\n\\item{na_rm}{Should missing values in \\code{order_by} be removed from the result?\nIf \\code{FALSE}, \\code{NA} values are sorted to the end (like in \\code{\\link[dplyr:arrange]{arrange()}}), so\nthey will only be included if there are insufficient non-missing values to\nreach \\code{n}/\\code{prop}.}\n}\n\\value{\nAn object of the same type as \\code{.data}. The output has the following\nproperties:\n\\itemize{\n\\item Each row may appear 0, 1, or many times in the output.\n\\item Columns are not modified.\n\\item Groups are not modified.\n\\item Data frame attributes are preserved.\n}\n}\n\\description{\n\\code{slice()} lets you index rows by their (integer) locations. It allows you\nto select, remove, and duplicate rows. It is accompanied by a number of\nhelpers for common use cases:\n\\itemize{\n\\item \\code{slice_head()} and \\code{slice_tail()} select the first or last rows.\n\\item \\code{slice_sample()} randomly selects rows.\n\\item \\code{slice_min()} and \\code{slice_max()} select rows with the smallest or largest\nvalues of a variable.\n}\n\nIf \\code{.data} is a \\link[dplyr]{grouped_df}, the operation will be performed on each group,\nso that (e.g.) \\code{slice_head(df, n = 5)} will select the first five rows in\neach group.\n}\n\\details{\nSlice does not work with relational databases because they have no\nintrinsic notion of row order. If you want to perform the equivalent\noperation, use \\code{\\link[dplyr:filter]{filter()}} and \\code{\\link[dplyr:row_number]{row_number()}}.\n\nFor \\code{slice_sample()}, note that the weights provided in \\code{weight_by} are\npassed through to the \\code{prob} argument of \\code{\\link[base:sample]{base::sample.int()}}. This means\nthey cannot be used to reconstruct summary statistics from the underlying\npopulation. See \\href{https://stats.stackexchange.com/q/639211/}{this discussion}\nfor more details.\n}\n\\section{Methods}{\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n\n\n\nThese function are \\strong{generic}s, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nMethods available in currently loaded packages:\n\\itemize{\n\\item \\code{slice()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice\")}.\n\\item \\code{slice_head()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_head\")}.\n\\item \\code{slice_tail()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_tail\")}.\n\\item \\code{slice_min()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_min\")}.\n\\item \\code{slice_max()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_max\")}.\n\\item \\code{slice_sample()}: \\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"slice_sample\")}.\n}\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> slice(1)\n\n# Slice group-wise using .by\npbmc_small |> slice(1:2, .by=groups)\n\n\n# slice_sample() allows you to random select with or without replacement\npbmc_small |> slice_sample(n=5)\n\n# if using replacement, and duplicate cells are returned, a tibble will be\n# returned because duplicate cells cannot exist in Seurat objects\npbmc_small |> slice_sample(n=1, replace=TRUE) # returns Seurat\npbmc_small |> slice_sample(n=100, replace=TRUE) # returns tibble\n\n# weight by a variable\npbmc_small |> slice_sample(n=5, weight_by=nCount_RNA)\n\n# sample by group\npbmc_small |> slice_sample(n=5, by=groups)\n\n# sample using proportions\npbmc_small |> slice_sample(prop=0.10)\n\n\n# First rows based on existing order\npbmc_small |> slice_head(n=5)\n\n\n# Last rows based on existing order\npbmc_small |> slice_tail(n=5)\n\n\n# Rows with minimum and maximum values of a metadata variable\npbmc_small |> slice_min(nFeature_RNA, n=5)\n\n# slice_min() and slice_max() may return more rows than requested\n# in the presence of ties.\npbmc_small |> slice_min(nFeature_RNA, n=2)\n\n# Use with_ties=FALSE to return exactly n matches\npbmc_small |> slice_min(nFeature_RNA, n=2, with_ties=FALSE)\n\n# Or use additional variables to break the tie:\npbmc_small |> slice_min(tibble::tibble(nFeature_RNA, nCount_RNA), n=2)\n\n# Use by for group-wise operations\npbmc_small |> slice_min(nFeature_RNA, n=5, by=groups)\n\n\n# Rows with minimum and maximum values of a metadata variable\npbmc_small |> slice_max(nFeature_RNA, n=5)\n\n}\n\\seealso{\nOther single table verbs: \n\\code{\\link{arrange}()},\n\\code{\\link{mutate}()},\n\\code{\\link{rename}()},\n\\code{\\link{summarise}()}\n}\n\\concept{single table verbs}\n"
},
{
"path": "man/summarise.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/dplyr_methods.R\n\\name{summarise}\n\\alias{summarise}\n\\alias{summarise.Seurat}\n\\alias{summarize}\n\\alias{summarize.Seurat}\n\\title{Summarise each group down to one row}\n\\usage{\n\\method{summarise}{Seurat}(.data, ...)\n\n\\method{summarize}{Seurat}(.data, ...)\n}\n\\arguments{\n\\item{.data}{A data frame, data frame extension (e.g. a tibble), or a\nlazy data frame (e.g. from dbplyr or dtplyr). See \\emph{Methods}, below, for\nmore details.}\n\n\\item{...}{<\\code{\\link[rlang:args_data_masking]{data-masking}}> Name-value pairs of\nsummary functions. The name will be the name of the variable in the result.\n\nThe value can be:\n\\itemize{\n\\item A vector of length 1, e.g. \\code{min(x)}, \\code{n()}, or \\code{sum(is.na(y))}.\n\\item A data frame with 1 row, to add multiple columns from a single expression.\n}}\n}\n\\value{\nAn object \\emph{usually} of the same type as \\code{.data}.\n\\itemize{\n\\item The rows come from the underlying \\code{\\link[dplyr:group_keys]{group_keys()}}.\n\\item The columns are a combination of the grouping keys and the summary\nexpressions that you provide.\n\\item The grouping structure is controlled by the \\verb{.groups=} argument, the\noutput may be another \\link[dplyr]{grouped_df}, a \\link[dplyr]{tibble} or a \\link[dplyr]{rowwise} data frame.\n\\item Data frame attributes are \\strong{not} preserved, because \\code{summarise()}\nfundamentally creates a new data frame.\n}\n}\n\\description{\n\\code{summarise()} creates a new data frame. It returns one row for each\ncombination of grouping variables; if there are no grouping variables, the\noutput will have a single row summarising all observations in the input. It\nwill contain one column for each grouping variable and one column for each of\nthe summary statistics that you have specified.\n\n\\code{summarise()} and \\code{summarize()} are synonyms.\n}\n\\section{Useful functions}{\n\n\n\\itemize{\n\\item Center: \\code{\\link[=mean]{mean()}}, \\code{\\link[=median]{median()}}\n\\item Spread: \\code{\\link[=sd]{sd()}}, \\code{\\link[=IQR]{IQR()}}, \\code{\\link[=mad]{mad()}}\n\\item Range: \\code{\\link[=min]{min()}}, \\code{\\link[=max]{max()}},\n\\item Position: \\code{\\link[dplyr:first]{first()}}, \\code{\\link[dplyr:last]{last()}}, \\code{\\link[dplyr:nth]{nth()}},\n\\item Count: \\code{\\link[dplyr:n]{n()}}, \\code{\\link[dplyr:n_distinct]{n_distinct()}}\n\\item Logical: \\code{\\link[=any]{any()}}, \\code{\\link[=all]{all()}}\n}\n\n}\n\n\\section{Backend variations}{\n\n\n\nThe data frame backend supports creating a variable and using it in the\nsame summary. This means that previously created summary variables can be\nfurther transformed or combined within the summary, as in \\code{\\link[dplyr:mutate]{mutate()}}.\nHowever, it also means that summary variables with the same names as previous\nvariables overwrite them, making those variables unavailable to later summary\nvariables.\n\nThis behaviour may not be supported in other backends. To avoid unexpected\nresults, consider using new names for your summary variables, especially when\ncreating multiple summaries.\n\n}\n\n\\section{Methods}{\n\n\nThis function is a \\strong{generic}, which means that packages can provide\nimplementations (methods) for other classes. See the documentation of\nindividual methods for extra arguments and differences in behaviour.\n\nThe following methods are currently available in loaded packages:\n\\Sexpr[stage=render,results=rd]{dplyr:::methods_rd(\"summarise\")}.\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> summarise(mean(nCount_RNA))\n\n}\n\\seealso{\nOther single table verbs: \n\\code{\\link{arrange}()},\n\\code{\\link{mutate}()},\n\\code{\\link{rename}()},\n\\code{\\link{slice}()}\n}\n\\concept{single table verbs}\n"
},
{
"path": "man/tbl_format_header.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/print_method.R\n\\name{tbl_format_header}\n\\alias{tbl_format_header}\n\\alias{tbl_format_header.tidySeurat}\n\\title{Format the header of a tibble}\n\\usage{\n\\method{tbl_format_header}{tidySeurat}(x, setup, ...)\n}\n\\arguments{\n\\item{x}{A tibble-like object.}\n\n\\item{setup}{A setup object returned from \\code{\\link[pillar:tbl_format_setup]{tbl_format_setup()}}.}\n\n\\item{...}{These dots are for future extensions and must be empty.}\n}\n\\value{\nA character vector.\n}\n\\description{\n\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\\strong{[Experimental]}}\n\nFor easier customization, the formatting of a tibble is split\ninto three components: header, body, and footer.\nThe \\code{tbl_format_header()} method is responsible for formatting the header\nof a tibble.\n\nOverride this method if you need to change the appearance\nof the entire header.\nIf you only need to change or extend the components shown in the header,\noverride or extend \\code{\\link[pillar:tbl_sum]{tbl_sum()}} for your class which is called by the\ndefault method.\n}\n\\examples{\n# TODO\n\n}\n"
},
{
"path": "man/tidy.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/methods.R\n\\name{tidy}\n\\alias{tidy}\n\\alias{tidy.Seurat}\n\\title{tidy for Seurat objects}\n\\usage{\n\\method{tidy}{Seurat}(x, ...)\n}\n\\arguments{\n\\item{x}{A Seurat object}\n\n\\item{...}{Additional arguments (not used)}\n}\n\\value{\nA tidyseurat object\n}\n\\description{\ntidy for Seurat objects\n}\n"
},
{
"path": "man/unite.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tidyr_methods.R\n\\name{unite}\n\\alias{unite}\n\\alias{unite.Seurat}\n\\title{Unite multiple columns into one by pasting strings together}\n\\usage{\n\\method{unite}{Seurat}(data, col, ..., sep = \"_\", remove = TRUE, na.rm = FALSE)\n}\n\\arguments{\n\\item{data}{A data frame.}\n\n\\item{col}{The name of the new column, as a string or symbol.\n\nThis argument is passed by expression and supports\n\\link[rlang:topic-inject]{quasiquotation} (you can unquote strings\nand symbols). The name is captured from the expression with\n\\code{\\link[rlang:defusing-advanced]{rlang::ensym()}} (note that this kind of interface where\nsymbols do not represent actual objects is now discouraged in the\ntidyverse; we support it here for backward compatibility).}\n\n\\item{...}{<\\code{\\link[tidyr:tidyr_tidy_select]{tidy-select}}> Columns to unite}\n\n\\item{sep}{Separator to use between values.}\n\n\\item{remove}{If \\code{TRUE}, remove input columns from output data frame.}\n\n\\item{na.rm}{If \\code{TRUE}, missing values will be removed prior to uniting\neach value.}\n}\n\\value{\n`tidyseurat`\n}\n\\description{\nConvenience function to paste together multiple columns into one.\n}\n\\examples{\ndata(pbmc_small)\npbmc_small |> unite(\n col=\"new_col\", \n c(\"orig.ident\", \"groups\"))\n \n}\n\\seealso{\n\\code{\\link[tidyr:separate]{separate()}}, the complement.\n}\n"
},
{
"path": "man/unnest.Rd",
"content": "% Generated by roxygen2: do not edit by hand\n% Please edit documentation in R/tidyr_methods.R\n\\name{unnest}\n\\alias{unnest}\n\\alias{unnest.tidyseurat_nested}\n\\alias{unnest_seurat}\n\\title{Unnest a list-column of data frames into rows and columns}\n\\usage{\n\\method{unnest}{tidyseurat_nested}(\n data,\n cols,\n ...,\n keep_empty = FALSE,\n ptype = NULL,\n names_sep = NULL,\n names_repair = \"check_unique\",\n .drop,\n .id,\n .sep,\n .preserve\n)\n\nunnest_seurat(\n data,\n cols,\n ...,\n keep_empty = FALSE,\n ptype = NULL,\n names_sep = NULL,\n names_repair = \"check_unique\",\n .drop,\n .id,\n .sep,\n .preserve\n)\n}\n\\arguments{\n\\item{data}{A data frame.}\n\n\\item{cols}{<\\code{\\link[tidyr:tidyr_tidy_select]{tidy-select}}> List-columns to unnest.\n\nWhen selecting multiple columns, values from the same row will be recycled\nto their common size.}\n\n\\item{...}{\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}:\npreviously you could write \\code{df |> unnest(x, y, z)}.\nConvert to \\code{df |> unnest(c(x, y, z))}. If you previously created a new\nvariable in \\code{unnest()} you'll now need to do it explicitly with \\code{mutate()}.\nConvert \\code{df |> unnest(y = fun(x, y, z))}\nto \\code{df |> mutate(y = fun(x, y, z)) |> unnest(y)}.}\n\n\\item{keep_empty}{By default, you get one row of output for each element\nof the list that you are unchopping/unnesting. This means that if there's a\nsize-0 element (like \\code{NULL} or an empty data frame or vector), then that\nentire row will be dropped from the output. If you want to preserve all\nrows, use \\code{keep_empty = TRUE} to replace size-0 elements with a single row\nof missing values.}\n\n\\item{ptype}{Optionally, a named list of column name-prototype pairs to\ncoerce \\code{cols} to, overriding the default that will be guessed from\ncombining the individual values. Alternatively, a single empty ptype\ncan be supplied, which will be applied to all \\code{cols}.}\n\n\\item{names_sep}{If \\code{NULL}, the default, the outer names will come from the\ninner names. If a string, the outer names will be formed by pasting\ntogether the outer and the inner column names, separated by \\code{names_sep}.}\n\n\\item{names_repair}{Used to check that output data frame has valid\nnames. Must be one of the following options:\n\\itemize{\n\\item \\verb{\"minimal}\": no name repair or checks, beyond basic existence,\n\\item \\verb{\"unique}\": make sure names are unique and not empty,\n\\item \\verb{\"check_unique}\": (the default), no name repair, but check they are unique,\n\\item \\verb{\"universal}\": make the names unique and syntactic\n\\item a function: apply custom name repair.\n\\item \\link[tidyr]{tidyr_legacy}: use the name repair from tidyr 0.8.\n\\item a formula: a purrr-style anonymous function (see \\code{\\link[rlang:as_function]{rlang::as_function()}})\n}\n\nSee \\code{\\link[vctrs:vec_as_names]{vctrs::vec_as_names()}} for more details on these terms and the\nstrategies used to enforce them.}\n\n\\item{.drop, .preserve}{\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}:\nall list-columns are now preserved; If there are any that you\ndon't want in the output use \\code{select()} to remove them prior to\nunnesting.}\n\n\\item{.id}{\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}:\nconvert \\code{df |> unnest(x, .id = \"id\")} to \\verb{df |> mutate(id = names(x)) |> unnest(x))}.}\n\n\\item{.sep}{\\ifelse{html}{\\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\\strong{[Deprecated]}}:\nuse \\code{names_sep} instead.}\n}\n\\value{\n`tidyseurat`\n}\n\\description{\nUnnest expands a list-column containing data frames into rows and columns.\n}\n\\section{New syntax}{\n\n\ntidyr 1.0.0 introduced a new syntax for \\code{nest()} and \\code{unnest()} that's\ndesigned to be more similar to other functions. Converting to the new syntax\nshould be straightforward (guided by the message you'll receive) but if\nyou just need to run an old analysis, you can easily revert to the previous\nbehaviour using \\code{\\link[tidyr:nest_legacy]{nest_legacy()}} and \\code{\\link[tidyr:unnest_legacy]{unnest_legacy()}} as follows:\n\n\\if{html}{\\out{}}\\preformatted{library(tidyr)\nnest <- nest_legacy\nunnest <- unnest_legacy\n}\\if{html}{\\out{
}}\n\n}\n\n\\examples{\ndata(pbmc_small)\npbmc_small |> \n nest(data=-groups) |> \n unnest(data)\n\n}\n\\seealso{\nOther rectangling: \n\\code{\\link[tidyr]{hoist}()},\n\\code{\\link[tidyr]{unnest_longer}()},\n\\code{\\link[tidyr]{unnest_wider}()}\n}\n"
},
{
"path": "tests/testthat/test-dplyr.R",
"content": "context('dplyr test')\n\nlibrary(Seurat)\ndata(\"pbmc_small\")\nset.seed(42)\n\ntest_that(\"arrange\", {\n \n pbmc_small |> \n arrange(nFeature_RNA) |> \n expect_warning(regexp = \"`arrange\\\\(\\\\)` was deprecated in tidyseurat .*\")\n \n # pbmc_small_pca_arranged <- pbmc_small |> arrange(nFeature_RNA) |> Seurat::ScaleData() |> Seurat::FindVariableFeatures() |> Seurat::RunPCA()\n # pbmc_small_pca <- pbmc_small |> Seurat::ScaleData() |> Seurat::FindVariableFeatures() |> Seurat::RunPCA()\n # expect_equal(\n # Seurat::VariableFeatures(pbmc_small_pca_arranged),\n # Seurat::VariableFeatures(pbmc_small_pca)\n # )\n \n # # Failing only for ATLAS CRAN, but succeding for the rest\n # expect_equal(\n # pbmc_small_pca_arranged[[\"pca\"]]@cell.embeddings,\n # pbmc_small_pca[[\"pca\"]]@cell.embeddings,\n # tolerance=0.1\n # )\n # expect_equal(\n # pbmc_small_pca_arranged |> as_tibble() |>dplyr::slice_head(n = 1),\n # pbmc_small_pca |> as_tibble() |> dplyr::slice_min(nFeature_RNA, n = 1)\n # )\n\n})\n\ntest_that(\"bind_cols\", {\n pbmc_small_bind <- pbmc_small |> select(nCount_RNA, nFeature_RNA)\n pbmc_small |>\n ttservice::bind_cols(pbmc_small_bind) |>\n select(nCount_RNA...2, nFeature_RNA...3) |>\n ncol() |>\n expect_equal(2)\n})\n\ntest_that(\"distinct\", {\n expect_equal(pbmc_small |> distinct(groups) |> ncol(), 1)\n})\n\ntest_that(\"filter\", {\n expect_equal(\n pbmc_small |> filter(groups == \"g1\") |> ncol(),\n sum(pbmc_small[[]]$groups == \"g1\")\n )\n})\n\ntest_that(\"group_by\", {\n expect_equal(\n pbmc_small |> group_by(groups) |> nrow(),\n nrow(pbmc_small[[]])\n )\n})\n\ntest_that(\"summarise\", {\n expect_equal(pbmc_small |> summarise(mean(nCount_RNA)) |> nrow(), 1)\n})\n\ntest_that(\"mutate\", {\n expect_equal(pbmc_small |> mutate(nFeature_RNA = 1) |> distinct(nFeature_RNA) |> nrow(), 1)\n})\n\ntest_that(\"rename\", {\n expect_equal(pbmc_small |> rename(s_score = nFeature_RNA) |> select(s_score) |> ncol(), 1)\n})\n\ntest_that(\"left_join\", {\n expect_equal(\n pbmc_small |> left_join(pbmc_small |> distinct(groups) |> mutate(new_column = 1:2) |> slice(1)) |> ncol(),\n nrow(pbmc_small[[]])\n )\n})\n\ntest_that(\"inner_join\", {\n expect_equal(\n pbmc_small |> inner_join(pbmc_small |> distinct(groups) |> mutate(new_column = 1:2) |> slice(1)) |> ncol(),\n sum(pbmc_small[[]]$groups == \"g2\")\n )\n})\n\ntest_that(\"right_join\", {\n expect_equal(\n pbmc_small |> right_join(pbmc_small |> distinct(groups) |> mutate(new_column = 1:2) |> slice(1)) |> ncol(),\n sum(pbmc_small[[]]$groups == \"g2\")\n )\n})\n\ntest_that(\"full_join\", {\n expect_equal(\n pbmc_small |> full_join(tibble::tibble(groups = \"g1\", other = 1:4)) |> nrow(),\n sum(pbmc_small[[]]$groups == \"g1\") * 4 + sum(pbmc_small[[]]$groups == \"g2\")\n )\n})\n\ntest_that(\"slice\", {\n expect_equal(pbmc_small |> slice(1) |> ncol(), 1)\n expect_equal(\n pbmc_small |> slice(1:6) |> colnames(),\n colnames(pbmc_small) |> head(6))\n})\n\ntest_that(\"sample_n\", {\n expect_equal(pbmc_small |> sample_n(50) |> ncol(), 50)\n expect_equal(\n pbmc_small |> sample_n(500, replace = TRUE) |> ncol(),\n pbmc_small |> as_tibble() |> ncol()\n )\n})\n\ntest_that(\"slice_sample\", {\n pbmc_small |>\n slice_sample(n = 50) |>\n ncol() |>\n expect_equal(50)\n})\n\ntest_that(\"slice_head\", {\n pbmc_small |>\n slice_head(n = 50) |>\n ncol() |>\n expect_equal(50)\n expect_equal(\n colnames(pbmc_small) |> head(n = 50),\n pbmc_small |> slice_head(n = 50) |> colnames()\n )\n})\n\ntest_that(\"slice_tail\", {\n pbmc_small |>\n slice_tail(n = 50) |>\n ncol() |>\n expect_equal(50)\n expect_equal(\n colnames(pbmc_small) |> tail(n = 50),\n pbmc_small |> slice_tail(n = 50) |> colnames()\n )\n})\n\ntest_that(\"slice_min\", {\n pbmc_small |>\n slice_min(nFeature_RNA, n = 5) |>\n ncol() |>\n expect_equal(5)\n \n # Arrange is deprecated\n # expect_equal(\n # pbmc_small |> as_tibble() |> arrange(nFeature_RNA) |> head(n = 5) %>% pull(.cell),\n # pbmc_small |> slice_min(nFeature_RNA, n = 5) |> colnames()\n # )\n})\n\ntest_that(\"slice_max\", {\n pbmc_small |>\n slice_max(nFeature_RNA, n = 5) |>\n ncol() |>\n expect_equal(5)\n \n # Arrange is deprecated\n # expect_equal(\n # pbmc_small |> as_tibble() |> arrange(desc(nFeature_RNA)) |> head(n = 5) %>% pull(.cell),\n # pbmc_small |> slice_max(nFeature_RNA, n = 5) |> colnames()\n # )\n})\n\ntest_that(\"slice_min slice_max tibble input for order_by\", {\n pbmc_small |>\n slice_min(tibble::tibble(nFeature_RNA, nCount_RNA), n = 5) |>\n ncol() |>\n expect_equal(5)\n pbmc_small |>\n slice_max(tibble::tibble(nFeature_RNA, nCount_RNA), n = 5) |>\n ncol() |>\n expect_equal(5)\n})\n\ntest_that(\"select\", {\n expect_equal(pbmc_small |> select(cell, orig.ident) |> class() |> as.character(), \"Seurat\")\n expect_equal(pbmc_small |> select(orig.ident) |> class() |> as.character() |> purrr::pluck(1), \"tbl_df\")\n})\n\ntest_that(\"sample_frac\", {\n expect_equal(\n pbmc_small |> sample_frac(0.1) |> ncol(),\n nrow(pbmc_small[[]]) * 0.1\n )\n expect_equal(\n pbmc_small |> sample_frac(10, replace = TRUE) |> ncol(),\n pbmc_small |> as_tibble() |> ncol()\n )\n})\n\ntest_that(\"count\", {\n expect_equal(\n pbmc_small |> count(groups) |> nrow(),\n pbmc_small[[]]$groups |> unique() |> length()\n )\n})\n\ntest_that(\"add_count\", {\n expect_equal(\n pbmc_small |> add_count(groups) |> nrow(),\n pbmc_small |> rownames() |> length()\n )\n})\n\ntest_that(\"rowwise\", {\n expect_equal(\n pbmc_small |> rowwise() |> mutate(m = mean(c(nCount_RNA, nFeature_RNA))) |> purrr::pluck(\"m\", 1),\n ((pbmc_small[, 1]$nCount_RNA + pbmc_small[, 1]$nFeature_RNA) / 2) |> unname()\n )\n})\n\ntest_that(\"group_split() works for one variable\", {\n fd <- pbmc_small |> \n group_split(groups)\n expect_equal(length(fd), length(unique(pbmc_small$groups)))\n})\n\ntest_that(\"group_split() works for combination of variables\", {\n fd <- pbmc_small |> \n group_split(groups, letter.idents)\n expect_equal(length(fd), length(unique(pbmc_small$groups)) *\n length(unique(pbmc_small$letter.idents)))\n})\n\ntest_that(\"group_split() works for one logical statement\", {\n fd_log <- pbmc_small |> \n group_split(groups==\"g1\")\n fd_var <- pbmc_small |> \n group_split(groups==\"g1\")\n expect_equal(lapply(fd_var, count), lapply(fd_log, count))\n})\n\ntest_that(\"group_split() works for two logical statements\", {\n fd <- pbmc_small |>\n group_split(PC_1>0 & groups==\"g1\")\n fd_counts <- lapply(fd, count)\n expect_equal(c(fd_counts[[1]], fd_counts[[2]], use.names = FALSE), \n list(75, 5))\n})\n"
},
{
"path": "tests/testthat/test-ggplotly_methods.R",
"content": "context('ggplot test')\n\ndata(\"pbmc_small\")\n\ndf <- pbmc_small\ndf$number <- rnorm(ncol(df))\ndf$factor <- sample(gl(3, 1, ncol(df)))\n\ntest_that(\"ggplot\", {\n # cell metadata\n p <- ggplot(df, aes(factor, number)) \n expect_silent(show(p))\n expect_s3_class(p, \"ggplot\")\n # assay data\n g <- sample(rownames(df), 1)\n fd <- join_features(df, g, shape=\"wide\")\n p <- ggplot(fd, aes(factor, .data[[g]]))\n expect_silent(show(p))\n expect_s3_class(p, \"ggplot\")\n # reduced dimensions\n p <- ggplot(df, aes(PC_1, PC_2, col=factor))\n expect_silent(show(p))\n expect_s3_class(p, \"ggplot\")\n})\n\ntest_that(\"plotly\", {\n # cell metadata\n p <- plot_ly(df, x=~factor, y=~number, type=\"violin\") \n expect_silent(show(p))\n expect_s3_class(p, \"plotly\")\n # assay data\n g <- sample(rownames(df), 1)\n fd <- join_features(df, g, shape=\"wide\")\n p <- plot_ly(fd, x=~factor, y=g, type=\"violin\") \n expect_silent(show(p))\n expect_s3_class(p, \"plotly\")\n # reduced dimensions\n p <- plot_ly(fd, x=~PC_1, y=~PC_2, type=\"scatter\", mode=\"markers\") \n expect_silent(show(p))\n expect_s3_class(p, \"plotly\")\n})\n"
},
{
"path": "tests/testthat/test-methods.R",
"content": "context('methods test')\n\ndata(\"pbmc_small\")\n\ntest_that(\"join_features_long\", {\n pbmc_small |> \n join_features(\"CD3D\", shape=\"long\") |> \n slice(1) |>\n pull(.abundance_RNA) |>\n expect_equal(6.35, tolerance = 0.1)\n})\n\ntest_that(\"join_features_wide\", {\n pbmc_small |> \n join_features(\"CD3D\", shape=\"wide\") |> \n slice(1) |>\n pull(CD3D) |>\n expect_equal(6.35, tolerance = 0.1)\n})\n\ntest_that(\"join_features_default_wide\", {\n pbmc_small |> \n join_features(\"CD3D\") |> \n slice(1) |>\n pull(CD3D) |>\n expect_equal(6.35, tolerance = 0.1)\n})\n\ntest_that(\"aggregate_cells() returns expected values\", {\n # Create pseudo-bulk object for testing\n pbmc_pseudo_bulk <-\n pbmc_small |>\n aggregate_cells(c(groups, letter.idents), assays = \"RNA\")\n \n # Check row length is unchanged\n pbmc_pseudo_bulk |>\n distinct(.feature) |> \n nrow() |>\n expect_equal(pbmc_small |> nrow())\n \n # Check column length is correctly modified\n pbmc_pseudo_bulk |> \n distinct(.sample) |> \n nrow() |>\n expect_equal(pbmc_small |>\n as_tibble() |>\n select(groups, letter.idents) |>\n unique() |>\n nrow()\n )\n # Spot check for correctly aggregated count value of ACAP1 gene\n pbmc_pseudo_bulk |> \n filter(.feature == \"ACAP1\" & .sample == \"g1___A\") |> \n select(RNA) |> \n as.numeric() |> \n expect_equal(\n Seurat::DietSeurat(pbmc_small, assays = \"RNA\", features = \"ACAP1\")[, pbmc_small |>\n as_tibble() |>\n filter(groups == \"g1\", letter.idents == \"A\") |>\n pull(.cell)] |>\n LayerData() |> \n sum())\n \n # Aggregate with tidyselect\n pbmc_small |>\n aggregate_cells(c(any_of(\"groups\"), letter.idents), assays = \"RNA\") |> \n expect_no_error()\n})\n\ntest_that(\"get_abundance_sc_wide\", {\n expect_equal(\n pbmc_small |> get_abundance_sc_wide() |> nrow(),\n pbmc_small[[]] |> nrow()\n )\n expect_equal(\n pbmc_small |> get_abundance_sc_wide() |> pull(\"S100A9\") |> sum(),\n pbmc_small |> FetchData(\"S100A9\") |> sum(), \n tolerance = 0.1\n )\n})\n\ntest_that(\"get_abundance_sc_long\", {\n expect_equal(pbmc_small |> get_abundance_sc_long() |> ncol(), 3)\n expect_equal(\n pbmc_small |> get_abundance_sc_long() |> filter(.feature == \"S100A9\") |> pull(\".abundance_RNA\") |> sum(),\n pbmc_small |> FetchData(\"S100A9\") |> sum(),\n tolerance = 0.1\n )\n})\n\n\n\n"
},
{
"path": "tests/testthat/test-pillar.R",
"content": "context('pillar test')\n\ntest_string <- \"A small string to test the function of pillar utilities.\"\n\ntest_that(\"pillar___format_comment\", {\n test_string |>\n pillar___format_comment(width = 20) |>\n stringr::str_count(\"# \") |> \n expect_equal(5)\n})\n\ntest_that(\"pillar___strwrap2\", {\n test_string |>\n pillar___strwrap2(width = 20, indent = 4) |>\n stringr::str_count(\" \") |> \n expect_equal(c(0, 1, 1, 1, 1))\n})\n\ntest_that(\"pillar___wrap\", {\n test_string |>\n pillar___wrap(width = 20) |>\n stringr::str_count(\"\\n\") |> \n expect_equal(3)\n})"
},
{
"path": "tests/testthat/test-print.R",
"content": "context('print test')\n\ndata(\"pbmc_small\")\n\ntest_that(\"print\", {\n text <- capture.output(print(pbmc_small))\n expect_equal(grep(\"Seurat-tibble abstraction\", text), 1)\n i <- grep(str <- \".*Features=([0-9]+).*\", text)\n expect_equal(gsub(str, \"\\\\1\", text[i]), paste(nrow(pbmc_small)))\n i <- grep(str <- \".*Cells=([0-9]+).*\", text)\n expect_equal(gsub(str, \"\\\\1\", text[i]), paste(ncol(pbmc_small)))\n})\n\ntest_that(\"glimpse\", {\n text <- capture.output(glimpse(pbmc_small))\n expect_equal(length(text), 37)\n})\n"
},
{
"path": "tests/testthat/test-tidyr.R",
"content": "context('tidyr test')\n\ndata(\"pbmc_small\")\ntt <- GetAssayData(pbmc_small, layer = 'counts', assay = \"RNA\") |> CreateSeuratObject() |> mutate(groups = sprintf(\"g%s\", rep(1:2, dplyr::n()/2)))\n\ntest_that(\"nest_unnest\", {\n col_names <- colnames(tt[[]]) |> c(\"cell\")\n x <- tt |> nest(data = -groups) |> unnest(data) |> Seurat::NormalizeData() |> Seurat::ScaleData() |> Seurat::FindVariableFeatures() |> Seurat::RunPCA()\n y <- tt |> Seurat::NormalizeData() |> Seurat::ScaleData() |> Seurat::FindVariableFeatures() |> Seurat::RunPCA()\n expect_equal(\n x[[\"pca\"]]@cell.embeddings |> as_tibble(rownames = \"cell\") |> arrange(cell) |> pull(PC_1),\n y[[\"pca\"]]@cell.embeddings |> as_tibble(rownames = \"cell\") |> arrange(cell) |> pull(PC_1)\n )\n})\n\ntest_that(\"fast_vs_slow_nest\", {\n expect_identical(\n tt |> mutate(groups2 = groups) |> nest(data = -c(groups, groups2)) |> select(-groups2),\n tt |> nest(data = -groups) \n )\n})\n\ntest_that(\"nest_unnest_slice_1\", {\n expect_equal(\n tt |> nest(data = -groups) |> slice(1) |> unnest(data) |> ncol(),\n sum(tt[[]]$groups == \"g1\")\n )\n})\ntest_that(\"unite separate\", {\n un <- tt |> unite(\"new_col\", c(orig.ident, groups))\n se <- un |> separate(col = new_col, into = c(\"orig.ident\", \"groups\"))\n expect_equal(un |> select(new_col) |> slice(1) |> pull(new_col), \"SeuratProject_g1\")\n expect_equal(se |> select(orig.ident) |> ncol(), 1)\n})\n\ntest_that(\"extract\", {\n expect_equal(\n tt |> extract(groups, into = \"g\", regex = \"g([0-9])\", convert = TRUE) |> pull(g) |> class(),\n \"integer\"\n )\n})\n\ntest_that(\"pivot_longer\", {\n expect_equal(\n tt |> pivot_longer(c(orig.ident, groups), names_to = \"name\", values_to = \"value\") |> class() |> magrittr::extract2(1),\n \"tbl_df\"\n )\n})\n"
},
{
"path": "tests/testthat/test-utilities.R",
"content": "context('utilities test')\n\ndata(\"pbmc_small\")\n\ntest_that(\"get_special_column_name_symbol\", {\n expect_equal(get_special_column_name_symbol(\".cell\")$symbol, rlang::sym(\".cell\"))\n expect_equal(get_special_column_name_symbol(\".cell\")$name, c(\".cell\"))\n})\n\ntest_that(\"ping_old_special_column_into_metadata\", {\n ping_old_special_column_into_metadata(pbmc_small) |>\n as_tibble() |>\n colnames() |>\n purrr::pluck(1) |>\n expect_equal(\"cell\")\n})\n\n"
},
{
"path": "tests/testthat.R",
"content": "library(testthat)\nlibrary(tidyseurat)\n\ntest_check(\"tidyseurat\")\n"
},
{
"path": "vignettes/figures_article.Rmd",
"content": "---\ntitle: \"Code for producing the figures in the article\"\nauthor: \"Stefano Mangiola\"\ndate: \"`r Sys.Date()`\"\npackage: tidyseurat\noutput:\n html_vignette:\n toc_float: true\nvignette: >\n %\\VignetteEngine{knitr::knitr}\n %\\VignetteIndexEntry{Code for producing the figures in the article}\n %\\usepackage[UTF-8]{inputenc}\n---\n\n\n[](https://lifecycle.r-lib.org/articles/stages.html)\n\n\n```{r include=FALSE}\n# Set path to plotly screenshot. We don't run the plotly code chunk as most servers do not have javascript libraries needed for interactive plotting\nscreenshot <- \"../man/figures/plotly.png\"\n\n# The chunk below uses Rmd in man/fragments to avoid duplication, as the content is shared with the vignette and README. As suggested here: https://www.garrickadenbuie.com/blog/dry-vignette-and-readme/\n\nvisual_cue <- \"../man/figures/logo_interaction-01.png\"\n\n```\n\n```{r eval=FALSE}\n# Article workflow\n\nlibrary(tidyverse)\nlibrary(Seurat)\nlibrary(SingleR)\nlibrary(plotly)\nlibrary(tidyHeatmap)\nlibrary(ggalluvial)\nlibrary(ggplot2)\nlibrary(tidyseurat)\noptions(future.globals.maxSize = 50068 * 1024^2)\n\n# Use colourblind-friendly colours\nfriendly_cols <- dittoSeq::dittoColors()\n\n# Set theme\ncustom_theme <-\n list(\n scale_fill_manual(values = friendly_cols),\n scale_color_manual(values = friendly_cols),\n theme_bw() +\n theme(\n panel.border = element_blank(),\n axis.line = element_line(),\n panel.grid.major = element_line(size = 0.2),\n panel.grid.minor = element_line(size = 0.1),\n text = element_text(size = 9),\n legend.position = \"bottom\",\n strip.background = element_blank(),\n axis.title.x = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10)),\n axis.title.y = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10)),\n axis.text.x = element_text(angle = 30, hjust = 1, vjust = 1)\n )\n )\n\nPBMC_clean_scaled_UMAP_cluster_cell_type <- readRDS(\"dev/PBMC_clean_scaled_UMAP_cluster_cell_type.rds\")\n```\n\n```{r eval=FALSE}\np1 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n pivot_longer(\n c(mito.fraction, S.Score, G2M.Score), \n names_to=\"property\", \n values_to=\"Value\"\n ) %>%\n mutate(property = factor(property, levels = c(\"mito.fraction\", \"G2M.Score\", \"S.Score\"))) %>%\n ggplot(aes(sample, Value)) + \n geom_boxplot(outlier.size = 0.5 ) + \n facet_wrap(~property, scales = \"free_y\" ) +\n custom_theme +\n theme(aspect.ratio=1)\n```\n\n```{r eval=FALSE}\np2 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n sample_n(20000) %>%\n ggplot(aes(UMAP_1, UMAP_2, color=seurat_clusters)) +\n geom_point(size=0.05, alpha=0.2) +\n custom_theme +\n theme(aspect.ratio=1)\n\nPBMC_clean_scaled_UMAP_cluster_cell_type %>%\n sample_n(20000) %>%\n plot_ly(\n x = ~`UMAP_1`,\n y = ~`UMAP_2`,\n z = ~`UMAP_3`,\n color = ~seurat_clusters,\n colors = friendly_cols[1:24],sizes = 50, size = 1\n )\n\nmarkers = readRDS(\"dev/PBMC_marker_df.rds\")\n```\n\n```{r eval=FALSE}\np3 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n arrange(first.labels) %>%\n mutate(seurat_clusters = fct_inorder(seurat_clusters)) %>%\n join_features(features=c(\"CD3D\", \"HLA-DRB1\")) %>%\n ggplot(aes(y=seurat_clusters , x=.abundance_SCT, fill=first.labels)) +\n geom_density_ridges(bandwidth = 0.2) +\n facet_wrap(~ .feature, nrow = 2) +\n coord_flip() +\n custom_theme\n```\n\n```{r eval=FALSE}\n# Plot heatmap\np4 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n sample_n(2000) %>%\n DoHeatmap(\n features = markers$gene,\n group.colors = friendly_cols\n )\n```\n\n```{r eval=FALSE}\np5 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n sample_n(1000) %>%\n join_features(features=markers$gene) %>%\n mutate(seurat_clusters = as.integer(seurat_clusters)) %>%\n filter(seurat_clusters<10) %>%\n group_by(seurat_clusters) %>%\n \n # Plot heatmap\n heatmap(\n .row = .feature,\n .column = .cell, \n .value = .abundance_SCT, \n palette_grouping = list(rep(\"black\",9)), \n palette_value = circlize::colorRamp2(c(-1.5, 0, 1.5), c(\"purple\", \"black\", \"yellow\")),\n \n # ComplexHeatmap parameters\n row_gap = unit(0.1, \"mm\"), column_gap = unit(0.1, \"mm\")\n ) %>%\n \n # Add annotation\n add_tile(sample, palette = friendly_cols[1:7]) %>%\n add_point(PC_1) \n```\n\n```{r eval=FALSE}\np6 = \n PBMC_clean_scaled_UMAP_cluster_cell_type %>%\n unite(\"cluster_cell_type\", c(first.labels, seurat_clusters), remove=FALSE) %>%\n pivot_longer(\n c(seurat_clusters, first.labels_single),\n names_to = \"classification\", values_to = \"value\"\n ) %>%\n \n ggplot(aes(x = classification, stratum = value, alluvium = cell,\n fill = first.labels, label = value)) +\n scale_x_discrete(expand = c(1, 1)) +\n geom_flow() +\n geom_stratum(alpha = .5) +\n # geom_text(stat = \"stratum\", size = 3) +\n geom_text_repel(stat = \"stratum\", size = 3,\n nudge_x = 0.05,\n direction = \"y\",\n angle = 0,\n vjust = 0,\n segment.size = 0.2\n ) +\n scale_fill_manual(values = friendly_cols) +\n #guides(fill = FALSE) +\n coord_flip() +\n theme_bw() +\n theme(\n panel.border = element_blank(),\n axis.line = element_line(),\n panel.grid.major = element_line(size = 0.2),\n panel.grid.minor = element_line(size = 0.1),\n text = element_text(size = 9),\n legend.position = \"bottom\",\n strip.background = element_blank(),\n axis.title.x = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10)),\n axis.title.y = element_text(margin = margin(t = 10, r = 10, b = 10, l = 10)),\n axis.text.x = element_text(angle = 30, hjust = 1, vjust = 1)\n )\n```\n\n"
},
{
"path": "vignettes/introduction.Rmd",
"content": "---\ntitle: \"Overview of the tidyseurat package\"\nauthor: \"Stefano Mangiola\"\ndate: \"`r Sys.Date()`\"\npackage: tidyseurat\noutput:\n html_vignette:\n toc_float: true\nbibliography: tidyseurat.bib\nvignette: >\n %\\VignetteEngine{knitr::knitr}\n %\\VignetteIndexEntry{Overview of the tidyseurat package}\n %\\usepackage[UTF-8]{inputenc}\n---\n\n\n[](https://lifecycle.r-lib.org/articles/stages.html)\n\n\n```{r include=FALSE}\n# Set path to plotly screenshot. We don't run the plotly code chunk as most servers do not have javascript libraries needed for interactive plotting\nscreenshot <- \"../man/figures/plotly.png\"\n\n# The chunk below uses Rmd in man/fragments to avoid duplication, as the content is shared with the vignette and README. As suggested here: https://www.garrickadenbuie.com/blog/dry-vignette-and-readme/\n\nvisual_cue <- \"../man/figures/logo_interaction-01.png\"\n\n```\n\n```{r child=\"../man/fragments/intro.Rmd\"}\n```\n\n# Session Info\n\n```{r}\nsessionInfo()\n```\n\n\n# References"
},
{
"path": "vignettes/tidyseurat.bib",
"content": "@article{butler2018integrating,\n title={Integrating single-cell transcriptomic data across different conditions, technologies, and species},\n author={Butler, Andrew and Hoffman, Paul and Smibert, Peter and Papalexi, Efthymia and Satija, Rahul},\n journal={Nature biotechnology},\n volume={36},\n number={5},\n pages={411--420},\n year={2018},\n publisher={Nature Publishing Group}\n}\n\n@article{stuart2019comprehensive,\n title={Comprehensive integration of single-cell data},\n author={Stuart, Tim and Butler, Andrew and Hoffman, Paul and Hafemeister, Christoph and Papalexi, Efthymia and Mauck III, William M and Hao, Yuhan and Stoeckius, Marlon and Smibert, Peter and Satija, Rahul},\n journal={Cell},\n volume={177},\n number={7},\n pages={1888--1902},\n year={2019},\n publisher={Elsevier}\n}\n\n@article{aran2019reference,\n title={Reference-based analysis of lung single-cell sequencing reveals a transitional profibrotic macrophage},\n author={Aran, Dvir and Looney, Agnieszka P and Liu, Leqian and Wu, Esther and Fong, Valerie and Hsu, Austin and Chak, Suzanna and Naikawadi, Ram P and Wolters, Paul J and Abate, Adam R and others},\n journal={Nature immunology},\n volume={20},\n number={2},\n pages={163--172},\n year={2019},\n publisher={Nature Publishing Group}\n}\n\n@article{cabello2020singlecellsignalr,\n title={SingleCellSignalR: inference of intercellular networks from single-cell transcriptomics},\n author={Cabello-Aguilar, Simon and Alame, M{\\'e}lissa and Kon-Sun-Tack, Fabien and Fau, Caroline and Lacroix, Matthieu and Colinge, Jacques},\n journal={Nucleic acids research},\n volume={48},\n number={10},\n pages={e55--e55},\n year={2020},\n publisher={Oxford University Press}\n}\n\n@article{wickham2019welcome,\n title={Welcome to the Tidyverse},\n author={Wickham, Hadley and Averick, Mara and Bryan, Jennifer and Chang, Winston and McGowan, Lucy D'Agostino and Fran{\\c{c}}ois, Romain and Grolemund, Garrett and Hayes, Alex and Henry, Lionel and Hester, Jim and others},\n journal={Journal of Open Source Software},\n volume={4},\n number={43},\n pages={1686},\n year={2019}\n}\n"
}
]![\"Watch](\"https://img.youtube.com/vi/wKnyocRCvW4/mqdefault.jpg\")
\n![\"visual](\"man/figures/logo_interaction-01.png\"){kind=logo}
\n![\"screenshot](\"man/figures/plotly.png\")
\n