s2H P@ޠ@
S="=P QM3S AdA)sdb-T}P"I~pnTQ
'K đ^l&enXe `feUG/|*HCGN!koQlF^Mp+=x/H
= dplyr/man/ 0000755 0001762 0000144 00000000000 14525503021 012154 5 ustar ligges users dplyr/man/cross_join.Rd 0000644 0001762 0000144 00000005050 14366556340 014632 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join-cross.R
\name{cross_join}
\alias{cross_join}
\title{Cross join}
\usage{
cross_join(x, y, ..., copy = FALSE, suffix = c(".x", ".y"))
}
\arguments{
\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or
lazy data frames (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{Other parameters passed onto methods.}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{suffix}{If there are non-joined duplicate variables in \code{x} and
\code{y}, these suffixes will be added to the output to disambiguate them.
Should be a character vector of length 2.}
}
\value{
An object of the same type as \code{x} (including the same groups). The output has
the following properties:
\itemize{
\item There are \code{nrow(x) * nrow(y)} rows returned.
\item Output columns include all columns from both \code{x} and \code{y}. Column name
collisions are resolved using \code{suffix}.
\item The order of the rows and columns of \code{x} is preserved as much as possible.
}
}
\description{
Cross joins match each row in \code{x} to every row in \code{y}, resulting in a data
frame with \code{nrow(x) * nrow(y)} rows.
Since cross joins result in all possible matches between \code{x} and \code{y}, they
technically serve as the basis for all \link[=mutate-joins]{mutating joins}, which
can generally be thought of as cross joins followed by a filter. In practice,
a more specialized procedure is used for better performance.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("cross_join")}.
}
\examples{
# Cross joins match each row in `x` to every row in `y`.
# Data within the columns is not used in the matching process.
cross_join(band_instruments, band_members)
# Control the suffix added to variables duplicated in
# `x` and `y` with `suffix`.
cross_join(band_instruments, band_members, suffix = c("", "_y"))
}
\seealso{
Other joins:
\code{\link{filter-joins}},
\code{\link{mutate-joins}},
\code{\link{nest_join}()}
}
\concept{joins}
dplyr/man/glimpse.Rd 0000644 0001762 0000144 00000001763 14366556340 014131 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/reexport-pillar.R
\name{glimpse}
\alias{glimpse}
\title{Get a glimpse of your data}
\value{
x original x is (invisibly) returned, allowing \code{glimpse()} to be
used within a data pipeline.
}
\description{
\code{glimpse()} is like a transposed version of \code{print()}:
columns run down the page, and data runs across.
This makes it possible to see every column in a data frame.
It's a little like \code{\link[=str]{str()}} applied to a data frame
but it tries to show you as much data as possible.
(And it always shows the underlying data, even when applied
to a remote data source.)
\code{glimpse()} is provided by the pillar package, and re-exported
by dplyr. See \code{\link[pillar:glimpse]{pillar::glimpse()}} for more details.
}
\examples{
glimpse(mtcars)
# Note that original x is (invisibly) returned, allowing `glimpse()` to be
# used within a pipeline.
mtcars \%>\%
glimpse() \%>\%
select(1:3)
glimpse(starwars)
}
dplyr/man/tbl_vars.Rd 0000644 0001762 0000144 00000001166 14366556340 014302 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/tbl.R
\name{tbl_vars}
\alias{tbl_vars}
\alias{tbl_nongroup_vars}
\title{List variables provided by a tbl.}
\usage{
tbl_vars(x)
tbl_nongroup_vars(x)
}
\arguments{
\item{x}{A tbl object}
}
\description{
\code{tbl_vars()} returns all variables while \code{tbl_nongroup_vars()}
returns only non-grouping variables. The \code{groups} attribute
of the object returned by \code{tbl_vars()} is a character vector of the
grouping columns.
}
\seealso{
\code{\link[=group_vars]{group_vars()}} for a function that returns grouping
variables.
}
\keyword{internal}
dplyr/man/count.Rd 0000644 0001762 0000144 00000007714 14420040360 013600 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/count-tally.R
\name{count}
\alias{count}
\alias{count.data.frame}
\alias{tally}
\alias{add_count}
\alias{add_tally}
\title{Count the observations in each group}
\usage{
count(x, ..., wt = NULL, sort = FALSE, name = NULL)
\method{count}{data.frame}(
x,
...,
wt = NULL,
sort = FALSE,
name = NULL,
.drop = group_by_drop_default(x)
)
tally(x, wt = NULL, sort = FALSE, name = NULL)
add_count(x, ..., wt = NULL, sort = FALSE, name = NULL, .drop = deprecated())
add_tally(x, wt = NULL, sort = FALSE, name = NULL)
}
\arguments{
\item{x}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr).}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Variables to group
by.}
\item{wt}{<\code{\link[rlang:args_data_masking]{data-masking}}> Frequency weights.
Can be \code{NULL} or a variable:
\itemize{
\item If \code{NULL} (the default), counts the number of rows in each group.
\item If a variable, computes \code{sum(wt)} for each group.
}}
\item{sort}{If \code{TRUE}, will show the largest groups at the top.}
\item{name}{The name of the new column in the output.
If omitted, it will default to \code{n}. If there's already a column called \code{n},
it will use \code{nn}. If there's a column called \code{n} and \code{nn}, it'll use
\code{nnn}, and so on, adding \code{n}s until it gets a new name.}
\item{.drop}{Handling of factor levels that don't appear in the data, passed
on to \code{\link[=group_by]{group_by()}}.
For \code{count()}: if \code{FALSE} will include counts for empty groups (i.e. for
levels of factors that don't exist in the data).
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}} For \code{add_count()}: deprecated since it
can't actually affect the output.}
}
\value{
An object of the same type as \code{.data}. \code{count()} and \code{add_count()}
group transiently, so the output has the same groups as the input.
}
\description{
\code{count()} lets you quickly count the unique values of one or more variables:
\code{df \%>\% count(a, b)} is roughly equivalent to
\code{df \%>\% group_by(a, b) \%>\% summarise(n = n())}.
\code{count()} is paired with \code{tally()}, a lower-level helper that is equivalent
to \code{df \%>\% summarise(n = n())}. Supply \code{wt} to perform weighted counts,
switching the summary from \code{n = n()} to \code{n = sum(wt)}.
\code{add_count()} and \code{add_tally()} are equivalents to \code{count()} and \code{tally()}
but use \code{mutate()} instead of \code{summarise()} so that they add a new column
with group-wise counts.
}
\examples{
# count() is a convenient way to get a sense of the distribution of
# values in a dataset
starwars \%>\% count(species)
starwars \%>\% count(species, sort = TRUE)
starwars \%>\% count(sex, gender, sort = TRUE)
starwars \%>\% count(birth_decade = round(birth_year, -1))
# use the `wt` argument to perform a weighted count. This is useful
# when the data has already been aggregated once
df <- tribble(
~name, ~gender, ~runs,
"Max", "male", 10,
"Sandra", "female", 1,
"Susan", "female", 4
)
# counts rows:
df \%>\% count(gender)
# counts runs:
df \%>\% count(gender, wt = runs)
# When factors are involved, `.drop = FALSE` can be used to retain factor
# levels that don't appear in the data
df2 <- tibble(
id = 1:5,
type = factor(c("a", "c", "a", NA, "a"), levels = c("a", "b", "c"))
)
df2 \%>\% count(type)
df2 \%>\% count(type, .drop = FALSE)
# Or, using `group_by()`:
df2 \%>\% group_by(type, .drop = FALSE) \%>\% count()
# tally() is a lower-level function that assumes you've done the grouping
starwars \%>\% tally()
starwars \%>\% group_by(species) \%>\% tally()
# both count() and tally() have add_ variants that work like
# mutate() instead of summarise
df \%>\% add_count(gender, wt = runs)
df \%>\% add_tally(wt = runs)
}
dplyr/man/summarise_each.Rd 0000644 0001762 0000144 00000001572 14272222416 015442 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-lazyeval.R
\name{summarise_each}
\alias{summarise_each}
\alias{summarise_each_}
\alias{mutate_each}
\alias{mutate_each_}
\alias{summarize_each}
\alias{summarize_each_}
\title{Summarise and mutate multiple columns.}
\usage{
summarise_each(tbl, funs, ...)
summarise_each_(tbl, funs, vars)
mutate_each(tbl, funs, ...)
mutate_each_(tbl, funs, vars)
summarize_each(tbl, funs, ...)
summarize_each_(tbl, funs, vars)
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
\code{mutate_each()} and \code{summarise_each()} are deprecated in favour of
the new \code{\link[=across]{across()}} function that works within \code{summarise()} and \code{mutate()}.
}
\keyword{internal}
dplyr/man/ntile.Rd 0000644 0001762 0000144 00000002604 14366556340 013577 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rank.R
\name{ntile}
\alias{ntile}
\title{Bucket a numeric vector into \code{n} groups}
\usage{
ntile(x = row_number(), n)
}
\arguments{
\item{x}{A vector to rank
By default, the smallest values will get the smallest ranks. Use \code{\link[=desc]{desc()}}
to reverse the direction so the largest values get the smallest ranks.
Missing values will be given rank \code{NA}. Use \code{coalesce(x, Inf)} or
\code{coalesce(x, -Inf)} if you want to treat them as the largest or smallest
values respectively.
To rank by multiple columns at once, supply a data frame.}
\item{n}{Number of groups to bucket into}
}
\description{
\code{ntile()} is a sort of very rough rank, which breaks the input vector into
\code{n} buckets. If \code{length(x)} is not an integer multiple of \code{n}, the size of
the buckets will differ by up to one, with larger buckets coming first.
Unlike other ranking functions, \code{ntile()} ignores ties: it will create
evenly sized buckets even if the same value of \code{x} ends up in different
buckets.
}
\examples{
x <- c(5, 1, 3, 2, 2, NA)
ntile(x, 2)
ntile(x, 4)
# If the bucket sizes are uneven, the larger buckets come first
ntile(1:8, 3)
# Ties are ignored
ntile(rep(1, 8), 3)
}
\seealso{
Other ranking functions:
\code{\link{percent_rank}()},
\code{\link{row_number}()}
}
\concept{ranking functions}
dplyr/man/do.Rd 0000644 0001762 0000144 00000003744 14366556340 013074 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-do.R
\name{do}
\alias{do}
\title{Do anything}
\usage{
do(.data, ...)
}
\arguments{
\item{.data}{a tbl}
\item{...}{Expressions to apply to each group. If named, results will be
stored in a new column. If unnamed, must return a data frame. You can
use \code{.} to refer to the current group. You can not mix named and
unnamed arguments.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{do()} is superseded as of dplyr 1.0.0, because its syntax never really
felt like it belonged with the rest of dplyr. It's replaced by a combination
of \code{\link[=reframe]{reframe()}} (which can produce multiple rows and multiple columns),
\code{\link[=nest_by]{nest_by()}} (which creates a \link{rowwise} tibble of nested data),
and \code{\link[=pick]{pick()}} (which allows you to access the data for the "current" group).
}
\examples{
# do() with unnamed arguments becomes reframe() or summarise()
# . becomes pick()
by_cyl <- mtcars \%>\% group_by(cyl)
by_cyl \%>\% do(head(., 2))
# ->
by_cyl \%>\% reframe(head(pick(everything()), 2))
by_cyl \%>\% slice_head(n = 2)
# Can refer to variables directly
by_cyl \%>\% do(mean = mean(.$vs))
# ->
by_cyl \%>\% summarise(mean = mean(vs))
# do() with named arguments becomes nest_by() + mutate() & list()
models <- by_cyl \%>\% do(mod = lm(mpg ~ disp, data = .))
# ->
models <- mtcars \%>\%
nest_by(cyl) \%>\%
mutate(mod = list(lm(mpg ~ disp, data = data)))
models \%>\% summarise(rsq = summary(mod)$r.squared)
# use broom to turn models into data
models \%>\% do(data.frame(
var = names(coef(.$mod)),
coef(summary(.$mod)))
)
\dontshow{if (requireNamespace("broom", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
# ->
models \%>\% reframe(broom::tidy(mod))
\dontshow{\}) # examplesIf}
}
\keyword{internal}
dplyr/man/top_n.Rd 0000644 0001762 0000144 00000003606 14266276767 013621 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/top-n.R
\name{top_n}
\alias{top_n}
\alias{top_frac}
\title{Select top (or bottom) n rows (by value)}
\usage{
top_n(x, n, wt)
top_frac(x, n, wt)
}
\arguments{
\item{x}{A data frame.}
\item{n}{Number of rows to return for \code{top_n()}, fraction of rows to
return for \code{top_frac()}. If \code{n} is positive, selects the top rows.
If negative, selects the bottom rows.
If \code{x} is grouped, this is the number (or fraction) of rows per group.
Will include more rows if there are ties.}
\item{wt}{(Optional). The variable to use for ordering. If not
specified, defaults to the last variable in the tbl.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{top_n()} has been superseded in favour of \code{\link[=slice_min]{slice_min()}}/\code{\link[=slice_max]{slice_max()}}.
While it will not be deprecated in the near future, retirement means
that we will only perform critical bug fixes, so we recommend moving to the
newer alternatives.
\code{top_n()} was superseded because the name was fundamentally confusing as
it returned what you might reasonably consider to be the \emph{bottom}
rows. Additionally, the \code{wt} variable had a confusing name, and strange
default (the last column in the data frame). Unfortunately we could not
see an easy way to fix the existing \code{top_n()} function without breaking
existing code, so we created a new alternative.
}
\examples{
df <- data.frame(x = c(6, 4, 1, 10, 3, 1, 1))
df \%>\% top_n(2) # highest values
df \%>\% top_n(-2) # lowest values
# now use
df \%>\% slice_max(x, n = 2)
df \%>\% slice_min(x, n = 2)
# top_frac() -> prop argument of slice_min()/slice_max()
df \%>\% top_frac(.5)
# ->
df \%>\% slice_max(x, prop = 0.5)
}
\keyword{internal}
dplyr/man/arrange_all.Rd 0000644 0001762 0000144 00000006420 14366556340 014733 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-arrange.R
\name{arrange_all}
\alias{arrange_all}
\alias{arrange_at}
\alias{arrange_if}
\title{Arrange rows by a selection of variables}
\usage{
arrange_all(.tbl, .funs = list(), ..., .by_group = FALSE, .locale = NULL)
arrange_at(.tbl, .vars, .funs = list(), ..., .by_group = FALSE, .locale = NULL)
arrange_if(
.tbl,
.predicate,
.funs = list(),
...,
.by_group = FALSE,
.locale = NULL
)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.by_group}{If \code{TRUE}, will sort first by grouping variable. Applies to
grouped data frames only.}
\item{.locale}{The locale to sort character vectors in.
\itemize{
\item If \code{NULL}, the default, uses the \code{"C"} locale unless the
\code{dplyr.legacy_locale} global option escape hatch is active. See the
\link{dplyr-locale} help page for more details.
\item If a single string from \code{\link[stringi:stri_locale_list]{stringi::stri_locale_list()}} is supplied, then
this will be used as the locale to sort with. For example, \code{"en"} will
sort with the American English locale. This requires the stringi package.
\item If \code{"C"} is supplied, then character vectors will always be sorted in the
C locale. This does not require stringi and is often much faster than
supplying a locale identifier.
}
The C locale is not the same as English locales, such as \code{"en"},
particularly when it comes to data containing a mix of upper and lower case
letters. This is explained in more detail on the \link[=dplyr-locale]{locale}
help page under the \verb{Default locale} section.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
These \link{scoped} variants of \code{\link[=arrange]{arrange()}} sort a data frame by a
selection of variables. Like \code{\link[=arrange]{arrange()}}, you can modify the
variables before ordering with the \code{.funs} argument.
}
\section{Grouping variables}{
The grouping variables that are part of the selection participate
in the sorting of the data frame.
}
\examples{
df <- as_tibble(mtcars)
arrange_all(df)
# ->
arrange(df, pick(everything()))
arrange_all(df, desc)
# ->
arrange(df, across(everything(), desc))
}
\keyword{internal}
dplyr/man/group_trim.Rd 0000644 0001762 0000144 00000002153 14366556340 014652 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-trim.R
\name{group_trim}
\alias{group_trim}
\title{Trim grouping structure}
\usage{
group_trim(.tbl, .drop = group_by_drop_default(.tbl))
}
\arguments{
\item{.tbl}{A \link[=grouped_df]{grouped data frame}}
\item{.drop}{See \code{\link[=group_by]{group_by()}}}
}
\value{
A \link[=grouped_df]{grouped data frame}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
Drop unused levels of all factors that are used as grouping variables,
then recalculates the grouping structure.
\code{group_trim()} is particularly useful after a \code{\link[=filter]{filter()}} that is intended
to select a subset of groups.
}
\examples{
iris \%>\%
group_by(Species) \%>\%
filter(Species == "setosa", .preserve = TRUE) \%>\%
group_trim()
}
\seealso{
Other grouping functions:
\code{\link{group_by}()},
\code{\link{group_map}()},
\code{\link{group_nest}()},
\code{\link{group_split}()}
}
\concept{grouping functions}
dplyr/man/last_dplyr_warnings.Rd 0000644 0001762 0000144 00000001225 14366556340 016547 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/conditions.R
\name{last_dplyr_warnings}
\alias{last_dplyr_warnings}
\title{Show warnings from the last command}
\usage{
last_dplyr_warnings(n = 5)
}
\arguments{
\item{n}{Passed to \code{\link[=head]{head()}} so that only the first \code{n} warnings are
displayed.}
}
\description{
Warnings that occur inside a dplyr verb like \code{mutate()} are caught
and stashed away instead of being emitted to the console. This
prevents rowwise and grouped data frames from flooding the console
with warnings. To see the original warnings, use
\code{last_dplyr_warnings()}.
}
\keyword{internal}
dplyr/man/summarise.Rd 0000644 0001762 0000144 00000014554 14406402754 014472 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/summarise.R
\name{summarise}
\alias{summarise}
\alias{summarize}
\title{Summarise each group down to one row}
\usage{
summarise(.data, ..., .by = NULL, .groups = NULL)
summarize(.data, ..., .by = NULL, .groups = NULL)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Name-value pairs of
summary functions. The name will be the name of the variable in the result.
The value can be:
\itemize{
\item A vector of length 1, e.g. \code{min(x)}, \code{n()}, or \code{sum(is.na(y))}.
\item A data frame, to add multiple columns from a single expression.
}
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}} Returning values with size 0 or >1 was
deprecated as of 1.1.0. Please use \code{\link[=reframe]{reframe()}} for this instead.}
\item{.by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
\item{.groups}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}} Grouping structure of the
result.
\itemize{
\item "drop_last": dropping the last level of grouping. This was the
only supported option before version 1.0.0.
\item "drop": All levels of grouping are dropped.
\item "keep": Same grouping structure as \code{.data}.
\item "rowwise": Each row is its own group.
}
When \code{.groups} is not specified, it is chosen
based on the number of rows of the results:
\itemize{
\item If all the results have 1 row, you get "drop_last".
\item If the number of rows varies, you get "keep" (note that returning a
variable number of rows was deprecated in favor of \code{\link[=reframe]{reframe()}}, which
also unconditionally drops all levels of grouping).
}
In addition, a message informs you of that choice, unless the result is ungrouped,
the option "dplyr.summarise.inform" is set to \code{FALSE},
or when \code{summarise()} is called from a function in a package.}
}
\value{
An object \emph{usually} of the same type as \code{.data}.
\itemize{
\item The rows come from the underlying \code{\link[=group_keys]{group_keys()}}.
\item The columns are a combination of the grouping keys and the summary
expressions that you provide.
\item The grouping structure is controlled by the \verb{.groups=} argument, the
output may be another \link{grouped_df}, a \link{tibble} or a \link{rowwise} data frame.
\item Data frame attributes are \strong{not} preserved, because \code{summarise()}
fundamentally creates a new data frame.
}
}
\description{
\code{summarise()} creates a new data frame. It returns one row for each
combination of grouping variables; if there are no grouping variables, the
output will have a single row summarising all observations in the input. It
will contain one column for each grouping variable and one column for each of
the summary statistics that you have specified.
\code{summarise()} and \code{summarize()} are synonyms.
}
\section{Useful functions}{
\itemize{
\item Center: \code{\link[=mean]{mean()}}, \code{\link[=median]{median()}}
\item Spread: \code{\link[=sd]{sd()}}, \code{\link[=IQR]{IQR()}}, \code{\link[=mad]{mad()}}
\item Range: \code{\link[=min]{min()}}, \code{\link[=max]{max()}},
\item Position: \code{\link[=first]{first()}}, \code{\link[=last]{last()}}, \code{\link[=nth]{nth()}},
\item Count: \code{\link[=n]{n()}}, \code{\link[=n_distinct]{n_distinct()}}
\item Logical: \code{\link[=any]{any()}}, \code{\link[=all]{all()}}
}
}
\section{Backend variations}{
The data frame backend supports creating a variable and using it in the
same summary. This means that previously created summary variables can be
further transformed or combined within the summary, as in \code{\link[=mutate]{mutate()}}.
However, it also means that summary variables with the same names as previous
variables overwrite them, making those variables unavailable to later summary
variables.
This behaviour may not be supported in other backends. To avoid unexpected
results, consider using new names for your summary variables, especially when
creating multiple summaries.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("summarise")}.
}
\examples{
# A summary applied to ungrouped tbl returns a single row
mtcars \%>\%
summarise(mean = mean(disp), n = n())
# Usually, you'll want to group first
mtcars \%>\%
group_by(cyl) \%>\%
summarise(mean = mean(disp), n = n())
# Each summary call removes one grouping level (since that group
# is now just a single row)
mtcars \%>\%
group_by(cyl, vs) \%>\%
summarise(cyl_n = n()) \%>\%
group_vars()
# BEWARE: reusing variables may lead to unexpected results
mtcars \%>\%
group_by(cyl) \%>\%
summarise(disp = mean(disp), sd = sd(disp))
# Refer to column names stored as strings with the `.data` pronoun:
var <- "mass"
summarise(starwars, avg = mean(.data[[var]], na.rm = TRUE))
# Learn more in ?rlang::args_data_masking
# In dplyr 1.1.0, returning multiple rows per group was deprecated in favor
# of `reframe()`, which never messages and always returns an ungrouped
# result:
mtcars \%>\%
group_by(cyl) \%>\%
summarise(qs = quantile(disp, c(0.25, 0.75)), prob = c(0.25, 0.75))
# ->
mtcars \%>\%
group_by(cyl) \%>\%
reframe(qs = quantile(disp, c(0.25, 0.75)), prob = c(0.25, 0.75))
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()}
}
\concept{single table verbs}
dplyr/man/bind_cols.Rd 0000644 0001762 0000144 00000002433 14525503021 014401 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/bind-cols.R
\name{bind_cols}
\alias{bind_cols}
\title{Bind multiple data frames by column}
\usage{
bind_cols(
...,
.name_repair = c("unique", "universal", "check_unique", "minimal")
)
}
\arguments{
\item{...}{Data frames to combine. Each argument can either be a data frame,
a list that could be a data frame, or a list of data frames.
Inputs are \link[vctrs:theory-faq-recycling]{recycled} to the same length,
then matched by position.}
\item{.name_repair}{One of \code{"unique"}, \code{"universal"}, or
\code{"check_unique"}. See \code{\link[vctrs:vec_as_names]{vctrs::vec_as_names()}} for the meaning of these
options.}
}
\value{
A data frame the same type as the first element of \code{...}.
}
\description{
Bind any number of data frames by column, making a wider result.
This is similar to \code{do.call(cbind, dfs)}.
Where possible prefer using a \link[=left_join]{join} to combine multiple
data frames. \code{bind_cols()} binds the rows in order in which they appear
so it is easy to create meaningless results without realising it.
}
\examples{
df1 <- tibble(x = 1:3)
df2 <- tibble(y = 3:1)
bind_cols(df1, df2)
# Row sizes must be compatible when column-binding
try(bind_cols(tibble(x = 1:3), tibble(y = 1:2)))
}
dplyr/man/dplyr-locale.Rd 0000644 0001762 0000144 00000006573 14366556340 015064 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/locale.R
\name{dplyr-locale}
\alias{dplyr-locale}
\title{Locale used by \code{arrange()}}
\description{
This page documents details about the locale used by \code{\link[=arrange]{arrange()}} when
ordering character vectors.
\subsection{Default locale}{
The default locale used by \code{arrange()} is the C locale. This is used when
\code{.locale = NULL} unless the \code{dplyr.legacy_locale} global option is set to
\code{TRUE}. You can also force the C locale to be used unconditionally with
\code{.locale = "C"}.
The C locale is not exactly the same as English locales, such as \code{"en"}. The
main difference is that the C locale groups the English alphabet by \emph{case},
while most English locales group the alphabet by \emph{letter}. For example,
\code{c("a", "b", "C", "B", "c")} will sort as \code{c("B", "C", "a", "b", "c")} in the
C locale, with all uppercase letters coming before lowercase letters, but
will sort as \code{c("a", "b", "B", "c", "C")} in an English locale. This often
makes little practical difference during data analysis, because both return
identical results when case is consistent between observations.
}
\subsection{Reproducibility}{
The C locale has the benefit of being completely reproducible across all
supported R versions and operating systems with no extra effort.
If you set \code{.locale} to an option from \code{\link[stringi:stri_locale_list]{stringi::stri_locale_list()}}, then
stringi must be installed by anyone who wants to run your code. If you
utilize this in a package, then stringi should be placed in \code{Imports}.
}
\subsection{Legacy behavior}{
Prior to dplyr 1.1.0, character columns were ordered in the system locale. If
you need to temporarily revert to this behavior, you can set the global
option \code{dplyr.legacy_locale} to \code{TRUE}, but this should be used sparingly and
you should expect this option to be removed in a future version of dplyr. It
is better to update existing code to explicitly use \code{.locale} instead. Note
that setting \code{dplyr.legacy_locale} will also force calls to \code{\link[=group_by]{group_by()}} to
use the system locale when internally ordering the groups.
Setting \code{.locale} will override any usage of \code{dplyr.legacy_locale}.
}
}
\examples{
\dontshow{if (dplyr:::has_minimum_stringi()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
df <- tibble(x = c("a", "b", "C", "B", "c"))
df
# Default locale is C, which groups the English alphabet by case, placing
# uppercase letters before lowercase letters.
arrange(df, x)
# The American English locale groups the alphabet by letter.
# Explicitly override `.locale` with `"en"` for this ordering.
arrange(df, x, .locale = "en")
# This Danish letter is expected to sort after `z`
df <- tibble(x = c("o", "p", "\u00F8", "z"))
df
# The American English locale sorts it right after `o`
arrange(df, x, .locale = "en")
# Using `"da"` for Danish ordering gives the expected result
arrange(df, x, .locale = "da")
# If you need the legacy behavior of `arrange()`, which respected the
# system locale, then you can set the global option `dplyr.legacy_locale`,
# but expect this to be removed in the future. We recommend that you use
# the `.locale` argument instead.
rlang::with_options(dplyr.legacy_locale = TRUE, {
arrange(df, x)
})
\dontshow{\}) # examplesIf}
}
\keyword{internal}
dplyr/man/group_nest.Rd 0000644 0001762 0000144 00000004452 14366556340 014654 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-nest.R
\name{group_nest}
\alias{group_nest}
\title{Nest a tibble using a grouping specification}
\usage{
group_nest(.tbl, ..., .key = "data", keep = FALSE)
}
\arguments{
\item{.tbl}{A tbl}
\item{...}{Grouping specification, forwarded to \code{\link[=group_by]{group_by()}}}
\item{.key}{the name of the list column}
\item{keep}{Should the grouping columns be kept in the list column.}
}
\value{
A tbl with one row per unique combination of the grouping variables.
The first columns are the grouping variables, followed by a list column of tibbles
with matching rows of the remaining columns.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
Nest a tibble using a grouping specification
}
\section{Lifecycle}{
\code{group_nest()} is not stable because \code{\link[tidyr:nest]{tidyr::nest(.by =)}}
provides very similar behavior. It may be deprecated in the future.
}
\section{Grouped data frames}{
The primary use case for \code{\link[=group_nest]{group_nest()}} is with already grouped data frames,
typically a result of \code{\link[=group_by]{group_by()}}. In this case \code{\link[=group_nest]{group_nest()}} only uses
the first argument, the grouped tibble, and warns when \code{...} is used.
}
\section{Ungrouped data frames}{
When used on ungrouped data frames, \code{\link[=group_nest]{group_nest()}} forwards the \code{...} to
\code{\link[=group_by]{group_by()}} before nesting, therefore the \code{...} are subject to the data mask.
}
\examples{
#----- use case 1: a grouped data frame
iris \%>\%
group_by(Species) \%>\%
group_nest()
# this can be useful if the grouped data has been altered before nesting
iris \%>\%
group_by(Species) \%>\%
filter(Sepal.Length > mean(Sepal.Length)) \%>\%
group_nest()
#----- use case 2: using group_nest() on a ungrouped data frame with
# a grouping specification that uses the data mask
starwars \%>\%
group_nest(species, homeworld)
}
\seealso{
Other grouping functions:
\code{\link{group_by}()},
\code{\link{group_map}()},
\code{\link{group_split}()},
\code{\link{group_trim}()}
}
\concept{grouping functions}
\keyword{internal}
dplyr/man/starwars.Rd 0000644 0001762 0000144 00000002321 14525503021 014307 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/data-starwars.R
\docType{data}
\name{starwars}
\alias{starwars}
\title{Starwars characters}
\format{
A tibble with 87 rows and 14 variables:
\describe{
\item{name}{Name of the character}
\item{height}{Height (cm)}
\item{mass}{Weight (kg)}
\item{hair_color,skin_color,eye_color}{Hair, skin, and eye colors}
\item{birth_year}{Year born (BBY = Before Battle of Yavin)}
\item{sex}{The biological sex of the character, namely male, female, hermaphroditic, or none (as in the case for Droids).}
\item{gender}{The gender role or gender identity of the character as determined by their personality or the way they were programmed (as in the case for Droids).}
\item{homeworld}{Name of homeworld}
\item{species}{Name of species}
\item{films}{List of films the character appeared in}
\item{vehicles}{List of vehicles the character has piloted}
\item{starships}{List of starships the character has piloted}
}
}
\usage{
starwars
}
\description{
The original data, from SWAPI, the Star Wars API, \url{https://swapi.py4e.com/}, has been revised
to reflect additional research into gender and sex determinations of characters.
}
\examples{
starwars
}
\keyword{datasets}
dplyr/man/select.Rd 0000644 0001762 0000144 00000021664 14416000530 013727 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/select.R
\name{select}
\alias{select}
\title{Keep or drop columns using their names and types}
\usage{
select(.data, ...)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> One or more unquoted
expressions separated by commas. Variable names can be used as if they
were positions in the data frame, so expressions like \code{x:y} can
be used to select a range of variables.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Rows are not affected.
\item Output columns are a subset of input columns, potentially with a different
order. Columns will be renamed if \code{new_name = old_name} form is used.
\item Data frame attributes are preserved.
\item Groups are maintained; you can't select off grouping variables.
}
}
\description{
Select (and optionally rename) variables in a data frame, using a concise
mini-language that makes it easy to refer to variables based on their name
(e.g. \code{a:f} selects all columns from \code{a} on the left to \code{f} on the
right) or type (e.g. \code{where(is.numeric)} selects all numeric columns).
\subsection{Overview of selection features}{
Tidyverse selections implement a dialect of R where operators make
it easy to select variables:
\itemize{
\item \code{:} for selecting a range of consecutive variables.
\item \code{!} for taking the complement of a set of variables.
\item \code{&} and \code{|} for selecting the intersection or the union of two
sets of variables.
\item \code{c()} for combining selections.
}
In addition, you can use \strong{selection helpers}. Some helpers select specific
columns:
\itemize{
\item \code{\link[tidyselect:everything]{everything()}}: Matches all variables.
\item \code{\link[tidyselect:everything]{last_col()}}: Select last variable, possibly with an offset.
\item \code{\link[=group_cols]{group_cols()}}: Select all grouping columns.
}
Other helpers select variables by matching patterns in their names:
\itemize{
\item \code{\link[tidyselect:starts_with]{starts_with()}}: Starts with a prefix.
\item \code{\link[tidyselect:starts_with]{ends_with()}}: Ends with a suffix.
\item \code{\link[tidyselect:starts_with]{contains()}}: Contains a literal string.
\item \code{\link[tidyselect:starts_with]{matches()}}: Matches a regular expression.
\item \code{\link[tidyselect:starts_with]{num_range()}}: Matches a numerical range like x01, x02, x03.
}
Or from variables stored in a character vector:
\itemize{
\item \code{\link[tidyselect:all_of]{all_of()}}: Matches variable names in a character vector. All
names must be present, otherwise an out-of-bounds error is
thrown.
\item \code{\link[tidyselect:all_of]{any_of()}}: Same as \code{all_of()}, except that no error is thrown
for names that don't exist.
}
Or using a predicate function:
\itemize{
\item \code{\link[tidyselect:where]{where()}}: Applies a function to all variables and selects those
for which the function returns \code{TRUE}.
}
}
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("select")}.
}
\section{Examples}{
Here we show the usage for the basic selection operators. See the
specific help pages to learn about helpers like \code{\link[=starts_with]{starts_with()}}.
The selection language can be used in functions like
\code{dplyr::select()} or \code{tidyr::pivot_longer()}. Let's first attach
the tidyverse:
\if{html}{\out{}}\preformatted{library(tidyverse)
# For better printing
iris <- as_tibble(iris)
}\if{html}{\out{
}}
Select variables by name:
\if{html}{\out{}}\preformatted{starwars \%>\% select(height)
#> # A tibble: 87 x 1
#> height
#>
#> 1 172
#> 2 167
#> 3 96
#> 4 202
#> # i 83 more rows
iris \%>\% pivot_longer(Sepal.Length)
#> # A tibble: 150 x 6
#> Sepal.Width Petal.Length Petal.Width Species name value
#>
#> 1 3.5 1.4 0.2 setosa Sepal.Length 5.1
#> 2 3 1.4 0.2 setosa Sepal.Length 4.9
#> 3 3.2 1.3 0.2 setosa Sepal.Length 4.7
#> 4 3.1 1.5 0.2 setosa Sepal.Length 4.6
#> # i 146 more rows
}\if{html}{\out{
}}
Select multiple variables by separating them with commas. Note how
the order of columns is determined by the order of inputs:
\if{html}{\out{}}\preformatted{starwars \%>\% select(homeworld, height, mass)
#> # A tibble: 87 x 3
#> homeworld height mass
#>
#> 1 Tatooine 172 77
#> 2 Tatooine 167 75
#> 3 Naboo 96 32
#> 4 Tatooine 202 136
#> # i 83 more rows
}\if{html}{\out{
}}
Functions like \code{tidyr::pivot_longer()} don't take variables with
dots. In this case use \code{c()} to select multiple variables:
\if{html}{\out{}}\preformatted{iris \%>\% pivot_longer(c(Sepal.Length, Petal.Length))
#> # A tibble: 300 x 5
#> Sepal.Width Petal.Width Species name value
#>
#> 1 3.5 0.2 setosa Sepal.Length 5.1
#> 2 3.5 0.2 setosa Petal.Length 1.4
#> 3 3 0.2 setosa Sepal.Length 4.9
#> 4 3 0.2 setosa Petal.Length 1.4
#> # i 296 more rows
}\if{html}{\out{
}}
\subsection{Operators:}{
The \code{:} operator selects a range of consecutive variables:
\if{html}{\out{}}\preformatted{starwars \%>\% select(name:mass)
#> # A tibble: 87 x 3
#> name height mass
#>
#> 1 Luke Skywalker 172 77
#> 2 C-3PO 167 75
#> 3 R2-D2 96 32
#> 4 Darth Vader 202 136
#> # i 83 more rows
}\if{html}{\out{
}}
The \code{!} operator negates a selection:
\if{html}{\out{}}\preformatted{starwars \%>\% select(!(name:mass))
#> # A tibble: 87 x 11
#> hair_color skin_color eye_color birth_year sex gender homeworld species
#>
#> 1 blond fair blue 19 male masculine Tatooine Human
#> 2 gold yellow 112 none masculine Tatooine Droid
#> 3 white, blue red 33 none masculine Naboo Droid
#> 4 none white yellow 41.9 male masculine Tatooine Human
#> # i 83 more rows
#> # i 3 more variables: films , vehicles , starships
iris \%>\% select(!c(Sepal.Length, Petal.Length))
#> # A tibble: 150 x 3
#> Sepal.Width Petal.Width Species
#>
#> 1 3.5 0.2 setosa
#> 2 3 0.2 setosa
#> 3 3.2 0.2 setosa
#> 4 3.1 0.2 setosa
#> # i 146 more rows
iris \%>\% select(!ends_with("Width"))
#> # A tibble: 150 x 3
#> Sepal.Length Petal.Length Species
#>
#> 1 5.1 1.4 setosa
#> 2 4.9 1.4 setosa
#> 3 4.7 1.3 setosa
#> 4 4.6 1.5 setosa
#> # i 146 more rows
}\if{html}{\out{
}}
\code{&} and \code{|} take the intersection or the union of two selections:
\if{html}{\out{}}\preformatted{iris \%>\% select(starts_with("Petal") & ends_with("Width"))
#> # A tibble: 150 x 1
#> Petal.Width
#>
#> 1 0.2
#> 2 0.2
#> 3 0.2
#> 4 0.2
#> # i 146 more rows
iris \%>\% select(starts_with("Petal") | ends_with("Width"))
#> # A tibble: 150 x 3
#> Petal.Length Petal.Width Sepal.Width
#>
#> 1 1.4 0.2 3.5
#> 2 1.4 0.2 3
#> 3 1.3 0.2 3.2
#> 4 1.5 0.2 3.1
#> # i 146 more rows
}\if{html}{\out{
}}
To take the difference between two selections, combine the \code{&} and
\code{!} operators:
\if{html}{\out{}}\preformatted{iris \%>\% select(starts_with("Petal") & !ends_with("Width"))
#> # A tibble: 150 x 1
#> Petal.Length
#>
#> 1 1.4
#> 2 1.4
#> 3 1.3
#> 4 1.5
#> # i 146 more rows
}\if{html}{\out{
}}
}
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/tbl_df.Rd 0000644 0001762 0000144 00000001017 14266276767 013726 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-tibble.R
\name{tbl_df}
\alias{tbl_df}
\alias{as.tbl}
\title{Coerce to a tibble}
\usage{
tbl_df(data)
as.tbl(x, ...)
}
\arguments{
\item{data, x}{Object to coerce}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
Please use \code{\link[tibble:as_tibble]{tibble::as_tibble()}} instead.
}
\keyword{internal}
dplyr/man/nth.Rd 0000644 0001762 0000144 00000005402 14366556340 013254 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/nth-value.R
\name{nth}
\alias{nth}
\alias{first}
\alias{last}
\title{Extract the first, last, or nth value from a vector}
\usage{
nth(x, n, order_by = NULL, default = NULL, na_rm = FALSE)
first(x, order_by = NULL, default = NULL, na_rm = FALSE)
last(x, order_by = NULL, default = NULL, na_rm = FALSE)
}
\arguments{
\item{x}{A vector}
\item{n}{For \code{nth()}, a single integer specifying the position.
Negative integers index from the end (i.e. \code{-1L} will return the
last value in the vector).}
\item{order_by}{An optional vector the same size as \code{x} used to determine the
order.}
\item{default}{A default value to use if the position does not exist in \code{x}.
If \code{NULL}, the default, a missing value is used.
If supplied, this must be a single value, which will be cast to the type of
\code{x}.
When \code{x} is a list , \code{default} is allowed to be any value. There are no
type or size restrictions in this case.}
\item{na_rm}{Should missing values in \code{x} be removed before extracting the
value?}
}
\value{
If \code{x} is a list, a single element from that list. Otherwise, a vector the
same type as \code{x} with size 1.
}
\description{
These are useful helpers for extracting a single value from a vector. They
are guaranteed to return a meaningful value, even when the input is shorter
than expected. You can also provide an optional secondary vector that defines
the ordering.
}
\details{
For most vector types, \code{first(x)}, \code{last(x)}, and \code{nth(x, n)} work like
\code{x[[1]]}, \verb{x[[length(x)]}, and \code{x[[n]]}, respectively. The primary exception
is data frames, where they instead retrieve rows, i.e. \code{x[1, ]}, \code{x[nrow(x), ]}, and \code{x[n, ]}. This is consistent with the tidyverse/vctrs principle which
treats data frames as a vector of rows, rather than a vector of columns.
}
\examples{
x <- 1:10
y <- 10:1
first(x)
last(y)
nth(x, 1)
nth(x, 5)
nth(x, -2)
# `first()` and `last()` are often useful in `summarise()`
df <- tibble(x = x, y = y)
df \%>\%
summarise(
across(x:y, first, .names = "{col}_first"),
y_last = last(y)
)
# Selecting a position that is out of bounds returns a default value
nth(x, 11)
nth(x, 0)
# This out of bounds behavior also applies to empty vectors
first(integer())
# You can customize the default value with `default`
nth(x, 11, default = -1L)
first(integer(), default = 0L)
# `order_by` provides optional ordering
last(x)
last(x, order_by = y)
# `na_rm` removes missing values before extracting the value
z <- c(NA, NA, 1, 3, NA, 5, NA)
first(z)
first(z, na_rm = TRUE)
last(z, na_rm = TRUE)
nth(z, 3, na_rm = TRUE)
# For data frames, these select entire rows
df <- tibble(a = 1:5, b = 6:10)
first(df)
nth(df, 4)
}
dplyr/man/same_src.Rd 0000644 0001762 0000144 00000000623 14366556340 014257 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/src.R
\name{same_src}
\alias{same_src}
\title{Figure out if two sources are the same (or two tbl have the same source)}
\usage{
same_src(x, y)
}
\arguments{
\item{x, y}{src or tbls to test}
}
\value{
a logical flag
}
\description{
Figure out if two sources are the same (or two tbl have the same source)
}
\keyword{internal}
dplyr/man/lead-lag.Rd 0000644 0001762 0000144 00000003357 14366556340 014140 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/lead-lag.R
\name{lead-lag}
\alias{lead-lag}
\alias{lag}
\alias{lead}
\title{Compute lagged or leading values}
\usage{
lag(x, n = 1L, default = NULL, order_by = NULL, ...)
lead(x, n = 1L, default = NULL, order_by = NULL, ...)
}
\arguments{
\item{x}{A vector}
\item{n}{Positive integer of length 1, giving the number of positions to
lag or lead by}
\item{default}{The value used to pad \code{x} back to its original size after the
lag or lead has been applied. The default, \code{NULL}, pads with a missing
value. If supplied, this must be a vector with size 1, which will be cast
to the type of \code{x}.}
\item{order_by}{An optional secondary vector that defines the ordering to use
when applying the lag or lead to \code{x}. If supplied, this must be the same
size as \code{x}.}
\item{...}{Not used.}
}
\value{
A vector with the same type and size as \code{x}.
}
\description{
Find the "previous" (\code{lag()}) or "next" (\code{lead()}) values in a vector. Useful
for comparing values behind of or ahead of the current values.
}
\examples{
lag(1:5)
lead(1:5)
x <- 1:5
tibble(behind = lag(x), x, ahead = lead(x))
# If you want to look more rows behind or ahead, use `n`
lag(1:5, n = 1)
lag(1:5, n = 2)
lead(1:5, n = 1)
lead(1:5, n = 2)
# If you want to define a value to pad with, use `default`
lag(1:5)
lag(1:5, default = 0)
lead(1:5)
lead(1:5, default = 6)
# If the data are not already ordered, use `order_by`
scrambled <- slice_sample(
tibble(year = 2000:2005, value = (0:5) ^ 2),
prop = 1
)
wrong <- mutate(scrambled, previous_year_value = lag(value))
arrange(wrong, year)
right <- mutate(scrambled, previous_year_value = lag(value, order_by = year))
arrange(right, year)
}
dplyr/man/storms.Rd 0000644 0001762 0000144 00000003636 14525503021 014002 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/data-storms.R
\docType{data}
\name{storms}
\alias{storms}
\title{Storm tracks data}
\format{
A tibble with 19,537 observations
and 13 variables:
\describe{
\item{name}{Storm Name}
\item{year,month,day}{Date of report}
\item{hour}{Hour of report (in UTC)}
\item{lat,long}{Location of storm center}
\item{status}{Storm classification (Tropical Depression, Tropical Storm,
or Hurricane)}
\item{category}{Saffir-Simpson hurricane category calculated from wind speed.
\itemize{
\item \code{NA}: Not a hurricane
\item 1: 64+ knots
\item 2: 83+ knots
\item 3: 96+ knots
\item 4: 113+ knots
\item 5: 137+ knots
}
}
\item{wind}{storm's maximum sustained wind speed (in knots)}
\item{pressure}{Air pressure at the storm's center (in millibars)}
\item{tropicalstorm_force_diameter}{Diameter (in nautical miles) of the
area experiencing tropical storm strength winds (34 knots or above).
Only available starting in 2004.}
\item{hurricane_force_diameter}{Diameter (in nautical miles) of the area
experiencing hurricane strength winds (64 knots or above). Only available
starting in 2004.}
}
}
\usage{
storms
}
\description{
This dataset is the NOAA Atlantic hurricane database best track data,
\url{https://www.nhc.noaa.gov/data/#hurdat}. The data includes the positions and
attributes of storms from 1975-2022. Storms
from 1979 onward are measured every six hours during the lifetime of the
storm. Storms in earlier years have some missing data.
}
\examples{
storms
# Show a few recent storm paths
if (requireNamespace("ggplot2", quietly = TRUE)) {
library(ggplot2)
storms \%>\%
filter(year >= 2000) \%>\%
ggplot(aes(long, lat, color = paste(year, name))) +
geom_path(show.legend = FALSE) +
facet_wrap(~year)
}
storms
}
\seealso{
The script to create the storms data set:
\url{https://github.com/tidyverse/dplyr/blob/main/data-raw/storms.R}
}
\keyword{datasets}
dplyr/man/auto_copy.Rd 0000644 0001762 0000144 00000001253 14366556340 014465 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/copy-to.R
\name{auto_copy}
\alias{auto_copy}
\title{Copy tables to same source, if necessary}
\usage{
auto_copy(x, y, copy = FALSE, ...)
}
\arguments{
\item{x, y}{\code{y} will be copied to \code{x}, if necessary.}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{...}{Other arguments passed on to methods.}
}
\description{
Copy tables to same source, if necessary
}
dplyr/man/scoped.Rd 0000644 0001762 0000144 00000012216 14366556340 013741 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise.R
\name{scoped}
\alias{scoped}
\title{Operate on a selection of variables}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
The variants suffixed with \verb{_if}, \verb{_at} or \verb{_all} apply an
expression (sometimes several) to all variables within a specified
subset. This subset can contain all variables (\verb{_all} variants), a
\code{\link[=vars]{vars()}} selection (\verb{_at} variants), or variables selected with a
predicate (\verb{_if} variants).
The verbs with scoped variants are:
\itemize{
\item \code{\link[=mutate]{mutate()}}, \code{\link[=transmute]{transmute()}} and \code{\link[=summarise]{summarise()}}. See \code{\link[=summarise_all]{summarise_all()}}.
\item \code{\link[=filter]{filter()}}. See \code{\link[=filter_all]{filter_all()}}.
\item \code{\link[=group_by]{group_by()}}. See \code{\link[=group_by_all]{group_by_all()}}.
\item \code{\link[=rename]{rename()}} and \code{\link[=select]{select()}}. See \code{\link[=select_all]{select_all()}}.
\item \code{\link[=arrange]{arrange()}}. See \code{\link[=arrange_all]{arrange_all()}}
}
There are three kinds of scoped variants. They differ in the scope
of the variable selection on which operations are applied:
\itemize{
\item Verbs suffixed with \verb{_all()} apply an operation on all variables.
\item Verbs suffixed with \verb{_at()} apply an operation on a subset of
variables specified with the quoting function \code{\link[=vars]{vars()}}. This
quoting function accepts \code{\link[tidyselect:vars_select]{tidyselect::vars_select()}} helpers like
\code{\link[=starts_with]{starts_with()}}. Instead of a \code{\link[=vars]{vars()}} selection, you can also
supply an \link[rlang:is_integerish]{integerish} vector of column
positions or a character vector of column names.
\item Verbs suffixed with \verb{_if()} apply an operation on the subset of
variables for which a predicate function returns \code{TRUE}. Instead
of a predicate function, you can also supply a logical vector.
}
}
\section{Grouping variables}{
Most of these operations also apply on the grouping variables when
they are part of the selection. This includes:
\itemize{
\item \code{\link[=arrange_all]{arrange_all()}}, \code{\link[=arrange_at]{arrange_at()}}, and \code{\link[=arrange_if]{arrange_if()}}
\item \code{\link[=distinct_all]{distinct_all()}}, \code{\link[=distinct_at]{distinct_at()}}, and \code{\link[=distinct_if]{distinct_if()}}
\item \code{\link[=filter_all]{filter_all()}}, \code{\link[=filter_at]{filter_at()}}, and \code{\link[=filter_if]{filter_if()}}
\item \code{\link[=group_by_all]{group_by_all()}}, \code{\link[=group_by_at]{group_by_at()}}, and \code{\link[=group_by_if]{group_by_if()}}
\item \code{\link[=select_all]{select_all()}}, \code{\link[=select_at]{select_at()}}, and \code{\link[=select_if]{select_if()}}
}
This is not the case for summarising and mutating variants where
operations are \emph{not} applied on grouping variables. The behaviour
depends on whether the selection is \strong{implicit} (\code{all} and \code{if}
selections) or \strong{explicit} (\code{at} selections). Grouping variables
covered by explicit selections (with \code{\link[=summarise_at]{summarise_at()}},
\code{\link[=mutate_at]{mutate_at()}}, and \code{\link[=transmute_at]{transmute_at()}}) are always an error. For
implicit selections, the grouping variables are always ignored. In
this case, the level of verbosity depends on the kind of operation:
\itemize{
\item Summarising operations (\code{\link[=summarise_all]{summarise_all()}} and \code{\link[=summarise_if]{summarise_if()}})
ignore grouping variables silently because it is obvious that
operations are not applied on grouping variables.
\item On the other hand it isn't as obvious in the case of mutating
operations (\code{\link[=mutate_all]{mutate_all()}}, \code{\link[=mutate_if]{mutate_if()}}, \code{\link[=transmute_all]{transmute_all()}}, and
\code{\link[=transmute_if]{transmute_if()}}). For this reason, they issue a message
indicating which grouping variables are ignored.
}
}
dplyr/man/src.Rd 0000644 0001762 0000144 00000001156 14366556340 013254 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/src.R
\name{src}
\alias{src}
\alias{is.src}
\title{Create a "src" object}
\usage{
src(subclass, ...)
is.src(x)
}
\arguments{
\item{subclass}{name of subclass. "src" is an abstract base class, so you
must supply this value. \code{src_} is automatically prepended to the
class name}
\item{...}{fields used by object.
These dots are evaluated with \link[rlang:list2]{explicit splicing}.}
\item{x}{object to test for "src"-ness.}
}
\description{
\code{src()} is the standard constructor for srcs and \code{is.src()} tests.
}
\keyword{internal}
dplyr/man/desc.Rd 0000644 0001762 0000144 00000000777 14366556340 013413 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/desc.R
\name{desc}
\alias{desc}
\title{Descending order}
\usage{
desc(x)
}
\arguments{
\item{x}{vector to transform}
}
\description{
Transform a vector into a format that will be sorted in descending order.
This is useful within \code{\link[=arrange]{arrange()}}.
}
\examples{
desc(1:10)
desc(factor(letters))
first_day <- seq(as.Date("1910/1/1"), as.Date("1920/1/1"), "years")
desc(first_day)
starwars \%>\% arrange(desc(mass))
}
dplyr/man/dplyr-package.Rd 0000644 0001762 0000144 00000002032 14406402754 015174 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/dplyr.R
\docType{package}
\name{dplyr-package}
\alias{dplyr}
\alias{dplyr-package}
\title{dplyr: A Grammar of Data Manipulation}
\description{
To learn more about dplyr, start with the vignettes:
\code{browseVignettes(package = "dplyr")}
}
\seealso{
Useful links:
\itemize{
\item \url{https://dplyr.tidyverse.org}
\item \url{https://github.com/tidyverse/dplyr}
\item Report bugs at \url{https://github.com/tidyverse/dplyr/issues}
}
}
\author{
\strong{Maintainer}: Hadley Wickham \email{hadley@posit.co} (\href{https://orcid.org/0000-0003-4757-117X}{ORCID})
Authors:
\itemize{
\item Romain François (\href{https://orcid.org/0000-0002-2444-4226}{ORCID})
\item Lionel Henry
\item Kirill Müller (\href{https://orcid.org/0000-0002-1416-3412}{ORCID})
\item Davis Vaughan \email{davis@posit.co} (\href{https://orcid.org/0000-0003-4777-038X}{ORCID})
}
Other contributors:
\itemize{
\item Posit Software, PBC [copyright holder, funder]
}
}
\keyword{internal}
dplyr/man/arrange.Rd 0000644 0001762 0000144 00000007510 14406402754 014076 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/arrange.R
\name{arrange}
\alias{arrange}
\alias{arrange.data.frame}
\title{Order rows using column values}
\usage{
arrange(.data, ..., .by_group = FALSE)
\method{arrange}{data.frame}(.data, ..., .by_group = FALSE, .locale = NULL)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Variables, or
functions of variables. Use \code{\link[=desc]{desc()}} to sort a variable in descending
order.}
\item{.by_group}{If \code{TRUE}, will sort first by grouping variable. Applies to
grouped data frames only.}
\item{.locale}{The locale to sort character vectors in.
\itemize{
\item If \code{NULL}, the default, uses the \code{"C"} locale unless the
\code{dplyr.legacy_locale} global option escape hatch is active. See the
\link{dplyr-locale} help page for more details.
\item If a single string from \code{\link[stringi:stri_locale_list]{stringi::stri_locale_list()}} is supplied, then
this will be used as the locale to sort with. For example, \code{"en"} will
sort with the American English locale. This requires the stringi package.
\item If \code{"C"} is supplied, then character vectors will always be sorted in the
C locale. This does not require stringi and is often much faster than
supplying a locale identifier.
}
The C locale is not the same as English locales, such as \code{"en"},
particularly when it comes to data containing a mix of upper and lower case
letters. This is explained in more detail on the \link[=dplyr-locale]{locale}
help page under the \verb{Default locale} section.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item All rows appear in the output, but (usually) in a different place.
\item Columns are not modified.
\item Groups are not modified.
\item Data frame attributes are preserved.
}
}
\description{
\code{arrange()} orders the rows of a data frame by the values of selected
columns.
Unlike other dplyr verbs, \code{arrange()} largely ignores grouping; you
need to explicitly mention grouping variables (or use \code{.by_group = TRUE})
in order to group by them, and functions of variables are evaluated
once per data frame, not once per group.
}
\details{
\subsection{Missing values}{
Unlike base sorting with \code{sort()}, \code{NA} are:
\itemize{
\item always sorted to the end for local data, even when wrapped with \code{desc()}.
\item treated differently for remote data, depending on the backend.
}
}
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("arrange")}.
}
\examples{
arrange(mtcars, cyl, disp)
arrange(mtcars, desc(disp))
# grouped arrange ignores groups
by_cyl <- mtcars \%>\% group_by(cyl)
by_cyl \%>\% arrange(desc(wt))
# Unless you specifically ask:
by_cyl \%>\% arrange(desc(wt), .by_group = TRUE)
# use embracing when wrapping in a function;
# see ?rlang::args_data_masking for more details
tidy_eval_arrange <- function(.data, var) {
.data \%>\%
arrange({{ var }})
}
tidy_eval_arrange(mtcars, mpg)
# Use `across()` or `pick()` to select columns with tidy-select
iris \%>\% arrange(pick(starts_with("Sepal")))
iris \%>\% arrange(across(starts_with("Sepal"), desc))
}
\seealso{
Other single table verbs:
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/nest_by.Rd 0000644 0001762 0000144 00000007454 14366556340 014137 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/nest-by.R
\name{nest_by}
\alias{nest_by}
\title{Nest by one or more variables}
\usage{
nest_by(.data, ..., .key = "data", .keep = FALSE)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{In \code{group_by()}, variables or computations to group by.
Computations are always done on the ungrouped data frame.
To perform computations on the grouped data, you need to use
a separate \code{mutate()} step before the \code{group_by()}.
Computations are not allowed in \code{nest_by()}.
In \code{ungroup()}, variables to remove from the grouping.}
\item{.key}{Name of the list column}
\item{.keep}{Should the grouping columns be kept in the list column.}
}
\value{
A \link{rowwise} data frame. The output has the following properties:
\itemize{
\item The rows come from the underlying \code{\link[=group_keys]{group_keys()}}.
\item The columns are the grouping keys plus one list-column of data frames.
\item Data frame attributes are \strong{not} preserved, because \code{nest_by()}
fundamentally creates a new data frame.
}
A tbl with one row per unique combination of the grouping variables.
The first columns are the grouping variables, followed by a list column of tibbles
with matching rows of the remaining columns.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
\code{nest_by()} is closely related to \code{\link[=group_by]{group_by()}}. However, instead of storing
the group structure in the metadata, it is made explicit in the data,
giving each group key a single row along with a list-column of data frames
that contain all the other data.
\code{nest_by()} returns a \link{rowwise} data frame, which makes operations on the
grouped data particularly elegant. See \code{vignette("rowwise")} for more
details.
}
\details{
Note that \code{df \%>\% nest_by(x, y)} is roughly equivalent to
\if{html}{\out{}}\preformatted{df \%>\%
group_by(x, y) \%>\%
summarise(data = list(pick(everything()))) \%>\%
rowwise()
}\if{html}{\out{
}}
If you want to unnest a nested data frame, you can either use
\code{tidyr::unnest()} or take advantage of \code{reframe()}s multi-row behaviour:
\if{html}{\out{}}\preformatted{nested \%>\%
reframe(data)
}\if{html}{\out{
}}
}
\section{Lifecycle}{
\code{nest_by()} is not stable because \code{\link[tidyr:nest]{tidyr::nest(.by =)}}
provides very similar behavior. It may be deprecated in the future.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("nest_by")}.
}
\examples{
# After nesting, you get one row per group
iris \%>\% nest_by(Species)
starwars \%>\% nest_by(species)
# The output is grouped by row, which makes modelling particularly easy
models <- mtcars \%>\%
nest_by(cyl) \%>\%
mutate(model = list(lm(mpg ~ wt, data = data)))
models
models \%>\% summarise(rsq = summary(model)$r.squared)
\dontshow{if (requireNamespace("broom", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
# This is particularly elegant with the broom functions
models \%>\% summarise(broom::glance(model))
models \%>\% reframe(broom::tidy(model))
\dontshow{\}) # examplesIf}
# Note that you can also `reframe()` to unnest the data
models \%>\% reframe(data)
}
\keyword{internal}
dplyr/man/rowwise.Rd 0000644 0001762 0000144 00000005351 14366556340 014165 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rowwise.R
\name{rowwise}
\alias{rowwise}
\title{Group input by rows}
\usage{
rowwise(data, ...)
}
\arguments{
\item{data}{Input data frame.}
\item{...}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Variables to be preserved
when calling \code{\link[=summarise]{summarise()}}. This is typically a set of variables whose
combination uniquely identify each row.
\strong{NB}: unlike \code{group_by()} you can not create new variables here but
instead you can select multiple variables with (e.g.) \code{everything()}.}
}
\value{
A row-wise data frame with class \code{rowwise_df}. Note that a
\code{rowwise_df} is implicitly grouped by row, but is not a \code{grouped_df}.
}
\description{
\code{rowwise()} allows you to compute on a data frame a row-at-a-time.
This is most useful when a vectorised function doesn't exist.
Most dplyr verbs preserve row-wise grouping. The exception is \code{\link[=summarise]{summarise()}},
which return a \link{grouped_df}. You can explicitly ungroup with \code{\link[=ungroup]{ungroup()}}
or \code{\link[=as_tibble]{as_tibble()}}, or convert to a \link{grouped_df} with \code{\link[=group_by]{group_by()}}.
}
\section{List-columns}{
Because a rowwise has exactly one row per group it offers a small
convenience for working with list-columns. Normally, \code{summarise()} and
\code{mutate()} extract a groups worth of data with \code{[}. But when you index
a list in this way, you get back another list. When you're working with
a \code{rowwise} tibble, then dplyr will use \code{[[} instead of \code{[} to make your
life a little easier.
}
\examples{
df <- tibble(x = runif(6), y = runif(6), z = runif(6))
# Compute the mean of x, y, z in each row
df \%>\% rowwise() \%>\% mutate(m = mean(c(x, y, z)))
# use c_across() to more easily select many variables
df \%>\% rowwise() \%>\% mutate(m = mean(c_across(x:z)))
# Compute the minimum of x and y in each row
df \%>\% rowwise() \%>\% mutate(m = min(c(x, y, z)))
# In this case you can use an existing vectorised function:
df \%>\% mutate(m = pmin(x, y, z))
# Where these functions exist they'll be much faster than rowwise
# so be on the lookout for them.
# rowwise() is also useful when doing simulations
params <- tribble(
~sim, ~n, ~mean, ~sd,
1, 1, 1, 1,
2, 2, 2, 4,
3, 3, -1, 2
)
# Here I supply variables to preserve after the computation
params \%>\%
rowwise(sim) \%>\%
reframe(z = rnorm(n, mean, sd))
# If you want one row per simulation, put the results in a list()
params \%>\%
rowwise(sim) \%>\%
summarise(z = list(rnorm(n, mean, sd)), .groups = "keep")
}
\seealso{
\code{\link[=nest_by]{nest_by()}} for a convenient way of creating rowwise data frames
with nested data.
}
dplyr/man/deprec-context.Rd 0000644 0001762 0000144 00000001425 14366556340 015410 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-context.R
\name{deprec-context}
\alias{deprec-context}
\alias{cur_data}
\alias{cur_data_all}
\title{Information about the "current" group or variable}
\usage{
cur_data()
cur_data_all()
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
These functions were deprecated in dplyr 1.1.0.
\itemize{
\item \code{cur_data()} is deprecated in favor of \code{\link[=pick]{pick()}}.
\item \code{cur_data_all()} is deprecated but does not have a direct replacement as
selecting the grouping variables is not well-defined and is unlikely to
ever be useful.
}
}
\keyword{internal}
dplyr/man/case_match.Rd 0000644 0001762 0000144 00000007330 14525503021 014535 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/case-match.R
\name{case_match}
\alias{case_match}
\title{A general vectorised \code{switch()}}
\usage{
case_match(.x, ..., .default = NULL, .ptype = NULL)
}
\arguments{
\item{.x}{A vector to match against.}
\item{...}{<\code{\link[rlang:dyn-dots]{dynamic-dots}}> A sequence of two-sided
formulas: \code{old_values ~ new_value}. The right hand side (RHS) determines
the output value for all values of \code{.x} that match the left hand side
(LHS).
The LHS must evaluate to the same type of vector as \code{.x}. It can be any
length, allowing you to map multiple \code{.x} values to the same RHS value.
If a value is repeated in the LHS, i.e. a value in \code{.x} matches to
multiple cases, the first match is used.
The RHS inputs will be coerced to their common type. Each RHS input will be
\link[vctrs:theory-faq-recycling]{recycled} to the size of \code{.x}.}
\item{.default}{The value used when values in \code{.x} aren't matched by any of
the LHS inputs. If \code{NULL}, the default, a missing value will be used.
\code{.default} is \link[vctrs:theory-faq-recycling]{recycled} to the size of
\code{.x}.}
\item{.ptype}{An optional prototype declaring the desired output type. If
not supplied, the output type will be taken from the common type of
all RHS inputs and \code{.default}.}
}
\value{
A vector with the same size as \code{.x} and the same type as the common type of
the RHS inputs and \code{.default} (if not overridden by \code{.ptype}).
}
\description{
This function allows you to vectorise multiple \code{\link[=switch]{switch()}} statements. Each
case is evaluated sequentially and the first match for each element
determines the corresponding value in the output vector. If no cases match,
the \code{.default} is used.
\code{case_match()} is an R equivalent of the SQL "simple" \verb{CASE WHEN} statement.
\subsection{Connection to \code{case_when()}}{
While \code{\link[=case_when]{case_when()}} uses logical expressions on the left-hand side of the
formula, \code{case_match()} uses values to match against \code{.x} with. The following
two statements are roughly equivalent:
\if{html}{\out{}}\preformatted{case_when(
x \%in\% c("a", "b") ~ 1,
x \%in\% "c" ~ 2,
x \%in\% c("d", "e") ~ 3
)
case_match(
x,
c("a", "b") ~ 1,
"c" ~ 2,
c("d", "e") ~ 3
)
}\if{html}{\out{
}}
}
}
\examples{
x <- c("a", "b", "a", "d", "b", NA, "c", "e")
# `case_match()` acts like a vectorized `switch()`.
# Unmatched values "fall through" as a missing value.
case_match(
x,
"a" ~ 1,
"b" ~ 2,
"c" ~ 3,
"d" ~ 4
)
# Missing values can be matched exactly, and `.default` can be used to
# control the value used for unmatched values of `.x`
case_match(
x,
"a" ~ 1,
"b" ~ 2,
"c" ~ 3,
"d" ~ 4,
NA ~ 0,
.default = 100
)
# Input values can be grouped into the same expression to map them to the
# same output value
case_match(
x,
c("a", "b") ~ "low",
c("c", "d", "e") ~ "high"
)
# `case_match()` isn't limited to character input:
y <- c(1, 2, 1, 3, 1, NA, 2, 4)
case_match(
y,
c(1, 3) ~ "odd",
c(2, 4) ~ "even",
.default = "missing"
)
# Setting `.default` to the original vector is a useful way to replace
# selected values, leaving everything else as is
case_match(y, NA ~ 0, .default = y)
starwars \%>\%
mutate(
# Replace missings, but leave everything else alone
hair_color = case_match(hair_color, NA ~ "unknown", .default = hair_color),
# Replace some, but not all, of the species
species = case_match(
species,
"Human" ~ "Humanoid",
"Droid" ~ "Robot",
c("Wookiee", "Ewok") ~ "Hairy",
.default = species
),
.keep = "used"
)
}
\seealso{
\code{\link[=case_when]{case_when()}}
}
dplyr/man/dplyr_extending.Rd 0000644 0001762 0000144 00000012454 14406402754 015661 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/generics.R
\name{dplyr_extending}
\alias{dplyr_extending}
\alias{dplyr_row_slice}
\alias{dplyr_col_modify}
\alias{dplyr_reconstruct}
\title{Extending dplyr with new data frame subclasses}
\usage{
dplyr_row_slice(data, i, ...)
dplyr_col_modify(data, cols)
dplyr_reconstruct(data, template)
}
\arguments{
\item{data}{A tibble. We use tibbles because they avoid some inconsistent
subset-assignment use cases.}
\item{i}{A numeric or logical vector that indexes the rows of \code{data}.}
\item{cols}{A named list used to modify columns. A \code{NULL} value should remove
an existing column.}
\item{template}{Template data frame to use for restoring attributes.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
These three functions, along with \verb{names<-} and 1d numeric \code{[}
(i.e. \code{x[loc]}) methods, provide a minimal interface for extending dplyr
to work with new data frame subclasses. This means that for simple cases
you should only need to provide a couple of methods, rather than a method
for every dplyr verb.
These functions are a stop-gap measure until we figure out how to solve
the problem more generally, but it's likely that any code you write to
implement them will find a home in what comes next.
}
\section{Basic advice}{
This section gives you basic advice if you want to extend dplyr to work with
your custom data frame subclass, and you want the dplyr methods to behave
in basically the same way.
\itemize{
\item If you have data frame attributes that don't depend on the rows or columns
(and should unconditionally be preserved), you don't need to do anything.
The one exception to this is if your subclass extends a data.frame
directly rather than extending a tibble. The \verb{[.data.frame} method does not
preserve attributes, so you'll need to write a \code{[} method for your subclass
that preserves attributes important for your class.
\item If you have \strong{scalar} attributes that depend on \strong{rows}, implement a
\code{dplyr_reconstruct()} method. Your method should recompute the attribute
depending on rows now present.
\item If you have \strong{scalar} attributes that depend on \strong{columns}, implement a
\code{dplyr_reconstruct()} method and a 1d \code{[} method. For example, if your
class requires that certain columns be present, your method should return
a data.frame or tibble when those columns are removed.
\item If your attributes are \strong{vectorised} over \strong{rows}, implement a
\code{dplyr_row_slice()} method. This gives you access to \code{i} so you can
modify the row attribute accordingly. You'll also need to think carefully
about how to recompute the attribute in \code{dplyr_reconstruct()}, and
you will need to carefully verify the behaviour of each verb, and provide
additional methods as needed.
\item If your attributes that are \strong{vectorised} over \strong{columns}, implement
\code{dplyr_col_modify()}, 1d \code{[}, and \verb{names<-} methods. All of these methods
know which columns are being modified, so you can update the column
attribute according. You'll also need to think carefully about how to
recompute the attribute in \code{dplyr_reconstruct()}, and you will need to
carefully verify the behaviour of each verb, and provide additional
methods as needed.
}
}
\section{Current usage}{
\itemize{
\item \code{arrange()}, \code{filter()}, \code{slice()} (and the rest of the \verb{slice_*()}
family), \code{semi_join()}, and \code{anti_join()} work by generating a vector of
row indices, and then subsetting with \code{dplyr_row_slice()}.
\item \code{mutate()} generates a list of new column value (using \code{NULL} to indicate
when columns should be deleted), then passes that to \code{dplyr_col_modify()}.
It also uses 1d \code{[} to implement \code{.keep}, and will call \code{relocate()} if
either \code{.before} or \code{.after} are supplied.
\item \code{summarise()} and \code{reframe()} work similarly to \code{mutate()} but the data
modified by \code{dplyr_col_modify()} comes from \code{group_data()} or is built
from \code{.by}.
\item \code{select()} uses 1d \code{[} to select columns, then \verb{names<-} to rename them.
\code{rename()} just uses \verb{names<-}. \code{relocate()} just uses 1d \code{[}.
\item \code{inner_join()}, \code{left_join()}, \code{right_join()}, and \code{full_join()}
coerce \code{x} to a tibble, modify the rows, then use \code{dplyr_reconstruct()}
to convert back to the same type as \code{x}.
\item \code{nest_join()} converts both \code{x} and \code{y} to tibbles, modifies the rows,
and uses \code{dplyr_col_modify()} to handle modified key variables and the
list-column that \code{y} becomes. It also uses \code{dplyr_reconstruct()} to convert
the outer result back to the type of \code{x}, and to convert the nested tibbles
back to the type of \code{y}.
\item \code{distinct()} does a \code{mutate()} if any expressions are present, then
uses 1d \code{[} to select variables to keep, then \code{dplyr_row_slice()} to
select distinct rows.
}
Note that \code{group_by()} and \code{ungroup()} don't use any of these generics and
you'll need to provide methods for them directly, or rely on \code{.by} for
per-operation grouping.
}
\keyword{internal}
dplyr/man/if_else.Rd 0000644 0001762 0000144 00000004574 14525503021 014063 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/if-else.R
\name{if_else}
\alias{if_else}
\title{Vectorised if-else}
\usage{
if_else(condition, true, false, missing = NULL, ..., ptype = NULL, size = NULL)
}
\arguments{
\item{condition}{A logical vector}
\item{true, false}{Vectors to use for \code{TRUE} and \code{FALSE} values of
\code{condition}.
Both \code{true} and \code{false} will be \link[vctrs:theory-faq-recycling]{recycled}
to the size of \code{condition}.
\code{true}, \code{false}, and \code{missing} (if used) will be cast to their common type.}
\item{missing}{If not \code{NULL}, will be used as the value for \code{NA} values of
\code{condition}. Follows the same size and type rules as \code{true} and \code{false}.}
\item{...}{These dots are for future extensions and must be empty.}
\item{ptype}{An optional prototype declaring the desired output type. If
supplied, this overrides the common type of \code{true}, \code{false}, and \code{missing}.}
\item{size}{An optional size declaring the desired output size. If supplied,
this overrides the size of \code{condition}.}
}
\value{
A vector with the same size as \code{condition} and the same type as the common
type of \code{true}, \code{false}, and \code{missing}.
Where \code{condition} is \code{TRUE}, the matching values from \code{true}, where it is
\code{FALSE}, the matching values from \code{false}, and where it is \code{NA}, the matching
values from \code{missing}, if provided, otherwise a missing value will be used.
}
\description{
\code{if_else()} is a vectorized \link[=if]{if-else}. Compared to the base R equivalent,
\code{\link[=ifelse]{ifelse()}}, this function allows you to handle missing values in the
\code{condition} with \code{missing} and always takes \code{true}, \code{false}, and \code{missing}
into account when determining what the output type should be.
}
\examples{
x <- c(-5:5, NA)
if_else(x < 0, NA, x)
# Explicitly handle `NA` values in the `condition` with `missing`
if_else(x < 0, "negative", "positive", missing = "missing")
# Unlike `ifelse()`, `if_else()` preserves types
x <- factor(sample(letters[1:5], 10, replace = TRUE))
ifelse(x \%in\% c("a", "b", "c"), x, NA)
if_else(x \%in\% c("a", "b", "c"), x, NA)
# `if_else()` is often useful for creating new columns inside of `mutate()`
starwars \%>\%
mutate(category = if_else(height < 100, "short", "tall"), .keep = "used")
}
dplyr/man/pick.Rd 0000644 0001762 0000144 00000005647 14406402754 013416 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/pick.R
\name{pick}
\alias{pick}
\title{Select a subset of columns}
\usage{
pick(...)
}
\arguments{
\item{...}{<\code{\link[=dplyr_tidy_select]{tidy-select}}>
Columns to pick.
You can't pick grouping columns because they are already automatically
handled by the verb (i.e. \code{\link[=summarise]{summarise()}} or \code{\link[=mutate]{mutate()}}).}
}
\value{
A tibble containing the selected columns for the current group.
}
\description{
\code{pick()} provides a way to easily select a subset of columns from your data
using \code{\link[=select]{select()}} semantics while inside a
\link[rlang:args_data_masking]{"data-masking"} function like \code{\link[=mutate]{mutate()}} or
\code{\link[=summarise]{summarise()}}. \code{pick()} returns a data frame containing the selected columns
for the current group.
\code{pick()} is complementary to \code{\link[=across]{across()}}:
\itemize{
\item With \code{pick()}, you typically apply a function to the full data frame.
\item With \code{across()}, you typically apply a function to each column.
}
}
\details{
Theoretically, \code{pick()} is intended to be replaceable with an equivalent call
to \code{tibble()}. For example, \code{pick(a, c)} could be replaced with
\code{tibble(a = a, c = c)}, and \code{pick(everything())} on a data frame with cols
\code{a}, \code{b}, and \code{c} could be replaced with \code{tibble(a = a, b = b, c = c)}.
\code{pick()} specially handles the case of an empty selection by returning a 1
row, 0 column tibble, so an exact replacement is more like:
\if{html}{\out{}}\preformatted{size <- vctrs::vec_size_common(..., .absent = 1L)
out <- vctrs::vec_recycle_common(..., .size = size)
tibble::new_tibble(out, nrow = size)
}\if{html}{\out{
}}
}
\examples{
df <- tibble(
x = c(3, 2, 2, 2, 1),
y = c(0, 2, 1, 1, 4),
z1 = c("a", "a", "a", "b", "a"),
z2 = c("c", "d", "d", "a", "c")
)
df
# `pick()` provides a way to select a subset of your columns using
# tidyselect. It returns a data frame.
df \%>\% mutate(cols = pick(x, y))
# This is useful for functions that take data frames as inputs.
# For example, you can compute a joint rank between `x` and `y`.
df \%>\% mutate(rank = dense_rank(pick(x, y)))
# `pick()` is also useful as a bridge between data-masking functions (like
# `mutate()` or `group_by()`) and functions with tidy-select behavior (like
# `select()`). For example, you can use `pick()` to create a wrapper around
# `group_by()` that takes a tidy-selection of columns to group on. For more
# bridge patterns, see
# https://rlang.r-lib.org/reference/topic-data-mask-programming.html#bridge-patterns.
my_group_by <- function(data, cols) {
group_by(data, pick({{ cols }}))
}
df \%>\% my_group_by(c(x, starts_with("z")))
# Or you can use it to dynamically select columns to `count()` by
df \%>\% count(pick(starts_with("z")))
}
\seealso{
\code{\link[=across]{across()}}
}
dplyr/man/tbl.Rd 0000644 0001762 0000144 00000000634 14366556340 013246 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/tbl.R
\name{tbl}
\alias{tbl}
\alias{is.tbl}
\title{Create a table from a data source}
\usage{
tbl(src, ...)
is.tbl(x)
}
\arguments{
\item{src}{A data source}
\item{...}{Other arguments passed on to the individual methods}
\item{x}{Any object}
}
\description{
This is a generic method that dispatches based on the first argument.
}
dplyr/man/dplyr_by.Rd 0000644 0001762 0000144 00000022570 14406402754 014306 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/by.R
\name{dplyr_by}
\alias{dplyr_by}
\title{Per-operation grouping with \code{.by}/\code{by}}
\description{
There are two ways to group in dplyr:
\itemize{
\item Persistent grouping with \code{\link[=group_by]{group_by()}}
\item Per-operation grouping with \code{.by}/\code{by}
}
This help page is dedicated to explaining where and why you might want to use the latter.
Depending on the dplyr verb, the per-operation grouping argument may be named \code{.by} or \code{by}.
The \emph{Supported verbs} section below outlines this on a case-by-case basis.
The remainder of this page will refer to \code{.by} for simplicity.
Grouping radically affects the computation of the dplyr verb you use it with, and one of the goals of \code{.by} is to allow you to place that grouping specification alongside the code that actually uses it.
As an added benefit, with \code{.by} you no longer need to remember to \code{\link[=ungroup]{ungroup()}} after \code{\link[=summarise]{summarise()}}, and \code{summarise()} won't ever message you about how it's handling the groups!
This idea comes from \href{https://CRAN.R-project.org/package=data.table}{data.table}, which allows you to specify \code{by} alongside modifications in \code{j}, like: \code{dt[, .(x = mean(x)), by = g]}.
\subsection{Supported verbs}{
\itemize{
\item \code{\link[=mutate]{mutate(.by = )}}
\item \code{\link[=summarise]{summarise(.by = )}}
\item \code{\link[=reframe]{reframe(.by = )}}
\item \code{\link[=filter]{filter(.by = )}}
\item \code{\link[=slice]{slice(.by = )}}
\item \code{\link[=slice_head]{slice_head(by = )}} and \code{\link[=slice_tail]{slice_tail(by = )}}
\item \code{\link[=slice_min]{slice_min(by = )}} and \code{\link[=slice_max]{slice_max(by = )}}
\item \code{\link[=slice_sample]{slice_sample(by = )}}
}
Note that some dplyr verbs use \code{by} while others use \code{.by}.
This is a purely technical difference.
}
\subsection{Differences between \code{.by} and \code{group_by()}}{\tabular{ll}{
\code{.by} \tab \code{group_by()} \cr
Grouping only affects a single verb \tab Grouping is persistent across multiple verbs \cr
Selects variables with \link[=dplyr_tidy_select]{tidy-select} \tab Computes expressions with \link[rlang:args_data_masking]{data-masking} \cr
Summaries use existing order of group keys \tab Summaries sort group keys in ascending order \cr
}
}
\subsection{Using \code{.by}}{
Let's take a look at the two grouping approaches using this \code{expenses} data set, which tracks costs accumulated across various \code{id}s and \code{region}s:
\if{html}{\out{}}\preformatted{expenses <- tibble(
id = c(1, 2, 1, 3, 1, 2, 3),
region = c("A", "A", "A", "B", "B", "A", "A"),
cost = c(25, 20, 19, 12, 9, 6, 6)
)
expenses
#> # A tibble: 7 x 3
#> id region cost
#>
#> 1 1 A 25
#> 2 2 A 20
#> 3 1 A 19
#> 4 3 B 12
#> 5 1 B 9
#> 6 2 A 6
#> 7 3 A 6
}\if{html}{\out{
}}
Imagine that you wanted to compute the average cost per region.
You'd probably write something like this:
\if{html}{\out{}}\preformatted{expenses \%>\%
group_by(region) \%>\%
summarise(cost = mean(cost))
#> # A tibble: 2 x 2
#> region cost
#>
#> 1 A 15.2
#> 2 B 10.5
}\if{html}{\out{
}}
Instead, you can now specify the grouping \emph{inline} within the verb:
\if{html}{\out{}}\preformatted{expenses \%>\%
summarise(cost = mean(cost), .by = region)
#> # A tibble: 2 x 2
#> region cost
#>
#> 1 A 15.2
#> 2 B 10.5
}\if{html}{\out{
}}
\code{.by} applies to a single operation, meaning that since \code{expenses} was an ungrouped data frame, the result after applying \code{.by} will also always be an ungrouped data frame, regardless of the number of grouping columns.
\if{html}{\out{}}\preformatted{expenses \%>\%
summarise(cost = mean(cost), .by = c(id, region))
#> # A tibble: 5 x 3
#> id region cost
#>
#> 1 1 A 22
#> 2 2 A 13
#> 3 3 B 12
#> 4 1 B 9
#> 5 3 A 6
}\if{html}{\out{
}}
Compare that with \code{group_by() \%>\% summarise()}, where \code{summarise()} generally peels off 1 layer of grouping by default, typically with a message that it is doing so:
\if{html}{\out{}}\preformatted{expenses \%>\%
group_by(id, region) \%>\%
summarise(cost = mean(cost))
#> `summarise()` has grouped output by 'id'. You can override using the `.groups`
#> argument.
#> # A tibble: 5 x 3
#> # Groups: id [3]
#> id region cost
#>
#> 1 1 A 22
#> 2 1 B 9
#> 3 2 A 13
#> 4 3 A 6
#> 5 3 B 12
}\if{html}{\out{
}}
Because \code{.by} grouping applies to a single operation, you don't need to worry about ungrouping, and it never needs to emit a message to remind you what it is doing with the groups.
Note that with \code{.by} we specified multiple columns to group by using the \link[=dplyr_tidy_select]{tidy-select} syntax \code{c(id, region)}.
If you have a character vector of column names you'd like to group by, you can do so with \code{.by = all_of(my_cols)}.
It will group by the columns in the order they were provided.
To prevent surprising results, you can't use \code{.by} on an existing grouped data frame:
\if{html}{\out{}}\preformatted{expenses \%>\%
group_by(id) \%>\%
summarise(cost = mean(cost), .by = c(id, region))
#> Error in `summarise()`:
#> ! Can't supply `.by` when `.data` is a grouped data frame.
}\if{html}{\out{
}}
So far we've focused on the usage of \code{.by} with \code{summarise()}, but \code{.by} works with a number of other dplyr verbs.
For example, you could append the mean cost per region onto the original data frame as a new column rather than computing a summary:
\if{html}{\out{}}\preformatted{expenses \%>\%
mutate(cost_by_region = mean(cost), .by = region)
#> # A tibble: 7 x 4
#> id region cost cost_by_region
#>
#> 1 1 A 25 15.2
#> 2 2 A 20 15.2
#> 3 1 A 19 15.2
#> 4 3 B 12 10.5
#> 5 1 B 9 10.5
#> 6 2 A 6 15.2
#> 7 3 A 6 15.2
}\if{html}{\out{
}}
Or you could slice out the maximum cost per combination of id and region:
\if{html}{\out{}}\preformatted{# Note that the argument is named `by` in `slice_max()`
expenses \%>\%
slice_max(cost, n = 1, by = c(id, region))
#> # A tibble: 5 x 3
#> id region cost
#>
#> 1 1 A 25
#> 2 2 A 20
#> 3 3 B 12
#> 4 1 B 9
#> 5 3 A 6
}\if{html}{\out{
}}
}
\subsection{Result ordering}{
When used with \code{.by}, \code{summarise()}, \code{reframe()}, and \code{slice()} all maintain the ordering of the existing data.
This is different from \code{group_by()}, which has always sorted the group keys in ascending order.
\if{html}{\out{}}\preformatted{df <- tibble(
month = c("jan", "jan", "feb", "feb", "mar"),
temp = c(20, 25, 18, 20, 40)
)
# Uses ordering by "first appearance" in the original data
df \%>\%
summarise(average_temp = mean(temp), .by = month)
#> # A tibble: 3 x 2
#> month average_temp
#>
#> 1 jan 22.5
#> 2 feb 19
#> 3 mar 40
# Sorts in ascending order
df \%>\%
group_by(month) \%>\%
summarise(average_temp = mean(temp))
#> # A tibble: 3 x 2
#> month average_temp
#>
#> 1 feb 19
#> 2 jan 22.5
#> 3 mar 40
}\if{html}{\out{
}}
If you need sorted group keys, we recommend that you explicitly use \code{\link[=arrange]{arrange()}} either before or after the call to \code{summarise()}, \code{reframe()}, or \code{slice()}.
This also gives you full access to all of \code{arrange()}'s features, such as \code{desc()} and the \code{.locale} argument.
}
\subsection{Verbs without \code{.by} support}{
If a dplyr verb doesn't support \code{.by}, then that typically means that the verb isn't inherently affected by grouping.
For example, \code{\link[=pull]{pull()}} and \code{\link[=rename]{rename()}} don't support \code{.by}, because specifying columns to group by would not affect their implementations.
That said, there are a few exceptions to this where sometimes a dplyr verb doesn't support \code{.by}, but \emph{does} have special support for grouped data frames created by \code{\link[=group_by]{group_by()}}.
This is typically because the verbs are required to retain the grouping columns, for example:
\itemize{
\item \code{\link[=select]{select()}} always retains grouping columns, with a message if any aren't specified in the \code{select()} call.
\item \code{\link[=distinct]{distinct()}} and \code{\link[=count]{count()}} place unspecified grouping columns at the front of the data frame before computing their results.
\item \code{\link[=arrange]{arrange()}} has a \code{.by_group} argument to optionally order by grouping columns first.
}
If \code{group_by()} didn't exist, then these verbs would not have special support for grouped data frames.
}
}
dplyr/man/percent_rank.Rd 0000644 0001762 0000144 00000003216 14366556340 015137 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rank.R
\name{percent_rank}
\alias{percent_rank}
\alias{cume_dist}
\title{Proportional ranking functions}
\usage{
percent_rank(x)
cume_dist(x)
}
\arguments{
\item{x}{A vector to rank
By default, the smallest values will get the smallest ranks. Use \code{\link[=desc]{desc()}}
to reverse the direction so the largest values get the smallest ranks.
Missing values will be given rank \code{NA}. Use \code{coalesce(x, Inf)} or
\code{coalesce(x, -Inf)} if you want to treat them as the largest or smallest
values respectively.
To rank by multiple columns at once, supply a data frame.}
}
\value{
A numeric vector containing a proportion.
}
\description{
These two ranking functions implement two slightly different ways to
compute a percentile. For each \code{x_i} in \code{x}:
\itemize{
\item \code{cume_dist(x)} counts the total number of values less than
or equal to \code{x_i}, and divides it by the number of observations.
\item \code{percent_rank(x)} counts the total number of values less than
\code{x_i}, and divides it by the number of observations minus 1.
}
In both cases, missing values are ignored when counting the number
of observations.
}
\examples{
x <- c(5, 1, 3, 2, 2)
cume_dist(x)
percent_rank(x)
# You can understand what's going on by computing it by hand
sapply(x, function(xi) sum(x <= xi) / length(x))
sapply(x, function(xi) sum(x < xi) / (length(x) - 1))
# The real computations are a little more complex in order to
# correctly deal with missing values
}
\seealso{
Other ranking functions:
\code{\link{ntile}()},
\code{\link{row_number}()}
}
\concept{ranking functions}
dplyr/man/cumall.Rd 0000644 0001762 0000144 00000002644 13663216626 013744 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/funs.R
\name{cumall}
\alias{cumall}
\alias{cumany}
\alias{cummean}
\title{Cumulativate versions of any, all, and mean}
\usage{
cumall(x)
cumany(x)
cummean(x)
}
\arguments{
\item{x}{For \code{cumall()} and \code{cumany()}, a logical vector; for
\code{cummean()} an integer or numeric vector.}
}
\value{
A vector the same length as \code{x}.
}
\description{
dplyr provides \code{cumall()}, \code{cumany()}, and \code{cummean()} to complete R's set
of cumulative functions.
}
\section{Cumulative logical functions}{
These are particularly useful in conjunction with \code{filter()}:
\itemize{
\item \code{cumall(x)}: all cases until the first \code{FALSE}.
\item \code{cumall(!x)}: all cases until the first \code{TRUE}.
\item \code{cumany(x)}: all cases after the first \code{TRUE}.
\item \code{cumany(!x)}: all cases after the first \code{FALSE}.
}
}
\examples{
# `cummean()` returns a numeric/integer vector of the same length
# as the input vector.
x <- c(1, 3, 5, 2, 2)
cummean(x)
cumsum(x) / seq_along(x)
# `cumall()` and `cumany()` return logicals
cumall(x < 5)
cumany(x == 3)
# `cumall()` vs. `cumany()`
df <- data.frame(
date = as.Date("2020-01-01") + 0:6,
balance = c(100, 50, 25, -25, -50, 30, 120)
)
# all rows after first overdraft
df \%>\% filter(cumany(balance < 0))
# all rows until first overdraft
df \%>\% filter(cumall(!(balance < 0)))
}
dplyr/man/grouped_df.Rd 0000644 0001762 0000144 00000001560 14366556340 014602 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/grouped-df.R
\name{grouped_df}
\alias{grouped_df}
\alias{is.grouped_df}
\alias{is_grouped_df}
\title{A grouped data frame.}
\usage{
grouped_df(data, vars, drop = group_by_drop_default(data))
is.grouped_df(x)
is_grouped_df(x)
}
\arguments{
\item{data}{a tbl or data frame.}
\item{vars}{A character vector.}
\item{drop}{When \code{.drop = TRUE}, empty groups are dropped.}
}
\description{
The easiest way to create a grouped data frame is to call the \code{group_by()}
method on a data frame or tbl: this will take care of capturing
the unevaluated expressions for you.
These functions are designed for programmatic use. For data analysis
purposes see \code{\link[=group_data]{group_data()}} for the accessor functions that retrieve
various metadata from a grouped data frames.
}
\keyword{internal}
dplyr/man/add_rownames.Rd 0000644 0001762 0000144 00000001140 14266276767 015134 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-tibble.R
\name{add_rownames}
\alias{add_rownames}
\title{Convert row names to an explicit variable.}
\usage{
add_rownames(df, var = "rowname")
}
\arguments{
\item{df}{Input data frame with rownames.}
\item{var}{Name of variable to use}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
Please use \code{\link[tibble:rownames]{tibble::rownames_to_column()}} instead.
}
\keyword{internal}
dplyr/man/tidyeval-compat.Rd 0000644 0001762 0000144 00000002254 14406415372 015561 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/utils-tidy-eval.R
\name{tidyeval-compat}
\alias{tidyeval-compat}
\alias{.data}
\alias{expr}
\alias{enquo}
\alias{enquos}
\alias{sym}
\alias{syms}
\alias{as_label}
\alias{quo}
\alias{quos}
\alias{quo_name}
\alias{ensym}
\alias{ensyms}
\alias{enexpr}
\alias{enexprs}
\title{Other tidy eval tools}
\description{
These tidy eval functions are no longer for normal usage, but are still
exported from dplyr for backward compatibility.
See \code{\link[rlang:args_data_masking]{?rlang::args_data_masking}} and
\code{vignette("programming")} for the latest recommendations.
\itemize{
\item \link[rlang:expr]{expr()}
\item \link[rlang:enquo]{enquo()}
\item \link[rlang:enquo]{enquos()}
\item \link[rlang:sym]{sym()}
\item \link[rlang:sym]{syms()}
\item \link[rlang:as_label]{as_label()}
\item \link[rlang:defusing-advanced]{quo()}
\item \link[rlang:defusing-advanced]{quos()}
\item \link[rlang:quo_label]{quo_name()}
\item \link[rlang:defusing-advanced]{ensym()}
\item \link[rlang:defusing-advanced]{ensyms()}
\item \link[rlang:defusing-advanced]{enexpr()}
\item \link[rlang:defusing-advanced]{enexprs()}
}
}
\keyword{internal}
dplyr/man/vars.Rd 0000644 0001762 0000144 00000002235 14366556340 013437 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise.R
\name{vars}
\alias{vars}
\title{Select variables}
\usage{
vars(...)
}
\arguments{
\item{...}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Variables to operate on.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{vars()} is superseded because it is only needed for the scoped verbs (i.e.
\code{\link[=mutate_at]{mutate_at()}}, \code{\link[=summarise_at]{summarise_at()}}, and friends), which have been been
superseded in favour of \code{\link[=across]{across()}}. See \code{vignette("colwise")} for details.
This helper is intended to provide tidy-select semantics for scoped verbs
like \code{mutate_at()} and \code{summarise_at()}. Note that anywhere you can supply
\code{vars()} specification, you can also supply a numeric vector of column
positions or a character vector of column names.
}
\seealso{
\code{\link[=all_vars]{all_vars()}} and \code{\link[=any_vars]{any_vars()}} for other quoting
functions that you can use with scoped verbs.
}
dplyr/man/distinct_all.Rd 0000644 0001762 0000144 00000005170 14366556340 015136 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-distinct.R
\name{distinct_all}
\alias{distinct_all}
\alias{distinct_at}
\alias{distinct_if}
\title{Select distinct rows by a selection of variables}
\usage{
distinct_all(.tbl, .funs = list(), ..., .keep_all = FALSE)
distinct_at(.tbl, .vars, .funs = list(), ..., .keep_all = FALSE)
distinct_if(.tbl, .predicate, .funs = list(), ..., .keep_all = FALSE)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.keep_all}{If \code{TRUE}, keep all variables in \code{.data}.
If a combination of \code{...} is not distinct, this keeps the
first row of values.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
These \link{scoped} variants of \code{\link[=distinct]{distinct()}} extract distinct rows by a
selection of variables. Like \code{distinct()}, you can modify the
variables before ordering with the \code{.funs} argument.
}
\section{Grouping variables}{
The grouping variables that are part of the selection are taken
into account to determine distinct rows.
}
\examples{
df <- tibble(x = rep(2:5, each = 2) / 2, y = rep(2:3, each = 4) / 2)
distinct_all(df)
# ->
distinct(df, pick(everything()))
distinct_at(df, vars(x,y))
# ->
distinct(df, pick(x, y))
distinct_if(df, is.numeric)
# ->
distinct(df, pick(where(is.numeric)))
# You can supply a function that will be applied before extracting the distinct values
# The variables of the sorted tibble keep their original values.
distinct_all(df, round)
# ->
distinct(df, across(everything(), round))
}
\keyword{internal}
dplyr/man/dplyr_data_masking.Rd 0000644 0001762 0000144 00000000453 14406402754 016312 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/utils-tidy-eval.R
\name{dplyr_data_masking}
\alias{dplyr_data_masking}
\title{Data-masking}
\description{
This page is now located at
\code{\link[rlang:args_data_masking]{?rlang::args_data_masking}}.
}
\keyword{internal}
dplyr/man/mutate_all.Rd 0000644 0001762 0000144 00000015541 14366556340 014617 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-mutate.R
\name{mutate_all}
\alias{mutate_all}
\alias{mutate_if}
\alias{mutate_at}
\alias{transmute_all}
\alias{transmute_if}
\alias{transmute_at}
\title{Mutate multiple columns}
\usage{
mutate_all(.tbl, .funs, ...)
mutate_if(.tbl, .predicate, .funs, ...)
mutate_at(.tbl, .vars, .funs, ..., .cols = NULL)
transmute_all(.tbl, .funs, ...)
transmute_if(.tbl, .predicate, .funs, ...)
transmute_at(.tbl, .vars, .funs, ..., .cols = NULL)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.cols}{This argument has been renamed to \code{.vars} to fit
dplyr's terminology and is deprecated.}
}
\value{
A data frame. By default, the newly created columns have the shortest
names needed to uniquely identify the output. To force inclusion of a name,
even when not needed, name the input (see examples for details).
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
The \link{scoped} variants of \code{\link[=mutate]{mutate()}} and \code{\link[=transmute]{transmute()}} make it easy to apply
the same transformation to multiple variables. There are three variants:
\itemize{
\item _all affects every variable
\item _at affects variables selected with a character vector or vars()
\item _if affects variables selected with a predicate function:
}
}
\section{Grouping variables}{
If applied on a grouped tibble, these operations are \emph{not} applied
to the grouping variables. The behaviour depends on whether the
selection is \strong{implicit} (\code{all} and \code{if} selections) or
\strong{explicit} (\code{at} selections).
\itemize{
\item Grouping variables covered by explicit selections in
\code{mutate_at()} and \code{transmute_at()} are always an error. Add
\code{-group_cols()} to the \code{\link[=vars]{vars()}} selection to avoid this:
\if{html}{\out{}}\preformatted{data \%>\% mutate_at(vars(-group_cols(), ...), myoperation)
}\if{html}{\out{
}}
Or remove \code{group_vars()} from the character vector of column names:
\if{html}{\out{}}\preformatted{nms <- setdiff(nms, group_vars(data))
data \%>\% mutate_at(vars, myoperation)
}\if{html}{\out{
}}
\item Grouping variables covered by implicit selections are ignored by
\code{mutate_all()}, \code{transmute_all()}, \code{mutate_if()}, and
\code{transmute_if()}.
}
}
\section{Naming}{
The names of the new columns are derived from the names of the
input variables and the names of the functions.
\itemize{
\item if there is only one unnamed function (i.e. if \code{.funs} is an unnamed list
of length one),
the names of the input variables are used to name the new columns;
\item for \verb{_at} functions, if there is only one unnamed variable (i.e.,
if \code{.vars} is of the form \code{vars(a_single_column)}) and \code{.funs} has length
greater than one,
the names of the functions are used to name the new columns;
\item otherwise, the new names are created by
concatenating the names of the input variables and the names of the
functions, separated with an underscore \code{"_"}.
}
The \code{.funs} argument can be a named or unnamed list.
If a function is unnamed and the name cannot be derived automatically,
a name of the form "fn#" is used.
Similarly, \code{\link[=vars]{vars()}} accepts named and unnamed arguments.
If a variable in \code{.vars} is named, a new column by that name will be created.
Name collisions in the new columns are disambiguated using a unique suffix.
}
\examples{
iris <- as_tibble(iris)
# All variants can be passed functions and additional arguments,
# purrr-style. The _at() variants directly support strings. Here
# we'll scale the variables `height` and `mass`:
scale2 <- function(x, na.rm = FALSE) (x - mean(x, na.rm = na.rm)) / sd(x, na.rm)
starwars \%>\% mutate_at(c("height", "mass"), scale2)
# ->
starwars \%>\% mutate(across(c("height", "mass"), scale2))
# You can pass additional arguments to the function:
starwars \%>\% mutate_at(c("height", "mass"), scale2, na.rm = TRUE)
starwars \%>\% mutate_at(c("height", "mass"), ~scale2(., na.rm = TRUE))
# ->
starwars \%>\% mutate(across(c("height", "mass"), ~ scale2(.x, na.rm = TRUE)))
# You can also supply selection helpers to _at() functions but you have
# to quote them with vars():
iris \%>\% mutate_at(vars(matches("Sepal")), log)
iris \%>\% mutate(across(matches("Sepal"), log))
# The _if() variants apply a predicate function (a function that
# returns TRUE or FALSE) to determine the relevant subset of
# columns. Here we divide all the numeric columns by 100:
starwars \%>\% mutate_if(is.numeric, scale2, na.rm = TRUE)
starwars \%>\% mutate(across(where(is.numeric), ~ scale2(.x, na.rm = TRUE)))
# mutate_if() is particularly useful for transforming variables from
# one type to another
iris \%>\% mutate_if(is.factor, as.character)
iris \%>\% mutate_if(is.double, as.integer)
# ->
iris \%>\% mutate(across(where(is.factor), as.character))
iris \%>\% mutate(across(where(is.double), as.integer))
# Multiple transformations ----------------------------------------
# If you want to apply multiple transformations, pass a list of
# functions. When there are multiple functions, they create new
# variables instead of modifying the variables in place:
iris \%>\% mutate_if(is.numeric, list(scale2, log))
iris \%>\% mutate_if(is.numeric, list(~scale2(.), ~log(.)))
iris \%>\% mutate_if(is.numeric, list(scale = scale2, log = log))
# ->
iris \%>\%
as_tibble() \%>\%
mutate(across(where(is.numeric), list(scale = scale2, log = log)))
# When there's only one function in the list, it modifies existing
# variables in place. Give it a name to instead create new variables:
iris \%>\% mutate_if(is.numeric, list(scale2))
iris \%>\% mutate_if(is.numeric, list(scale = scale2))
}
\seealso{
\link[=scoped]{The other scoped verbs}, \code{\link[=vars]{vars()}}
}
\keyword{internal}
dplyr/man/group_map.Rd 0000644 0001762 0000144 00000010452 14366556340 014455 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-map.R
\name{group_map}
\alias{group_map}
\alias{group_modify}
\alias{group_walk}
\title{Apply a function to each group}
\usage{
group_map(.data, .f, ..., .keep = FALSE)
group_modify(.data, .f, ..., .keep = FALSE)
group_walk(.data, .f, ..., .keep = FALSE)
}
\arguments{
\item{.data}{A grouped tibble}
\item{.f}{A function or formula to apply to each group.
If a \strong{function}, it is used as is. It should have at least 2 formal arguments.
If a \strong{formula}, e.g. \code{~ head(.x)}, it is converted to a function.
In the formula, you can use
\itemize{
\item \code{.} or \code{.x} to refer to the subset of rows of \code{.tbl}
for the given group
\item \code{.y} to refer to the key, a one row tibble with one column per grouping variable
that identifies the group
}}
\item{...}{Additional arguments passed on to \code{.f}}
\item{.keep}{are the grouping variables kept in \code{.x}}
}
\value{
\itemize{
\item \code{group_modify()} returns a grouped tibble. In that case \code{.f} must return a data frame.
\item \code{group_map()} returns a list of results from calling \code{.f} on each group.
\item \code{group_walk()} calls \code{.f} for side effects and returns the input \code{.tbl}, invisibly.
}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
\code{group_map()}, \code{group_modify()} and \code{group_walk()} are purrr-style functions that can
be used to iterate on grouped tibbles.
}
\details{
Use \code{group_modify()} when \code{summarize()} is too limited, in terms of what you need
to do and return for each group. \code{group_modify()} is good for "data frame in, data frame out".
If that is too limited, you need to use a \link[=group_nest]{nested} or \link[=group_split]{split} workflow.
\code{group_modify()} is an evolution of \code{\link[=do]{do()}}, if you have used that before.
Each conceptual group of the data frame is exposed to the function \code{.f} with two pieces of information:
\itemize{
\item The subset of the data for the group, exposed as \code{.x}.
\item The key, a tibble with exactly one row and columns for each grouping variable, exposed as \code{.y}.
}
For completeness, \code{group_modify()}, \code{group_map} and \code{group_walk()} also work on
ungrouped data frames, in that case the function is applied to the
entire data frame (exposed as \code{.x}), and \code{.y} is a one row tibble with no
column, consistently with \code{\link[=group_keys]{group_keys()}}.
}
\examples{
# return a list
mtcars \%>\%
group_by(cyl) \%>\%
group_map(~ head(.x, 2L))
# return a tibble grouped by `cyl` with 2 rows per group
# the grouping data is recalculated
mtcars \%>\%
group_by(cyl) \%>\%
group_modify(~ head(.x, 2L))
\dontshow{if (requireNamespace("broom", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
# a list of tibbles
iris \%>\%
group_by(Species) \%>\%
group_map(~ broom::tidy(lm(Petal.Length ~ Sepal.Length, data = .x)))
# a restructured grouped tibble
iris \%>\%
group_by(Species) \%>\%
group_modify(~ broom::tidy(lm(Petal.Length ~ Sepal.Length, data = .x)))
\dontshow{\}) # examplesIf}
# a list of vectors
iris \%>\%
group_by(Species) \%>\%
group_map(~ quantile(.x$Petal.Length, probs = c(0.25, 0.5, 0.75)))
# to use group_modify() the lambda must return a data frame
iris \%>\%
group_by(Species) \%>\%
group_modify(~ {
quantile(.x$Petal.Length, probs = c(0.25, 0.5, 0.75)) \%>\%
tibble::enframe(name = "prob", value = "quantile")
})
iris \%>\%
group_by(Species) \%>\%
group_modify(~ {
.x \%>\%
purrr::map_dfc(fivenum) \%>\%
mutate(nms = c("min", "Q1", "median", "Q3", "max"))
})
# group_walk() is for side effects
dir.create(temp <- tempfile())
iris \%>\%
group_by(Species) \%>\%
group_walk(~ write.csv(.x, file = file.path(temp, paste0(.y$Species, ".csv"))))
list.files(temp, pattern = "csv$")
unlink(temp, recursive = TRUE)
# group_modify() and ungrouped data frames
mtcars \%>\%
group_modify(~ head(.x, 2L))
}
\seealso{
Other grouping functions:
\code{\link{group_by}()},
\code{\link{group_nest}()},
\code{\link{group_split}()},
\code{\link{group_trim}()}
}
\concept{grouping functions}
dplyr/man/rename.Rd 0000644 0001762 0000144 00000005626 14406402754 013734 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rename.R
\name{rename}
\alias{rename}
\alias{rename_with}
\title{Rename columns}
\usage{
rename(.data, ...)
rename_with(.data, .fn, .cols = everything(), ...)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{For \code{rename()}: <\code{\link[=dplyr_tidy_select]{tidy-select}}> Use
\code{new_name = old_name} to rename selected variables.
For \code{rename_with()}: additional arguments passed onto \code{.fn}.}
\item{.fn}{A function used to transform the selected \code{.cols}. Should
return a character vector the same length as the input.}
\item{.cols}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Columns to rename;
defaults to all columns.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Rows are not affected.
\item Column names are changed; column order is preserved.
\item Data frame attributes are preserved.
\item Groups are updated to reflect new names.
}
}
\description{
\code{rename()} changes the names of individual variables using
\code{new_name = old_name} syntax; \code{rename_with()} renames columns using a
function.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rename")}.
}
\examples{
iris <- as_tibble(iris) # so it prints a little nicer
rename(iris, petal_length = Petal.Length)
# Rename using a named vector and `all_of()`
lookup <- c(pl = "Petal.Length", sl = "Sepal.Length")
rename(iris, all_of(lookup))
# If your named vector might contain names that don't exist in the data,
# use `any_of()` instead
lookup <- c(lookup, new = "unknown")
try(rename(iris, all_of(lookup)))
rename(iris, any_of(lookup))
rename_with(iris, toupper)
rename_with(iris, toupper, starts_with("Petal"))
rename_with(iris, ~ tolower(gsub(".", "_", .x, fixed = TRUE)))
\dontshow{if (getRversion() > "4.0.1") (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
# If your renaming function uses `paste0()`, make sure to set
# `recycle0 = TRUE` to ensure that empty selections are recycled correctly
try(rename_with(
iris,
~ paste0("prefix_", .x),
starts_with("nonexistent")
))
rename_with(
iris,
~ paste0("prefix_", .x, recycle0 = TRUE),
starts_with("nonexistent")
)
\dontshow{\}) # examplesIf}
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/args_by.Rd 0000644 0001762 0000144 00000001333 14366556340 014110 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/by.R
\name{args_by}
\alias{args_by}
\title{Helper for consistent documentation of \code{.by}}
\arguments{
\item{.by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
}
\description{
Use \verb{@inheritParams args_by} to consistently document \code{.by}.
}
\keyword{internal}
dplyr/man/sql.Rd 0000644 0001762 0000144 00000000706 14272553254 013261 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/compat-dbplyr.R
\name{sql}
\alias{sql}
\title{SQL escaping.}
\usage{
sql(...)
}
\arguments{
\item{...}{Character vectors that will be combined into a single SQL
expression.}
}
\description{
These functions are critical when writing functions that translate R
functions to sql functions. Typically a conversion function should escape
all its inputs and return an sql object.
}
dplyr/man/sample_n.Rd 0000644 0001762 0000144 00000005504 14366556340 014264 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/sample.R
\name{sample_n}
\alias{sample_n}
\alias{sample_frac}
\title{Sample n rows from a table}
\usage{
sample_n(tbl, size, replace = FALSE, weight = NULL, .env = NULL, ...)
sample_frac(tbl, size = 1, replace = FALSE, weight = NULL, .env = NULL, ...)
}
\arguments{
\item{tbl}{A data.frame.}
\item{size}{<\code{\link[=dplyr_tidy_select]{tidy-select}}>
For \code{sample_n()}, the number of rows to select.
For \code{sample_frac()}, the fraction of rows to select.
If \code{tbl} is grouped, \code{size} applies to each group.}
\item{replace}{Sample with or without replacement?}
\item{weight}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Sampling weights.
This must evaluate to a vector of non-negative numbers the same length as
the input. Weights are automatically standardised to sum to 1.}
\item{.env}{DEPRECATED.}
\item{...}{ignored}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{sample_n()} and \code{sample_frac()} have been superseded in favour of
\code{\link[=slice_sample]{slice_sample()}}. While they will not be deprecated in the near future,
retirement means that we will only perform critical bug fixes, so we recommend
moving to the newer alternative.
These functions were superseded because we realised it was more convenient to
have two mutually exclusive arguments to one function, rather than two
separate functions. This also made it to clean up a few other smaller
design issues with \code{sample_n()}/\code{sample_frac}:
\itemize{
\item The connection to \code{slice()} was not obvious.
\item The name of the first argument, \code{tbl}, is inconsistent with other
single table verbs which use \code{.data}.
\item The \code{size} argument uses tidy evaluation, which is surprising and
undocumented.
\item It was easier to remove the deprecated \code{.env} argument.
\item \code{...} was in a suboptimal position.
}
}
\examples{
df <- tibble(x = 1:5, w = c(0.1, 0.1, 0.1, 2, 2))
# sample_n() -> slice_sample() ----------------------------------------------
# Was:
sample_n(df, 3)
sample_n(df, 10, replace = TRUE)
sample_n(df, 3, weight = w)
# Now:
slice_sample(df, n = 3)
slice_sample(df, n = 10, replace = TRUE)
slice_sample(df, n = 3, weight_by = w)
# Note that sample_n() would error if n was bigger than the group size
# slice_sample() will just use the available rows for consistency with
# the other slice helpers like slice_head()
try(sample_n(df, 10))
slice_sample(df, n = 10)
# sample_frac() -> slice_sample() -------------------------------------------
# Was:
sample_frac(df, 0.25)
sample_frac(df, 2, replace = TRUE)
# Now:
slice_sample(df, prop = 0.25)
slice_sample(df, prop = 2, replace = TRUE)
}
\keyword{internal}
dplyr/man/mutate.Rd 0000644 0001762 0000144 00000016766 14406402754 013773 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/mutate.R
\name{mutate}
\alias{mutate}
\alias{mutate.data.frame}
\title{Create, modify, and delete columns}
\usage{
mutate(.data, ...)
\method{mutate}{data.frame}(
.data,
...,
.by = NULL,
.keep = c("all", "used", "unused", "none"),
.before = NULL,
.after = NULL
)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Name-value pairs.
The name gives the name of the column in the output.
The value can be:
\itemize{
\item A vector of length 1, which will be recycled to the correct length.
\item A vector the same length as the current group (or the whole data frame
if ungrouped).
\item \code{NULL}, to remove the column.
\item A data frame or tibble, to create multiple columns in the output.
}}
\item{.by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
\item{.keep}{Control which columns from \code{.data} are retained in the output. Grouping
columns and columns created by \code{...} are always kept.
\itemize{
\item \code{"all"} retains all columns from \code{.data}. This is the default.
\item \code{"used"} retains only the columns used in \code{...} to create new
columns. This is useful for checking your work, as it displays inputs
and outputs side-by-side.
\item \code{"unused"} retains only the columns \emph{not} used in \code{...} to create new
columns. This is useful if you generate new columns, but no longer need
the columns used to generate them.
\item \code{"none"} doesn't retain any extra columns from \code{.data}. Only the grouping
variables and columns created by \code{...} are kept.
}}
\item{.before, .after}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, control where new columns
should appear (the default is to add to the right hand side). See
\code{\link[=relocate]{relocate()}} for more details.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Columns from \code{.data} will be preserved according to the \code{.keep} argument.
\item Existing columns that are modified by \code{...} will always be returned in
their original location.
\item New columns created through \code{...} will be placed according to the
\code{.before} and \code{.after} arguments.
\item The number of rows is not affected.
\item Columns given the value \code{NULL} will be removed.
\item Groups will be recomputed if a grouping variable is mutated.
\item Data frame attributes are preserved.
}
}
\description{
\code{mutate()} creates new columns that are functions of existing variables.
It can also modify (if the name is the same as an existing
column) and delete columns (by setting their value to \code{NULL}).
}
\section{Useful mutate functions}{
\itemize{
\item \code{\link{+}}, \code{\link{-}}, \code{\link[=log]{log()}}, etc., for their usual mathematical meanings
\item \code{\link[=lead]{lead()}}, \code{\link[=lag]{lag()}}
\item \code{\link[=dense_rank]{dense_rank()}}, \code{\link[=min_rank]{min_rank()}}, \code{\link[=percent_rank]{percent_rank()}}, \code{\link[=row_number]{row_number()}},
\code{\link[=cume_dist]{cume_dist()}}, \code{\link[=ntile]{ntile()}}
\item \code{\link[=cumsum]{cumsum()}}, \code{\link[=cummean]{cummean()}}, \code{\link[=cummin]{cummin()}}, \code{\link[=cummax]{cummax()}}, \code{\link[=cumany]{cumany()}}, \code{\link[=cumall]{cumall()}}
\item \code{\link[=na_if]{na_if()}}, \code{\link[=coalesce]{coalesce()}}
\item \code{\link[=if_else]{if_else()}}, \code{\link[=recode]{recode()}}, \code{\link[=case_when]{case_when()}}
}
}
\section{Grouped tibbles}{
Because mutating expressions are computed within groups, they may
yield different results on grouped tibbles. This will be the case
as soon as an aggregating, lagging, or ranking function is
involved. Compare this ungrouped mutate:
\if{html}{\out{}}\preformatted{starwars \%>\%
select(name, mass, species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
}\if{html}{\out{
}}
With the grouped equivalent:
\if{html}{\out{}}\preformatted{starwars \%>\%
select(name, mass, species) \%>\%
group_by(species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
}\if{html}{\out{
}}
The former normalises \code{mass} by the global average whereas the
latter normalises by the averages within species levels.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("mutate")}.
}
\examples{
# Newly created variables are available immediately
starwars \%>\%
select(name, mass) \%>\%
mutate(
mass2 = mass * 2,
mass2_squared = mass2 * mass2
)
# As well as adding new variables, you can use mutate() to
# remove variables and modify existing variables.
starwars \%>\%
select(name, height, mass, homeworld) \%>\%
mutate(
mass = NULL,
height = height * 0.0328084 # convert to feet
)
# Use across() with mutate() to apply a transformation
# to multiple columns in a tibble.
starwars \%>\%
select(name, homeworld, species) \%>\%
mutate(across(!name, as.factor))
# see more in ?across
# Window functions are useful for grouped mutates:
starwars \%>\%
select(name, mass, homeworld) \%>\%
group_by(homeworld) \%>\%
mutate(rank = min_rank(desc(mass)))
# see `vignette("window-functions")` for more details
# By default, new columns are placed on the far right.
df <- tibble(x = 1, y = 2)
df \%>\% mutate(z = x + y)
df \%>\% mutate(z = x + y, .before = 1)
df \%>\% mutate(z = x + y, .after = x)
# By default, mutate() keeps all columns from the input data.
df <- tibble(x = 1, y = 2, a = "a", b = "b")
df \%>\% mutate(z = x + y, .keep = "all") # the default
df \%>\% mutate(z = x + y, .keep = "used")
df \%>\% mutate(z = x + y, .keep = "unused")
df \%>\% mutate(z = x + y, .keep = "none")
# Grouping ----------------------------------------
# The mutate operation may yield different results on grouped
# tibbles because the expressions are computed within groups.
# The following normalises `mass` by the global average:
starwars \%>\%
select(name, mass, species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
# Whereas this normalises `mass` by the averages within species
# levels:
starwars \%>\%
select(name, mass, species) \%>\%
group_by(species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
# Indirection ----------------------------------------
# Refer to column names stored as strings with the `.data` pronoun:
vars <- c("mass", "height")
mutate(starwars, prod = .data[[vars[[1]]]] * .data[[vars[[2]]]])
# Learn more in ?rlang::args_data_masking
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/na_if.Rd 0000644 0001762 0000144 00000003321 14525503021 013516 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/na-if.R
\name{na_if}
\alias{na_if}
\title{Convert values to \code{NA}}
\usage{
na_if(x, y)
}
\arguments{
\item{x}{Vector to modify}
\item{y}{Value or vector to compare against. When \code{x} and \code{y} are equal, the
value in \code{x} will be replaced with \code{NA}.
\code{y} is \link[vctrs:theory-faq-coercion]{cast} to the type of \code{x} before
comparison.
\code{y} is \link[vctrs:theory-faq-recycling]{recycled} to the size of \code{x} before
comparison. This means that \code{y} can be a vector with the same size as \code{x},
but most of the time this will be a single value.}
}
\value{
A modified version of \code{x} that replaces any values that
are equal to \code{y} with \code{NA}.
}
\description{
This is a translation of the SQL command \code{NULLIF}. It is useful if you want
to convert an annoying value to \code{NA}.
}
\examples{
na_if(1:5, 5:1)
x <- c(1, -1, 0, 10)
100 / x
100 / na_if(x, 0)
y <- c("abc", "def", "", "ghi")
na_if(y, "")
# `na_if()` allows you to replace `NaN` with `NA`,
# even though `NaN == NaN` returns `NA`
z <- c(1, NaN, NA, 2, NaN)
na_if(z, NaN)
# `na_if()` is particularly useful inside `mutate()`,
# and is meant for use with vectors rather than entire data frames
starwars \%>\%
select(name, eye_color) \%>\%
mutate(eye_color = na_if(eye_color, "unknown"))
# `na_if()` can also be used with `mutate()` and `across()`
# to alter multiple columns
starwars \%>\%
mutate(across(where(is.character), ~na_if(., "unknown")))
}
\seealso{
\code{\link[=coalesce]{coalesce()}} to replace missing values with a specified
value.
\code{\link[tidyr:replace_na]{tidyr::replace_na()}} to replace \code{NA} with a value.
}
dplyr/man/check_dbplyr.Rd 0000644 0001762 0000144 00000001577 14266276767 015140 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/compat-dbplyr.R
\name{check_dbplyr}
\alias{check_dbplyr}
\alias{wrap_dbplyr_obj}
\title{dbplyr compatibility functions}
\usage{
check_dbplyr()
wrap_dbplyr_obj(obj_name)
}
\description{
In dplyr 0.7.0, a number of database and SQL functions moved from dplyr to
dbplyr. The generic functions stayed in dplyr (since there is no easy way
to conditionally import a generic from different packages), but many other
SQL and database helper functions moved. If you have written a backend,
these functions generate the code you need to work with both dplyr 0.5.0
dplyr 0.7.0.
}
\examples{
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
wrap_dbplyr_obj("build_sql")
wrap_dbplyr_obj("base_agg")
\dontshow{\}) # examplesIf}
}
\keyword{internal}
dplyr/man/dim_desc.Rd 0000644 0001762 0000144 00000000645 14366556340 014236 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/utils-format.R
\name{dim_desc}
\alias{dim_desc}
\title{Describing dimensions}
\usage{
dim_desc(x)
}
\arguments{
\item{x}{Object to show dimensions for.}
}
\description{
Prints the dimensions of an array-like object in a user-friendly manner,
substituting \code{NA} with ?? (for SQL queries).
}
\examples{
dim_desc(mtcars)
}
\keyword{internal}
dplyr/man/nest_join.Rd 0000644 0001762 0000144 00000013534 14366556340 014460 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join.R
\name{nest_join}
\alias{nest_join}
\alias{nest_join.data.frame}
\title{Nest join}
\usage{
nest_join(x, y, by = NULL, copy = FALSE, keep = NULL, name = NULL, ...)
\method{nest_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
keep = NULL,
name = NULL,
...,
na_matches = c("na", "never"),
unmatched = "drop"
)
}
\arguments{
\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or
lazy data frames (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{by}{A join specification created with \code{\link[=join_by]{join_by()}}, or a character
vector of variables to join by.
If \code{NULL}, the default, \verb{*_join()} will perform a natural join, using all
variables in common across \code{x} and \code{y}. A message lists the variables so
that you can check they're correct; suppress the message by supplying \code{by}
explicitly.
To join on different variables between \code{x} and \code{y}, use a \code{\link[=join_by]{join_by()}}
specification. For example, \code{join_by(a == b)} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a \code{\link[=join_by]{join_by()}} specification with
multiple expressions. For example, \code{join_by(a == b, c == d)} will match
\code{x$a} to \code{y$b} and \code{x$c} to \code{y$d}. If the column names are the same between
\code{x} and \code{y}, you can shorten this by listing only the variable names, like
\code{join_by(a, c)}.
\code{\link[=join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap
joins. See the documentation at \link[=join_by]{?join_by} for details on
these types of joins.
For simple equality joins, you can alternatively specify a character vector
of variable names to join by. For example, \code{by = c("a", "b")} joins \code{x$a}
to \code{y$a} and \code{x$b} to \code{y$b}. If variable names differ between \code{x} and \code{y},
use a named character vector like \code{by = c("x_a" = "y_a", "x_b" = "y_b")}.
To perform a cross-join, generating all combinations of \code{x} and \code{y}, see
\code{\link[=cross_join]{cross_join()}}.}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{keep}{Should the new list-column contain join keys? The default
will preserve the join keys for inequality joins.}
\item{name}{The name of the list-column created by the join. If \code{NULL},
the default, the name of \code{y} is used.}
\item{...}{Other parameters passed onto methods.}
\item{na_matches}{Should two \code{NA} or two \code{NaN} values match?
\itemize{
\item \code{"na"}, the default, treats two \code{NA} or two \code{NaN} values as equal, like
\code{\%in\%}, \code{\link[=match]{match()}}, and \code{\link[=merge]{merge()}}.
\item \code{"never"} treats two \code{NA} or two \code{NaN} values as different, and will
never match them together or to any other values. This is similar to joins
for database sources and to \code{base::merge(incomparables = NA)}.
}}
\item{unmatched}{How should unmatched keys that would result in dropped rows
be handled?
\itemize{
\item \code{"drop"} drops unmatched keys from the result.
\item \code{"error"} throws an error if unmatched keys are detected.
}
\code{unmatched} is intended to protect you from accidentally dropping rows
during a join. It only checks for unmatched keys in the input that could
potentially drop rows.
\itemize{
\item For left joins, it checks \code{y}.
\item For right joins, it checks \code{x}.
\item For inner joins, it checks both \code{x} and \code{y}. In this case, \code{unmatched} is
also allowed to be a character vector of length 2 to specify the behavior
for \code{x} and \code{y} independently.
}}
}
\value{
The output:
\itemize{
\item Is same type as \code{x} (including having the same groups).
\item Has exactly the same number of rows as \code{x}.
\item Contains all the columns of \code{x} in the same order with the same values.
They are only modified (slightly) if \code{keep = FALSE}, when columns listed
in \code{by} will be coerced to their common type across \code{x} and \code{y}.
\item Gains one new column called \code{{name}} on the far right, a list column
containing data frames the same type as \code{y}.
}
}
\description{
A nest join leaves \code{x} almost unchanged, except that it adds a new
list-column, where each element contains the rows from \code{y} that match the
corresponding row in \code{x}.
}
\section{Relationship to other joins}{
You can recreate many other joins from the result of a nest join:
\itemize{
\item \code{\link[=inner_join]{inner_join()}} is a \code{nest_join()} plus \code{\link[tidyr:unnest]{tidyr::unnest()}}.
\item \code{\link[=left_join]{left_join()}} is a \code{nest_join()} plus \code{tidyr::unnest(keep_empty = TRUE)}.
\item \code{\link[=semi_join]{semi_join()}} is a \code{nest_join()} plus a \code{filter()} where you check
that every element of data has at least one row.
\item \code{\link[=anti_join]{anti_join()}} is a \code{nest_join()} plus a \code{filter()} where you check that every
element has zero rows.
}
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("nest_join")}.
}
\examples{
df1 <- tibble(x = 1:3)
df2 <- tibble(x = c(2, 3, 3), y = c("a", "b", "c"))
out <- nest_join(df1, df2)
out
out$df2
}
\seealso{
Other joins:
\code{\link{cross_join}()},
\code{\link{filter-joins}},
\code{\link{mutate-joins}}
}
\concept{joins}
dplyr/man/pull.Rd 0000644 0001762 0000144 00000004076 14266276767 013460 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/pull.R
\name{pull}
\alias{pull}
\title{Extract a single column}
\usage{
pull(.data, var = -1, name = NULL, ...)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{var}{A variable specified as:
\itemize{
\item a literal variable name
\item a positive integer, giving the position counting from the left
\item a negative integer, giving the position counting from the right.
}
The default returns the last column (on the assumption that's the
column you've created most recently).
This argument is taken by expression and supports
\link[rlang:topic-inject]{quasiquotation} (you can unquote column
names and column locations).}
\item{name}{An optional parameter that specifies the column to be used
as names for a named vector. Specified in a similar manner as \code{var}.}
\item{...}{For use by methods.}
}
\value{
A vector the same size as \code{.data}.
}
\description{
\code{pull()} is similar to \code{$}. It's mostly useful because it looks a little
nicer in pipes, it also works with remote data frames, and it can optionally
name the output.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("pull")}.
}
\examples{
mtcars \%>\% pull(-1)
mtcars \%>\% pull(1)
mtcars \%>\% pull(cyl)
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE) && requireNamespace("RSQLite", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
# Also works for remote sources
df <- dbplyr::memdb_frame(x = 1:10, y = 10:1, .name = "pull-ex")
df \%>\%
mutate(z = x * y) \%>\%
pull()
\dontshow{\}) # examplesIf}
# Pull a named vector
starwars \%>\% pull(height, name)
}
dplyr/man/filter-joins.Rd 0000644 0001762 0000144 00000011150 14366556340 015065 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join.R
\name{filter-joins}
\alias{filter-joins}
\alias{semi_join}
\alias{semi_join.data.frame}
\alias{anti_join}
\alias{anti_join.data.frame}
\title{Filtering joins}
\usage{
semi_join(x, y, by = NULL, copy = FALSE, ...)
\method{semi_join}{data.frame}(x, y, by = NULL, copy = FALSE, ..., na_matches = c("na", "never"))
anti_join(x, y, by = NULL, copy = FALSE, ...)
\method{anti_join}{data.frame}(x, y, by = NULL, copy = FALSE, ..., na_matches = c("na", "never"))
}
\arguments{
\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or
lazy data frames (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{by}{A join specification created with \code{\link[=join_by]{join_by()}}, or a character
vector of variables to join by.
If \code{NULL}, the default, \verb{*_join()} will perform a natural join, using all
variables in common across \code{x} and \code{y}. A message lists the variables so
that you can check they're correct; suppress the message by supplying \code{by}
explicitly.
To join on different variables between \code{x} and \code{y}, use a \code{\link[=join_by]{join_by()}}
specification. For example, \code{join_by(a == b)} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a \code{\link[=join_by]{join_by()}} specification with
multiple expressions. For example, \code{join_by(a == b, c == d)} will match
\code{x$a} to \code{y$b} and \code{x$c} to \code{y$d}. If the column names are the same between
\code{x} and \code{y}, you can shorten this by listing only the variable names, like
\code{join_by(a, c)}.
\code{\link[=join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap
joins. See the documentation at \link[=join_by]{?join_by} for details on
these types of joins.
For simple equality joins, you can alternatively specify a character vector
of variable names to join by. For example, \code{by = c("a", "b")} joins \code{x$a}
to \code{y$a} and \code{x$b} to \code{y$b}. If variable names differ between \code{x} and \code{y},
use a named character vector like \code{by = c("x_a" = "y_a", "x_b" = "y_b")}.
To perform a cross-join, generating all combinations of \code{x} and \code{y}, see
\code{\link[=cross_join]{cross_join()}}.}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{...}{Other parameters passed onto methods.}
\item{na_matches}{Should two \code{NA} or two \code{NaN} values match?
\itemize{
\item \code{"na"}, the default, treats two \code{NA} or two \code{NaN} values as equal, like
\code{\%in\%}, \code{\link[=match]{match()}}, and \code{\link[=merge]{merge()}}.
\item \code{"never"} treats two \code{NA} or two \code{NaN} values as different, and will
never match them together or to any other values. This is similar to joins
for database sources and to \code{base::merge(incomparables = NA)}.
}}
}
\value{
An object of the same type as \code{x}. The output has the following properties:
\itemize{
\item Rows are a subset of the input, but appear in the same order.
\item Columns are not modified.
\item Data frame attributes are preserved.
\item Groups are taken from \code{x}. The number of groups may be reduced.
}
}
\description{
Filtering joins filter rows from \code{x} based on the presence or absence
of matches in \code{y}:
\itemize{
\item \code{semi_join()} return all rows from \code{x} with a match in \code{y}.
\item \code{anti_join()} return all rows from \code{x} with\strong{out} a match in \code{y}.
}
}
\section{Methods}{
These function are \strong{generic}s, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{semi_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("semi_join")}.
\item \code{anti_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("anti_join")}.
}
}
\examples{
# "Filtering" joins keep cases from the LHS
band_members \%>\% semi_join(band_instruments)
band_members \%>\% anti_join(band_instruments)
# To suppress the message about joining variables, supply `by`
band_members \%>\% semi_join(band_instruments, by = join_by(name))
# This is good practice in production code
}
\seealso{
Other joins:
\code{\link{cross_join}()},
\code{\link{mutate-joins}},
\code{\link{nest_join}()}
}
\concept{joins}
dplyr/man/group_by_all.Rd 0000644 0001762 0000144 00000006122 14366556340 015141 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-group-by.R
\name{group_by_all}
\alias{group_by_all}
\alias{group_by_at}
\alias{group_by_if}
\title{Group by a selection of variables}
\usage{
group_by_all(
.tbl,
.funs = list(),
...,
.add = FALSE,
.drop = group_by_drop_default(.tbl)
)
group_by_at(
.tbl,
.vars,
.funs = list(),
...,
.add = FALSE,
.drop = group_by_drop_default(.tbl)
)
group_by_if(
.tbl,
.predicate,
.funs = list(),
...,
.add = FALSE,
.drop = group_by_drop_default(.tbl)
)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.add}{See \code{\link[=group_by]{group_by()}}}
\item{.drop}{Drop groups formed by factor levels that don't appear in the
data? The default is \code{TRUE} except when \code{.data} has been previously
grouped with \code{.drop = FALSE}. See \code{\link[=group_by_drop_default]{group_by_drop_default()}} for details.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
These \link{scoped} variants of \code{\link[=group_by]{group_by()}} group a data frame by a
selection of variables. Like \code{\link[=group_by]{group_by()}}, they have optional
\link{mutate} semantics.
}
\section{Grouping variables}{
Existing grouping variables are maintained, even if not included in
the selection.
}
\examples{
# Group a data frame by all variables:
group_by_all(mtcars)
# ->
mtcars \%>\% group_by(pick(everything()))
# Group by variables selected with a predicate:
group_by_if(iris, is.factor)
# ->
iris \%>\% group_by(pick(where(is.factor)))
# Group by variables selected by name:
group_by_at(mtcars, vars(vs, am))
# ->
mtcars \%>\% group_by(pick(vs, am))
# Like group_by(), the scoped variants have optional mutate
# semantics. This provide a shortcut for group_by() + mutate():
d <- tibble(x=c(1,1,2,2), y=c(1,2,1,2))
group_by_all(d, as.factor)
# ->
d \%>\% group_by(across(everything(), as.factor))
group_by_if(iris, is.factor, as.character)
# ->
iris \%>\% group_by(across(where(is.factor), as.character))
}
\keyword{internal}
dplyr/man/recode.Rd 0000644 0001762 0000144 00000012014 14366556340 013721 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/recode.R
\name{recode}
\alias{recode}
\alias{recode_factor}
\title{Recode values}
\usage{
recode(.x, ..., .default = NULL, .missing = NULL)
recode_factor(.x, ..., .default = NULL, .missing = NULL, .ordered = FALSE)
}
\arguments{
\item{.x}{A vector to modify}
\item{...}{<\code{\link[rlang:dyn-dots]{dynamic-dots}}> Replacements. For character and factor \code{.x}, these should be named
and replacement is based only on their name. For numeric \code{.x}, these can be
named or not. If not named, the replacement is done based on position i.e.
\code{.x} represents positions to look for in replacements. See examples.
When named, the argument names should be the current values to be replaced, and the
argument values should be the new (replacement) values.
All replacements must be the same type, and must have either
length one or the same length as \code{.x}.}
\item{.default}{If supplied, all values not otherwise matched will
be given this value. If not supplied and if the replacements are
the same type as the original values in \code{.x}, unmatched
values are not changed. If not supplied and if the replacements
are not compatible, unmatched values are replaced with \code{NA}.
\code{.default} must be either length 1 or the same length as
\code{.x}.}
\item{.missing}{If supplied, any missing values in \code{.x} will be
replaced by this value. Must be either length 1 or the same length as
\code{.x}.}
\item{.ordered}{If \code{TRUE}, \code{recode_factor()} creates an
ordered factor.}
}
\value{
A vector the same length as \code{.x}, and the same type as
the first of \code{...}, \code{.default}, or \code{.missing}.
\code{recode_factor()} returns a factor whose levels are in the same order as
in \code{...}. The levels in \code{.default} and \code{.missing} come last.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{recode()} is superseded in favor of \code{\link[=case_match]{case_match()}}, which handles the most
important cases of \code{recode()} with a more elegant interface.
\code{recode_factor()} is also superseded, however, its direct replacement is not
currently available but will eventually live in
\href{https://forcats.tidyverse.org/}{forcats}. For creating new variables based
on logical vectors, use \code{\link[=if_else]{if_else()}}. For even more complicated criteria, use
\code{\link[=case_when]{case_when()}}.
\code{recode()} is a vectorised version of \code{\link[=switch]{switch()}}: you can replace numeric
values based on their position or their name, and character or factor values
only by their name. This is an S3 generic: dplyr provides methods for
numeric, character, and factors. You can use \code{recode()} directly with
factors; it will preserve the existing order of levels while changing the
values. Alternatively, you can use \code{recode_factor()}, which will change the
order of levels to match the order of replacements.
}
\examples{
char_vec <- sample(c("a", "b", "c"), 10, replace = TRUE)
# `recode()` is superseded by `case_match()`
recode(char_vec, a = "Apple", b = "Banana")
case_match(char_vec, "a" ~ "Apple", "b" ~ "Banana", .default = char_vec)
# With `case_match()`, you don't need typed missings like `NA_character_`
recode(char_vec, a = "Apple", b = "Banana", .default = NA_character_)
case_match(char_vec, "a" ~ "Apple", "b" ~ "Banana", .default = NA)
# Throws an error as `NA` is logical, not character.
try(recode(char_vec, a = "Apple", b = "Banana", .default = NA))
# `case_match()` is easier to use with numeric vectors, because you don't
# need to turn the numeric values into names
num_vec <- c(1:4, NA)
recode(num_vec, `2` = 20L, `4` = 40L)
case_match(num_vec, 2 ~ 20, 4 ~ 40, .default = num_vec)
# `case_match()` doesn't have the ability to match by position like
# `recode()` does with numeric vectors
recode(num_vec, "a", "b", "c", "d")
recode(c(1,5,3), "a", "b", "c", "d", .default = "nothing")
# For `case_match()`, incompatible types are an error rather than a warning
recode(num_vec, `2` = "b", `4` = "d")
try(case_match(num_vec, 2 ~ "b", 4 ~ "d", .default = num_vec))
# The factor method of `recode()` can generally be replaced with
# `forcats::fct_recode()`
factor_vec <- factor(c("a", "b", "c"))
recode(factor_vec, a = "Apple")
# `recode_factor()` does not currently have a direct replacement, but we
# plan to add one to forcats. In the meantime, you can use the `.ptype`
# argument to `case_match()`.
recode_factor(
num_vec,
`1` = "z",
`2` = "y",
`3` = "x",
.default = "D",
.missing = "M"
)
case_match(
num_vec,
1 ~ "z",
2 ~ "y",
3 ~ "x",
NA ~ "M",
.default = "D",
.ptype = factor(levels = c("z", "y", "x", "D", "M"))
)
}
\seealso{
\code{\link[=na_if]{na_if()}} to replace specified values with a \code{NA}.
\code{\link[=coalesce]{coalesce()}} to replace missing values with a specified value.
\code{\link[tidyr:replace_na]{tidyr::replace_na()}} to replace \code{NA} with a value.
}
dplyr/man/transmute.Rd 0000644 0001762 0000144 00000003777 14406402754 014514 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/transmute.R
\name{transmute}
\alias{transmute}
\title{Create, modify, and delete columns}
\usage{
transmute(.data, ...)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Name-value pairs.
The name gives the name of the column in the output.
The value can be:
\itemize{
\item A vector of length 1, which will be recycled to the correct length.
\item A vector the same length as the current group (or the whole data frame
if ungrouped).
\item \code{NULL}, to remove the column.
\item A data frame or tibble, to create multiple columns in the output.
}}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Columns created or modified through \code{...} will be returned in the order
specified by \code{...}.
\item Unmodified grouping columns will be placed at the front.
\item The number of rows is not affected.
\item Columns given the value \code{NULL} will be removed.
\item Groups will be recomputed if a grouping variable is mutated.
\item Data frame attributes are preserved.
}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{transmute()} creates a new data frame containing only the specified
computations. It's superseded because you can perform the same job
with \code{mutate(.keep = "none")}.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("transmute")}.
}
\keyword{internal}
dplyr/man/mutate-joins.Rd 0000644 0001762 0000144 00000033477 14406402754 015111 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join.R
\name{mutate-joins}
\alias{mutate-joins}
\alias{join}
\alias{join.data.frame}
\alias{inner_join}
\alias{inner_join.data.frame}
\alias{left_join}
\alias{left_join.data.frame}
\alias{right_join}
\alias{right_join.data.frame}
\alias{full_join}
\alias{full_join.data.frame}
\title{Mutating joins}
\usage{
inner_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL
)
\method{inner_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL,
na_matches = c("na", "never"),
multiple = "all",
unmatched = "drop",
relationship = NULL
)
left_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL
)
\method{left_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL,
na_matches = c("na", "never"),
multiple = "all",
unmatched = "drop",
relationship = NULL
)
right_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL
)
\method{right_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL,
na_matches = c("na", "never"),
multiple = "all",
unmatched = "drop",
relationship = NULL
)
full_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL
)
\method{full_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = NULL,
na_matches = c("na", "never"),
multiple = "all",
relationship = NULL
)
}
\arguments{
\item{x, y}{A pair of data frames, data frame extensions (e.g. a tibble), or
lazy data frames (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{by}{A join specification created with \code{\link[=join_by]{join_by()}}, or a character
vector of variables to join by.
If \code{NULL}, the default, \verb{*_join()} will perform a natural join, using all
variables in common across \code{x} and \code{y}. A message lists the variables so
that you can check they're correct; suppress the message by supplying \code{by}
explicitly.
To join on different variables between \code{x} and \code{y}, use a \code{\link[=join_by]{join_by()}}
specification. For example, \code{join_by(a == b)} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a \code{\link[=join_by]{join_by()}} specification with
multiple expressions. For example, \code{join_by(a == b, c == d)} will match
\code{x$a} to \code{y$b} and \code{x$c} to \code{y$d}. If the column names are the same between
\code{x} and \code{y}, you can shorten this by listing only the variable names, like
\code{join_by(a, c)}.
\code{\link[=join_by]{join_by()}} can also be used to perform inequality, rolling, and overlap
joins. See the documentation at \link[=join_by]{?join_by} for details on
these types of joins.
For simple equality joins, you can alternatively specify a character vector
of variable names to join by. For example, \code{by = c("a", "b")} joins \code{x$a}
to \code{y$a} and \code{x$b} to \code{y$b}. If variable names differ between \code{x} and \code{y},
use a named character vector like \code{by = c("x_a" = "y_a", "x_b" = "y_b")}.
To perform a cross-join, generating all combinations of \code{x} and \code{y}, see
\code{\link[=cross_join]{cross_join()}}.}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{suffix}{If there are non-joined duplicate variables in \code{x} and
\code{y}, these suffixes will be added to the output to disambiguate them.
Should be a character vector of length 2.}
\item{...}{Other parameters passed onto methods.}
\item{keep}{Should the join keys from both \code{x} and \code{y} be preserved in the
output?
\itemize{
\item If \code{NULL}, the default, joins on equality retain only the keys from \code{x},
while joins on inequality retain the keys from both inputs.
\item If \code{TRUE}, all keys from both inputs are retained.
\item If \code{FALSE}, only keys from \code{x} are retained. For right and full joins,
the data in key columns corresponding to rows that only exist in \code{y} are
merged into the key columns from \code{x}. Can't be used when joining on
inequality conditions.
}}
\item{na_matches}{Should two \code{NA} or two \code{NaN} values match?
\itemize{
\item \code{"na"}, the default, treats two \code{NA} or two \code{NaN} values as equal, like
\code{\%in\%}, \code{\link[=match]{match()}}, and \code{\link[=merge]{merge()}}.
\item \code{"never"} treats two \code{NA} or two \code{NaN} values as different, and will
never match them together or to any other values. This is similar to joins
for database sources and to \code{base::merge(incomparables = NA)}.
}}
\item{multiple}{Handling of rows in \code{x} with multiple matches in \code{y}.
For each row of \code{x}:
\itemize{
\item \code{"all"}, the default, returns every match detected in \code{y}. This is the
same behavior as SQL.
\item \code{"any"} returns one match detected in \code{y}, with no guarantees on which
match will be returned. It is often faster than \code{"first"} and \code{"last"}
if you just need to detect if there is at least one match.
\item \code{"first"} returns the first match detected in \code{y}.
\item \code{"last"} returns the last match detected in \code{y}.
}}
\item{unmatched}{How should unmatched keys that would result in dropped rows
be handled?
\itemize{
\item \code{"drop"} drops unmatched keys from the result.
\item \code{"error"} throws an error if unmatched keys are detected.
}
\code{unmatched} is intended to protect you from accidentally dropping rows
during a join. It only checks for unmatched keys in the input that could
potentially drop rows.
\itemize{
\item For left joins, it checks \code{y}.
\item For right joins, it checks \code{x}.
\item For inner joins, it checks both \code{x} and \code{y}. In this case, \code{unmatched} is
also allowed to be a character vector of length 2 to specify the behavior
for \code{x} and \code{y} independently.
}}
\item{relationship}{Handling of the expected relationship between the keys of
\code{x} and \code{y}. If the expectations chosen from the list below are
invalidated, an error is thrown.
\itemize{
\item \code{NULL}, the default, doesn't expect there to be any relationship between
\code{x} and \code{y}. However, for equality joins it will check for a many-to-many
relationship (which is typically unexpected) and will warn if one occurs,
encouraging you to either take a closer look at your inputs or make this
relationship explicit by specifying \code{"many-to-many"}.
See the \emph{Many-to-many relationships} section for more details.
\item \code{"one-to-one"} expects:
\itemize{
\item Each row in \code{x} matches at most 1 row in \code{y}.
\item Each row in \code{y} matches at most 1 row in \code{x}.
}
\item \code{"one-to-many"} expects:
\itemize{
\item Each row in \code{y} matches at most 1 row in \code{x}.
}
\item \code{"many-to-one"} expects:
\itemize{
\item Each row in \code{x} matches at most 1 row in \code{y}.
}
\item \code{"many-to-many"} doesn't perform any relationship checks, but is provided
to allow you to be explicit about this relationship if you know it
exists.
}
\code{relationship} doesn't handle cases where there are zero matches. For that,
see \code{unmatched}.}
}
\value{
An object of the same type as \code{x} (including the same groups). The order of
the rows and columns of \code{x} is preserved as much as possible. The output has
the following properties:
\itemize{
\item The rows are affect by the join type.
\itemize{
\item \code{inner_join()} returns matched \code{x} rows.
\item \code{left_join()} returns all \code{x} rows.
\item \code{right_join()} returns matched of \code{x} rows, followed by unmatched \code{y} rows.
\item \code{full_join()} returns all \code{x} rows, followed by unmatched \code{y} rows.
}
\item Output columns include all columns from \code{x} and all non-key columns from
\code{y}. If \code{keep = TRUE}, the key columns from \code{y} are included as well.
\item If non-key columns in \code{x} and \code{y} have the same name, \code{suffix}es are added
to disambiguate. If \code{keep = TRUE} and key columns in \code{x} and \code{y} have
the same name, \code{suffix}es are added to disambiguate these as well.
\item If \code{keep = FALSE}, output columns included in \code{by} are coerced to their
common type between \code{x} and \code{y}.
}
}
\description{
Mutating joins add columns from \code{y} to \code{x}, matching observations based on
the keys. There are four mutating joins: the inner join, and the three outer
joins.
\subsection{Inner join}{
An \code{inner_join()} only keeps observations from \code{x} that have a matching key
in \code{y}.
The most important property of an inner join is that unmatched rows in either
input are not included in the result. This means that generally inner joins
are not appropriate in most analyses, because it is too easy to lose
observations.
}
\subsection{Outer joins}{
The three outer joins keep observations that appear in at least one of the
data frames:
\itemize{
\item A \code{left_join()} keeps all observations in \code{x}.
\item A \code{right_join()} keeps all observations in \code{y}.
\item A \code{full_join()} keeps all observations in \code{x} and \code{y}.
}
}
}
\section{Many-to-many relationships}{
By default, dplyr guards against many-to-many relationships in equality joins
by throwing a warning. These occur when both of the following are true:
\itemize{
\item A row in \code{x} matches multiple rows in \code{y}.
\item A row in \code{y} matches multiple rows in \code{x}.
}
This is typically surprising, as most joins involve a relationship of
one-to-one, one-to-many, or many-to-one, and is often the result of an
improperly specified join. Many-to-many relationships are particularly
problematic because they can result in a Cartesian explosion of the number of
rows returned from the join.
If a many-to-many relationship is expected, silence this warning by
explicitly setting \code{relationship = "many-to-many"}.
In production code, it is best to preemptively set \code{relationship} to whatever
relationship you expect to exist between the keys of \code{x} and \code{y}, as this
forces an error to occur immediately if the data doesn't align with your
expectations.
Inequality joins typically result in many-to-many relationships by nature, so
they don't warn on them by default, but you should still take extra care when
specifying an inequality join, because they also have the capability to
return a large number of rows.
Rolling joins don't warn on many-to-many relationships either, but many
rolling joins follow a many-to-one relationship, so it is often useful to
set \code{relationship = "many-to-one"} to enforce this.
Note that in SQL, most database providers won't let you specify a
many-to-many relationship between two tables, instead requiring that you
create a third \emph{junction table} that results in two one-to-many relationships
instead.
}
\section{Methods}{
These functions are \strong{generic}s, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{inner_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("inner_join")}.
\item \code{left_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("left_join")}.
\item \code{right_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("right_join")}.
\item \code{full_join()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("full_join")}.
}
}
\examples{
band_members \%>\% inner_join(band_instruments)
band_members \%>\% left_join(band_instruments)
band_members \%>\% right_join(band_instruments)
band_members \%>\% full_join(band_instruments)
# To suppress the message about joining variables, supply `by`
band_members \%>\% inner_join(band_instruments, by = join_by(name))
# This is good practice in production code
# Use an equality expression if the join variables have different names
band_members \%>\% full_join(band_instruments2, by = join_by(name == artist))
# By default, the join keys from `x` and `y` are coalesced in the output; use
# `keep = TRUE` to keep the join keys from both `x` and `y`
band_members \%>\%
full_join(band_instruments2, by = join_by(name == artist), keep = TRUE)
# If a row in `x` matches multiple rows in `y`, all the rows in `y` will be
# returned once for each matching row in `x`.
df1 <- tibble(x = 1:3)
df2 <- tibble(x = c(1, 1, 2), y = c("first", "second", "third"))
df1 \%>\% left_join(df2)
# If a row in `y` also matches multiple rows in `x`, this is known as a
# many-to-many relationship, which is typically a result of an improperly
# specified join or some kind of messy data. In this case, a warning is
# thrown by default:
df3 <- tibble(x = c(1, 1, 1, 3))
df3 \%>\% left_join(df2)
# In the rare case where a many-to-many relationship is expected, set
# `relationship = "many-to-many"` to silence this warning
df3 \%>\% left_join(df2, relationship = "many-to-many")
# Use `join_by()` with a condition other than `==` to perform an inequality
# join. Here we match on every instance where `df1$x > df2$x`.
df1 \%>\% left_join(df2, join_by(x > x))
# By default, NAs match other NAs so that there are two
# rows in the output of this join:
df1 <- data.frame(x = c(1, NA), y = 2)
df2 <- data.frame(x = c(1, NA), z = 3)
left_join(df1, df2)
# You can optionally request that NAs don't match, giving a
# a result that more closely resembles SQL joins
left_join(df1, df2, na_matches = "never")
}
\seealso{
Other joins:
\code{\link{cross_join}()},
\code{\link{filter-joins}},
\code{\link{nest_join}()}
}
\concept{joins}
dplyr/man/src_tbls.Rd 0000644 0001762 0000144 00000000766 14366556340 014306 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/src.R
\name{src_tbls}
\alias{src_tbls}
\title{List all tbls provided by a source.}
\usage{
src_tbls(x, ...)
}
\arguments{
\item{x}{a data src.}
\item{...}{other arguments passed on to the individual methods.}
}
\description{
This is a generic method which individual src's will provide methods for.
Most methods will not be documented because it's usually pretty obvious what
possible results will be.
}
\keyword{internal}
dplyr/man/filter_all.Rd 0000644 0001762 0000144 00000006321 14366556340 014601 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-filter.R
\name{filter_all}
\alias{filter_all}
\alias{filter_if}
\alias{filter_at}
\title{Filter within a selection of variables}
\usage{
filter_all(.tbl, .vars_predicate, .preserve = FALSE)
filter_if(.tbl, .predicate, .vars_predicate, .preserve = FALSE)
filter_at(.tbl, .vars, .vars_predicate, .preserve = FALSE)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.vars_predicate}{A quoted predicate expression as returned by
\code{\link[=all_vars]{all_vars()}} or \code{\link[=any_vars]{any_vars()}}.
Can also be a function or purrr-like formula. In this case, the
intersection of the results is taken by default and there's
currently no way to request the union.}
\item{.preserve}{when \code{FALSE} (the default), the grouping structure
is recalculated based on the resulting data, otherwise it is kept as is.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=if_all]{if_all()}} or \code{\link[=if_any]{if_any()}} in an existing verb. See \code{vignette("colwise")} for
details.
These \link{scoped} filtering verbs apply a predicate expression to a
selection of variables. The predicate expression should be quoted
with \code{\link[=all_vars]{all_vars()}} or \code{\link[=any_vars]{any_vars()}} and should mention the pronoun
\code{.} to refer to variables.
}
\section{Grouping variables}{
The grouping variables that are part of the selection are taken
into account to determine filtered rows.
}
\examples{
# While filter() accepts expressions with specific variables, the
# scoped filter verbs take an expression with the pronoun `.` and
# replicate it over all variables. This expression should be quoted
# with all_vars() or any_vars():
all_vars(is.na(.))
any_vars(is.na(.))
# You can take the intersection of the replicated expressions:
filter_all(mtcars, all_vars(. > 150))
# ->
filter(mtcars, if_all(everything(), ~ .x > 150))
# Or the union:
filter_all(mtcars, any_vars(. > 150))
# ->
filter(mtcars, if_any(everything(), ~ . > 150))
# You can vary the selection of columns on which to apply the
# predicate. filter_at() takes a vars() specification:
filter_at(mtcars, vars(starts_with("d")), any_vars((. \%\% 2) == 0))
# ->
filter(mtcars, if_any(starts_with("d"), ~ (.x \%\% 2) == 0))
# And filter_if() selects variables with a predicate function:
filter_if(mtcars, ~ all(floor(.) == .), all_vars(. != 0))
# ->
is_int <- function(x) all(floor(x) == x)
filter(mtcars, if_all(where(is_int), ~ .x != 0))
}
\keyword{internal}
dplyr/man/dplyr_tidy_select.Rd 0000644 0001762 0000144 00000005741 14472225345 016207 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-params.R
\name{dplyr_tidy_select}
\alias{dplyr_tidy_select}
\title{Argument type: tidy-select}
\description{
This page describes the \verb{} argument modifier which indicates
the argument supports \strong{tidy selections}. Tidy selection provides a concise
dialect of R for selecting variables based on their names or properties.
Tidy selection is a variant of tidy evaluation. This means that inside
functions, tidy-select arguments require special attention, as described in
the \emph{Indirection} section below. If you've never heard of tidy evaluation
before, start with \code{vignette("programming")}.
}
\section{Overview of selection features}{
Tidyverse selections implement a dialect of R where operators make
it easy to select variables:
\itemize{
\item \code{:} for selecting a range of consecutive variables.
\item \code{!} for taking the complement of a set of variables.
\item \code{&} and \code{|} for selecting the intersection or the union of two
sets of variables.
\item \code{c()} for combining selections.
}
In addition, you can use \strong{selection helpers}. Some helpers select specific
columns:
\itemize{
\item \code{\link[tidyselect:everything]{everything()}}: Matches all variables.
\item \code{\link[tidyselect:everything]{last_col()}}: Select last variable, possibly with an offset.
\item \code{\link[=group_cols]{group_cols()}}: Select all grouping columns.
}
Other helpers select variables by matching patterns in their names:
\itemize{
\item \code{\link[tidyselect:starts_with]{starts_with()}}: Starts with a prefix.
\item \code{\link[tidyselect:starts_with]{ends_with()}}: Ends with a suffix.
\item \code{\link[tidyselect:starts_with]{contains()}}: Contains a literal string.
\item \code{\link[tidyselect:starts_with]{matches()}}: Matches a regular expression.
\item \code{\link[tidyselect:starts_with]{num_range()}}: Matches a numerical range like x01, x02, x03.
}
Or from variables stored in a character vector:
\itemize{
\item \code{\link[tidyselect:all_of]{all_of()}}: Matches variable names in a character vector. All
names must be present, otherwise an out-of-bounds error is
thrown.
\item \code{\link[tidyselect:all_of]{any_of()}}: Same as \code{all_of()}, except that no error is thrown
for names that don't exist.
}
Or using a predicate function:
\itemize{
\item \code{\link[tidyselect:where]{where()}}: Applies a function to all variables and selects those
for which the function returns \code{TRUE}.
}
}
\section{Indirection}{
There are two main cases:
\itemize{
\item If you have a character vector of column names, use \code{all_of()}
or \code{any_of()}, depending on whether or not you want unknown variable
names to cause an error, e.g. \code{select(df, all_of(vars))},
\code{select(df, !any_of(vars))}.
\item If you want the user to be able to supply a tidyselect specification in
a function argument, embrace the function argument, e.g.
\code{select(df, {{ vars }})}.
}
}
\keyword{internal}
dplyr/man/select_all.Rd 0000644 0001762 0000144 00000005742 14266276767 014614 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-select.R
\name{select_all}
\alias{select_all}
\alias{rename_all}
\alias{select_if}
\alias{rename_if}
\alias{select_at}
\alias{rename_at}
\title{Select and rename a selection of variables}
\usage{
select_all(.tbl, .funs = list(), ...)
rename_all(.tbl, .funs = list(), ...)
select_if(.tbl, .predicate, .funs = list(), ...)
rename_if(.tbl, .predicate, .funs = list(), ...)
select_at(.tbl, .vars, .funs = list(), ...)
rename_at(.tbl, .vars, .funs = list(), ...)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a purrr style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{rename_if()}, \code{rename_at()}, and \code{rename_all()} have been superseded by
\code{rename_with()}. The matching select statements have been superseded by the
combination of a \code{select()} + \code{rename_with()}. Any predicate functions passed
as arguments to \code{select()} or \code{rename_with()} must be wrapped in \code{\link[=where]{where()}}.
These functions were superseded because \code{mutate_if()} and friends were
superseded by \code{across()}. \code{select_if()} and \code{rename_if()} already use tidy
selection so they can't be replaced by \code{across()} and instead we need a new
function.
}
\examples{
mtcars <- as_tibble(mtcars) # for nicer printing
mtcars \%>\% rename_all(toupper)
# ->
mtcars \%>\% rename_with(toupper)
# NB: the transformation comes first in rename_with
is_whole <- function(x) all(floor(x) == x)
mtcars \%>\% rename_if(is_whole, toupper)
# ->
mtcars \%>\% rename_with(toupper, where(is_whole))
mtcars \%>\% rename_at(vars(mpg:hp), toupper)
# ->
mtcars \%>\% rename_with(toupper, mpg:hp)
# You now must select() and then rename
mtcars \%>\% select_all(toupper)
# ->
mtcars \%>\% rename_with(toupper)
# Selection drops unselected variables:
mtcars \%>\% select_if(is_whole, toupper)
# ->
mtcars \%>\% select(where(is_whole)) \%>\% rename_with(toupper)
mtcars \%>\% select_at(vars(-contains("ar"), starts_with("c")), toupper)
# ->
mtcars \%>\%
select(!contains("ar") | starts_with("c")) \%>\%
rename_with(toupper)
}
\keyword{internal}
dplyr/man/funs.Rd 0000644 0001762 0000144 00000003241 14406402754 013427 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-funs.R
\name{funs}
\alias{funs}
\title{Create a list of function calls}
\usage{
funs(..., .args = list())
}
\arguments{
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> A list of functions
specified by:
\itemize{
\item Their name, \code{"mean"}
\item The function itself, \code{mean}
\item A call to the function with \code{.} as a dummy argument,
\code{mean(., na.rm = TRUE)}
}
The following notations are \strong{not} supported, see examples:
\itemize{
\item An anonymous function, \code{function(x) mean(x, na.rm = TRUE)}
\item An anonymous function in \pkg{purrr} notation, \code{~mean(., na.rm = TRUE)}
}}
\item{.args, args}{A named list of additional arguments to be added to all
function calls. As \code{funs()} is being deprecated, use other methods to
supply arguments: \code{...} argument in \link[=summarise_at]{scoped verbs} or make
own functions with \code{\link[purrr:partial]{purrr::partial()}}.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
\code{funs()} is deprecated; please use \code{list()} instead. We deprecated this
function because it provided a unique way of specifying anonymous functions,
rather than adopting the conventions used by purrr and other packages
in the tidyverse.
}
\examples{
funs("mean", mean(., na.rm = TRUE))
# ->
list(mean = mean, mean = ~ mean(.x, na.rm = TRUE))
funs(m1 = mean, m2 = "mean", m3 = mean(., na.rm = TRUE))
# ->
list(m1 = mean, m2 = "mean", m3 = ~ mean(.x, na.rm = TRUE))
}
\keyword{internal}
dplyr/man/n_distinct.Rd 0000644 0001762 0000144 00000002056 14366556340 014623 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/n-distinct.R
\name{n_distinct}
\alias{n_distinct}
\title{Count unique combinations}
\usage{
n_distinct(..., na.rm = FALSE)
}
\arguments{
\item{...}{Unnamed vectors. If multiple vectors are supplied, then they should
have the same length.}
\item{na.rm}{If \code{TRUE}, exclude missing observations from the count.
If there are multiple vectors in \code{...}, an observation will
be excluded if \emph{any} of the values are missing.}
}
\value{
A single number.
}
\description{
\code{n_distinct()} counts the number of unique/distinct combinations in a set
of one or more vectors. It's a faster and more concise equivalent to
\code{nrow(unique(data.frame(...)))}.
}
\examples{
x <- c(1, 1, 2, 2, 2)
n_distinct(x)
y <- c(3, 3, NA, 3, 3)
n_distinct(y)
n_distinct(y, na.rm = TRUE)
# Pairs (1, 3), (2, 3), and (2, NA) are distinct
n_distinct(x, y)
# (2, NA) is dropped, leaving 2 distinct combinations
n_distinct(x, y, na.rm = TRUE)
# Also works with data frames
n_distinct(data.frame(x, y))
}
dplyr/man/explain.Rd 0000644 0001762 0000144 00000003113 14366556340 014120 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/explain.R
\name{explain}
\alias{explain}
\alias{show_query}
\title{Explain details of a tbl}
\usage{
explain(x, ...)
show_query(x, ...)
}
\arguments{
\item{x}{An object to explain}
\item{...}{Other parameters possibly used by generic}
}
\value{
The first argument, invisibly.
}
\description{
This is a generic function which gives more details about an object than
\code{\link[=print]{print()}}, and is more focused on human readable output than
\code{\link[=str]{str()}}.
}
\section{Databases}{
Explaining a \code{tbl_sql} will run the SQL \code{EXPLAIN} command which
will describe the query plan. This requires a little bit of knowledge about
how \code{EXPLAIN} works for your database, but is very useful for
diagnosing performance problems.
}
\examples{
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE) && requireNamespace("RSQLite", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
\donttest{
lahman_s <- dbplyr::lahman_sqlite()
batting <- tbl(lahman_s, "Batting")
batting \%>\% show_query()
batting \%>\% explain()
# The batting database has indices on all ID variables:
# SQLite automatically picks the most restrictive index
batting \%>\% filter(lgID == "NL" & yearID == 2000L) \%>\% explain()
# OR's will use multiple indexes
batting \%>\% filter(lgID == "NL" | yearID == 2000) \%>\% explain()
# Joins will use indexes in both tables
teams <- tbl(lahman_s, "Teams")
batting \%>\% left_join(teams, c("yearID", "teamID")) \%>\% explain()
}
\dontshow{\}) # examplesIf}
}
dplyr/man/src_dbi.Rd 0000644 0001762 0000144 00000004726 14321267312 014065 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-dbi.R
\name{src_dbi}
\alias{src_dbi}
\alias{src_mysql}
\alias{src_postgres}
\alias{src_sqlite}
\title{Source for database backends}
\usage{
src_mysql(
dbname,
host = NULL,
port = 0L,
username = "root",
password = "",
...
)
src_postgres(
dbname = NULL,
host = NULL,
port = NULL,
user = NULL,
password = NULL,
...
)
src_sqlite(path, create = FALSE)
}
\arguments{
\item{dbname}{Database name}
\item{host, port}{Host name and port number of database}
\item{...}{for the src, other arguments passed on to the underlying
database connector, \code{\link[DBI:dbConnect]{DBI::dbConnect()}}. For the tbl, included for
compatibility with the generic, but otherwise ignored.}
\item{user, username, password}{User name and password.
Generally, you should avoid saving username and password in your
scripts as it is easy to accidentally expose valuable credentials.
Instead, retrieve them from environment variables, or use database
specific credential scores. For example, with MySQL you can set up \code{my.cnf}
as described in \code{\link[RMySQL:MySQLDriver-class]{RMySQL::MySQL()}}.}
\item{path}{Path to SQLite database. You can use the special path
":memory:" to create a temporary in memory database.}
\item{create}{if \code{FALSE}, \code{path} must already exist. If
\code{TRUE}, will create a new SQLite3 database at \code{path} if
\code{path} does not exist and connect to the existing database if
\code{path} does exist.}
}
\value{
An S3 object with class \code{src_dbi}, \code{src_sql}, \code{src}.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
These functions have been deprecated; instead please use \code{\link[=tbl]{tbl()}}
directly on an \code{DBIConnection}. See \url{https://dbplyr.tidyverse.org/} for
more details.
}
\examples{
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE) && requireNamespace("RSQLite", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
con <- DBI::dbConnect(RSQLite::SQLite(), ":memory:")
copy_to(con, mtcars)
# To retrieve a single table from a source, use `tbl()`
mtcars <- con \%>\% tbl("mtcars")
mtcars
# You can also use pass raw SQL if you want a more sophisticated query
con \%>\% tbl(sql("SELECT * FROM mtcars WHERE cyl == 8"))
\dontshow{\}) # examplesIf}
}
\keyword{internal}
dplyr/man/src_local.Rd 0000644 0001762 0000144 00000001375 14366556340 014431 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-src-local.R
\name{src_local}
\alias{src_local}
\alias{src_df}
\title{A local source}
\usage{
src_local(tbl, pkg = NULL, env = NULL)
src_df(pkg = NULL, env = NULL)
}
\arguments{
\item{tbl}{name of the function used to generate \code{tbl} objects}
\item{pkg, env}{Either the name of a package or an environment object in
which to look for objects.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
This function was deprecated since it existed to support a style of testing
dplyr backends that turned out not to be useful.
}
\keyword{internal}
dplyr/man/setops.Rd 0000644 0001762 0000144 00000004161 14366556340 014001 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/sets.R
\name{setops}
\alias{setops}
\alias{intersect}
\alias{union}
\alias{union_all}
\alias{setdiff}
\alias{setequal}
\alias{symdiff}
\title{Set operations}
\usage{
intersect(x, y, ...)
union(x, y, ...)
union_all(x, y, ...)
setdiff(x, y, ...)
setequal(x, y, ...)
symdiff(x, y, ...)
}
\arguments{
\item{x, y}{Pair of compatible data frames. A pair of data frames is
compatible if they have the same column names (possibly in different
orders) and compatible types.}
\item{...}{These dots are for future extensions and must be empty.}
}
\description{
Perform set operations using the rows of a data frame.
\itemize{
\item \code{intersect(x, y)} finds all rows in both \code{x} and \code{y}.
\item \code{union(x, y)} finds all rows in either \code{x} or \code{y}, excluding duplicates.
\item \code{union_all(x, y)} finds all rows in either \code{x} or \code{y}, including duplicates.
\item \code{setdiff(x, y)} finds all rows in \code{x} that aren't in \code{y}.
\item \code{symdiff(x, y)} computes the symmetric difference, i.e. all rows in
\code{x} that aren't in \code{y} and all rows in \code{y} that aren't in \code{x}.
\item \code{setequal(x, y)} returns \code{TRUE} if \code{x} and \code{y} contain the same rows
(ignoring order).
}
Note that \code{intersect()}, \code{union()}, \code{setdiff()}, and \code{symdiff()} remove
duplicates in \code{x} and \code{y}.
}
\section{Base functions}{
\code{intersect()}, \code{union()}, \code{setdiff()}, and \code{setequal()} override the base
functions of the same name in order to make them generic. The existing
behaviour for vectors is preserved by providing default methods that call
the base functions.
}
\examples{
df1 <- tibble(x = 1:3)
df2 <- tibble(x = 3:5)
intersect(df1, df2)
union(df1, df2)
union_all(df1, df2)
setdiff(df1, df2)
setdiff(df2, df1)
symdiff(df1, df2)
setequal(df1, df2)
setequal(df1, df1[3:1, ])
# Note that the following functions remove pre-existing duplicates:
df1 <- tibble(x = c(1:3, 3, 3))
df2 <- tibble(x = c(3:5, 5))
intersect(df1, df2)
union(df1, df2)
setdiff(df1, df2)
symdiff(df1, df2)
}
dplyr/man/with_order.Rd 0000644 0001762 0000144 00000000735 13663216626 014634 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/order-by.R
\name{with_order}
\alias{with_order}
\title{Run a function with one order, translating result back to original order}
\usage{
with_order(order_by, fun, x, ...)
}
\arguments{
\item{order_by}{vector to order by}
\item{fun}{window function}
\item{x, ...}{arguments to \code{f}}
}
\description{
This is used to power the ordering parameters of dplyr's window functions
}
\keyword{internal}
dplyr/man/near.Rd 0000644 0001762 0000144 00000001015 13663216626 013403 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/near.R
\name{near}
\alias{near}
\title{Compare two numeric vectors}
\usage{
near(x, y, tol = .Machine$double.eps^0.5)
}
\arguments{
\item{x, y}{Numeric vectors to compare}
\item{tol}{Tolerance of comparison.}
}
\description{
This is a safe way of comparing if two vectors of floating point numbers
are (pairwise) equal. This is safer than using \code{==}, because it has
a built in tolerance
}
\examples{
sqrt(2) ^ 2 == 2
near(sqrt(2) ^ 2, 2)
}
dplyr/man/group_by_prepare.Rd 0000644 0001762 0000144 00000001531 14366556340 016026 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/distinct.R, R/group-by.R
\name{distinct_prepare}
\alias{distinct_prepare}
\alias{group_by_prepare}
\title{Same basic philosophy as group_by_prepare(): lazy_dots comes in, list of data and
vars (character vector) comes out.}
\usage{
distinct_prepare(
.data,
vars,
group_vars = character(),
.keep_all = FALSE,
caller_env = caller_env(2),
error_call = caller_env()
)
group_by_prepare(
.data,
...,
.add = FALSE,
.dots = deprecated(),
add = deprecated(),
error_call = caller_env()
)
}
\value{
A list
\item{data}{Modified tbl}
\item{groups}{Modified groups}
}
\description{
\verb{*_prepare()} performs standard manipulation that is needed prior
to actual data processing. They are only be needed by packages
that implement dplyr backends.
}
\keyword{internal}
dplyr/man/figures/ 0000755 0001762 0000144 00000000000 14406402754 013631 5 ustar ligges users dplyr/man/figures/lifecycle-defunct.svg 0000644 0001762 0000144 00000001704 13663216626 017746 0 ustar ligges users dplyr/man/figures/lifecycle-maturing.svg 0000644 0001762 0000144 00000001706 13663216626 020146 0 ustar ligges users dplyr/man/figures/logo.png 0000644 0001762 0000144 00000123705 14406402754 015307 0 ustar ligges users PNG
IHDR ޫh gAMA a cHRM z& u0 ` : pQ< bKGD tIME6
IDATxwx$uU hsI,fRT"mAeAao^|k[Aʖ-˶2E
")a89FTu?fHb tWUo#&oy衇
V?wy@<#WTID\&/6t?Е(F^_
.6\_ǁ,5ߠbuϫIx3{
* "sy?u>N.98 :::vgi/5 o7|8{r2dttadUCWW^u ,䭕k B
Ͻpz};55 pxSί>Z[[+s3cik B-"!W+daafffu}SUQ'
M_855 o Q=vblll6t:줷߿8emq7A>A;X=vs9N366xKgg'nR5 7CRDϽ24?;4Mcff-P(D?ͨKHx ?~kMk i}4QOJI8 f``i4M))B?uuua1h_^ru/SF[=v͕H$,?7N_T$nkjjV Q-N˓k )w#2 ŮR6$~>:::p\_ -~k˖k ހނ z}q,W\xijj,3|?hk ^"ch]4
?nT `ΝSOU55p8hmmmsk
5 W Em@Q=6[\. I:ӟ4Z?o h/ymQ \RD{3@cכ7(r98}4[uEaǎ | !t:I$J;"
Wn]?~(4p)A5@զ%mmm}x嗪r9>Od6<466{n*}[#Iהk .4H
UDF ^o ۸;hll\R(
vmQ +|)x .^ mI 项Ө MRLLL0::J*~Z[[q8 ƈ?<5ڢ%4 >lE) (>|SOpĉMsMxt]gjjO Fۡ(G \Z ߯ROQu?Lss3`D/G\. d߾}|K_"0;;K,###|3Ao!P(;::dE"LAfffC[#D p.
4?W܍D:Nkk+.kCl[[y{ؿ?\'|H$XoMKK .}tIFGGI$>f< LNNx['g z0 ~x4?!eɤU444_9x BTU!4l۶
] B155){r蠳k=fgg Joaa]}oF[ߴ .A(Fr)
3::! B
xffD"aU5[199iEkjjhjj:UU jkkQ]YZZbxx꽺4Mcbby驄Xq}߆ oRJx}a4# ~n6ettӧO355uY@(
>|Zb1^}U|> >((.]^׳sed2 .\`iiiR`}> ړU| FFHZ%h~*όV733C2(9+DY:;;RDMM
XYnooˑhkk6!f2^]hSNYqEQ1?~Cho
;)Lk\}_ZZbppɪ?aY`v9zh iLNNr!QWWG,# hMVhiivot:iooϝgxx+aR277G8 >Zx piLf%h~?ޫH$ )%~0@n _}!TjY@ (Bcc#===YKKK\5r x< jjjp:4bQމf @~ s-1s'''Xs刮VNVJImm-Pp8yߏT*ECCê &Jz@֫j}=XlI0&1L2>>~U2k{zzYLD@oj?f|#p .݈d}kLsg劢viiia``%r Mkk+.\({E"eֶYkD4Etƙ3g<7Kgg'x,O>dUljv+F"UN"JGSS$If xS(m.۳ccceYaf+p8eāQrA/ z衫xUx+h~b555(6"yٳ)%G #,Ky< \xhmmepp:i{糧{Y⢍eQߕe型;Y2큶RM= ]]][̦T*e+-$wU [U }I(ͯX}c9)Ce;NxW&Nxp8 YfCQv߿FqREբmYcmS9? -,,=̇<^w#wch㯐-^- .AFMKԄ]Av-h2o0{yW'Zڥ
EQVQnNnӆfMd2x< h匿ˢ.6Ks9?8`ڊ JP( A!(YC=tUL[b .2Rկ>;opp f飚r VCgϞIM,cnned2,?n)f~inw>FT_^cm>dV3S㌏.M9N[=LڢYY!m],-f{O5i~,BPSSCss3+^=
7܀Ge>Z-]C255{2eZ^k SUU(G 婧bjj]vdp\8Nك 4?{TJY`e+OTVv[d{p|hU4qC[>A[4-N]) o)h~4Xcu||WMMM-Qږ -ooi $ ;(hԺ % ?\n}>IFGGQVYE0m%a38ǭ\Ckś bm%mqS\gN+Kof% 3??OkkUxH&kˊi<:ujYTN:s@Vcc㲇 = ~;⋼+ ݶm;hRXƱ_R鳖+(͵g2+8WMnֶ6`dN0mqKh"6R\mSrN2}T3L&$N[9 q =ZR̢ۙh4MMM+ 7yvQŚsNvif$J_*%iZ=Vg5Ý˸sss7y$1::j+H4is vǫWJ
f4sssb1sx' ' 377gfv V
%I0XLtΝڵv73ܹsW~8SjZ3Pwww q \[KR?)5d'Ճ1|ShUp1V+777ǥK\Nv;\=uHlll\=l.cbb#69goݻɺ1 xO۲*%h~ eYaf~&' +tɑHǏ311]*hSXueϜW5fYt}quYeպuǎ l=%''-3{
7X7=L&y7yj8v$###% Jjjj,n7gYSUz%L[Q-#Fj
x+h~% s= 9r_ L ;^444 {V9 AjEX)TUU+_
Xgs̙+b:oWg-~j%[-BBu}TUE4"DJ- 5MOOo)pp\^@Jouthhh`vvYP1NK-+wk-4a$"Jq=t:ygz˕jao6K&F}WZLêr5aW>p^{͚&Q__VYCſdŊ \d.wRu{q
!Ƀ>}ݷ^Opv]w݅rٳgYZZ" SWW>p뭷
V-OOOSOsϭkVJBSOY]&lͯ=N6[y(%;Cʬ2r'''%%)cV
W--fj55m*bzz>t]</OH DA<)%/ٳ͢uuu|h_dEhll\v}ƘHd2\m )L[h:^i~[F!8x .2ogggO|3e
{fՏ=l'O'ҥK+n7"ϼuE+峚 \LV0.w
Ehj
} 0l_5pXMLЧ?iJLm߾J~+k ҥK<8qbXnVTWM淕bI9N[doaڢ4?s]躾 TBULp}vv! c /֚wweEQWzmˠ-"F59mqm+h~asVL`ppjnn5544zXL]paY !<+|R~ԛgJ6J )7¼>|žekƌ? F[tbǫxyŢ*w{r9{ymѫMF-!uPDQN<
eĤ-mπ z!́4a%J!ft.`.^ >lU zz W4RbOTB3r>kf6*&'۪Pd[45Ĥ-3W {bdd"^D`L4
qsmY\{=5@ X={n5R3_-ETp5N0]d2TUEUJAe[788xU!#v6P ;vpѱ"dsgffcMOO[3TUeϞ=>}ટW) h+E+jjR[[Kww)WK=Nb/Ir躾iݫ.jޜw5!+D?s?G[[۲f XaZR)jkk oi~o6]JUz٣Wr*Ii3-گW)) `!xǯd=5r@2ŋ<Ze+$/|w B!FGGygVvYhhhF+%MLLYl4+!v\Ij5E b9qWt3-&!?L5 /~ <ȩSͲfrUp?PLU2Jv38 b*ñ~(\nݕDQX,Ƴ>{Eοj4R7 5^.G~n%bll~?e墲WJI/7:2 `][qH lɍ)|sqnR*rؽ{wp z5VROZ.f|l12~AWCg-- DVCYff ! J\)kOtlʐD%J+)I]J===e
ŝ&LcorDWDJ \&FFc1 m&AQ9qϣХ$N75uzY-D.X.D.ˬ#!7֥\1'f3( n?tBg L]b5Y<
+JpJW\[!H$#q~ᣧ)D(B*uu w8ۿ@FJ"d.L$If,J(t <0#$It$߆vӋk <[e(7=Vkvd5-P&GW2MO,Ic4NHwQP eg,oSBШ:hR \^YǜKE5pYvJi
#E ]7k-As.8w&F7JR+vR"iF$2O :HI]V/bg,Ig2?JDA6Mr :&cXuTc)9)-M A
"1*)y9_" ;GKb-\)/H[X@:Yjب盋}C{zMJ"]jMpq7w#˾goYbr>ntS \ӓH H@vS+%JIo^EK7) n l`>>w<R,WCZ5AyS >Pz#
ïznf[Q P)d.йh#bd.vQ`^$t>;<A&'yynm
Q߅3k v.O D[) `Yoh w(5`-zŻAGg56N^晧RqV OE Sܲ/Zi"_1]|*# $I~v*x!L ri~|AQ
ahߡ /G*k?KGL.4? UZ)QPd-oR Hi6n }aob,sYM,,D -naMFjZr*w$pQ]}_߫>&&8 %ժIx t_f& b*Ϣ]p)Fd'wr'@E 6_ 3e_[֧ Sy|tvKk;}[RpkԤ$StoV`zz뭫h~Ĵ]O grNa \>|<ȃRVx[h+|Y]ͧ2T w-?eeX p,`H}O^% 5BJTa.Bqs7
.R"v 0u0zѕiNziGAaIT\w
5Rbj[xqƁ5|*
鎾x΄L\JTMJ^I'8*hE~a7Z(< tiW3oMڵi9*9TS=V:n$Dև 5xC f7 (U #p/ln;/)_"*S̊\0YmK=@e.fbt'SK hҹ/(8 v8Xf2钯Hzvh~%vho"At{'6Rd5Hő&}={ CoCp en\d|WJ oυފpƼ><Ȯ-n j JY ]rB"u}ӴUL%u9I2hW
RK_-G?C%XJjv.5ɴA/uWg_57siWtS V $:Iעy\H셭h4xg@8O STVFa͐Dt'KIA<9+JR
]:-ߵt@V"w/( t LV|{|\F+|=>|Ym4`ú@Q3: wE*.@w-ƹ1>U5k3G- ZnUBp)D* ^J5q"bx"Wx
=
@ӐtlOh_{wm'@ԮbڵcTO*~gͯ
Ý0 -AԥD7cZxmI㘢h_<(Ld @U %u<F>|d̟zNH@8pq+.EkK M!H˦]ZH7ɕԮ2s,f_Sѻ^%r oO hg'y=ǁK(sQd@G0 %zϡ+`41ޥ@ G |%<,'"d*}7>cg"4+pC˞To]I5
]ˉBNNÿ=<}Azȓu }Kɖx4JVp /4W*M8{HMt0{LXnVeS\F _-u m=_!Qѹ^$벑i|6S~5[4q^e^IESP5@TT]EՌ|s 9`aͯТ:6 E3Zܬ&~[&ڼݹg&3Q7]CoGO,Z@릇YjJџK'p~>H$ah ZwހY%?^BU75>#(>C|ު(6ՠA+ mq' \Iy\Bge cӜq?־HKg3ev,dF,8xW;iϸ ^sLI Bp'c(Z Xx ^gٶvL'$5}Cms%m|佈/S! ;/)
+_: /"?5
λxuK=}RE^
r4X,fKhc-M vs;>-$#St~p4kU*B)aMui{gs3( 8 _-]LJɟ<[U~'q~
aant~p/}gu<[.7*yƓ?ArmPX
2[DeS.զࠛ} m 526M /24NNE\Yq9Kw/stll&K
>z;kk6zHc]E.PucdN7絳qiWH
(fj#&ulY,lUf
#
x// fCqs,3%U
ܴ˥4<6&o,5Xߗo^y
)PkƖ:>4#dQ}pG݂;Z
!GL6rr*yfjK*mpmEj":Vo,"TGy ߡﯫ Vd4QL31mD\xanni^e yH-兓p(nClSH &9WmX$ϫ/V7աuYq#~CU֑OVtz=z$BURkd27^t3h~tQnZI\> dUnR5
sg1R)NU4"_Qp
=Fe%hGǃd3 23 $tRk\?KfMm:az,H ߚ$|L7iHF/Ã *ĨZB>teo퐑~ڞEǕ&}( RYEGFFp/Zܽrh~*j.Fu'_fumthu/ʒS-@@= )nD7ax5ɟ䪥| nJ Do @{O cc5"@MW/]}e\[[˾}iq(t,zC+p 5 ,5mmm*T7[
#>; }uL.|r)ul;6f{3R-?|] puo/£]_Fؔa݁;'ދpR.kWWqxJUr#.GvttDXͯ tЌ Pb\`7Y|H:dq^5 3~c4*-f$JUҼ ~kͨ*K]A5Ff*"C{
y>x}0: !iG|S/
GԼƋڭP(Tr] &/N{nNp $hy 9|
d"^hp=ЪdoI~%ɿT5ژ8ȴ ^+催
-Hpj })$&P3Vx=O;~_EGkD].
z($> 3Y<ꋸgH4x~}vig%=IY: sҥ5i~M>*vv+ ZjXH #B}E% Z0㧵+\*IQUᥬ~ 9bL2텬{\-¡/ E!En)y;1
5w
|"XKyA!/+ Ƌ](eKb}4X&vv(ju%Nbߤ.e^FNJ6*4Ԩhgp2w=÷QTb s*, "^ "[kuQ8<'v!>v*1s
$
qv
M ZE mmm%{W%e\J ;h]b6Q@,UZy V隀hC6^.SJ-Eih^"zjuOKue# 25\z]dkfrwl\
d܃hp
k M^XzGJM^AW!70LcếwjϏ@QhB-]mmK_T6n{IXuɕv" q H]
{\i: 5njJ{AG~sSvL籉r9iokۨu6οcJX6ZDҍAK`מ DWarw=7![M^ HxQdɅ,0uuu< G3xpq^"D(sYxʙϦUU =xjMN'$>'3`niXz/Vz6nNY;RaE0/i q R֢ȯG&܈KȾiD}vp97_xqo 6@uek5H\v͗hx˚WֻXs>avtth>&+Sԕ H 藧~TID Z_2nStWdN1ӓ:ͬlgbE߇0oȡY s=c&B'&+kAs.=Q`ji~
@=d8i'bȼ&P$|ȯ?ؽC 7-PpFWi φ|ټTbUDu<= lf"rC(BǥSn^Gmf<&ZҺ=x6?7jfH1*ISu g@
Zkh!q7zu0{ͤ{Lrr 0@ba8Di h.?y5#wN )?b&'vY
Z|9
˚Wjra\Whz(%4qpc4U&
%M .e+( ]<ͷ]lE
%.h@0EguMq!W@:'9: dR ~ [ZQAh m
Ӵ?pk'9 dB^V %X2A Aw 9pw]7!N6!@osvVKa{
d[Lc5)sssfaGG䤎Y+I2ZEH ܪ/
^
vaO`G-@ip2lkj]S#B["n-'n8-|qblڷ ~ ߊ q0QwHv@X{+]@' o z˞ t؇ucCԚ<6$f5z8]_{
`Ӝ### d'9n 1fBf&$YU'Ԉ;sD9 S0GDdE2y;N4:D0qIhs0$ \d7-hں$ 5$
l#a#qW$A~KWya 3i"h2~ejR1.O m;\nuF|v,z)z1^byEqk H[dDbcLlv0+5H1MQ3h 5ăuH;5bZѩ FGHe61 &׳q>tZu Zh\'ӓ
c禍ԳӒLX >@h\ v߭ !ڷ- . 歆kuXv+L% zm- ,ʖVQmHt= X,A6;M.M `{4S2 1,3 @ԝ%Hkg; 1#H4 ̘jK!QK* J?7d!#0/J24x-E4(Qg~h9!]XBH2f3I@#P8o!@j
"F*-ɗ/Zּ^Բ|ִfXvd:;R -\1 Y~y- ɂL0 'जs'(BAu"333+*\vg4*ׇyt<ǫ'Ԃd(ƛyw" ?6 z Rؿ>U[Fxd}aԋT"-fQ^c~KC ,ٛ\=-$ )tDQ\Jw2?,ȉ
-*AS$aOsYIXv1¤X~ך= \ F{pU*ۜnTgUX;VdD:W 3܋ AWpfW.)pY_ÜrdBKhǙ]A+`\N݀Ċ'}?ʹsд[`9 Iĝc> /$/rrvXv/SSSCww \&c=+<5(? *3I
d#ڠNDny'q7P,<|b k,m 9 ocJo^8~qH#Y&ͯQufDhi݅~שF =Mۙpjmpn .Y (p:'{.s2G_|Bv;j,ñ0se0? wBqmx濊|` VЁA;)ʅ5y8}&O Gq~kA-Uu
̷p?i֗EfXUB2S\S3&If㋌ 0;3^O\Jv;־%#Vd"P{x#øz uk_ Z D4t0}#joP
ljG{POi3R7+ "RǗF_
,bz) 8rxu_4S }1k#02Bu(yEz f9{Z5۲%M946E81h0AN(RD .
!hll5LMMڃkwԆp
a:* xtq'EZ5AvD,VP<
R b))uIXS[7'_8GOdxpn^1F58K`v/h~cc-Im>R"tO
)Mՙν:} GVARp847#kalllYSH 6s
"\ qr L[ v lURu 7[\.m UWb,}5y$* x0dLh]
,c 2"ã9];:u[.5\q)I/#fO5DQNT@X,f->!PB`?߳Qc5]B=|uj_cǦMRnvpr<VͿ̓hi6u_sp~n l'W2+V9XafQӣlaƤ͉ FIt#LODHi'f t
)u9D9AOOn"r-EUUNmmXH#H|>ÁJ/b*ɓ |N p a%Q9 EL߷1dHG*E냴="
/5*
DQ 2;}C :p5
Gᕣ0=cVlͯ~P+\s)߃N-"JE+j^# *Ql:B*t#"St
5V4EL8 d C* %ӧSG~nqE`' TN@0Ma E1a 9o,\YE{ bOQgPҙb7 -q=5,WJT tsMQ689QJ5+Qs8̝lG/[iU "SL,!kFHxc|5#$7@K? ү c : ma`Men'b
FQ@09Aƭ?λgngQcfypD#4?:xV73 Svx< ZJ8sL`jjj,kX
͔H?RJk(V
S~h#Wtu*n 7
M1,@LG\ӕ3ƢӨpx YjqXz9 'D\SI&v ,l
hw( rHIUCcU(h\<- &Zyj {oA֭\]1x( \@kmmEQM\p5M#XVd ુW6l 16Wwkw
re;o_w"y-) YJo>6]X8#-7Lh/N ㈛*f?+= ZĘ}אKByʰ!x۟-չ$ڏaý24 Jm
HMV>kf|֧_{/. 0ܲ4?(4 _3 ȿl9o&_qX(e
WӪf*044c%_[^۷[ph~ 4Jk(MMpt0WzSï")m_ b_t/;~&dѤez&YHAj $@VPDsUgbcQ+Hl)+ڧ/~LJ 71KӯqS5'
4r~n"gOA&8qDn=Qk[2߶K)ihfZJnXH,t*pr<йQs~^ƭ/o6_<UOPI)Km=)<23
QH
"4~LCn G-@(#Ϳ%1G@ Fq:P@4 <0+i&[X$ٻ
/V tKc/؛%===8uM \ ,ǝ_s!N3::zҺF`d2|$Od B4pONI"$'T51Ȁgq뫛;Mqb1O'i\b)rScLOT9PD o>9 8d$GI
s]
X+bv2A R2&p5McvzI
4?E?ei?w) 'c^;M,O \F&/%e<22ŋzlD^)W qdYZ011A,Ջo ܮ/G噷{rm5 6J$
p85bZY 1(Bdd Rufg6 j/n$ 0XDoKf)- y<:su˧ M3i~w6b ˩$?^Y4|>b1N8al]%RU({e|54?UUѤ䥋nFg'- } :?dy3a*Wygm]=&)qHz-p"E))c8DUl?y#jKmԉ"ղ 2rh00C)QVSg
,T |5 c#֓h~
5`.ix+Ƀ_MdžHWRV* !D " dOl߹:Ss
^s~|0gBT>n
şK@+8K*hP_"+Q͛Z,r{b5 0 r#(UN
(v%~%%Kؿ<͎݇ P"VzX ic/Å
+i~AxC]qӓ/Y) Y,5*~\[7JIqLdW+^hqD"M/~m4|6O6 9"*giR^Q} Af As\qrKNElssusخM6hG \@:j0s;ĿQMcS'X7h~ ]k?F#p-%K}}=9sP# v)/!^znYzbrEThI:_dA6eWzy! 4}z?_"U)
~'#L+NjmctAr`Z%s(Bn g+OUf` yځ^7= !!/&;Gwg'mq+'7 aVDZ`f:usDOkk+DӧOhj7KEW[O?25.͝ A .xyLa5dY7i% Z+Vs; w!z /|atRS>ͷ Bh -4("_1dkKVY؊Lj^q+d^j"N
PtMMM)/b e<'cwW. }5r֣(8\.BZp*,W |fnj,PS6p' \]WUWk_G .~}U"u&|TiSA} 0wz mk vÚQȭ*GUTt:#Tbhh!|WܖV$#3;.Hoo/555[j79xݸ\.@Er
7Ԗpx~o?qe s$M>=ԅ.meved\淮J/nD C{AQ}~җٝ7^!%g;| D ߥ^9Slt6a])Bne9P__m4>]Ф̝-\9GYw}&߂#F!E"OS@-9g{P~xy4KA^ L[Ji~kJ} ;`1n _BbjJd.^jsG+'qeUm +[]ji 4=9+AnTaDyaJh ]{֦e3p" ;jTS>/NW>؆s rhT~]6m곱W
YstMGϒ}{(fMK]zgXvmg/e(t/296 VxNhh~Yof6u!.ɑiw0A^cT(~DoO71Vt?o
^VCwDhxC_K#2U)cyhdQ H uM+TTNbS:TM f?̌~P5b3i"CP9K=zc r7i~Ĵ6[qTv.ޛm,^BnsfC(x
O6Zl%U}mFwqnn܊IDFmK/C⁹P~ٵ.V <3˱64~)>#]ˠk?>YM(9= IލꦃT^9N;pXp 29{VN0BoY^щ㥭>A8ٛ$DfꂯO0qV}m/лf-2
C+Pgh/t!R du4E
& ]q4ff6-ݦM/h 4T4nz8]G)p(Iҩ }1[> w 7Ә7MN6i # KAFWHԬR=Pb}{IWײk9eE8g=lB\zϾύ|"z F ^o^ۧH55iRҾD϶Y%lL&D禷J $..dl*v|&9J\NgrjIB%h~eZgh+M3\ڬo?n f_עOĻൡ_y׆Bs*B| (&,
7t'7]Et>t9GGGf 1s+W^CzYvΡ4ͺk/W
)!Bde ٟ!شh \]Yt G 4?r*__wdͦfsK mKanl Lxh7?B4?ի2L受Ն C$7/#Ȑ'Uw-Ƀw4ͬ /\m]Pc\N#ΒeO nN ,˖7#!ѥ܇o5ΧDA ۜL*x>+gP :Pg ecb2I5@cڗ*y(q :]I4d^+q A
e͕o" ! ԠLӮ>F_*3d9&'&h~4?֠M~4JofH)
o͎!PΗe
k|- Hv9
oZ-x=Nv-e,^J?d_2Xϵ^*$͎,Ĺ AGM\Hy됲 ݻ
z j_GƟaWܨm,k\I$_3XJBfc,)>q#dŨI8QwYf:iLjU,WMQv>:˅ &bqiZV2)EOG}w &sg<|X~~n~{ǮU5vyrÙAZ빘⡇ ZaJ)fE[K#|h >[nkmK #8_7΄i6˂TIR Ъjxh=Vv 䤟ُ3櫶W|r z[N3<=OXM*4#?uwPޟ垽Vtz\inE ߝ£?qH8ęd
=4C7g5˴UU-+XV\.g E@]8z]
w.6DGl5+p!#ƙ
@ #hUIg&n
p)Q{ *BCy͙s,;^I4:<1p}Z'L54
fxM]}?4>tL=u9x|gA{f <]Q7L5V e_݇xp/M5)DKo$ɠK*ݳ#rP7lnxr?`u#29CdO3Z܁/g6n8o٬1w
_gg'mx]j/s=ț0wL6g& 2$+pSM AH q<[UB^}Qv_x\ 5 HvD4 1Z*T>|Z`p.Lt}ou2#"5A0,-mph~4\4?zyA?0Y
{k |mEn,UtB ]Y^Kr
}N>"ҿ(poƵ6-O L85yri~o9Ռ; 7w
wI~ 0<
xvg_i`'ik0lYmh} J,
8'sȭpj-̦uÞ ? y^m t1{/nx dw%F^=
+i~]
b0mT{}0v
Ot>X)oddl13=хew{<;f ~n 9 CS^VP$1r MYWE4?s^j4.Z[۩ܴ}<̞0YQLaNDF)U[/܄l4wirfIvy{4kpLnK5o ߆- !T0cHC6R}789^
3307m5&3\}EPe7A| j/bA+%%/kEŗ5`Fц|`9jtU@ Rq yk3,L2z~ki~uA3QÛpo`0x@p[ d0FT_#/HW٤R_wwM-45gs;P`k
ֺ@]9R=jM[mctnx5)x*3Lg?`\ ?;9Qmg֘ҷI3N¡1j"LFy}^ߪk|rb4 2! Eh0pΨ ^xR4?B@lE0vӑ/RG{)#-._['un>{o N` 1G ]/ܔ\osI$mjbFHW|#q|de÷\QzP<|#G.s#'"LCoHp 8 (cFܺi~fӾV;DJs >DXKk$Rhx ]pD`lb4Zx6G5BD*kiʆqZE$sMdgѥle4nA?u;gqk`g ה<9aLC8
tw-p?Z((^ !Y9\3]'W&XU\9??og Ү&c#\h7/΅SjaSm|8uLh/_@19_n[e WT3z&]!zRja3ȥ=G /W_ )ɃGq YpÙ ,8m֍鳎f<|K_.;`2x97kCfH;Ì;
#7z
bқ%$UyFiD
mO
%45 ִJp/䂯(۔ϱ0}u.GLo#4RU0CLj1{ޑ @I=
'NkM[X4Jk ps3 EoPTAkf[5 M\|uUi~]]4:{Q:S y!Uкᜃ#u<
ӓ7*_DeD{,, I :y/QfNi~k{Gj<-K*1iW |m p:ͨ!T )\ >W?7+j2{܉u ȚYda[uT{m*(i70eHjl90s ^ytbim흄Nna-_AN`1߀[)Iּ@pv6Cnb7Q-:ZLGs=Zۂ
ԩw;ʦj<-75n _`]DŽ'ĸ'Ęiw G
5I diH 9?9=yLv\$V^Uò:[NDߍ.-l Y{ 80\X4n?48"Vy * aVtUG'G"%8, ^3=C=iwhz6탸E Hnp~/69x{pW_)a:4Z4V;㴙bRT `ityۀ < t46w1٬\qΧL'D{\5OOO5v8h3_Y?~%",|s] ؈x< V<6,IN軙b^l*lf,6K!';, +
7B{$
ӂ*З34Mh~ ]n4 0:,;}R7!<λM^@kD^VF3n+Xe4Mhj66t7ؽx ٟe^2^\| 9mCT]\ &IDAT.gttm70NDENX![\4r/ao gD= J-3"75] EC㶌*82r|Ǧ&P_ޮ%SF܊9 - 3kCNb㻮5FýsIaD'kx8\0oɷm5VA41$jbIs,w4j,]T:Fs2{̏\ͬb0i-i~>+YdIͬv+aR) iKXy:a{ȑ?g0 0 .#{W;4yVg;.P輤≛5FhҠM~^GDoK so`0d=98
sI]Na 3[Ye!x:|1\ڶV\ 5kz2Dil]iqOKoWvO7yDXAf[:kc5א
JKj4I 1yF^r]m1pdf9` 7,ϜH$*h
s7`c,jF2}Nvq+#ÑI^y}NƉ 4v( ~:=8tC=_* &:` a .4:Js+tɸ{H܅r4?g{ťU%etDe?s-=,j-£ȩpR,VP&h5YC\v b^6f@|s2E D~ LZ2 v
o0kCHAJä@і2h > >%g/J>Ｎ9ͯƐ[vޛݱ"L V
_ .7JJc݆6FͶOA|^8p,SxO۵B R4R6~[\\5"Ϥ *qgN 5M0VO{4m\v]ϼ~+YxQNnz9I haEhi~-^nmZ\ߒJ밂3-4Y$PUܵSz@v5uGxMq ngU=K s J6\`\ѡ}@uA KFk]X3fmvZKo!kd)7ͯZ =FJ2@LeQ 1 z%@[8|$ 0bW #ۻͯ Zkci WWR>yQ&7EZ5 g ةslf "sl{Asaqf6cM;r:1?׃hߋ&ؐ/0lNy(TLӺ֩^-d܆ >t#?+` KH
yڡj`SlBt`xfvH;p2S m)ufZonr -8{, l5ZVLMXˢ~ RZb3OB|;lO4e5Q}P2X ,kRwc+7/OJDl9borVO8T5rIJLʹ}2R?ε0sI4exxxo#/WZWUUTU @[u߄~4
l9T 4"- ,jY oYDZ@ E~n1RC"{y4eeΔmX낊/47+Gkwߡ0_ < Z P 9ť lQMy7%U2*R沢Tܥ n܇!esҥ
7"_n)!+=$dK^DҲM:
`S͔e@ԧ`".:;Y4355em]~nN0)=R75ineh;\ 7js\AB]... $ ǝB<e@˗/3::UUtvtPp
Aۯ0mׂL
1kB"ƾ
G@_fF]SSS /<~Fe9H$00 hqC5-
]u
np9-72n~F pʸuy /zwlR+}L' G3 .DFb Uss' 5SbdpTImg ˥%iyA!Fw-`j7i!a\zq MNvh3{+#wj(t鏚B>Ico,Z:jJɂtm J~ "` ~8SKh\cbb _J|c~sHp9
@LJJ#W nJwz BvhAL1I_,6e_1eX[@r
W###n<
h ?QTV*J| /`Ɯ\Yf)iSRJK< hfg(vfv5Pʀ@?D*gB!悁nԂqM!^ !2?PJEQZ`~/98w +o`:B o 39_@ȟ0ۓ=M)KC #p|sF߽mН=0dA{ 4ŎYjkܞd1 Au[ 3^CAКTdO[s +`8e}rz8עrrG4ģ qLP,cap1sbf W܁^~%C?
\KHF&8_ LXƚݒ}qڸ۔Y\ , 3,Kf,~+LlT:܇>pM빺6L G$luW}ݾZ)'71 J78 k~nfX7\(.)Mxl7ر SQP+m|eZV*Ihm:kn 6QprLt:G*淦wjB*2+91O)Zׁ{
5"Z={E156 P} 9 E1T,|}4̅]\oIf26nm5?0N!yS91el;D(DUC!7/#_ fH [_eBlt Mþ&LJpdTp ers $9|{>ې(XaFDyfqT s{L<\8 oDdE^/SS&ws#cMDUmT?{ǖ N#X#Hh6@I "u2s23l2MDU;%fLG] *t%MOz ϡF8"7i0
yF%g ̧q
ט6 vt"$҄~2.}0q]=%c[b>drC/]0Kfj~D"Y<آ!k|<5 b0v(T"NBpLU '埐O711] ["CPWA97մ.*4(D_^G:9;T*iIlTM]Z=m@c #Q ?I'(c#0WX-,_! H:l ; ;XCD-a20hzÉc7 _8 N?fƭ >MimE8?1ոNݰҴ8e}~tzo1x5O[ J<{G)`9Β+i` ,a\U0pYBB oA\4"T@&"t Oy8Tȕ7
P5;QLsK?8#63s`~Һ"`/q]`ou !~9| kq wE4>-Q>MPe슘6wWX-oƕЄ4 &{냠w]z6"x7twulLV
u70,-~ aH#.5u 9J=
ߐ1.+75% 3MR+|\g1q QhNhK<5Z>%^ Xg~)шþ)ு!C̯P6bϱ0BQ4WFGф,Yann.Y&{O TN1×!A$n,+P-V *[ip~xmܥj
{f_I]Yt
ޙ
8
h`~_N7q
m(م-Ml1+76F0 Ͷ4wo\槫V$6(F|Tƭ&*2}k.n
ng/ Ld7t6`JMpl?~m 15B\Qn߫_ 6q
mHâ[.9ð9N:Lܠ!_c\* $]ɿ?cOÑY~;)xsDԔꦥ*F3bGko_c5 ˧1?ؘ
l`C)F[V:W!w `+Ah sG ؖXWpU9lE66FqR
S5}AdHjn
3|j{څn [xŹ1k Ԯf6tof$_~YLM=n7yaP#GY [5Sҿ-DCa_m\רo% sFc6\qƹj
|4d7Pw*6*=8 {]2nF6-ނ-._ĚM.hEgyR>ȹWP)1!C=]HU(W7eglKF|W{1747N0B0l>dZآn{ZGGWN#ekb̦h2S &ݼtçCƤ<dS%Aެcuy.&#%{ia~Ue`X4n?^99=mCԖe?3 Z*=
z14>qnj#5PLs4x_͟a8T}צss01$v5BJ1 $ׯ#ZRƤ r 4]̡X3@&f4шm j.l&J* 2n &蝮O?X1ΝBNN}'pUk`C) iEko\bӸq쭝 ZXp $*j^Z8w5 >;, *{i-
wd3+z[1TĹuuh ;lI0/@qЄB]^>sMjy({vsjkJ̯߸*RխbGR>{:}mW sK&]vM(9T ;6H߳&1ab~yac{<`~Cb~'o%0z([V[4RiEU ֘kFBQ>3@12U60W(m'n `bҟe UUQUuA>25!
YdVCnz|''5oӘ_8V6/
⧐1"iiddi^E<'Q5.rw XΓ'vrj&o1o 0Aƺ+NQ
x[|?V[B (
d|x`KNW;97]{ ca~Ri- B B,aLlUa>m-45|NX- {)1Bher#ݙoNm_ByptN`8\=*1oj̯P*8-->29?\ V;}e_tDБ@W}M<6"֯ssH/J0Bh,d1 [| iE8H$
ٜa+Q:BSy$r'yk w;Vm<`~/cb~*^4sYǦq+\ n2ۆ;nޙo-g"J̯P*xZ[|9ޚ+Qqol}[GW iVlO/F9ƹȡ\Ř_T4pJ1^$ײآUcxJ4Ž\[Ҹ`D
uj;+̛')qhT4p-މ-V::R1Il:# 7"k6xl7s%Z&!1W(
g` @&ܘɹ&h-ؾ\0){U%́^"=xZ12T2yb_bRBQŋڵ ds9@nS
ᄋ -H,CJNQEvUpdc^ g#k塃R^C-->%ĵb{< rSYd{9#i6~2ķu2*js gxc~RP
Nd||7fVevy{5dyEW¥|B'?hzȜC@}O )S5Ⱥǟ#lQP[m#sf%eYU [纸,s 0#hBh+eX݅-nI>Q. wR
m- D9. bb~^`ѼU%#0+kx{XB:8-Lz 0{"*x- N3>v'G8(b~BEo 1]n[ ߄qhWH)Fށ̭9`r]5qT4T
x+rX^V-^A_mX
e1r9&x,E [&q7JV7#&Cl1 # _? *xh lѨ11M7x`)?DV9(b~TEoR` Db7dxq$}ߦVX)67OiNEn^
|(ćH/U4U$KNSe({5 ֎X: %tEXtdate:create 2023-03-06T19:54:22+00:00r
%tEXtdate:modify 2023-03-06T19:54:22+00:00m tEXtSoftware Adobe ImageReadyqe< IENDB` dplyr/man/figures/lifecycle-archived.svg 0000644 0001762 0000144 00000001707 13663216626 020106 0 ustar ligges users dplyr/man/figures/lifecycle-soft-deprecated.svg 0000644 0001762 0000144 00000001726 13663216626 021373 0 ustar ligges users dplyr/man/figures/lifecycle-questioning.svg 0000644 0001762 0000144 00000001714 13663216626 020664 0 ustar ligges users dplyr/man/figures/lifecycle-superseded.svg 0000644 0001762 0000144 00000001713 13663216626 020461 0 ustar ligges users dplyr/man/figures/lifecycle-stable.svg 0000644 0001762 0000144 00000001674 13663216626 017576 0 ustar ligges users dplyr/man/figures/lifecycle-experimental.svg 0000644 0001762 0000144 00000001716 13663216626 021016 0 ustar ligges users dplyr/man/figures/lifecycle-deprecated.svg 0000644 0001762 0000144 00000001712 13663216626 020415 0 ustar ligges users dplyr/man/figures/lifecycle-retired.svg 0000644 0001762 0000144 00000001705 13663216626 017755 0 ustar ligges users dplyr/man/consecutive_id.Rd 0000644 0001762 0000144 00000001631 14366556340 015466 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/consecutive-id.R
\name{consecutive_id}
\alias{consecutive_id}
\title{Generate a unique identifier for consecutive combinations}
\usage{
consecutive_id(...)
}
\arguments{
\item{...}{Unnamed vectors. If multiple vectors are supplied, then they should
have the same length.}
}
\value{
A numeric vector the same length as the longest
element of \code{...}.
}
\description{
\code{consecutive_id()} generates a unique identifier that increments every time
a variable (or combination of variables) changes. Inspired by
\code{data.table::rleid()}.
}
\examples{
consecutive_id(c(TRUE, TRUE, FALSE, FALSE, TRUE, FALSE, NA, NA))
consecutive_id(c(1, 1, 1, 2, 1, 1, 2, 2))
df <- data.frame(x = c(0, 0, 1, 0), y = c(2, 2, 2, 2))
df \%>\% group_by(x, y) \%>\% summarise(n = n())
df \%>\% group_by(id = consecutive_id(x, y), x, y) \%>\% summarise(n = n())
}
dplyr/man/reexports.Rd 0000644 0001762 0000144 00000003163 14366556340 014520 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/reexport-magrittr.R, R/reexport-pillar.R,
% R/reexport-tibble.R, R/select-helpers.R
\docType{import}
\name{reexports}
\alias{reexports}
\alias{\%>\%}
\alias{type_sum}
\alias{data_frame}
\alias{as_data_frame}
\alias{lst}
\alias{add_row}
\alias{tribble}
\alias{tibble}
\alias{as_tibble}
\alias{view}
\alias{contains}
\alias{select_helpers}
\alias{ends_with}
\alias{everything}
\alias{matches}
\alias{num_range}
\alias{one_of}
\alias{starts_with}
\alias{last_col}
\alias{any_of}
\alias{all_of}
\alias{where}
\title{Objects exported from other packages}
\keyword{internal}
\description{
These objects are imported from other packages. Follow the links
below to see their documentation.
\describe{
\item{magrittr}{\code{\link[magrittr:pipe]{\%>\%}}}
\item{pillar}{\code{\link[pillar]{type_sum}}}
\item{tibble}{\code{\link[tibble]{add_row}}, \code{\link[tibble:deprecated]{as_data_frame}}, \code{\link[tibble]{as_tibble}}, \code{\link[tibble:deprecated]{data_frame}}, \code{\link[tibble]{lst}}, \code{\link[tibble]{tibble}}, \code{\link[tibble]{tribble}}, \code{\link[tibble]{view}}}
\item{tidyselect}{\code{\link[tidyselect]{all_of}}, \code{\link[tidyselect:all_of]{any_of}}, \code{\link[tidyselect:starts_with]{contains}}, \code{\link[tidyselect:starts_with]{ends_with}}, \code{\link[tidyselect]{everything}}, \code{\link[tidyselect:everything]{last_col}}, \code{\link[tidyselect:starts_with]{matches}}, \code{\link[tidyselect:starts_with]{num_range}}, \code{\link[tidyselect]{one_of}}, \code{\link[tidyselect]{starts_with}}, \code{\link[tidyselect]{where}}}
}}
dplyr/man/make_tbl.Rd 0000644 0001762 0000144 00000001134 14472225345 014233 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/tbl.R
\name{make_tbl}
\alias{make_tbl}
\title{Create a "tbl" object}
\usage{
make_tbl(subclass, ...)
}
\arguments{
\item{subclass}{name of subclass. "tbl" is an abstract base class, so you
must supply this value. \code{tbl_} is automatically prepended to the
class name}
\item{...}{For \code{tbl()}, other fields used by class. For \code{as.tbl()},
other arguments passed to methods.}
}
\description{
\code{tbl()} is the standard constructor for tbls. \code{as.tbl()} coerces,
and \code{is.tbl()} tests.
}
\keyword{internal}
dplyr/man/group_by.Rd 0000644 0001762 0000144 00000012621 14366556340 014312 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-by.R
\name{group_by}
\alias{group_by}
\alias{ungroup}
\title{Group by one or more variables}
\usage{
group_by(.data, ..., .add = FALSE, .drop = group_by_drop_default(.data))
ungroup(x, ...)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{In \code{group_by()}, variables or computations to group by.
Computations are always done on the ungrouped data frame.
To perform computations on the grouped data, you need to use
a separate \code{mutate()} step before the \code{group_by()}.
Computations are not allowed in \code{nest_by()}.
In \code{ungroup()}, variables to remove from the grouping.}
\item{.add}{When \code{FALSE}, the default, \code{group_by()} will
override existing groups. To add to the existing groups, use
\code{.add = TRUE}.
This argument was previously called \code{add}, but that prevented
creating a new grouping variable called \code{add}, and conflicts with
our naming conventions.}
\item{.drop}{Drop groups formed by factor levels that don't appear in the
data? The default is \code{TRUE} except when \code{.data} has been previously
grouped with \code{.drop = FALSE}. See \code{\link[=group_by_drop_default]{group_by_drop_default()}} for details.}
\item{x}{A \code{\link[=tbl]{tbl()}}}
}
\value{
A grouped data frame with class \code{\link{grouped_df}},
unless the combination of \code{...} and \code{add} yields a empty set of
grouping columns, in which case a tibble will be returned.
}
\description{
Most data operations are done on groups defined by variables.
\code{group_by()} takes an existing tbl and converts it into a grouped tbl
where operations are performed "by group". \code{ungroup()} removes grouping.
}
\section{Methods}{
These function are \strong{generic}s, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{group_by()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("group_by")}.
\item \code{ungroup()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("ungroup")}.
}
}
\section{Ordering}{
Currently, \code{group_by()} internally orders the groups in ascending order. This
results in ordered output from functions that aggregate groups, such as
\code{\link[=summarise]{summarise()}}.
When used as grouping columns, character vectors are ordered in the C locale
for performance and reproducibility across R sessions. If the resulting
ordering of your grouped operation matters and is dependent on the locale,
you should follow up the grouped operation with an explicit call to
\code{\link[=arrange]{arrange()}} and set the \code{.locale} argument. For example:
\if{html}{\out{}}\preformatted{data \%>\%
group_by(chr) \%>\%
summarise(avg = mean(x)) \%>\%
arrange(chr, .locale = "en")
}\if{html}{\out{
}}
This is often useful as a preliminary step before generating content intended
for humans, such as an HTML table.
\subsection{Legacy behavior}{
Prior to dplyr 1.1.0, character vector grouping columns were ordered in the
system locale. If you need to temporarily revert to this behavior, you can
set the global option \code{dplyr.legacy_locale} to \code{TRUE}, but this should be
used sparingly and you should expect this option to be removed in a future
version of dplyr. It is better to update existing code to explicitly call
\code{arrange(.locale = )} instead. Note that setting \code{dplyr.legacy_locale} will
also force calls to \code{\link[=arrange]{arrange()}} to use the system locale.
}
}
\examples{
by_cyl <- mtcars \%>\% group_by(cyl)
# grouping doesn't change how the data looks (apart from listing
# how it's grouped):
by_cyl
# It changes how it acts with the other dplyr verbs:
by_cyl \%>\% summarise(
disp = mean(disp),
hp = mean(hp)
)
by_cyl \%>\% filter(disp == max(disp))
# Each call to summarise() removes a layer of grouping
by_vs_am <- mtcars \%>\% group_by(vs, am)
by_vs <- by_vs_am \%>\% summarise(n = n())
by_vs
by_vs \%>\% summarise(n = sum(n))
# To removing grouping, use ungroup
by_vs \%>\%
ungroup() \%>\%
summarise(n = sum(n))
# By default, group_by() overrides existing grouping
by_cyl \%>\%
group_by(vs, am) \%>\%
group_vars()
# Use add = TRUE to instead append
by_cyl \%>\%
group_by(vs, am, .add = TRUE) \%>\%
group_vars()
# You can group by expressions: this is a short-hand
# for a mutate() followed by a group_by()
mtcars \%>\%
group_by(vsam = vs + am)
# The implicit mutate() step is always performed on the
# ungrouped data. Here we get 3 groups:
mtcars \%>\%
group_by(vs) \%>\%
group_by(hp_cut = cut(hp, 3))
# If you want it to be performed by groups,
# you have to use an explicit mutate() call.
# Here we get 3 groups per value of vs
mtcars \%>\%
group_by(vs) \%>\%
mutate(hp_cut = cut(hp, 3)) \%>\%
group_by(hp_cut)
# when factors are involved and .drop = FALSE, groups can be empty
tbl <- tibble(
x = 1:10,
y = factor(rep(c("a", "c"), each = 5), levels = c("a", "b", "c"))
)
tbl \%>\%
group_by(y, .drop = FALSE) \%>\%
group_rows()
}
\seealso{
Other grouping functions:
\code{\link{group_map}()},
\code{\link{group_nest}()},
\code{\link{group_split}()},
\code{\link{group_trim}()}
}
\concept{grouping functions}
dplyr/man/group_split.Rd 0000644 0001762 0000144 00000004320 14366556340 015030 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-split.R
\name{group_split}
\alias{group_split}
\title{Split data frame by groups}
\usage{
group_split(.tbl, ..., .keep = TRUE)
}
\arguments{
\item{.tbl}{A tbl.}
\item{...}{If \code{.tbl} is an ungrouped data frame, a grouping specification,
forwarded to \code{\link[=group_by]{group_by()}}.}
\item{.keep}{Should the grouping columns be kept?}
}
\value{
A list of tibbles. Each tibble contains the rows of \code{.tbl} for the
associated group and all the columns, including the grouping variables.
Note that this returns a \link[vctrs:list_of]{list_of} which is slightly
stricter than a simple list but is useful for representing lists where
every element has the same type.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
\code{\link[=group_split]{group_split()}} works like \code{\link[base:split]{base::split()}} but:
\itemize{
\item It uses the grouping structure from \code{\link[=group_by]{group_by()}} and therefore is subject
to the data mask
\item It does not name the elements of the list based on the grouping as this
only works well for a single character grouping variable. Instead,
use \code{\link[=group_keys]{group_keys()}} to access a data frame that defines the groups.
}
\code{group_split()} is primarily designed to work with grouped data frames.
You can pass \code{...} to group and split an ungrouped data frame, but this
is generally not very useful as you want have easy access to the group
metadata.
}
\section{Lifecycle}{
\code{group_split()} is not stable because you can achieve very similar results by
manipulating the nested column returned from
\code{\link[tidyr:nest]{tidyr::nest(.by =)}}. That also retains the group keys all
within a single data structure. \code{group_split()} may be deprecated in the
future.
}
\examples{
ir <- iris \%>\% group_by(Species)
group_split(ir)
group_keys(ir)
}
\seealso{
Other grouping functions:
\code{\link{group_by}()},
\code{\link{group_map}()},
\code{\link{group_nest}()},
\code{\link{group_trim}()}
}
\concept{grouping functions}
\keyword{internal}
dplyr/man/ident.Rd 0000644 0001762 0000144 00000001312 14303720412 013542 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/compat-dbplyr.R
\name{ident}
\alias{ident}
\title{Flag a character vector as SQL identifiers}
\usage{
ident(...)
}
\arguments{
\item{...}{A character vector, or name-value pairs}
}
\description{
\code{ident()} takes unquoted strings and flags them as identifiers.
\code{ident_q()} assumes its input has already been quoted, and ensures
it does not get quoted again. This is currently used only for
\code{schema.table}.
}
\examples{
# Identifiers are escaped with "
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
ident("x")
\dontshow{\}) # examplesIf}
}
dplyr/man/across.Rd 0000644 0001762 0000144 00000021106 14406402754 013746 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/across.R
\name{across}
\alias{across}
\alias{if_any}
\alias{if_all}
\title{Apply a function (or functions) across multiple columns}
\usage{
across(.cols, .fns, ..., .names = NULL, .unpack = FALSE)
if_any(.cols, .fns, ..., .names = NULL)
if_all(.cols, .fns, ..., .names = NULL)
}
\arguments{
\item{.cols}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Columns to transform.
You can't select grouping columns because they are already automatically
handled by the verb (i.e. \code{\link[=summarise]{summarise()}} or \code{\link[=mutate]{mutate()}}).}
\item{.fns}{Functions to apply to each of the selected columns.
Possible values are:
\itemize{
\item A function, e.g. \code{mean}.
\item A purrr-style lambda, e.g. \code{~ mean(.x, na.rm = TRUE)}
\item A named list of functions or lambdas, e.g.
\verb{list(mean = mean, n_miss = ~ sum(is.na(.x))}. Each function is applied
to each column, and the output is named by combining the function name
and the column name using the glue specification in \code{.names}.
}
Within these functions you can use \code{\link[=cur_column]{cur_column()}} and \code{\link[=cur_group]{cur_group()}}
to access the current column and grouping keys respectively.}
\item{...}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
Additional arguments for the function calls in \code{.fns} are no longer
accepted in \code{...} because it's not clear when they should be evaluated:
once per \code{across()} or once per group? Instead supply additional arguments
directly in \code{.fns} by using a lambda. For example, instead of
\code{across(a:b, mean, na.rm = TRUE)} write
\code{across(a:b, ~ mean(.x, na.rm = TRUE))}.}
\item{.names}{A glue specification that describes how to name the output
columns. This can use \code{{.col}} to stand for the selected column name, and
\code{{.fn}} to stand for the name of the function being applied. The default
(\code{NULL}) is equivalent to \code{"{.col}"} for the single function case and
\code{"{.col}_{.fn}"} for the case where a list is used for \code{.fns}.}
\item{.unpack}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
Optionally \link[tidyr:pack]{unpack} data frames returned by functions in
\code{.fns}, which expands the df-columns out into individual columns, retaining
the number of rows in the data frame.
\itemize{
\item If \code{FALSE}, the default, no unpacking is done.
\item If \code{TRUE}, unpacking is done with a default glue specification of
\code{"{outer}_{inner}"}.
\item Otherwise, a single glue specification can be supplied to describe how to
name the unpacked columns. This can use \code{{outer}} to refer to the name
originally generated by \code{.names}, and \code{{inner}} to refer to the names of
the data frame you are unpacking.
}}
}
\value{
\code{across()} typically returns a tibble with one column for each column in
\code{.cols} and each function in \code{.fns}. If \code{.unpack} is used, more columns may
be returned depending on how the results of \code{.fns} are unpacked.
\code{if_any()} and \code{if_all()} return a logical vector.
}
\description{
\code{across()} makes it easy to apply the same transformation to multiple
columns, allowing you to use \code{\link[=select]{select()}} semantics inside in "data-masking"
functions like \code{\link[=summarise]{summarise()}} and \code{\link[=mutate]{mutate()}}. See \code{vignette("colwise")} for
more details.
\code{if_any()} and \code{if_all()} apply the same
predicate function to a selection of columns and combine the
results into a single logical vector: \code{if_any()} is \code{TRUE} when
the predicate is \code{TRUE} for \emph{any} of the selected columns, \code{if_all()}
is \code{TRUE} when the predicate is \code{TRUE} for \emph{all} selected columns.
If you just need to select columns without applying a transformation to each
of them, then you probably want to use \code{\link[=pick]{pick()}} instead.
\code{across()} supersedes the family of "scoped variants" like
\code{summarise_at()}, \code{summarise_if()}, and \code{summarise_all()}.
}
\section{Timing of evaluation}{
R code in dplyr verbs is generally evaluated once per group.
Inside \code{across()} however, code is evaluated once for each
combination of columns and groups. If the evaluation timing is
important, for example if you're generating random variables, think
about when it should happen and place your code in consequence.
\if{html}{\out{}}\preformatted{gdf <-
tibble(g = c(1, 1, 2, 3), v1 = 10:13, v2 = 20:23) \%>\%
group_by(g)
set.seed(1)
# Outside: 1 normal variate
n <- rnorm(1)
gdf \%>\% mutate(across(v1:v2, ~ .x + n))
#> # A tibble: 4 x 3
#> # Groups: g [3]
#> g v1 v2
#>
#> 1 1 9.37 19.4
#> 2 1 10.4 20.4
#> 3 2 11.4 21.4
#> 4 3 12.4 22.4
# Inside a verb: 3 normal variates (ngroup)
gdf \%>\% mutate(n = rnorm(1), across(v1:v2, ~ .x + n))
#> # A tibble: 4 x 4
#> # Groups: g [3]
#> g v1 v2 n
#>
#> 1 1 10.2 20.2 0.184
#> 2 1 11.2 21.2 0.184
#> 3 2 11.2 21.2 -0.836
#> 4 3 14.6 24.6 1.60
# Inside `across()`: 6 normal variates (ncol * ngroup)
gdf \%>\% mutate(across(v1:v2, ~ .x + rnorm(1)))
#> # A tibble: 4 x 3
#> # Groups: g [3]
#> g v1 v2
#>
#> 1 1 10.3 20.7
#> 2 1 11.3 21.7
#> 3 2 11.2 22.6
#> 4 3 13.5 22.7
}\if{html}{\out{
}}
}
\examples{
# For better printing
iris <- as_tibble(iris)
# across() -----------------------------------------------------------------
# Different ways to select the same set of columns
# See for details
iris \%>\%
mutate(across(c(Sepal.Length, Sepal.Width), round))
iris \%>\%
mutate(across(c(1, 2), round))
iris \%>\%
mutate(across(1:Sepal.Width, round))
iris \%>\%
mutate(across(where(is.double) & !c(Petal.Length, Petal.Width), round))
# Using an external vector of names
cols <- c("Sepal.Length", "Petal.Width")
iris \%>\%
mutate(across(all_of(cols), round))
# If the external vector is named, the output columns will be named according
# to those names
names(cols) <- tolower(cols)
iris \%>\%
mutate(across(all_of(cols), round))
# A purrr-style formula
iris \%>\%
group_by(Species) \%>\%
summarise(across(starts_with("Sepal"), ~ mean(.x, na.rm = TRUE)))
# A named list of functions
iris \%>\%
group_by(Species) \%>\%
summarise(across(starts_with("Sepal"), list(mean = mean, sd = sd)))
# Use the .names argument to control the output names
iris \%>\%
group_by(Species) \%>\%
summarise(across(starts_with("Sepal"), mean, .names = "mean_{.col}"))
iris \%>\%
group_by(Species) \%>\%
summarise(across(starts_with("Sepal"), list(mean = mean, sd = sd), .names = "{.col}.{.fn}"))
# If a named external vector is used for column selection, .names will use
# those names when constructing the output names
iris \%>\%
group_by(Species) \%>\%
summarise(across(all_of(cols), mean, .names = "mean_{.col}"))
# When the list is not named, .fn is replaced by the function's position
iris \%>\%
group_by(Species) \%>\%
summarise(across(starts_with("Sepal"), list(mean, sd), .names = "{.col}.fn{.fn}"))
# When the functions in .fns return a data frame, you typically get a
# "packed" data frame back
quantile_df <- function(x, probs = c(0.25, 0.5, 0.75)) {
tibble(quantile = probs, value = quantile(x, probs))
}
iris \%>\%
reframe(across(starts_with("Sepal"), quantile_df))
# Use .unpack to automatically expand these packed data frames into their
# individual columns
iris \%>\%
reframe(across(starts_with("Sepal"), quantile_df, .unpack = TRUE))
# .unpack can utilize a glue specification if you don't like the defaults
iris \%>\%
reframe(across(starts_with("Sepal"), quantile_df, .unpack = "{outer}.{inner}"))
# This is also useful inside mutate(), for example, with a multi-lag helper
multilag <- function(x, lags = 1:3) {
names(lags) <- as.character(lags)
purrr::map_dfr(lags, lag, x = x)
}
iris \%>\%
group_by(Species) \%>\%
mutate(across(starts_with("Sepal"), multilag, .unpack = TRUE)) \%>\%
select(Species, starts_with("Sepal"))
# if_any() and if_all() ----------------------------------------------------
iris \%>\%
filter(if_any(ends_with("Width"), ~ . > 4))
iris \%>\%
filter(if_all(ends_with("Width"), ~ . > 2))
}
\seealso{
\code{\link[=c_across]{c_across()}} for a function that returns a vector
}
dplyr/man/filter.Rd 0000644 0001762 0000144 00000013067 14406402754 013750 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/filter.R
\name{filter}
\alias{filter}
\title{Keep rows that match a condition}
\usage{
filter(.data, ..., .by = NULL, .preserve = FALSE)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Expressions that
return a logical value, and are defined in terms of the variables in
\code{.data}. If multiple expressions are included, they are combined with the
\code{&} operator. Only rows for which all conditions evaluate to \code{TRUE} are
kept.}
\item{.by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
\item{.preserve}{Relevant when the \code{.data} input is grouped.
If \code{.preserve = FALSE} (the default), the grouping structure
is recalculated based on the resulting data, otherwise the grouping is kept as is.}
}
\value{
An object of the same type as \code{.data}. The output has the following properties:
\itemize{
\item Rows are a subset of the input, but appear in the same order.
\item Columns are not modified.
\item The number of groups may be reduced (if \code{.preserve} is not \code{TRUE}).
\item Data frame attributes are preserved.
}
}
\description{
The \code{filter()} function is used to subset a data frame,
retaining all rows that satisfy your conditions.
To be retained, the row must produce a value of \code{TRUE} for all conditions.
Note that when a condition evaluates to \code{NA}
the row will be dropped, unlike base subsetting with \code{[}.
}
\details{
The \code{filter()} function is used to subset the rows of
\code{.data}, applying the expressions in \code{...} to the column values to determine which
rows should be retained. It can be applied to both grouped and ungrouped data (see \code{\link[=group_by]{group_by()}} and
\code{\link[=ungroup]{ungroup()}}). However, dplyr is not yet smart enough to optimise the filtering
operation on grouped datasets that do not need grouped calculations. For this
reason, filtering is often considerably faster on ungrouped data.
}
\section{Useful filter functions}{
There are many functions and operators that are useful when constructing the
expressions used to filter the data:
\itemize{
\item \code{\link{==}}, \code{\link{>}}, \code{\link{>=}} etc
\item \code{\link{&}}, \code{\link{|}}, \code{\link{!}}, \code{\link[=xor]{xor()}}
\item \code{\link[=is.na]{is.na()}}
\item \code{\link[=between]{between()}}, \code{\link[=near]{near()}}
}
}
\section{Grouped tibbles}{
Because filtering expressions are computed within groups, they may
yield different results on grouped tibbles. This will be the case
as soon as an aggregating, lagging, or ranking function is
involved. Compare this ungrouped filtering:
\if{html}{\out{}}\preformatted{starwars \%>\% filter(mass > mean(mass, na.rm = TRUE))
}\if{html}{\out{
}}
With the grouped equivalent:
\if{html}{\out{}}\preformatted{starwars \%>\% group_by(gender) \%>\% filter(mass > mean(mass, na.rm = TRUE))
}\if{html}{\out{
}}
In the ungrouped version, \code{filter()} compares the value of \code{mass} in each row to
the global average (taken over the whole data set), keeping only the rows with
\code{mass} greater than this global average. In contrast, the grouped version calculates
the average mass separately for each \code{gender} group, and keeps rows with \code{mass} greater
than the relevant within-gender average.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("filter")}.
}
\examples{
# Filtering by one criterion
filter(starwars, species == "Human")
filter(starwars, mass > 1000)
# Filtering by multiple criteria within a single logical expression
filter(starwars, hair_color == "none" & eye_color == "black")
filter(starwars, hair_color == "none" | eye_color == "black")
# When multiple expressions are used, they are combined using &
filter(starwars, hair_color == "none", eye_color == "black")
# The filtering operation may yield different results on grouped
# tibbles because the expressions are computed within groups.
#
# The following filters rows where `mass` is greater than the
# global average:
starwars \%>\% filter(mass > mean(mass, na.rm = TRUE))
# Whereas this keeps rows with `mass` greater than the gender
# average:
starwars \%>\% group_by(gender) \%>\% filter(mass > mean(mass, na.rm = TRUE))
# To refer to column names that are stored as strings, use the `.data` pronoun:
vars <- c("mass", "height")
cond <- c(80, 150)
starwars \%>\%
filter(
.data[[vars[[1]]]] > cond[[1]],
.data[[vars[[2]]]] > cond[[2]]
)
# Learn more in ?rlang::args_data_masking
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/between.Rd 0000644 0001762 0000144 00000001667 14366556340 014125 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/funs.R
\name{between}
\alias{between}
\title{Detect where values fall in a specified range}
\usage{
between(x, left, right)
}
\arguments{
\item{x}{A vector}
\item{left, right}{Boundary values. Both \code{left} and \code{right} are recycled to
the size of \code{x}.}
}
\value{
A logical vector the same size as \code{x}.
}
\description{
This is a shortcut for \code{x >= left & x <= right}, implemented for local
vectors and translated to the appropriate SQL for remote tables.
}
\details{
\code{x}, \code{left}, and \code{right} are all cast to their common type before the
comparison is made.
}
\examples{
between(1:12, 7, 9)
x <- rnorm(1e2)
x[between(x, -1, 1)]
# On a tibble using `filter()`
filter(starwars, between(height, 100, 150))
}
\seealso{
\code{\link[=join_by]{join_by()}} if you are looking for documentation for the \code{between()} overlap
join helper.
}
dplyr/man/relocate.Rd 0000644 0001762 0000144 00000004430 14366556340 014261 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/relocate.R
\name{relocate}
\alias{relocate}
\title{Change column order}
\usage{
relocate(.data, ..., .before = NULL, .after = NULL)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Columns to move.}
\item{.before, .after}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Destination of
columns selected by \code{...}. Supplying neither will move columns to the
left-hand side; specifying both is an error.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Rows are not affected.
\item The same columns appear in the output, but (usually) in a different place
and possibly renamed.
\item Data frame attributes are preserved.
\item Groups are not affected.
}
}
\description{
Use \code{relocate()} to change column positions, using the same syntax as
\code{select()} to make it easy to move blocks of columns at once.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("relocate")}.
}
\examples{
df <- tibble(a = 1, b = 1, c = 1, d = "a", e = "a", f = "a")
df \%>\% relocate(f)
df \%>\% relocate(a, .after = c)
df \%>\% relocate(f, .before = b)
df \%>\% relocate(a, .after = last_col())
# relocated columns can change name
df \%>\% relocate(ff = f)
# Can also select variables based on their type
df \%>\% relocate(where(is.character))
df \%>\% relocate(where(is.numeric), .after = last_col())
# Or with any other select helper
df \%>\% relocate(any_of(c("a", "e", "i", "o", "u")))
# When .before or .after refers to multiple variables they will be
# moved to be immediately before/after the selected variables.
df2 <- tibble(a = 1, b = "a", c = 1, d = "a")
df2 \%>\% relocate(where(is.numeric), .after = where(is.character))
df2 \%>\% relocate(where(is.numeric), .before = where(is.character))
}
dplyr/man/group_cols.Rd 0000644 0001762 0000144 00000001720 13663216626 014635 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/select-helpers.R
\name{group_cols}
\alias{group_cols}
\title{Select grouping variables}
\usage{
group_cols(vars = NULL, data = NULL)
}
\arguments{
\item{vars}{Deprecated; please use data instead.}
\item{data}{For advanced use only. The default \code{NULL} automatically
finds the "current" data frames.}
}
\description{
This selection helpers matches grouping variables. It can be used
in \code{\link[=select]{select()}} or \code{\link[=vars]{vars()}} selections.
}
\examples{
gdf <- iris \%>\% group_by(Species)
gdf \%>\% select(group_cols())
# Remove the grouping variables from mutate selections:
gdf \%>\% mutate_at(vars(-group_cols()), `/`, 100)
# -> No longer necessary with across()
gdf \%>\% mutate(across(everything(), ~ . / 100))
}
\seealso{
\code{\link[=groups]{groups()}} and \code{\link[=group_vars]{group_vars()}} for retrieving the grouping
variables outside selection contexts.
}
dplyr/man/compute.Rd 0000644 0001762 0000144 00000004120 14366556340 014133 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/compute-collect.R
\name{compute}
\alias{compute}
\alias{collect}
\alias{collapse}
\title{Force computation of a database query}
\usage{
compute(x, ...)
collect(x, ...)
collapse(x, ...)
}
\arguments{
\item{x}{A data frame, data frame extension (e.g. a tibble), or a lazy
data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for more
details.}
\item{...}{Arguments passed on to methods}
}
\description{
\code{compute()} stores results in a remote temporary table.
\code{collect()} retrieves data into a local tibble.
\code{collapse()} is slightly different: it doesn't force computation, but
instead forces generation of the SQL query. This is sometimes needed to work
around bugs in dplyr's SQL generation.
All functions preserve grouping and ordering.
}
\section{Methods}{
These functions are \strong{generics}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{compute()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("compute")}
\item \code{collect()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("collect")}
\item \code{collapse()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("collapse")}
}
}
\examples{
\dontshow{if (requireNamespace("dbplyr", quietly = TRUE) && requireNamespace("RSQLite", quietly = TRUE)) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
mtcars2 <- dbplyr::src_memdb() \%>\%
copy_to(mtcars, name = "mtcars2-cc", overwrite = TRUE)
remote <- mtcars2 \%>\%
filter(cyl == 8) \%>\%
select(mpg:drat)
# Compute query and save in remote table
compute(remote)
# Compute query bring back to this session
collect(remote)
# Creates a fresh query based on the generated SQL
collapse(remote)
\dontshow{\}) # examplesIf}
}
\seealso{
\code{\link[=copy_to]{copy_to()}}, the opposite of \code{collect()}: it takes a local data
frame and uploads it to the remote source.
}
dplyr/man/case_when.Rd 0000644 0001762 0000144 00000012202 14472225345 014407 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/case-when.R
\name{case_when}
\alias{case_when}
\title{A general vectorised if-else}
\usage{
case_when(..., .default = NULL, .ptype = NULL, .size = NULL)
}
\arguments{
\item{...}{<\code{\link[rlang:dyn-dots]{dynamic-dots}}> A sequence of two-sided
formulas. The left hand side (LHS) determines which values match this case.
The right hand side (RHS) provides the replacement value.
The LHS inputs must evaluate to logical vectors.
The RHS inputs will be coerced to their common type.
All inputs will be recycled to their common size. That said, we encourage
all LHS inputs to be the same size. Recycling is mainly useful for RHS
inputs, where you might supply a size 1 input that will be recycled to the
size of the LHS inputs.
\code{NULL} inputs are ignored.}
\item{.default}{The value used when all of the LHS inputs return either
\code{FALSE} or \code{NA}.
\code{.default} must be size 1 or the same size as the common size computed
from \code{...}.
\code{.default} participates in the computation of the common type with the RHS
inputs.
\code{NA} values in the LHS conditions are treated like \code{FALSE}, meaning that
the result at those locations will be assigned the \code{.default} value. To
handle missing values in the conditions differently, you must explicitly
catch them with another condition before they fall through to the
\code{.default}. This typically involves some variation of \code{is.na(x) ~ value}
tailored to your usage of \code{case_when()}.
If \code{NULL}, the default, a missing value will be used.}
\item{.ptype}{An optional prototype declaring the desired output type. If
supplied, this overrides the common type of the RHS inputs.}
\item{.size}{An optional size declaring the desired output size. If supplied,
this overrides the common size computed from \code{...}.}
}
\value{
A vector with the same size as the common size computed from the
inputs in \code{...} and the same type as the common type of the RHS inputs
in \code{...}.
}
\description{
This function allows you to vectorise multiple \code{\link[=if_else]{if_else()}} statements. Each
case is evaluated sequentially and the first match for each element
determines the corresponding value in the output vector. If no cases match,
the \code{.default} is used as a final "else" statment.
\code{case_when()} is an R equivalent of the SQL "searched" \verb{CASE WHEN} statement.
}
\examples{
x <- 1:70
case_when(
x \%\% 35 == 0 ~ "fizz buzz",
x \%\% 5 == 0 ~ "fizz",
x \%\% 7 == 0 ~ "buzz",
.default = as.character(x)
)
# Like an if statement, the arguments are evaluated in order, so you must
# proceed from the most specific to the most general. This won't work:
case_when(
x \%\% 5 == 0 ~ "fizz",
x \%\% 7 == 0 ~ "buzz",
x \%\% 35 == 0 ~ "fizz buzz",
.default = as.character(x)
)
# If none of the cases match and no `.default` is supplied, NA is used:
case_when(
x \%\% 35 == 0 ~ "fizz buzz",
x \%\% 5 == 0 ~ "fizz",
x \%\% 7 == 0 ~ "buzz",
)
# Note that `NA` values on the LHS are treated like `FALSE` and will be
# assigned the `.default` value. You must handle them explicitly if you
# want to use a different value. The exact way to handle missing values is
# dependent on the set of LHS conditions you use.
x[2:4] <- NA_real_
case_when(
x \%\% 35 == 0 ~ "fizz buzz",
x \%\% 5 == 0 ~ "fizz",
x \%\% 7 == 0 ~ "buzz",
is.na(x) ~ "nope",
.default = as.character(x)
)
# `case_when()` evaluates all RHS expressions, and then constructs its
# result by extracting the selected (via the LHS expressions) parts.
# In particular `NaN`s are produced in this case:
y <- seq(-2, 2, by = .5)
case_when(
y >= 0 ~ sqrt(y),
.default = y
)
# `case_when()` is particularly useful inside `mutate()` when you want to
# create a new variable that relies on a complex combination of existing
# variables
starwars \%>\%
select(name:mass, gender, species) \%>\%
mutate(
type = case_when(
height > 200 | mass > 200 ~ "large",
species == "Droid" ~ "robot",
.default = "other"
)
)
# `case_when()` is not a tidy eval function. If you'd like to reuse
# the same patterns, extract the `case_when()` call in a normal
# function:
case_character_type <- function(height, mass, species) {
case_when(
height > 200 | mass > 200 ~ "large",
species == "Droid" ~ "robot",
.default = "other"
)
}
case_character_type(150, 250, "Droid")
case_character_type(150, 150, "Droid")
# Such functions can be used inside `mutate()` as well:
starwars \%>\%
mutate(type = case_character_type(height, mass, species)) \%>\%
pull(type)
# `case_when()` ignores `NULL` inputs. This is useful when you'd
# like to use a pattern only under certain conditions. Here we'll
# take advantage of the fact that `if` returns `NULL` when there is
# no `else` clause:
case_character_type <- function(height, mass, species, robots = TRUE) {
case_when(
height > 200 | mass > 200 ~ "large",
if (robots) species == "Droid" ~ "robot",
.default = "other"
)
}
starwars \%>\%
mutate(type = case_character_type(height, mass, species, robots = FALSE)) \%>\%
pull(type)
}
\seealso{
\code{\link[=case_match]{case_match()}}
}
dplyr/man/backend_dbplyr.Rd 0000644 0001762 0000144 00000007421 13663216626 015430 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/dbplyr.R
\name{backend_dbplyr}
\alias{backend_dbplyr}
\alias{db_desc}
\alias{sql_translate_env}
\alias{db_list_tables}
\alias{db_has_table}
\alias{db_data_type}
\alias{db_save_query}
\alias{db_begin}
\alias{db_commit}
\alias{db_rollback}
\alias{db_write_table}
\alias{db_create_table}
\alias{db_insert_into}
\alias{db_create_indexes}
\alias{db_create_index}
\alias{db_drop_table}
\alias{db_analyze}
\alias{db_explain}
\alias{db_query_fields}
\alias{db_query_rows}
\alias{sql_select}
\alias{sql_subquery}
\alias{sql_join}
\alias{sql_semi_join}
\alias{sql_set_op}
\alias{sql_escape_string}
\alias{sql_escape_ident}
\title{Database and SQL generics.}
\usage{
db_desc(x)
sql_translate_env(con)
db_list_tables(con)
db_has_table(con, table)
db_data_type(con, fields)
db_save_query(con, sql, name, temporary = TRUE, ...)
db_begin(con, ...)
db_commit(con, ...)
db_rollback(con, ...)
db_write_table(con, table, types, values, temporary = FALSE, ...)
db_create_table(con, table, types, temporary = FALSE, ...)
db_insert_into(con, table, values, ...)
db_create_indexes(con, table, indexes = NULL, unique = FALSE, ...)
db_create_index(con, table, columns, name = NULL, unique = FALSE, ...)
db_drop_table(con, table, force = FALSE, ...)
db_analyze(con, table, ...)
db_explain(con, sql, ...)
db_query_fields(con, sql, ...)
db_query_rows(con, sql, ...)
sql_select(
con,
select,
from,
where = NULL,
group_by = NULL,
having = NULL,
order_by = NULL,
limit = NULL,
distinct = FALSE,
...
)
sql_subquery(con, from, name = random_table_name(), ...)
sql_join(con, x, y, vars, type = "inner", by = NULL, ...)
sql_semi_join(con, x, y, anti = FALSE, by = NULL, ...)
sql_set_op(con, x, y, method)
sql_escape_string(con, x)
sql_escape_ident(con, x)
}
\arguments{
\item{con}{A database connection.}
\item{table}{A string, the table name.}
\item{fields}{A list of fields, as in a data frame.}
}
\value{
Usually a logical value indicating success. Most failures should generate
an error. However, \code{db_has_table()} should return \code{NA} if
temporary tables cannot be listed with \code{\link[DBI:dbListTables]{DBI::dbListTables()}} (due to backend
API limitations for example). As a result, you methods will rely on the
backend to throw an error if a table exists when it shouldn't.
}
\description{
The \code{sql_} generics are used to build the different types of SQL queries.
The default implementations in dbplyr generates ANSI 92 compliant SQL.
The \code{db_} generics execute actions on the database. The default
implementations in dbplyr typically just call the standard DBI S4
method.
}
\details{
A few backend methods do not call the standard DBI S4 methods including
\itemize{
\item \code{db_data_type()}: Calls \code{\link[DBI:dbDataType]{DBI::dbDataType()}} for every field
(e.g. data frame column) and returns a vector of corresponding SQL data
types
\item \code{db_save_query()}: Builds and executes a
\verb{CREATE [TEMPORARY] TABLE ...} SQL command.
\item \code{db_create_index()}: Builds and executes a
\verb{CREATE INDEX ON } SQL command.
\item \code{db_drop_table()}: Builds and executes a
\verb{DROP TABLE [IF EXISTS] } SQL command.
\item \code{db_analyze()}: Builds and executes an
\verb{ANALYZE } SQL command.
}
Currently, \code{\link[=copy_to]{copy_to()}} is the only user of \code{db_begin()}, \code{db_commit()},
\code{db_rollback()}, \code{db_write_table()}, \code{db_create_indexes()}, \code{db_drop_table()} and
\code{db_analyze()}. If you find yourself overriding many of these
functions it may suggest that you should just override \code{copy_to()}
instead.
\code{db_create_table()} and \code{db_insert_into()} have been deprecated
in favour of \code{db_write_table()}.
}
\keyword{internal}
dplyr/man/with_groups.Rd 0000644 0001762 0000144 00000002426 14366556340 015040 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/groups-with.R
\name{with_groups}
\alias{with_groups}
\title{Perform an operation with temporary groups}
\usage{
with_groups(.data, .groups, .f, ...)
}
\arguments{
\item{.data}{A data frame}
\item{.groups}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> One or more variables
to group by. Unlike \code{\link[=group_by]{group_by()}}, you can only group by existing variables,
and you can use tidy-select syntax like \code{c(x, y, z)} to select multiple
variables.
Use \code{NULL} to temporarily \strong{un}group.}
\item{.f}{Function to apply to regrouped data.
Supports purrr-style \code{~} syntax}
\item{...}{Additional arguments passed on to \code{...}.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
This was an experimental function that allows you to modify the grouping
variables for a single operation; it is superseded in favour of using the
\code{.by} argument to individual verbs.
}
\examples{
df <- tibble(g = c(1, 1, 2, 2, 3), x = runif(5))
# Old
df \%>\%
with_groups(g, mutate, x_mean = mean(x))
# New
df \%>\% mutate(x_mean = mean(x), .by = g)
}
\keyword{internal}
dplyr/man/copy_to.Rd 0000644 0001762 0000144 00000002630 14366556340 014137 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/copy-to.R
\name{copy_to}
\alias{copy_to}
\title{Copy a local data frame to a remote src}
\usage{
copy_to(dest, df, name = deparse(substitute(df)), overwrite = FALSE, ...)
}
\arguments{
\item{dest}{remote data source}
\item{df}{local data frame}
\item{name}{name for new remote table.}
\item{overwrite}{If \code{TRUE}, will overwrite an existing table with
name \code{name}. If \code{FALSE}, will throw an error if \code{name} already
exists.}
\item{...}{other parameters passed to methods.}
}
\value{
a \code{tbl} object in the remote source
}
\description{
This function uploads a local data frame into a remote data source, creating
the table definition as needed. Wherever possible, the new object will be
temporary, limited to the current connection to the source.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("copy_to")}.
}
\examples{
\dontrun{
iris2 <- dbplyr::src_memdb() \%>\% copy_to(iris, overwrite = TRUE)
iris2
}
}
\seealso{
\code{\link[=collect]{collect()}} for the opposite action; downloading remote data into
a local dbl.
}
dplyr/man/tbl_ptype.Rd 0000644 0001762 0000144 00000000715 13663216626 014466 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise.R
\name{tbl_ptype}
\alias{tbl_ptype}
\title{Return a prototype of a tbl}
\usage{
tbl_ptype(.data)
}
\description{
Used in \verb{_if} functions to enable type-based selection even when the data
is lazily generated. Should either return the complete tibble, or if that
can not be computed quickly, a 0-row tibble where the columns are of
the correct type.
}
\keyword{internal}
dplyr/man/combine.Rd 0000644 0001762 0000144 00000001542 14266276767 014113 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-combine.R
\name{combine}
\alias{combine}
\title{Combine vectors}
\usage{
combine(...)
}
\arguments{
\item{...}{Vectors to combine.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
\code{combine()} is deprecated in favour of \code{\link[vctrs:vec_c]{vctrs::vec_c()}}. \code{combine()}
attempted to automatically guess whether you wanted \code{\link[=c]{c()}} or \code{\link[=unlist]{unlist()}},
but could fail in surprising ways. We now believe it's better to be explicit.
}
\examples{
f1 <- factor("a")
f2 <- factor("b")
combine(f1, f2)
# ->
vctrs::vec_c(f1, f1)
combine(list(f1, f2))
# ->
vctrs::vec_c(!!!list(f1, f2))
}
\keyword{internal}
dplyr/man/all_equal.Rd 0000644 0001762 0000144 00000003163 14366556340 014424 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/all-equal.R
\name{all_equal}
\alias{all_equal}
\title{Flexible equality comparison for data frames}
\usage{
all_equal(
target,
current,
ignore_col_order = TRUE,
ignore_row_order = TRUE,
convert = FALSE,
...
)
}
\arguments{
\item{target, current}{Two data frames to compare.}
\item{ignore_col_order}{Should order of columns be ignored?}
\item{ignore_row_order}{Should order of rows be ignored?}
\item{convert}{Should similar classes be converted? Currently this will
convert factor to character and integer to double.}
\item{...}{Ignored. Needed for compatibility with \code{all.equal()}.}
}
\value{
\code{TRUE} if equal, otherwise a character vector describing
the reasons why they're not equal. Use \code{\link[=isTRUE]{isTRUE()}} if using the
result in an \code{if} expression.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
\code{all_equal()} allows you to compare data frames, optionally ignoring
row and column names. It is deprecated as of dplyr 1.1.0, because it
makes it too easy to ignore important differences.
}
\examples{
scramble <- function(x) x[sample(nrow(x)), sample(ncol(x))]
# `all_equal()` ignored row and column ordering by default,
# but we now feel that that makes it too easy to make mistakes
mtcars2 <- scramble(mtcars)
all_equal(mtcars, mtcars2)
# Instead, be explicit about the row and column ordering
all.equal(
mtcars,
mtcars2[rownames(mtcars), names(mtcars)]
)
}
\keyword{internal}
dplyr/man/join_by.Rd 0000644 0001762 0000144 00000022336 14366556340 014121 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join-by.R
\name{join_by}
\alias{join_by}
\alias{closest}
\alias{overlaps}
\alias{within}
\title{Join specifications}
\usage{
join_by(...)
}
\arguments{
\item{...}{Expressions specifying the join.
Each expression should consist of one of the following:
\itemize{
\item Equality condition: \code{==}
\item Inequality conditions: \code{>=}, \code{>}, \code{<=}, or \code{<}
\item Rolling helper: \code{closest()}
\item Overlap helpers: \code{between()}, \code{within()}, or \code{overlaps()}
}
Other expressions are not supported. If you need to perform a join on
a computed variable, e.g. \code{join_by(sales_date - 40 >= promo_date)},
you'll need to precompute and store it in a separate column.
Column names should be specified as quoted or unquoted names. By default,
the name on the left-hand side of a join condition refers to the left-hand
table, unless overridden by explicitly prefixing the column name with
either \verb{x$} or \verb{y$}.
If a single column name is provided without any join conditions, it is
interpreted as if that column name was duplicated on each side of \code{==},
i.e. \code{x} is interpreted as \code{x == x}.}
}
\description{
\code{join_by()} constructs a specification that describes how to join two tables
using a small domain specific language. The result can be supplied as the
\code{by} argument to any of the join functions (such as \code{\link[=left_join]{left_join()}}).
}
\section{Join types}{
The following types of joins are supported by dplyr:
\itemize{
\item Equality joins
\item Inequality joins
\item Rolling joins
\item Overlap joins
\item Cross joins
}
Equality, inequality, rolling, and overlap joins are discussed in more detail
below. Cross joins are implemented through \code{\link[=cross_join]{cross_join()}}.
\subsection{Equality joins}{
Equality joins require keys to be equal between one or more pairs of columns,
and are the most common type of join. To construct an equality join using
\code{join_by()}, supply two column names to join with separated by \code{==}.
Alternatively, supplying a single name will be interpreted as an equality
join between two columns of the same name. For example, \code{join_by(x)} is
equivalent to \code{join_by(x == x)}.
}
\subsection{Inequality joins}{
Inequality joins match on an inequality, such as \code{>}, \code{>=}, \code{<}, or \code{<=}, and
are common in time series analysis and genomics. To construct an inequality
join using \code{join_by()}, supply two column names separated by one of the above
mentioned inequalities.
Note that inequality joins will match a single row in \code{x} to a potentially
large number of rows in \code{y}. Be extra careful when constructing inequality
join specifications!
}
\subsection{Rolling joins}{
Rolling joins are a variant of inequality joins that limit the results
returned from an inequality join condition. They are useful for "rolling" the
closest match forward/backwards when there isn't an exact match. To construct
a rolling join, wrap an inequality with \code{closest()}.
\itemize{
\item \code{closest(expr)}
\code{expr} must be an inequality involving one of: \code{>}, \code{>=}, \code{<}, or \code{<=}.
For example, \code{closest(x >= y)} is interpreted as: For each value in \code{x},
find the closest value in \code{y} that is less than or equal to that \code{x} value.
}
\code{closest()} will always use the left-hand table (\code{x}) as the primary table,
and the right-hand table (\code{y}) as the one to find the closest match in,
regardless of how the inequality is specified. For example,
\code{closest(y$a >= x$b)} will always be interpreted as \code{closest(x$b <= y$a)}.
}
\subsection{Overlap joins}{
Overlap joins are a special case of inequality joins involving one or two
columns from the left-hand table \emph{overlapping} a range defined by two columns
from the right-hand table. There are three helpers that \code{join_by()}
recognizes to assist with constructing overlap joins, all of which can be
constructed from simpler inequalities.
\itemize{
\item \code{between(x, y_lower, y_upper, ..., bounds = "[]")}
For each value in \code{x}, this finds everywhere that value falls between
\verb{[y_lower, y_upper]}. Equivalent to \verb{x >= y_lower, x <= y_upper} by
default.
\code{bounds} can be one of \code{"[]"}, \code{"[)"}, \code{"(]"}, or
\code{"()"} to alter the inclusiveness of the lower and upper bounds. This
changes whether \code{>=} or \code{>} and \code{<=} or \code{<} are used to build the
inequalities shown above.
Dots are for future extensions and must be empty.
\item \code{within(x_lower, x_upper, y_lower, y_upper)}
For each range in \verb{[x_lower, x_upper]}, this finds everywhere that range
falls completely within \verb{[y_lower, y_upper]}. Equivalent to \verb{x_lower >= y_lower, x_upper <= y_upper}.
The inequalities used to build \code{within()} are the same regardless of the
inclusiveness of the supplied ranges.
\item \code{overlaps(x_lower, x_upper, y_lower, y_upper, ..., bounds = "[]")}
For each range in \verb{[x_lower, x_upper]}, this finds everywhere that range
overlaps \verb{[y_lower, y_upper]} in any capacity. Equivalent to \verb{x_lower <= y_upper, x_upper >= y_lower} by default.
\code{bounds} can be one of \code{"[]"}, \code{"[)"}, \code{"(]"}, or
\code{"()"} to alter the inclusiveness of the lower and upper bounds.
\code{"[]"} uses \code{<=} and \code{>=}, but the 3 other options use \code{<} and \code{>}
and generate the exact same inequalities.
Dots are for future extensions and must be empty.
}
These conditions assume that the ranges are well-formed and non-empty, i.e.
\code{x_lower <= x_upper} when bounds are treated as \code{"[]"}, and
\code{x_lower < x_upper} otherwise.
}
}
\section{Column referencing}{
When specifying join conditions, \code{join_by()} assumes that column names on the
left-hand side of the condition refer to the left-hand table (\code{x}), and names
on the right-hand side of the condition refer to the right-hand table (\code{y}).
Occasionally, it is clearer to be able to specify a right-hand table name on
the left-hand side of the condition, and vice versa. To support this, column
names can be prefixed by \verb{x$} or \verb{y$} to explicitly specify which table they
come from.
}
\examples{
sales <- tibble(
id = c(1L, 1L, 1L, 2L, 2L),
sale_date = as.Date(c("2018-12-31", "2019-01-02", "2019-01-05", "2019-01-04", "2019-01-01"))
)
sales
promos <- tibble(
id = c(1L, 1L, 2L),
promo_date = as.Date(c("2019-01-01", "2019-01-05", "2019-01-02"))
)
promos
# Match `id` to `id`, and `sale_date` to `promo_date`
by <- join_by(id, sale_date == promo_date)
left_join(sales, promos, by)
# For each `sale_date` within a particular `id`,
# find all `promo_date`s that occurred before that particular sale
by <- join_by(id, sale_date >= promo_date)
left_join(sales, promos, by)
# For each `sale_date` within a particular `id`,
# find only the closest `promo_date` that occurred before that sale
by <- join_by(id, closest(sale_date >= promo_date))
left_join(sales, promos, by)
# If you want to disallow exact matching in rolling joins, use `>` rather
# than `>=`. Note that the promo on `2019-01-05` is no longer considered the
# closest match for the sale on the same date.
by <- join_by(id, closest(sale_date > promo_date))
left_join(sales, promos, by)
# Same as before, but also require that the promo had to occur at most 1
# day before the sale was made. We'll use a full join to see that id 2's
# promo on `2019-01-02` is no longer matched to the sale on `2019-01-04`.
sales <- mutate(sales, sale_date_lower = sale_date - 1)
by <- join_by(id, closest(sale_date >= promo_date), sale_date_lower <= promo_date)
full_join(sales, promos, by)
# ---------------------------------------------------------------------------
segments <- tibble(
segment_id = 1:4,
chromosome = c("chr1", "chr2", "chr2", "chr1"),
start = c(140, 210, 380, 230),
end = c(150, 240, 415, 280)
)
segments
reference <- tibble(
reference_id = 1:4,
chromosome = c("chr1", "chr1", "chr2", "chr2"),
start = c(100, 200, 300, 415),
end = c(150, 250, 399, 450)
)
reference
# Find every time a segment `start` falls between the reference
# `[start, end]` range.
by <- join_by(chromosome, between(start, start, end))
full_join(segments, reference, by)
# If you wanted the reference columns first, supply `reference` as `x`
# and `segments` as `y`, then explicitly refer to their columns using `x$`
# and `y$`.
by <- join_by(chromosome, between(y$start, x$start, x$end))
full_join(reference, segments, by)
# Find every time a segment falls completely within a reference.
# Sometimes using `x$` and `y$` makes your intentions clearer, even if they
# match the default behavior.
by <- join_by(chromosome, within(x$start, x$end, y$start, y$end))
inner_join(segments, reference, by)
# Find every time a segment overlaps a reference in any way.
by <- join_by(chromosome, overlaps(x$start, x$end, y$start, y$end))
full_join(segments, reference, by)
# It is common to have right-open ranges with bounds like `[)`, which would
# mean an end value of `415` would no longer overlap a start value of `415`.
# Setting `bounds` allows you to compute overlaps with those kinds of ranges.
by <- join_by(chromosome, overlaps(x$start, x$end, y$start, y$end, bounds = "[)"))
full_join(segments, reference, by)
}
dplyr/man/summarise_all.Rd 0000644 0001762 0000144 00000013346 14366556340 015326 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise-mutate.R
\name{summarise_all}
\alias{summarise_all}
\alias{summarise_if}
\alias{summarise_at}
\alias{summarize_all}
\alias{summarize_if}
\alias{summarize_at}
\title{Summarise multiple columns}
\usage{
summarise_all(.tbl, .funs, ...)
summarise_if(.tbl, .predicate, .funs, ...)
summarise_at(.tbl, .vars, .funs, ..., .cols = NULL)
summarize_all(.tbl, .funs, ...)
summarize_if(.tbl, .predicate, .funs, ...)
summarize_at(.tbl, .vars, .funs, ..., .cols = NULL)
}
\arguments{
\item{.tbl}{A \code{tbl} object.}
\item{.funs}{A function \code{fun}, a quosure style lambda \code{~ fun(.)} or a list of either form.}
\item{...}{Additional arguments for the function calls in
\code{.funs}. These are evaluated only once, with \link[rlang:dyn-dots]{tidy dots} support.}
\item{.predicate}{A predicate function to be applied to the columns
or a logical vector. The variables for which \code{.predicate} is or
returns \code{TRUE} are selected. This argument is passed to
\code{\link[rlang:as_function]{rlang::as_function()}} and thus supports quosure-style lambda
functions and strings representing function names.}
\item{.vars}{A list of columns generated by \code{\link[=vars]{vars()}},
a character vector of column names, a numeric vector of column
positions, or \code{NULL}.}
\item{.cols}{This argument has been renamed to \code{.vars} to fit
dplyr's terminology and is deprecated.}
}
\value{
A data frame. By default, the newly created columns have the shortest
names needed to uniquely identify the output. To force inclusion of a name,
even when not needed, name the input (see examples for details).
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
Scoped verbs (\verb{_if}, \verb{_at}, \verb{_all}) have been superseded by the use of
\code{\link[=pick]{pick()}} or \code{\link[=across]{across()}} in an existing verb. See \code{vignette("colwise")} for
details.
The \link{scoped} variants of \code{\link[=summarise]{summarise()}} make it easy to apply the same
transformation to multiple variables.
There are three variants.
\itemize{
\item \code{summarise_all()} affects every variable
\item \code{summarise_at()} affects variables selected with a character vector or
vars()
\item \code{summarise_if()} affects variables selected with a predicate function
}
}
\section{Grouping variables}{
If applied on a grouped tibble, these operations are \emph{not} applied
to the grouping variables. The behaviour depends on whether the
selection is \strong{implicit} (\code{all} and \code{if} selections) or
\strong{explicit} (\code{at} selections).
\itemize{
\item Grouping variables covered by explicit selections in
\code{summarise_at()} are always an error. Add \code{-group_cols()} to the
\code{\link[=vars]{vars()}} selection to avoid this:
\if{html}{\out{}}\preformatted{data \%>\%
summarise_at(vars(-group_cols(), ...), myoperation)
}\if{html}{\out{
}}
Or remove \code{group_vars()} from the character vector of column names:
\if{html}{\out{}}\preformatted{nms <- setdiff(nms, group_vars(data))
data \%>\% summarise_at(nms, myoperation)
}\if{html}{\out{
}}
\item Grouping variables covered by implicit selections are silently
ignored by \code{summarise_all()} and \code{summarise_if()}.
}
}
\section{Naming}{
The names of the new columns are derived from the names of the
input variables and the names of the functions.
\itemize{
\item if there is only one unnamed function (i.e. if \code{.funs} is an unnamed list
of length one),
the names of the input variables are used to name the new columns;
\item for \verb{_at} functions, if there is only one unnamed variable (i.e.,
if \code{.vars} is of the form \code{vars(a_single_column)}) and \code{.funs} has length
greater than one,
the names of the functions are used to name the new columns;
\item otherwise, the new names are created by
concatenating the names of the input variables and the names of the
functions, separated with an underscore \code{"_"}.
}
The \code{.funs} argument can be a named or unnamed list.
If a function is unnamed and the name cannot be derived automatically,
a name of the form "fn#" is used.
Similarly, \code{\link[=vars]{vars()}} accepts named and unnamed arguments.
If a variable in \code{.vars} is named, a new column by that name will be created.
Name collisions in the new columns are disambiguated using a unique suffix.
}
\examples{
# The _at() variants directly support strings:
starwars \%>\%
summarise_at(c("height", "mass"), mean, na.rm = TRUE)
# ->
starwars \%>\% summarise(across(c("height", "mass"), ~ mean(.x, na.rm = TRUE)))
# You can also supply selection helpers to _at() functions but you have
# to quote them with vars():
starwars \%>\%
summarise_at(vars(height:mass), mean, na.rm = TRUE)
# ->
starwars \%>\%
summarise(across(height:mass, ~ mean(.x, na.rm = TRUE)))
# The _if() variants apply a predicate function (a function that
# returns TRUE or FALSE) to determine the relevant subset of
# columns. Here we apply mean() to the numeric columns:
starwars \%>\%
summarise_if(is.numeric, mean, na.rm = TRUE)
starwars \%>\%
summarise(across(where(is.numeric), ~ mean(.x, na.rm = TRUE)))
by_species <- iris \%>\%
group_by(Species)
# If you want to apply multiple transformations, pass a list of
# functions. When there are multiple functions, they create new
# variables instead of modifying the variables in place:
by_species \%>\%
summarise_all(list(min, max))
# ->
by_species \%>\%
summarise(across(everything(), list(min = min, max = max)))
}
\seealso{
\link[=scoped]{The other scoped verbs}, \code{\link[=vars]{vars()}}
}
\keyword{internal}
dplyr/man/row_number.Rd 0000644 0001762 0000144 00000004654 14366556340 014652 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rank.R
\name{row_number}
\alias{row_number}
\alias{min_rank}
\alias{dense_rank}
\title{Integer ranking functions}
\usage{
row_number(x)
min_rank(x)
dense_rank(x)
}
\arguments{
\item{x}{A vector to rank
By default, the smallest values will get the smallest ranks. Use \code{\link[=desc]{desc()}}
to reverse the direction so the largest values get the smallest ranks.
Missing values will be given rank \code{NA}. Use \code{coalesce(x, Inf)} or
\code{coalesce(x, -Inf)} if you want to treat them as the largest or smallest
values respectively.
To rank by multiple columns at once, supply a data frame.}
}
\value{
An integer vector.
}
\description{
Three ranking functions inspired by SQL2003. They differ primarily in how
they handle ties:
\itemize{
\item \code{row_number()} gives every input a unique rank, so that \code{c(10, 20, 20, 30)}
would get ranks \code{c(1, 2, 3, 4)}. It's equivalent to
\code{rank(ties.method = "first")}.
\item \code{min_rank()} gives every tie the same (smallest) value so that
\code{c(10, 20, 20, 30)} gets ranks \code{c(1, 2, 2, 4)}. It's the way that ranks
are usually computed in sports and is equivalent to
\code{rank(ties.method = "min")}.
\item \code{dense_rank()} works like \code{min_rank()}, but doesn't leave any gaps,
so that \code{c(10, 20, 20, 30)} gets ranks \code{c(1, 2, 2, 3)}.
}
}
\examples{
x <- c(5, 1, 3, 2, 2, NA)
row_number(x)
min_rank(x)
dense_rank(x)
# Ranking functions can be used in `filter()` to select top/bottom rows
df <- data.frame(
grp = c(1, 1, 1, 2, 2, 2, 3, 3, 3),
x = c(3, 2, 1, 1, 2, 2, 1, 1, 1),
y = c(1, 3, 2, 3, 2, 2, 4, 1, 2),
id = 1:9
)
# Always gives exactly 1 row per group
df \%>\% group_by(grp) \%>\% filter(row_number(x) == 1)
# May give more than 1 row if ties
df \%>\% group_by(grp) \%>\% filter(min_rank(x) == 1)
# Rank by multiple columns (to break ties) by selecting them with `pick()`
df \%>\% group_by(grp) \%>\% filter(min_rank(pick(x, y)) == 1)
# See slice_min() and slice_max() for another way to tackle the same problem
# You can use row_number() without an argument to refer to the "current"
# row number.
df \%>\% group_by(grp) \%>\% filter(row_number() == 1)
# It's easiest to see what this does with mutate():
df \%>\% group_by(grp) \%>\% mutate(grp_id = row_number())
}
\seealso{
Other ranking functions:
\code{\link{ntile}()},
\code{\link{percent_rank}()}
}
\concept{ranking functions}
dplyr/man/coalesce.Rd 0000644 0001762 0000144 00000003201 14525503021 014215 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/coalesce.R
\name{coalesce}
\alias{coalesce}
\title{Find the first non-missing element}
\usage{
coalesce(..., .ptype = NULL, .size = NULL)
}
\arguments{
\item{...}{<\code{\link[rlang:dyn-dots]{dynamic-dots}}>
One or more vectors. These will be
\link[vctrs:theory-faq-recycling]{recycled} against each other, and will be
cast to their common type.}
\item{.ptype}{An optional prototype declaring the desired output type. If
supplied, this overrides the common type of the vectors in \code{...}.}
\item{.size}{An optional size declaring the desired output size. If supplied,
this overrides the common size of the vectors in \code{...}.}
}
\value{
A vector with the same type and size as the common type and common
size of the vectors in \code{...}.
}
\description{
Given a set of vectors, \code{coalesce()} finds the first non-missing value at
each position. It's inspired by the SQL \code{COALESCE} function which does the
same thing for SQL \code{NULL}s.
}
\examples{
# Use a single value to replace all missing values
x <- sample(c(1:5, NA, NA, NA))
coalesce(x, 0L)
# The equivalent to a missing value in a list is `NULL`
coalesce(list(1, 2, NULL), list(NA))
# Or generate a complete vector from partially missing pieces
y <- c(1, 2, NA, NA, 5)
z <- c(NA, NA, 3, 4, 5)
coalesce(y, z)
# Supply lists by splicing them into dots:
vecs <- list(
c(1, 2, NA, NA, 5),
c(NA, NA, 3, 4, 5)
)
coalesce(!!!vecs)
}
\seealso{
\code{\link[=na_if]{na_if()}} to replace specified values with an \code{NA}.
\code{\link[tidyr:replace_na]{tidyr::replace_na()}} to replace \code{NA} with a value.
}
dplyr/man/order_by.Rd 0000644 0001762 0000144 00000002101 13663216626 014260 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/order-by.R
\name{order_by}
\alias{order_by}
\title{A helper function for ordering window function output}
\usage{
order_by(order_by, call)
}
\arguments{
\item{order_by}{a vector to order_by}
\item{call}{a function call to a window function, where the first argument
is the vector being operated on}
}
\description{
This function makes it possible to control the ordering of window functions
in R that don't have a specific ordering parameter. When translated to SQL
it will modify the order clause of the OVER function.
}
\details{
This function works by changing the \code{call} to instead call
\code{\link[=with_order]{with_order()}} with the appropriate arguments.
}
\examples{
order_by(10:1, cumsum(1:10))
x <- 10:1
y <- 1:10
order_by(x, cumsum(y))
df <- data.frame(year = 2000:2005, value = (0:5) ^ 2)
scrambled <- df[sample(nrow(df)), ]
wrong <- mutate(scrambled, running = cumsum(value))
arrange(wrong, year)
right <- mutate(scrambled, running = order_by(year, cumsum(value)))
arrange(right, year)
}
dplyr/man/progress_estimated.Rd 0000644 0001762 0000144 00000003126 14266276767 016402 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/progress.R
\name{progress_estimated}
\alias{progress_estimated}
\title{Progress bar with estimated time.}
\usage{
progress_estimated(n, min_time = 0)
}
\arguments{
\item{n}{Total number of items}
\item{min_time}{Progress bar will wait until at least \code{min_time}
seconds have elapsed before displaying any results.}
}
\value{
A ref class with methods \code{tick()}, \code{print()},
\code{pause()}, and \code{stop()}.
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
This progress bar has been deprecated since providing progress bars is not
the responsibility of dplyr. Instead, you might try the more powerful
\href{https://github.com/r-lib/progress}{progress} package.
This reference class represents a text progress bar displayed estimated
time remaining. When finished, it displays the total duration. The
automatic progress bar can be disabled by setting option
\code{dplyr.show_progress} to \code{FALSE}.
}
\examples{
p <- progress_estimated(3)
p$tick()
p$tick()
p$tick()
p <- progress_estimated(3)
for (i in 1:3) p$pause(0.1)$tick()$print()
p <- progress_estimated(3)
p$tick()$print()$
pause(1)$stop()
# If min_time is set, progress bar not shown until that many
# seconds have elapsed
p <- progress_estimated(3, min_time = 3)
for (i in 1:3) p$pause(0.1)$tick()$print()
\dontrun{
p <- progress_estimated(10, min_time = 3)
for (i in 1:10) p$pause(0.5)$tick()$print()
}
}
\keyword{internal}
dplyr/man/defunct.Rd 0000644 0001762 0000144 00000002726 14366556340 014121 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/defunct.R
\name{defunct}
\alias{defunct}
\alias{id}
\alias{failwith}
\alias{select_vars}
\alias{rename_vars}
\alias{select_var}
\alias{current_vars}
\alias{bench_tbls}
\alias{compare_tbls}
\alias{compare_tbls2}
\alias{eval_tbls}
\alias{eval_tbls2}
\alias{location}
\alias{changes}
\title{Defunct functions}
\usage{
# Deprecated in 0.5.0 -------------------------------------
id(.variables, drop = FALSE)
# Deprecated in 0.7.0 -------------------------------------
failwith(default = NULL, f, quiet = FALSE)
# Deprecated in 0.8.* -------------------------------------
select_vars(vars = chr(), ..., include = chr(), exclude = chr())
rename_vars(vars = chr(), ..., strict = TRUE)
select_var(vars, var = -1)
current_vars(...)
# Deprecated in 1.0.0 -------------------------------------
bench_tbls(tbls, op, ..., times = 10)
compare_tbls(tbls, op, ref = NULL, compare = equal_data_frame, ...)
compare_tbls2(tbls_x, tbls_y, op, ref = NULL, compare = equal_data_frame, ...)
eval_tbls(tbls, op)
eval_tbls2(tbls_x, tbls_y, op)
location(df)
changes(x, y)
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#defunct}{\figure{lifecycle-defunct.svg}{options: alt='[Defunct]'}}}{\strong{[Defunct]}}
These functions were deprecated for at least two years before being
made defunct. If there's a known replacement, calling the function
will tell you about it.
}
\keyword{internal}
dplyr/man/se-deprecated.Rd 0000644 0001762 0000144 00000007432 14406402754 015167 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-lazyeval.R
\name{se-deprecated}
\alias{se-deprecated}
\alias{add_count_}
\alias{add_tally_}
\alias{arrange_}
\alias{count_}
\alias{distinct_}
\alias{do_}
\alias{filter_}
\alias{funs_}
\alias{group_by_}
\alias{group_indices_}
\alias{mutate_}
\alias{tally_}
\alias{transmute_}
\alias{rename_}
\alias{rename_vars_}
\alias{select_}
\alias{select_vars_}
\alias{slice_}
\alias{summarise_}
\alias{summarize_}
\title{Deprecated SE versions of main verbs.}
\usage{
add_count_(x, vars, wt = NULL, sort = FALSE)
add_tally_(x, wt, sort = FALSE)
arrange_(.data, ..., .dots = list())
count_(x, vars, wt = NULL, sort = FALSE, .drop = group_by_drop_default(x))
distinct_(.data, ..., .dots, .keep_all = FALSE)
do_(.data, ..., .dots = list())
filter_(.data, ..., .dots = list())
funs_(dots, args = list(), env = base_env())
group_by_(.data, ..., .dots = list(), add = FALSE)
group_indices_(.data, ..., .dots = list())
mutate_(.data, ..., .dots = list())
tally_(x, wt, sort = FALSE)
transmute_(.data, ..., .dots = list())
rename_(.data, ..., .dots = list())
rename_vars_(vars, args)
select_(.data, ..., .dots = list())
select_vars_(vars, args, include = chr(), exclude = chr())
slice_(.data, ..., .dots = list())
summarise_(.data, ..., .dots = list())
summarize_(.data, ..., .dots = list())
}
\arguments{
\item{x}{A \code{\link[=tbl]{tbl()}}}
\item{vars}{Various meanings depending on the verb.}
\item{wt}{<\code{\link[rlang:args_data_masking]{data-masking}}> Frequency weights.
Can be \code{NULL} or a variable:
\itemize{
\item If \code{NULL} (the default), counts the number of rows in each group.
\item If a variable, computes \code{sum(wt)} for each group.
}}
\item{sort}{If \code{TRUE}, will show the largest groups at the top.}
\item{.data}{A data frame.}
\item{.drop}{Drop groups formed by factor levels that don't appear in the
data? The default is \code{TRUE} except when \code{.data} has been previously
grouped with \code{.drop = FALSE}. See \code{\link[=group_by_drop_default]{group_by_drop_default()}} for details.}
\item{.keep_all}{If \code{TRUE}, keep all variables in \code{.data}.
If a combination of \code{...} is not distinct, this keeps the
first row of values.}
\item{dots, .dots, ...}{Pair/values of expressions coercible to lazy objects.}
\item{args}{Various meanings depending on the verb.}
\item{env}{The environment in which functions should be evaluated.}
\item{add}{When \code{FALSE}, the default, \code{group_by()} will
override existing groups. To add to the existing groups, use
\code{.add = TRUE}.
This argument was previously called \code{add}, but that prevented
creating a new grouping variable called \code{add}, and conflicts with
our naming conventions.}
\item{include, exclude}{Character vector of column names to always
include/exclude.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
dplyr used to offer twin versions of each verb suffixed with an
underscore. These versions had standard evaluation (SE) semantics:
rather than taking arguments by code, like NSE verbs, they took
arguments by value. Their purpose was to make it possible to
program with dplyr. However, dplyr now uses tidy evaluation
semantics. NSE verbs still capture their arguments, but you can now
unquote parts of these arguments. This offers full programmability
with NSE verbs. Thus, the underscored versions are now superfluous.
Unquoting triggers immediate evaluation of its operand and inlines
the result within the captured expression. This result can be a
value or an expression to be evaluated later with the rest of the
argument. See \code{vignette("programming")} for more information.
}
\keyword{internal}
dplyr/man/group_data.Rd 0000644 0001762 0000144 00000003550 14366556340 014612 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-data.R
\name{group_data}
\alias{group_data}
\alias{group_keys}
\alias{group_rows}
\alias{group_indices}
\alias{group_vars}
\alias{groups}
\alias{group_size}
\alias{n_groups}
\title{Grouping metadata}
\usage{
group_data(.data)
group_keys(.tbl, ...)
group_rows(.data)
group_indices(.data, ...)
group_vars(x)
groups(x)
group_size(x)
n_groups(x)
}
\arguments{
\item{.data, .tbl, x}{A data frame or extension (like a tibble or grouped
tibble).}
\item{...}{Use of \code{...} is now deprecated; please use \code{group_by()} first
instead.}
}
\description{
This collection of functions accesses data about grouped data frames in
various ways:
\itemize{
\item \code{group_data()} returns a data frame that defines the grouping structure.
The columns give the values of the grouping variables. The last column,
always called \code{.rows}, is a list of integer vectors that gives the
location of the rows in each group.
\item \code{group_keys()} returns a data frame describing the groups.
\item \code{group_rows()} returns a list of integer vectors giving the rows that
each group contains.
\item \code{group_indices()} returns an integer vector the same length as \code{.data}
that gives the group that each row belongs to.
\item \code{group_vars()} gives names of grouping variables as character vector.
\item \code{groups()} gives the names of the grouping variables as a list of symbols.
\item \code{group_size()} gives the size of each group.
\item \code{n_groups()} gives the total number of groups.
}
See \link{context} for equivalent functions that return values for the \emph{current}
group.
}
\examples{
df <- tibble(x = c(1,1,2,2))
group_vars(df)
group_rows(df)
group_data(df)
group_indices(df)
gf <- group_by(df, x)
group_vars(gf)
group_rows(gf)
group_data(gf)
group_indices(gf)
}
\keyword{internal}
dplyr/man/slice.Rd 0000644 0001762 0000144 00000017135 14472225345 013564 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/slice.R
\name{slice}
\alias{slice}
\alias{slice_head}
\alias{slice_tail}
\alias{slice_min}
\alias{slice_max}
\alias{slice_sample}
\title{Subset rows using their positions}
\usage{
slice(.data, ..., .by = NULL, .preserve = FALSE)
slice_head(.data, ..., n, prop, by = NULL)
slice_tail(.data, ..., n, prop, by = NULL)
slice_min(
.data,
order_by,
...,
n,
prop,
by = NULL,
with_ties = TRUE,
na_rm = FALSE
)
slice_max(
.data,
order_by,
...,
n,
prop,
by = NULL,
with_ties = TRUE,
na_rm = FALSE
)
slice_sample(.data, ..., n, prop, by = NULL, weight_by = NULL, replace = FALSE)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{For \code{slice()}: <\code{\link[rlang:args_data_masking]{data-masking}}>
Integer row values.
Provide either positive values to keep, or negative values to drop.
The values provided must be either all positive or all negative.
Indices beyond the number of rows in the input are silently ignored.
For \verb{slice_*()}, these arguments are passed on to methods.}
\item{.by, by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
\item{.preserve}{Relevant when the \code{.data} input is grouped.
If \code{.preserve = FALSE} (the default), the grouping structure
is recalculated based on the resulting data, otherwise the grouping is kept as is.}
\item{n, prop}{Provide either \code{n}, the number of rows, or \code{prop}, the
proportion of rows to select. If neither are supplied, \code{n = 1} will be
used. If \code{n} is greater than the number of rows in the group
(or \code{prop > 1}), the result will be silently truncated to the group size.
\code{prop} will be rounded towards zero to generate an integer number of
rows.
A negative value of \code{n} or \code{prop} will be subtracted from the group
size. For example, \code{n = -2} with a group of 5 rows will select 5 - 2 = 3
rows; \code{prop = -0.25} with 8 rows will select 8 * (1 - 0.25) = 6 rows.}
\item{order_by}{<\code{\link[rlang:args_data_masking]{data-masking}}> Variable or
function of variables to order by. To order by multiple variables, wrap
them in a data frame or tibble.}
\item{with_ties}{Should ties be kept together? The default, \code{TRUE},
may return more rows than you request. Use \code{FALSE} to ignore ties,
and return the first \code{n} rows.}
\item{na_rm}{Should missing values in \code{order_by} be removed from the result?
If \code{FALSE}, \code{NA} values are sorted to the end (like in \code{\link[=arrange]{arrange()}}), so
they will only be included if there are insufficient non-missing values to
reach \code{n}/\code{prop}.}
\item{weight_by}{<\code{\link[rlang:args_data_masking]{data-masking}}> Sampling
weights. This must evaluate to a vector of non-negative numbers the same
length as the input. Weights are automatically standardised to sum to 1.}
\item{replace}{Should sampling be performed with (\code{TRUE}) or without
(\code{FALSE}, the default) replacement.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Each row may appear 0, 1, or many times in the output.
\item Columns are not modified.
\item Groups are not modified.
\item Data frame attributes are preserved.
}
}
\description{
\code{slice()} lets you index rows by their (integer) locations. It allows you
to select, remove, and duplicate rows. It is accompanied by a number of
helpers for common use cases:
\itemize{
\item \code{slice_head()} and \code{slice_tail()} select the first or last rows.
\item \code{slice_sample()} randomly selects rows.
\item \code{slice_min()} and \code{slice_max()} select rows with the smallest or largest
values of a variable.
}
If \code{.data} is a \link{grouped_df}, the operation will be performed on each group,
so that (e.g.) \code{slice_head(df, n = 5)} will select the first five rows in
each group.
}
\details{
Slice does not work with relational databases because they have no
intrinsic notion of row order. If you want to perform the equivalent
operation, use \code{\link[=filter]{filter()}} and \code{\link[=row_number]{row_number()}}.
}
\section{Methods}{
These function are \strong{generic}s, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{slice()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice")}.
\item \code{slice_head()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice_head")}.
\item \code{slice_tail()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice_tail")}.
\item \code{slice_min()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice_min")}.
\item \code{slice_max()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice_max")}.
\item \code{slice_sample()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("slice_sample")}.
}
}
\examples{
# Similar to head(mtcars, 1):
mtcars \%>\% slice(1L)
# Similar to tail(mtcars, 1):
mtcars \%>\% slice(n())
mtcars \%>\% slice(5:n())
# Rows can be dropped with negative indices:
slice(mtcars, -(1:4))
# First and last rows based on existing order
mtcars \%>\% slice_head(n = 5)
mtcars \%>\% slice_tail(n = 5)
# Rows with minimum and maximum values of a variable
mtcars \%>\% slice_min(mpg, n = 5)
mtcars \%>\% slice_max(mpg, n = 5)
# slice_min() and slice_max() may return more rows than requested
# in the presence of ties.
mtcars \%>\% slice_min(cyl, n = 1)
# Use with_ties = FALSE to return exactly n matches
mtcars \%>\% slice_min(cyl, n = 1, with_ties = FALSE)
# Or use additional variables to break the tie:
mtcars \%>\% slice_min(tibble(cyl, mpg), n = 1)
# slice_sample() allows you to random select with or without replacement
mtcars \%>\% slice_sample(n = 5)
mtcars \%>\% slice_sample(n = 5, replace = TRUE)
# you can optionally weight by a variable - this code weights by the
# physical weight of the cars, so heavy cars are more likely to get
# selected
mtcars \%>\% slice_sample(weight_by = wt, n = 5)
# Group wise operation ----------------------------------------
df <- tibble(
group = rep(c("a", "b", "c"), c(1, 2, 4)),
x = runif(7)
)
# All slice helpers operate per group, silently truncating to the group
# size, so the following code works without error
df \%>\% group_by(group) \%>\% slice_head(n = 2)
# When specifying the proportion of rows to include non-integer sizes
# are rounded down, so group a gets 0 rows
df \%>\% group_by(group) \%>\% slice_head(prop = 0.5)
# Filter equivalents --------------------------------------------
# slice() expressions can often be written to use `filter()` and
# `row_number()`, which can also be translated to SQL. For many databases,
# you'll need to supply an explicit variable to use to compute the row number.
filter(mtcars, row_number() == 1L)
filter(mtcars, row_number() == n())
filter(mtcars, between(row_number(), 5, n()))
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{reframe}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/c_across.Rd 0000644 0001762 0000144 00000002172 14366556340 014260 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/across.R
\name{c_across}
\alias{c_across}
\title{Combine values from multiple columns}
\usage{
c_across(cols)
}
\arguments{
\item{cols}{<\code{\link[=dplyr_tidy_select]{tidy-select}}> Columns to transform.
You can't select grouping columns because they are already automatically
handled by the verb (i.e. \code{\link[=summarise]{summarise()}} or \code{\link[=mutate]{mutate()}}).}
}
\description{
\code{c_across()} is designed to work with \code{\link[=rowwise]{rowwise()}} to make it easy to
perform row-wise aggregations. It has two differences from \code{c()}:
\itemize{
\item It uses tidy select semantics so you can easily select multiple variables.
See \code{vignette("rowwise")} for more details.
\item It uses \code{\link[vctrs:vec_c]{vctrs::vec_c()}} in order to give safer outputs.
}
}
\examples{
df <- tibble(id = 1:4, w = runif(4), x = runif(4), y = runif(4), z = runif(4))
df \%>\%
rowwise() \%>\%
mutate(
sum = sum(c_across(w:z)),
sd = sd(c_across(w:z))
)
}
\seealso{
\code{\link[=across]{across()}} for a function that returns a tibble.
}
dplyr/man/rows.Rd 0000644 0001762 0000144 00000015420 14366556340 013456 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/rows.R
\name{rows}
\alias{rows}
\alias{rows_insert}
\alias{rows_append}
\alias{rows_update}
\alias{rows_patch}
\alias{rows_upsert}
\alias{rows_delete}
\title{Manipulate individual rows}
\usage{
rows_insert(
x,
y,
by = NULL,
...,
conflict = c("error", "ignore"),
copy = FALSE,
in_place = FALSE
)
rows_append(x, y, ..., copy = FALSE, in_place = FALSE)
rows_update(
x,
y,
by = NULL,
...,
unmatched = c("error", "ignore"),
copy = FALSE,
in_place = FALSE
)
rows_patch(
x,
y,
by = NULL,
...,
unmatched = c("error", "ignore"),
copy = FALSE,
in_place = FALSE
)
rows_upsert(x, y, by = NULL, ..., copy = FALSE, in_place = FALSE)
rows_delete(
x,
y,
by = NULL,
...,
unmatched = c("error", "ignore"),
copy = FALSE,
in_place = FALSE
)
}
\arguments{
\item{x, y}{A pair of data frames or data frame extensions (e.g. a tibble).
\code{y} must have the same columns of \code{x} or a subset.}
\item{by}{An unnamed character vector giving the key columns. The key columns
must exist in both \code{x} and \code{y}. Keys typically uniquely identify each row,
but this is only enforced for the key values of \code{y} when \code{rows_update()},
\code{rows_patch()}, or \code{rows_upsert()} are used.
By default, we use the first column in \code{y}, since the first column is
a reasonable place to put an identifier variable.}
\item{...}{Other parameters passed onto methods.}
\item{conflict}{For \code{rows_insert()}, how should keys in \code{y} that conflict
with keys in \code{x} be handled? A conflict arises if there is a key in \code{y}
that already exists in \code{x}.
One of:
\itemize{
\item \code{"error"}, the default, will error if there are any keys in \code{y} that
conflict with keys in \code{x}.
\item \code{"ignore"} will ignore rows in \code{y} with keys that conflict with keys in
\code{x}.
}}
\item{copy}{If \code{x} and \code{y} are not from the same data source,
and \code{copy} is \code{TRUE}, then \code{y} will be copied into the
same src as \code{x}. This allows you to join tables across srcs, but
it is a potentially expensive operation so you must opt into it.}
\item{in_place}{Should \code{x} be modified in place? This argument is only
relevant for mutable backends (e.g. databases, data.tables).
When \code{TRUE}, a modified version of \code{x} is returned invisibly;
when \code{FALSE}, a new object representing the resulting changes is returned.}
\item{unmatched}{For \code{rows_update()}, \code{rows_patch()}, and \code{rows_delete()},
how should keys in \code{y} that are unmatched by the keys in \code{x} be handled?
One of:
\itemize{
\item \code{"error"}, the default, will error if there are any keys in \code{y} that
are unmatched by the keys in \code{x}.
\item \code{"ignore"} will ignore rows in \code{y} with keys that are unmatched by the
keys in \code{x}.
}}
}
\value{
An object of the same type as \code{x}. The order of the rows and columns of \code{x}
is preserved as much as possible. The output has the following properties:
\itemize{
\item \code{rows_update()} and \code{rows_patch()} preserve the number of rows;
\code{rows_insert()}, \code{rows_append()}, and \code{rows_upsert()} return all existing
rows and potentially new rows; \code{rows_delete()} returns a subset of the
rows.
\item Columns are not added, removed, or relocated, though the data may be
updated.
\item Groups are taken from \code{x}.
\item Data frame attributes are taken from \code{x}.
}
If \code{in_place = TRUE}, the result will be returned invisibly.
}
\description{
These functions provide a framework for modifying rows in a table using a
second table of data. The two tables are matched \code{by} a set of key variables
whose values typically uniquely identify each row. The functions are inspired
by SQL's \code{INSERT}, \code{UPDATE}, and \code{DELETE}, and can optionally modify
\code{in_place} for selected backends.
\itemize{
\item \code{rows_insert()} adds new rows (like \code{INSERT}). By default, key values in
\code{y} must not exist in \code{x}.
\item \code{rows_append()} works like \code{rows_insert()} but ignores keys.
\item \code{rows_update()} modifies existing rows (like \code{UPDATE}). Key values in \code{y}
must be unique, and, by default, key values in \code{y} must exist in \code{x}.
\item \code{rows_patch()} works like \code{rows_update()} but only overwrites \code{NA} values.
\item \code{rows_upsert()} inserts or updates depending on whether or not the
key value in \code{y} already exists in \code{x}. Key values in \code{y} must be unique.
\item \code{rows_delete()} deletes rows (like \code{DELETE}). By default, key values in \code{y}
must exist in \code{x}.
}
}
\section{Methods}{
These function are \strong{generic}s, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
Methods available in currently loaded packages:
\itemize{
\item \code{rows_insert()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_insert")}.
\item \code{rows_append()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_append")}.
\item \code{rows_update()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_update")}.
\item \code{rows_patch()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_patch")}.
\item \code{rows_upsert()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_upsert")}.
\item \code{rows_delete()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("rows_delete")}.
}
}
\examples{
data <- tibble(a = 1:3, b = letters[c(1:2, NA)], c = 0.5 + 0:2)
data
# Insert
rows_insert(data, tibble(a = 4, b = "z"))
# By default, if a key in `y` matches a key in `x`, then it can't be inserted
# and will throw an error. Alternatively, you can ignore rows in `y`
# containing keys that conflict with keys in `x` with `conflict = "ignore"`,
# or you can use `rows_append()` to ignore keys entirely.
try(rows_insert(data, tibble(a = 3, b = "z")))
rows_insert(data, tibble(a = 3, b = "z"), conflict = "ignore")
rows_append(data, tibble(a = 3, b = "z"))
# Update
rows_update(data, tibble(a = 2:3, b = "z"))
rows_update(data, tibble(b = "z", a = 2:3), by = "a")
# Variants: patch and upsert
rows_patch(data, tibble(a = 2:3, b = "z"))
rows_upsert(data, tibble(a = 2:4, b = "z"))
# Delete and truncate
rows_delete(data, tibble(a = 2:3))
rows_delete(data, tibble(a = 2:3, b = "b"))
# By default, for update, patch, and delete it is an error if a key in `y`
# doesn't exist in `x`. You can ignore rows in `y` that have unmatched keys
# with `unmatched = "ignore"`.
y <- tibble(a = 3:4, b = "z")
try(rows_update(data, y, by = "a"))
rows_update(data, y, by = "a", unmatched = "ignore")
rows_patch(data, y, by = "a", unmatched = "ignore")
rows_delete(data, y, by = "a", unmatched = "ignore")
}
dplyr/man/context.Rd 0000644 0001762 0000144 00000003522 14366556340 014150 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/context.R
\name{context}
\alias{context}
\alias{n}
\alias{cur_group}
\alias{cur_group_id}
\alias{cur_group_rows}
\alias{cur_column}
\title{Information about the "current" group or variable}
\usage{
n()
cur_group()
cur_group_id()
cur_group_rows()
cur_column()
}
\description{
These functions return information about the "current" group or "current"
variable, so only work inside specific contexts like \code{\link[=summarise]{summarise()}} and
\code{\link[=mutate]{mutate()}}.
\itemize{
\item \code{n()} gives the current group size.
\item \code{cur_group()} gives the group keys, a tibble with one row and one column
for each grouping variable.
\item \code{cur_group_id()} gives a unique numeric identifier for the current group.
\item \code{cur_group_rows()} gives the row indices for the current group.
\item \code{cur_column()} gives the name of the current column (in \code{\link[=across]{across()}} only).
}
See \code{\link[=group_data]{group_data()}} for equivalent functions that return values for all
groups.
See \code{\link[=pick]{pick()}} for a way to select a subset of columns using tidyselect syntax
while inside \code{summarise()} or \code{mutate()}.
}
\section{data.table}{
If you're familiar with data.table:
\itemize{
\item \code{cur_group_id()} <-> \code{.GRP}
\item \code{cur_group()} <-> \code{.BY}
\item \code{cur_group_rows()} <-> \code{.I}
}
See \code{\link[=pick]{pick()}} for an equivalent to \code{.SD}.
}
\examples{
df <- tibble(
g = sample(rep(letters[1:3], 1:3)),
x = runif(6),
y = runif(6)
)
gf <- df \%>\% group_by(g)
gf \%>\% summarise(n = n())
gf \%>\% mutate(id = cur_group_id())
gf \%>\% reframe(row = cur_group_rows())
gf \%>\% summarise(data = list(cur_group()))
gf \%>\% mutate(across(everything(), ~ paste(cur_column(), round(.x, 2))))
}
dplyr/man/rmd/ 0000755 0001762 0000144 00000000000 14406402754 012747 5 ustar ligges users dplyr/man/rmd/select.Rmd 0000644 0001762 0000144 00000003033 14366556340 014677 0 ustar ligges users ```{r, include=FALSE}
# So the second library() call doesn't show messages
library(tidyverse)
```
Here we show the usage for the basic selection operators. See the
specific help pages to learn about helpers like [starts_with()].
The selection language can be used in functions like
`dplyr::select()` or `tidyr::pivot_longer()`. Let's first attach
the tidyverse:
```{r}
library(tidyverse)
# For better printing
iris <- as_tibble(iris)
```
Select variables by name:
```{r}
starwars %>% select(height)
iris %>% pivot_longer(Sepal.Length)
```
Select multiple variables by separating them with commas. Note how
the order of columns is determined by the order of inputs:
```{r}
starwars %>% select(homeworld, height, mass)
```
Functions like `tidyr::pivot_longer()` don't take variables with
dots. In this case use `c()` to select multiple variables:
```{r}
iris %>% pivot_longer(c(Sepal.Length, Petal.Length))
```
## Operators:
The `:` operator selects a range of consecutive variables:
```{r}
starwars %>% select(name:mass)
```
The `!` operator negates a selection:
```{r}
starwars %>% select(!(name:mass))
iris %>% select(!c(Sepal.Length, Petal.Length))
iris %>% select(!ends_with("Width"))
```
`&` and `|` take the intersection or the union of two selections:
```{r}
iris %>% select(starts_with("Petal") & ends_with("Width"))
iris %>% select(starts_with("Petal") | ends_with("Width"))
```
To take the difference between two selections, combine the `&` and
`!` operators:
```{r}
iris %>% select(starts_with("Petal") & !ends_with("Width"))
```
dplyr/man/rmd/by.Rmd 0000644 0001762 0000144 00000014670 14406402754 014035 0 ustar ligges users ---
output: html_document
editor_options:
chunk_output_type: console
---
```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```
There are two ways to group in dplyr:
- Persistent grouping with [group_by()]
- Per-operation grouping with `.by`/`by`
This help page is dedicated to explaining where and why you might want to use the latter.
Depending on the dplyr verb, the per-operation grouping argument may be named `.by` or `by`.
The *Supported verbs* section below outlines this on a case-by-case basis.
The remainder of this page will refer to `.by` for simplicity.
Grouping radically affects the computation of the dplyr verb you use it with, and one of the goals of `.by` is to allow you to place that grouping specification alongside the code that actually uses it.
As an added benefit, with `.by` you no longer need to remember to [ungroup()] after [summarise()], and `summarise()` won't ever message you about how it's handling the groups!
This idea comes from [data.table](https://CRAN.R-project.org/package=data.table), which allows you to specify `by` alongside modifications in `j`, like: `dt[, .(x = mean(x)), by = g]`.
### Supported verbs
- [`mutate(.by = )`][mutate()]
- [`summarise(.by = )`][summarise()]
- [`reframe(.by = )`][reframe()]
- [`filter(.by = )`][filter()]
- [`slice(.by = )`][slice()]
- [`slice_head(by = )`][slice_head()] and [`slice_tail(by = )`][slice_tail()]
- [`slice_min(by = )`][slice_min()] and [`slice_max(by = )`][slice_max()]
- [`slice_sample(by = )`][slice_sample()]
Note that some dplyr verbs use `by` while others use `.by`.
This is a purely technical difference.
### Differences between `.by` and `group_by()`
| `.by` | `group_by()` |
|---------------------------------------------------------|--------------------------------------------------------------------|
| Grouping only affects a single verb | Grouping is persistent across multiple verbs |
| Selects variables with [tidy-select][dplyr_tidy_select] | Computes expressions with [data-masking][rlang::args_data_masking] |
| Summaries use existing order of group keys | Summaries sort group keys in ascending order |
### Using `.by`
Let's take a look at the two grouping approaches using this `expenses` data set, which tracks costs accumulated across various `id`s and `region`s:
```{r}
expenses <- tibble(
id = c(1, 2, 1, 3, 1, 2, 3),
region = c("A", "A", "A", "B", "B", "A", "A"),
cost = c(25, 20, 19, 12, 9, 6, 6)
)
expenses
```
Imagine that you wanted to compute the average cost per region.
You'd probably write something like this:
```{r}
expenses %>%
group_by(region) %>%
summarise(cost = mean(cost))
```
Instead, you can now specify the grouping *inline* within the verb:
```{r}
expenses %>%
summarise(cost = mean(cost), .by = region)
```
`.by` applies to a single operation, meaning that since `expenses` was an ungrouped data frame, the result after applying `.by` will also always be an ungrouped data frame, regardless of the number of grouping columns.
```{r}
expenses %>%
summarise(cost = mean(cost), .by = c(id, region))
```
Compare that with `group_by() %>% summarise()`, where `summarise()` generally peels off 1 layer of grouping by default, typically with a message that it is doing so:
```{r}
expenses %>%
group_by(id, region) %>%
summarise(cost = mean(cost))
```
Because `.by` grouping applies to a single operation, you don't need to worry about ungrouping, and it never needs to emit a message to remind you what it is doing with the groups.
Note that with `.by` we specified multiple columns to group by using the [tidy-select][dplyr_tidy_select] syntax `c(id, region)`.
If you have a character vector of column names you'd like to group by, you can do so with `.by = all_of(my_cols)`.
It will group by the columns in the order they were provided.
To prevent surprising results, you can't use `.by` on an existing grouped data frame:
```{r, error=TRUE}
expenses %>%
group_by(id) %>%
summarise(cost = mean(cost), .by = c(id, region))
```
So far we've focused on the usage of `.by` with `summarise()`, but `.by` works with a number of other dplyr verbs.
For example, you could append the mean cost per region onto the original data frame as a new column rather than computing a summary:
```{r}
expenses %>%
mutate(cost_by_region = mean(cost), .by = region)
```
Or you could slice out the maximum cost per combination of id and region:
```{r}
# Note that the argument is named `by` in `slice_max()`
expenses %>%
slice_max(cost, n = 1, by = c(id, region))
```
### Result ordering
When used with `.by`, `summarise()`, `reframe()`, and `slice()` all maintain the ordering of the existing data.
This is different from `group_by()`, which has always sorted the group keys in ascending order.
```{r}
df <- tibble(
month = c("jan", "jan", "feb", "feb", "mar"),
temp = c(20, 25, 18, 20, 40)
)
# Uses ordering by "first appearance" in the original data
df %>%
summarise(average_temp = mean(temp), .by = month)
# Sorts in ascending order
df %>%
group_by(month) %>%
summarise(average_temp = mean(temp))
```
If you need sorted group keys, we recommend that you explicitly use [arrange()] either before or after the call to `summarise()`, `reframe()`, or `slice()`.
This also gives you full access to all of `arrange()`'s features, such as `desc()` and the `.locale` argument.
### Verbs without `.by` support
If a dplyr verb doesn't support `.by`, then that typically means that the verb isn't inherently affected by grouping.
For example, [pull()] and [rename()] don't support `.by`, because specifying columns to group by would not affect their implementations.
That said, there are a few exceptions to this where sometimes a dplyr verb doesn't support `.by`, but *does* have special support for grouped data frames created by [group_by()].
This is typically because the verbs are required to retain the grouping columns, for example:
- [select()] always retains grouping columns, with a message if any aren't specified in the `select()` call.
- [distinct()] and [count()] place unspecified grouping columns at the front of the data frame before computing their results.
- [arrange()] has a `.by_group` argument to optionally order by grouping columns first.
If `group_by()` didn't exist, then these verbs would not have special support for grouped data frames.
dplyr/man/rmd/overview.Rmd 0000644 0001762 0000144 00000003003 14366556340 015263 0 ustar ligges users
Tidyverse selections implement a dialect of R where operators make
it easy to select variables:
- `:` for selecting a range of consecutive variables.
- `!` for taking the complement of a set of variables.
- `&` and `|` for selecting the intersection or the union of two
sets of variables.
- `c()` for combining selections.
In addition, you can use __selection helpers__. Some helpers select specific
columns:
* [`everything()`][tidyselect::everything]: Matches all variables.
* [`last_col()`][tidyselect::last_col]: Select last variable, possibly with an offset.
* [group_cols()]: Select all grouping columns.
Other helpers select variables by matching patterns in their names:
* [`starts_with()`][tidyselect::starts_with]: Starts with a prefix.
* [`ends_with()`][tidyselect::ends_with()]: Ends with a suffix.
* [`contains()`][tidyselect::contains()]: Contains a literal string.
* [`matches()`][tidyselect::matches()]: Matches a regular expression.
* [`num_range()`][tidyselect::num_range()]: Matches a numerical range like x01, x02, x03.
Or from variables stored in a character vector:
* [`all_of()`][tidyselect::all_of()]: Matches variable names in a character vector. All
names must be present, otherwise an out-of-bounds error is
thrown.
* [`any_of()`][tidyselect::any_of()]: Same as `all_of()`, except that no error is thrown
for names that don't exist.
Or using a predicate function:
* [`where()`][tidyselect::where()]: Applies a function to all variables and selects those
for which the function returns `TRUE`.
dplyr/man/distinct.Rd 0000644 0001762 0000144 00000005126 14406402754 014301 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/distinct.R
\name{distinct}
\alias{distinct}
\title{Keep distinct/unique rows}
\usage{
distinct(.data, ..., .keep_all = FALSE)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}> Optional variables to
use when determining uniqueness. If there are multiple rows for a given
combination of inputs, only the first row will be preserved. If omitted,
will use all variables in the data frame.}
\item{.keep_all}{If \code{TRUE}, keep all variables in \code{.data}.
If a combination of \code{...} is not distinct, this keeps the
first row of values.}
}
\value{
An object of the same type as \code{.data}. The output has the following
properties:
\itemize{
\item Rows are a subset of the input but appear in the same order.
\item Columns are not modified if \code{...} is empty or \code{.keep_all} is \code{TRUE}.
Otherwise, \code{distinct()} first calls \code{mutate()} to create new columns.
\item Groups are not modified.
\item Data frame attributes are preserved.
}
}
\description{
Keep only unique/distinct rows from a data frame. This is similar
to \code{\link[=unique.data.frame]{unique.data.frame()}} but considerably faster.
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("distinct")}.
}
\examples{
df <- tibble(
x = sample(10, 100, rep = TRUE),
y = sample(10, 100, rep = TRUE)
)
nrow(df)
nrow(distinct(df))
nrow(distinct(df, x, y))
distinct(df, x)
distinct(df, y)
# You can choose to keep all other variables as well
distinct(df, x, .keep_all = TRUE)
distinct(df, y, .keep_all = TRUE)
# You can also use distinct on computed variables
distinct(df, diff = abs(x - y))
# Use `pick()` to select columns with tidy-select
distinct(starwars, pick(contains("color")))
# Grouping -------------------------------------------------
df <- tibble(
g = c(1, 1, 2, 2, 2),
x = c(1, 1, 2, 1, 2),
y = c(3, 2, 1, 3, 1)
)
df <- df \%>\% group_by(g)
# With grouped data frames, distinctness is computed within each group
df \%>\% distinct(x)
# When `...` are omitted, `distinct()` still computes distinctness using
# all variables in the data frame
df \%>\% distinct()
}
dplyr/man/bind_rows.Rd 0000644 0001762 0000144 00000002513 14366556340 014451 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/bind-rows.R
\name{bind_rows}
\alias{bind_rows}
\alias{bind}
\title{Bind multiple data frames by row}
\usage{
bind_rows(..., .id = NULL)
}
\arguments{
\item{...}{Data frames to combine. Each argument can either be a data frame,
a list that could be a data frame, or a list of data frames. Columns are
matched by name, and any missing columns will be filled with \code{NA}.}
\item{.id}{The name of an optional identifier column. Provide a string to
create an output column that identifies each input. The column will use
names if available, otherwise it will use positions.}
}
\value{
A data frame the same type as the first element of \code{...}.
}
\description{
Bind any number of data frames by row, making a longer result. This is
similar to \code{do.call(rbind, dfs)}, but the output will contain all columns
that appear in any of the inputs.
}
\examples{
df1 <- tibble(x = 1:2, y = letters[1:2])
df2 <- tibble(x = 4:5, z = 1:2)
# You can supply individual data frames as arguments:
bind_rows(df1, df2)
# Or a list of data frames:
bind_rows(list(df1, df2))
# When you supply a column name with the `.id` argument, a new
# column is created to link each row to its original data frame
bind_rows(list(df1, df2), .id = "id")
bind_rows(list(a = df1, b = df2), .id = "id")
}
dplyr/man/all_vars.Rd 0000644 0001762 0000144 00000002406 14406402754 014261 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/colwise.R
\name{all_vars}
\alias{all_vars}
\alias{any_vars}
\title{Apply predicate to all variables}
\usage{
all_vars(expr)
any_vars(expr)
}
\arguments{
\item{expr}{<\code{\link[rlang:args_data_masking]{data-masking}}> An expression that
returns a logical vector, using \code{.} to refer to the "current" variable.}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#superseded}{\figure{lifecycle-superseded.svg}{options: alt='[Superseded]'}}}{\strong{[Superseded]}}
\code{all_vars()} and \code{any_vars()} were only needed for the scoped verbs, which
have been superseded by the use of \code{\link[=across]{across()}} in an existing verb. See
\code{vignette("colwise")} for details.
These quoting functions signal to scoped filtering verbs
(e.g. \code{\link[=filter_if]{filter_if()}} or \code{\link[=filter_all]{filter_all()}}) that a predicate expression
should be applied to all relevant variables. The \code{all_vars()}
variant takes the intersection of the predicate expressions with
\code{&} while the \code{any_vars()} variant takes the union with \code{|}.
}
\seealso{
\code{\link[=vars]{vars()}} for other quoting functions that you
can use with scoped verbs.
}
dplyr/man/reframe.Rd 0000644 0001762 0000144 00000011150 14406402754 014073 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/reframe.R
\name{reframe}
\alias{reframe}
\title{Transform each group to an arbitrary number of rows}
\usage{
reframe(.data, ..., .by = NULL)
}
\arguments{
\item{.data}{A data frame, data frame extension (e.g. a tibble), or a
lazy data frame (e.g. from dbplyr or dtplyr). See \emph{Methods}, below, for
more details.}
\item{...}{<\code{\link[rlang:args_data_masking]{data-masking}}>
Name-value pairs of functions. The name will be the name of the variable in
the result. The value can be a vector of any length.
Unnamed data frame values add multiple columns from a single expression.}
\item{.by}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
<\code{\link[=dplyr_tidy_select]{tidy-select}}> Optionally, a selection of columns to
group by for just this operation, functioning as an alternative to \code{\link[=group_by]{group_by()}}. For
details and examples, see \link[=dplyr_by]{?dplyr_by}.}
}
\value{
If \code{.data} is a tibble, a tibble. Otherwise, a data.frame.
\itemize{
\item The rows originate from the underlying grouping keys.
\item The columns are a combination of the grouping keys and the
expressions that you provide.
\item The output is always ungrouped.
\item Data frame attributes are \strong{not} preserved, because \code{reframe()}
fundamentally creates a new data frame.
}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
While \code{\link[=summarise]{summarise()}} requires that each argument returns a single value, and
\code{\link[=mutate]{mutate()}} requires that each argument returns the same number of rows as the
input, \code{reframe()} is a more general workhorse with no requirements on the
number of rows returned per group.
\code{reframe()} creates a new data frame by applying functions to columns of an
existing data frame. It is most similar to \code{summarise()}, with two big
differences:
\itemize{
\item \code{reframe()} can return an arbitrary number of rows per group, while
\code{summarise()} reduces each group down to a single row.
\item \code{reframe()} always returns an ungrouped data frame, while \code{summarise()}
might return a grouped or rowwise data frame, depending on the scenario.
}
We expect that you'll use \code{summarise()} much more often than \code{reframe()}, but
\code{reframe()} can be particularly helpful when you need to apply a complex
function that doesn't return a single summary value.
}
\section{Connection to tibble}{
\code{reframe()} is theoretically connected to two functions in tibble,
\code{\link[tibble:enframe]{tibble::enframe()}} and \code{\link[tibble:enframe]{tibble::deframe()}}:
\itemize{
\item \code{enframe()}: vector -> data frame
\item \code{deframe()}: data frame -> vector
\item \code{reframe()}: data frame -> data frame
}
}
\section{Methods}{
This function is a \strong{generic}, which means that packages can provide
implementations (methods) for other classes. See the documentation of
individual methods for extra arguments and differences in behaviour.
The following methods are currently available in loaded packages:
\Sexpr[stage=render,results=rd]{dplyr:::methods_rd("reframe")}.
}
\examples{
table <- c("a", "b", "d", "f")
df <- tibble(
g = c(1, 1, 1, 2, 2, 2, 2),
x = c("e", "a", "b", "c", "f", "d", "a")
)
# `reframe()` allows you to apply functions that return
# an arbitrary number of rows
df \%>\%
reframe(x = intersect(x, table))
# Functions are applied per group, and each group can return a
# different number of rows.
df \%>\%
reframe(x = intersect(x, table), .by = g)
# The output is always ungrouped, even when using `group_by()`
df \%>\%
group_by(g) \%>\%
reframe(x = intersect(x, table))
# You can add multiple columns at once using a single expression by returning
# a data frame.
quantile_df <- function(x, probs = c(0.25, 0.5, 0.75)) {
tibble(
val = quantile(x, probs, na.rm = TRUE),
quant = probs
)
}
x <- c(10, 15, 18, 12)
quantile_df(x)
starwars \%>\%
reframe(quantile_df(height))
starwars \%>\%
reframe(quantile_df(height), .by = homeworld)
starwars \%>\%
reframe(
across(c(height, mass), quantile_df, .unpack = TRUE),
.by = homeworld
)
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/new_grouped_df.Rd 0000644 0001762 0000144 00000003152 14366556340 015452 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/grouped-df.R, R/rowwise.R
\name{new_grouped_df}
\alias{new_grouped_df}
\alias{validate_grouped_df}
\alias{new_rowwise_df}
\alias{validate_rowwise_df}
\title{Low-level construction and validation for the grouped_df and rowwise_df classes}
\usage{
new_grouped_df(x, groups, ..., class = character())
validate_grouped_df(x, check_bounds = FALSE)
new_rowwise_df(data, group_data = NULL, ..., class = character())
validate_rowwise_df(x)
}
\arguments{
\item{x}{A data frame}
\item{groups}{The grouped structure, \code{groups} should be a data frame.
Its last column should be called \code{.rows} and be
a list of 1 based integer vectors that all are between 1 and the number of rows of \code{.data}.}
\item{...}{additional attributes}
\item{class}{additional class, will be prepended to canonical classes.}
\item{check_bounds}{whether to check all indices for out of bounds problems in \code{grouped_df} objects}
}
\description{
\code{new_grouped_df()} and \code{new_rowwise_df()} are constructors designed to be high-performance so only
check types, not values. This means it is the caller's responsibility
to create valid values, and hence this is for expert use only.
\code{validate_grouped_df()} and \code{validate_rowwise_df()} validate the attributes
of a \code{grouped_df} or a \code{rowwise_df}.
}
\examples{
# 5 bootstrap samples
tbl <- new_grouped_df(
tibble(x = rnorm(10)),
groups = tibble(".rows" := replicate(5, sample(1:10, replace = TRUE), simplify = FALSE))
)
# mean of each bootstrap sample
summarise(tbl, x = mean(x))
}
\keyword{internal}
dplyr/man/band_members.Rd 0000644 0001762 0000144 00000001665 13663216626 015107 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/data-bands.R
\docType{data}
\name{band_members}
\alias{band_members}
\alias{band_instruments}
\alias{band_instruments2}
\title{Band membership}
\format{
Each is a tibble with two variables and three observations
}
\usage{
band_members
band_instruments
band_instruments2
}
\description{
These data sets describe band members of the Beatles and Rolling Stones. They
are toy data sets that can be displayed in their entirety on a slide (e.g. to
demonstrate a join).
}
\details{
\code{band_instruments} and \code{band_instruments2} contain the same data but use
different column names for the first column of the data set.
\code{band_instruments} uses \code{name}, which matches the name of the key column of
\code{band_members}; \code{band_instruments2} uses \code{artist}, which does not.
}
\examples{
band_members
band_instruments
band_instruments2
}
\keyword{datasets}
dplyr/man/common_by.Rd 0000644 0001762 0000144 00000000422 14277513434 014440 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/join-common-by.R
\name{common_by}
\alias{common_by}
\title{Extract out common by variables}
\usage{
common_by(by = NULL, x, y)
}
\description{
Extract out common by variables
}
\keyword{internal}
dplyr/man/group_by_drop_default.Rd 0000644 0001762 0000144 00000001240 14366556340 017035 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/group-by.R
\name{group_by_drop_default}
\alias{group_by_drop_default}
\title{Default value for .drop argument of group_by}
\usage{
group_by_drop_default(.tbl)
}
\arguments{
\item{.tbl}{A data frame}
}
\value{
\code{TRUE} unless \code{.tbl} is a grouped data frame that was previously
obtained by \code{group_by(.drop = FALSE)}
}
\description{
Default value for .drop argument of group_by
}
\examples{
group_by_drop_default(iris)
iris \%>\%
group_by(Species) \%>\%
group_by_drop_default()
iris \%>\%
group_by(Species, .drop = FALSE) \%>\%
group_by_drop_default()
}
\keyword{internal}
dplyr/DESCRIPTION 0000644 0001762 0000144 00000004114 14525714672 013127 0 ustar ligges users Type: Package
Package: dplyr
Title: A Grammar of Data Manipulation
Version: 1.1.4
Authors@R: c(
person("Hadley", "Wickham", , "hadley@posit.co", role = c("aut", "cre"),
comment = c(ORCID = "0000-0003-4757-117X")),
person("Romain", "François", role = "aut",
comment = c(ORCID = "0000-0002-2444-4226")),
person("Lionel", "Henry", role = "aut"),
person("Kirill", "Müller", role = "aut",
comment = c(ORCID = "0000-0002-1416-3412")),
person("Davis", "Vaughan", , "davis@posit.co", role = "aut",
comment = c(ORCID = "0000-0003-4777-038X")),
person("Posit Software, PBC", role = c("cph", "fnd"))
)
Description: A fast, consistent tool for working with data frame like
objects, both in memory and out of memory.
License: MIT + file LICENSE
URL: https://dplyr.tidyverse.org, https://github.com/tidyverse/dplyr
BugReports: https://github.com/tidyverse/dplyr/issues
Depends: R (>= 3.5.0)
Imports: cli (>= 3.4.0), generics, glue (>= 1.3.2), lifecycle (>=
1.0.3), magrittr (>= 1.5), methods, pillar (>= 1.9.0), R6,
rlang (>= 1.1.0), tibble (>= 3.2.0), tidyselect (>= 1.2.0),
utils, vctrs (>= 0.6.4)
Suggests: bench, broom, callr, covr, DBI, dbplyr (>= 2.2.1), ggplot2,
knitr, Lahman, lobstr, microbenchmark, nycflights13, purrr,
rmarkdown, RMySQL, RPostgreSQL, RSQLite, stringi (>= 1.7.6),
testthat (>= 3.1.5), tidyr (>= 1.3.0), withr
VignetteBuilder: knitr
Config/Needs/website: tidyverse, shiny, pkgdown, tidyverse/tidytemplate
Config/testthat/edition: 3
Encoding: UTF-8
LazyData: true
RoxygenNote: 7.2.3
NeedsCompilation: yes
Packaged: 2023-11-16 21:48:56 UTC; hadleywickham
Author: Hadley Wickham [aut, cre] (),
Romain François [aut] (),
Lionel Henry [aut],
Kirill Müller [aut] (),
Davis Vaughan [aut] (),
Posit Software, PBC [cph, fnd]
Maintainer: Hadley Wickham
Repository: CRAN
Date/Publication: 2023-11-17 16:50:02 UTC
dplyr/build/ 0000755 0001762 0000144 00000000000 14525507110 012503 5 ustar ligges users dplyr/build/vignette.rds 0000644 0001762 0000144 00000000662 14525507110 015046 0 ustar ligges users R0CȏHGDy
6 ۤvĴ-)d|{OᣋrPm ՏPo-<:B%Ix [0c5 p'-p"Xl 'ƱI~'Evԥ2+ mx1 _|e?8ׂ=0" WRiQ+* 9H E Kf X6;SZ\t/*B9 mU`źsWYгm
ܳ>N+^֥*\C@S-z kU V 9\n`1o97:5 5 N"
yi
SMQ} ) W˄zsY_/[oxUHQSkէ?: dplyr/build/stage23.rdb 0000644 0001762 0000144 00000354743 14525507072 014473 0 ustar ligges users | ɚ'%H IL< P n$HHv$GwnGfU%lVU=;3CҮмfd{w%Kvf-Kc-XYmYZYZKk= KZI_?
,wT }a֯3z֓3ga'<-u/q]=+Kfa7+vYrͪv %Z2
=nz\zXc͇ Tj,9swyqK?:wx̹dV^" 1Q+
_Ԣuџk
Oo;r&8CSGeKn^8ntF!m5=Kx
)e%GɟQ&ZH}zRH ȐJLu$&8y0{PC J ,U6nzn OIw p\a(dދ&ۑXaﬞP 0 Գ*!ypGz?JzB}ݽYtJ\u !<FUNPNj~٫ Tw͇n'
bģX,'QXΙ|>bs5sƜ0Pf:S+> # I-!WX?A3I^RTbKn)%u*[ ō އ|_cKYŤEEٸߩԌHֱt&?FfSԸ1+%+|{ri$N&9N67]i48feNPs뙖h )ٲuus+f@y"[
HϛOl͍jzY&fKkik<6>+dCÁY뜹zfETf)U\6Kv`9e?/H1k_g ;]I`q] %?Y؆3>;$݈p>}yo{9]Co]J3Z艊b g hNe*˾ǥnfB+.-/(K/4 <)UxUUtKIN%%7 Y?j)mWO-ϱB'C
6ׁ!?Tfup^-m`.3_عjcjߦ%M/@Бzv?yK N@Z&IQ?|?k}lC%nWiOo@2M.K0ܜ`}\ 7{̡>aP1vkL
%AP
.S.ȻzT ?fiSD 0Ýovsϑ&*)Vo|Ńwĭ`ޜʎ-QceÌ]&8BZ^mC |K h{`1/)؋C
$ψBB] `K (.YU l\-}x"e:b[ ⑤c7sg4tui"ڥNja"t f@ \/gK4C`Aάm- @n`rN֏ Q9:kid1^KzlLCM
x=mɶb\,lFf8*jd%Ͱrh%IBy@62mNH9 9 whbsgUZG|Į
{xaQnDi )rSY;6pa3̖f+y;l ƕ7y뎇Qڥ,
L.,# eEH^C^ w@ץ6J _wcu0VZ}ZNUa' ?SXrÊHQ+Ҫ(BR Oy
,( d
V9%8 7%# F5+u3kB$l<1>
XJCdu/LGoCQ MenUfΗ;Zc|F[$5D\ bA¬Yr%~YRF88\5?! Mny,bCUWPޕM.Jo3z n_e-ᷞ;MښR Wr 8YYs\)#SՃ !6zP]rJl~="ɭ5
iQF\pF; OBz?oɣM
2g(f$,K0Ymkrye>̒`{am|Q|5=r&U(IyɢMkh2h$\> Fc.BLi- x8D1UΫ/ UlϤ_x#Ep"Tnq (S5 ̲-Y;!>s\q6EN
>vh^):AH&bhCE9z5K0KCmCɜ#ZWI |tOj#e "ȼ"DN%֪3wצɒ莦a[Xd[->85\x!4>`MlM}ts!]P) "s8yD[
}\.(Qe5B).۪:|U]"}~. +(k됯6MGR*Nq̮- @wkM CS7^F })%++uûߕN`#2"F7£* -̼2aFJ5_= Q|QX ?`GȝUdzL_l^x |DQYlŭ~.: N6+*sOe9}%z'm`/o)35 =1ʶؕg\cB~b{Aea_'akuBQ"עkV߳*0\sSZyA[0^ĭhPť_%lyw)4 nV9bb.aJ
AȃʔqEw}O^ #B.讪W=a"/8adu*ck9ڢxqY`Fo H;F=Qv1K蹾?6.{YsH@[l/n=>),lA:ꭹ9~KOȲ/fG%xNBT|ag(!uKpPidb}y-i%$bE= ʏ~Y5s(z!DʀKӦ(%PmЉ ؞ 7LjFw@ޡ͚SðRr D`p7G=Ar(}7J=X'_ 49~m
U.W0ǯ:jO= m=9:K++nY#WW֑mMC lzvU40G 2̱lt,nL2̱lt,j`U[X4+0JMsdkc˦Y9V:jSm4FFrN[fX5/P*FVӐt,,
kۤ*eVQ3=_eJ _:]Xb-&1ta.Jn[ *5 b" !yy[~h=&L׀]oEux$kg{ܱzO߷hґ ds-HIy 0"k!z ҌmC6a;n-!PޑF;!ؓiYom6f26'R+~iw = s}yh)Հ8Vƽ5'umi{;R KVm_8txg*NVM mxޭqzr>ھqd nfULRl u wl|Ӫvg.wy}p{כ;㚭XXYA[FKݺWL16xvi fvfZx!TVߪݴ#r&<{jd˫ݲ@-nXr-Kx1Om6?evvWoZbYZ ől ۻ֮&^a n9A eC[Vw~ ]՜P%yr){jgښ涤Uu N~ o [E+$5ٍšv> [|p@i0NՁ?y_z_/WALKnezzqHZ3#K 2w6-4GrH~qͳs7hDL RM^7|7=>z 6c,><[u䰾' &? %|܄U>8?؎n_<{qi2gN+~طԦ&k v!A683w' 3%`3[,dݬ
as+Rv =2B+VXYg/ = =hHF#`ڕ!y"o=?2O>| Kc~7J{w#!!g/B.<>H31C1;zrM> l7 >`R 9|w)j$}wDXtAG'΄.Y̝Ojr>! [Oφ4r5NARפqcTOQ^ؘ4ߨ;
/zTl(^FM"߂-mm[U{{@OYH8F o Kp=n>*ȗZk j>DN2A? &FTԅK/#A#qk;
*T]h RƳɮB ^%xj7!KMbt N6Iy):=lX'\nd#ދQN6NZFl"6p6RpS/dKCI)l& smFMX wV߮ފ ^h09Qc*: d1J>! ImzW:;m7'?Ų
؛AC}ԯT H;FS LjSJMc5p#CpӍL!XHx$Pfzuoi; llsub*GM`Wi C
Bl(re1|hmEÛXG\풇 |m/
t8d\"h ^M~ c-5
[siWat,Q8;Qqq%x qeEu4by8Yi#0>9syiOpqZV1$ Fgj>* yg5i)S
NB*ϡ&1R)btݱ)p
t} ujHIjgZF-{ Qd$6O!}G!j.T5w
\i73 ̰Rrn\J/fŚKa5w<2t]m*L RuHRr@n%K"w!}ե! MKtԱ\,?ڡ7Kz8#W(IR
+"#_aF(]Xj4Hv+F6m"cws̳]w]ZۄG|f-g"ij ">m2ެ |Dm< YjN7MȦHɝEe! )V 9H]0%
zx7kegxlt xMe5c;s'U]!V_BRyΒ^,>c2X$,+,PwMLuK#FW;*JC*dl2Y7d!<ܶ=F._{} }mBо6A8R <rөwW[ %L8*IY*X \vLUFJ5U`}N*Y ֗J;*yK>EHJ'o ֧7CxG^.W$CkYZ2>$uFOqGRg=Lf(dQf3=N 0ݍ=|ؽ#doƔ!i*ZSJ[ IKjlk%m&tt +7Y %öhS:1vt7TcK
:
Y_K |f
(de?x
:h}
S6rXdGЖۣ'C KVUwC(K!dRVy#=:pŪ' Tv #j@v#k pA =F !Ӷ&mME*%oܳerhB6 QG2 ,ykV=/t" )M@#FK nUY`|+E]ކ|[YQ}Ul$ h @~L5Ju)N;۸dfQ} ɚ["jr.GU "FnjkmFՕ! C7Nau'!OfoGx4~}vJXݬ-auU:lPϲFe
@/U-KP({a3[ ofk]
Yn!oj#L d6=_uFo҈ N+Ϻt>#-Ay p:_oƪDe!C6h9o1_r8y]%w<[~ EH ?2g,+N ݦzsyvjHp >l2YOrwY?<@s}WSw]xo* VĪ9N9#A#9>|G=mƪ[9ߝWCޞV( V3!KObv|ҍfJ~'m RjIj1R; ZwղQM-=5yK˕f {3Wؑ j ΛHH ɯ NXW(ɃYY[v ZVU:}ƚ
h\R@x.+H?;VgNBd!_ٕRJ灳F#rf.s4%s*G) o"p'L()+-!(Aȃ78@rr2Btpsd&Y[ d)OKz(x jg6HKdm: De?Cd0:eG[2j9<6#!,tr8Y}g8>^DNQUd9Ѳ[V䇯Б)AF;"m3]Ng솒0w
NQM Hhwou:Eq6Lsf Ȅ!
2N]
iѤ2mMd,S
L>u;?%; Y}NK*
dMDйQh1Eu/ )9i2 g܉
o:AU4lKZ)Zm.[XGo&C3]lc-toCllL*aiD[O5'"15BEd oc42dJ͓n==%'t`
b*ZQEx 'e1䏕32dɭKY\<؞l-bd;M#~?aP3)**lzU QQ֊ó8:М
Vj@DmͣAIH cpV&iY;T+#͑sv H!I B &N!ׂqmFcoz7)I+
< dJ. TvAS\aV]t z 撈q3K %m)}
ֺ!Ex\OڹvȻ]?n,UP&u3ϔm C6NhI"8y6DmBںER.,?yĨ۾ĩmuSQ=c\nwQef^Py _bE,R93mqKl%?4y`R˛(7E82:@ zK2cd_UvC!=ho[TÞl/bU%neC@ne\AN43Ap63A=ne$|+CQ>ڊ XKz,Gí y-52cխ |[(][$ԩ[1` ls+$lpڕ[@0V3H:F=MN2wo(CV.l#. P*7!ߔAoi!Qz^بU áDځJ'ub#܍VٙQsťo^Zx2
eH6uzmԼEi wH6,4 #=l
{Y\\sG0r.Nsq
a7"EE^dؕa}TuJ1c}/]6ᖣQQa62aA2* eՋJEK?/,HT0."Y;fkHB*N$7ci'& jjQᮇPm4:s('t0
iSuhp҈8id5Г% OsǫC ֘lWQϞR![J
l v.nnh~fz7a!Q܄!1UzRjOAY)R&,(U):؛ 1$ iC[FW [Qj^+744' ,`Vv-HI|ˬurňG VHܲ!cח#ݐ iU:lfö+č9qFfCԸoѲD4$|RMH) ASmw!u*jBFmEC嫐f)u*$e]Ub7V*$|S{9]C/uьZ艊rmB g hNk 땭-/(/s0 <)UxUev2Ex
TRm \ѪO?2u6_%cTi3Y4z~2%vNLǙβ] rnJƛMZӦ Z^a ئ8q#x ˩[q.Iݱij]g$IC4&k Y7Cz;(C |_>%8N?a[h@ ؙ1H Ky
<zG3TV5z2 BP֜lXSQ'qluxMeE֠ooCcWX-d+R1CNd,k dRMX |B61Y)i)x/xE AVw5ЄX66-I̧%QڙpGS=#T|x$Khf,轄!60dFG_WM\! )XWQ]G/[0[9g4 daVa5
Z.JGL9l;!H 'K9ӯ|Q3hZmy kX$aa_ 7!RE=!H߸_▜vz#]Y84d
6 m? ծԂZKtɔ55t x| w2LV4 Kͨsȟ+D|R _(Av|;'j""2Lh"-O㢆Bv vP(*+h P &jR BrW)y;)v$yX: ~NgVq. A~#Ǎ'5:r;U~p #s" ms± VsS涕Q^k]I 5]Z{8ģ ү/Cw)GߓWSꆌA(
?4`mEwA S7a= o@a!H'N(IΨX٤``jG56MYE_6QR hްodPr ~6UtS=$f%cȏۂ"WYt{8Tk5n>c=ۂ
S{-hoV*㯄g9 KdGUA{kA{)]':X 3a-A{%v'h8lpr^,7&;?>h/AKwLAJ|Ɨҿ<+Tj {W46jU(p(8)јDbT%|]NN|mA{%e`^Q1aRgP0gFMB,ؙyfj۫sLς !7Wd:b+k3&2RnUk%N<?:NK=cQ {x*$&!TsOۙ79sE /{pZwxZDjaAަ֊8->ʵ>ZZVڅQn
K۴8_!,|mJCo|VDWt
rWJΝhgVIa.jD8d.Z5LSu%Efi j*co >cMf
&Yڗ5jl]Ke _"Nie"@8 Vs
=彶(V>DѭSF ȸo&aB`t·-էh ͈L'nz,ҎQOY*Lsq& ̳c{DȝP9z GZ퍆űs1P8#ވ| F6GƯÑ z\EaelQ<8r2o! wFϨ e%:L~P ZkU{R87BS%0fp`1'H;F=ꛢ/JC | pP8!rFC#7tnd])$L1
OS= +Uo Sdې:uRWF_3>h Ƨot|!FcԯȵQ'>A8gҤW*>x$hHߧ1w@!,} DY酒!@/0qwB*T-N}b( Ѥ>߮8k^(>.62
~;k! MZ;oOQ& (( Y+C Umj Umzތ
@
j6
W.6P&)aswfTV9Z̕y} F I `f\! I+OC1Ԓ,|{v'hsfѭėKRge*>~2i4%ޭپ TH_ .!RS #N3DE=md~$4rhB%]I$x8p
FFY}3ˎ D4/|*<|29kq."+')yCt5!UaBM`^Ep6K { LQrw!?A qGVM,9s IdU0Gtz[
;xmYFcYOK< tƀ.(LC>.x\O \Q\tᴌRf RRI/%QG " ?,U1ڐ{ J~C<4 99 818Y>C{":d33f!&6wjx[%wxYuo*9`dtxUmjZ%;dk*f)~1Yj:?Y%+
2*y|Y6*~
Se?~YSkG"m6Pψ"Y'lIG$;H+[ )zx %-.dxmR)9r<ږi[J;/ lQ7lƌvXXPqx;.V,]-bw
x 1mFWK*yr\-j{}:GhlOj-Ark\-bԩ)q K SR-̌a!jv9˚:9<D6:9 < Y=l5,ΞVM"ìOU^|AY%EL5lK3_+27g} | 6͉OSOv""ϐ;3܍(yA]IW] J0 p7d sj9>m,bt9& ն\+ 3R# hx-wD" Y_T #>isujmH {WᯛSߏ}&$|G h$ !@tqB3 VM-j3~Y9~Bjn`%gzn9Tbf항Xk)e Kq+tdn8ރ|O՞Ц鲖Z vk@BGZou>͏N3nrjzzEǩm² v
g7dn\$qH o
M۶B~/;D,pԌXQ0j*7Bރ,א&&!?F+ @V߲,uAS(X/>6OW
Bg+f ddj p :+kAF'[S';0{23Єl&R*9 Kzf.>uDtRz1ǥlr)C6",r.w" 8i.
K/ ܆,aQSEDq(}NJSB7R㐥Ɗj 2%C^~NxH 1[[YO:9<,S d:%56D+C 3_&:0l=f&`l9pE8=Q
q7r,?:#wH~7rǝqQ5]3&p+ _3 %G|? <$2OEx:MI-jf
fe G!K M=TkQ0m dkQ6dgÄ)7aȎ6U[Lp -)S%V5%1s ;t)GO xzd 8ކz3Y'63Xz]:٪0!&&d"r8Y54s8ykbPr1$^ꚆB||N$2 Ц1eӐ+Eh, ϭMzeW3%e1!k<#Q3:C ;s2JF bB=T/J3< w`q.y|Ҟmb9<#19}thycC5ax?BIrΟ"w1JGcQ%F=)Tj^-Fy?ϛV1V/%H @ ɢwG!K-¸3_/9a\*f_YϮyS&ǀ!Z5Ǯjܽc!2nVb$>wA4/߀ArZr۩hV92a uM^xQJ(T*-/spTR8K`Nx
5\
XmdWg/
+ctCุU8N ӣʋ[2ktmSd 5-գ9MJ'& 't,"WZMWӡ{8:4:e#:Q~t0
|iSS! <(]D=)~ ?D fUBVxG|tH!w~tX)>*+? <YRyn+uK}.҅r q0Jvћ]v\-vlUm?ij0ݐunO1 pdR"{J;ŬRj|
#$u ¶ʾaPmt{8TkFf3"p[-ڵ %u!C{1+Uo<.%#ۆ9bA݆K}
~d/\~۞[5YɠR| sf͙˓ u\:Թ KgΝ&K8ۛXXcҭ}
]w=>uܼ nhoViv %+u~ k_bnVӹ u{ >]UnW+qo&f`~LOL'УO}^ bKc?/oO/RDC[_Uo245^4&8kr-qQ٦fZ8Ud\Ǖ %C<4MQq (U/0!dsJqh,%u ^# xj7 KMb[eJ 5l0vR %?! M*1?v([f菅NcnOB>QY5_gJY8x$գ *-8dX"o|> <?Bof?-\ |V i&֡FYH
l
VU:}ї4Y' IZ?p -2m.FwY9NͿt
h苍|dNPs,8h c~..zsޜ
tKnI5>c%_W$lPK]?zbDó3wVuq9NBo
ƲIYFD"Yi=wռm:bh&Zucȏݎ#*ew)Zu N.൶W R'YÄQ~ǚhꘅ^jmC UQ7R/NLnHNXrV
L,W$tS16a+% }ohSㆧݖ=}M"K~7oN@#6zyye j>d]8 \ѕDx<1f'pE~
Se7 F_ U=R|8nqZ 7 ^|Aو։ Q pGRRvq&!S) ɚ0J 5v ң68yHz>eV ~;GOq9C%źIJpA.dA
Mo@LlQc9Ed,W5 Y3 Jns cQH^fdB4xŠ.õ o@V7ǡy{v*SXVZ
iG{tYoɡ:FNGǐ w3%) єoBC=RP= l69lDs/1&##&t8p #smD4gҺP5Xwc[8 A:h3|K^+Џrx p6 5ކ>¡ٴge2|hsvG9C6p=)
<%7
6JF-k9sڔ#- A~^ ?v\u!O!Kr˱H .'[VVxNcQ[ W`!f*k26Q2Ǎ5( M ;'rjCAU:'/i RT|6;mp'55qy\i':[; |NGqIR/C}o7- ]RI 3 MF+5,obu.@>L{9D G+Y}
Q8[ WA֧p
Tw= !pt)26 6-t#ejc\:Au-[q>G=|0\\dŰI&`VԠ$p
%7,as!^G13 -Ay .-JG|4!ֳBrx뾶m/g
J L3ƕxB|SF6d.-9y8NE $E1U;$~#ޜ&
;%stó-˚.6]VRBy\ T:O!yp'6 rROpPm8M} 2DƐ~i4vZM U,ͨS6c'K ~YT5L/B:E+n
%ȗaiE (LB]9Y.3mؙ 35Zvrӵ0&uVPrݐi6 Y*3q' c8 <Yg?1,Ok01j &vICo̍5a !drpx \1l|oxX}#ȏ:b6̄%A'Kw7_~YDN C~Ȉsd]̙aݹmwUKVkFYN>R< nՅfER.7 כUь́&ƊcKfYX= ΟC8X8[;~Pܵ֒˖onH={Ѣ39 3=J7JGaD3p JoΩ.ea -,ol{`I ̺*~cLc.sF4z% Y*ߚwRrb߭{Ef\Mcrx$dLrz BS; )CV,o]{myyqԯJ Y*sf{sƤxV.my,^
¾&%yEGzo*} itLN=tQj[{!KTP+>r;O;J~C~YV1]=~7u5h|,@.(GE1 JDT("3T'ވxsC.<{8ē5ob\ ,%=dmIۢZV_ w1JS% )H9 We$X ~ Y}5t_`n D
8s7 ybGBJnX߄ASmZr¢./`H?ħfqB}UϨ0 @V*>%
+%y3/im.uZ$5ZKshb`H6X dw@ޡLLfTKͼzcn]e]*}W`iF+*xoZQy\ B}+ߙ -zwviV
n|Mժ\pk?p=5%r
B KvK~Y!|r.^0c#d:d;KExAe;͈ũy ρ
_9^XZo"%x)4^'n *5 bHar^ %C.ԝrS.X/9wޚdWOVd˵F:HzrlGyYbzEzv:9.9}d p~$S⚙R?~qUcnuk}ػݮC'LX +ޟUOG< ؏Ah(aK+Sm5U~x{W47 ĺ\tl[ YZ7j>de;Ae+n=KxieE1Z
h$#/UJFB a5gV%8y({{1NA ,U8nzn +i1[_ȖR( Ѥ^ "_2 넻 e#ދQoE9nϴ^c9 W[HlzC>QUڴ$<D$x$U]餎{(˽W*g T2g̹On?<~~Qz9Nb f {Ss*> cH^64coXOI}uZL}H+k8k %! 7Jgk#I28? (m klwj6Jfl'@)T]ebp0ijb0 pݝ-[YYG\Ɍ#`6N2-X6 TUt e]pG@Lm[($QȏfDGa4 ';5%D9ē5#(;3ȶb R3ȭ!T ~- @_>,XrqVOUٖG3kDP]++ D*5 '*H( 2bUS3AƷ%*G |;NMe%
:EQy rDuM?mkM^|1䁗 _RBE*bn4
| k27TDfW'p❵RWiЄ,U |TYK6ߍp&*'IM{7>eE> Q_ͣ[n,Hd< {Xy`r1S 4Tt@b
wMyhJO4 tEM t{'gM >-ն%zWA,#ٴfBt@> Kw7 B X)-+%ɝnƸ٤ βj?( єA̶bۥT|x$ۆ~U: 9lb0J(+ڌx.Jpj}ߐ,jܢiԑE8
9N; {rN!ӉĢ1|6|NY'{ Z{R VL$'R AVξXns4 ]^0IM,ئgujG2d}7=_$@Z-]rr( ՜^U:?! R:A4Lvg}SeWa[%]@ֽhnʀ0+qt Wvjs{W8jWʗm/M'ۍ
_'OGW3#tDGBdG <
9oFһ1NC/HxT R ;on5,"t bQb[l95,cjDp_k B0eDSSx L$ɵ;.).Fϥ G!K
![Oyx}SŰ-,Zz.;%1D>t oB7*QK0Ζ\v
==~ ASmZr¢[e`$3(*% :%4xy'
vm$ 6g
݂i-[N
XYvRzjp
t4Z4aeztTG,ei"J fjJ`)\lC< ]tp=)^^Ro['e8lvIǶ5Ԩk #S ~v^jCuW~hK| wxtRr=ƪ;<2^` ]f)OPu)πCjBS̪$02F!)hFAݡ#J= +$z)Ŕ )}
eP҅F脯5WW
GK <3cu@.d3nBix$|NHܥ~ w{ Nm ,á >۫ZpRZؔ*݈}7騱uC'(~ 0\8wA Dg9B>YHA~fP47aw!\kҖEq{Bgȋ! sW{Bgd#@aor;;]cgah IrGGO{(0,FO\ck).YU 8s٦siZDg3͛f-Ze x^l6R~x-Ac9a >+ak)4=iԶB*iZ AB*J~C\1G +a-`M \/+&(75~hUE3 7ѵ' /݂U6]vD |ͤYO bv8i4vzB <
dU*:<6I#*W!_F' _SI#oX1q\nuS34 f }2l 7mp ?4/v52AЧ0h}>NGmy,ش5hq l~ O#bh~>C 1. 6Ǭ㢕6!K9bsF-vֱUʛ TPu W}1>0}|. ?2]VwxL1jK߀Q,#sD4 d)Ӂ9zȅ8 Cu*%xe=k::]D#ȏ˖~T/ CL.%! Me֞dtF9J FUkJ'eňGXF +/+eʄY : RN]He-aQSy@1tPɵ}
_\\r_G'ri캯|s
G5 Z\}|wBn;xpu~gh>jaO{#fS ^R[-ccyFiٚV|
x4A 駀S;Ȭ}j]Kl"w n,9~-^-&y'HXeUIsZiUĕ^E8)e.qmnmaIi Bg|h
@?PLTf 4V(3G tbאvz*QLU
5q^\Ad0
@0UGG8Q/E w(gj 3?.G iǨ7ҼyҌn֕ЖPo3z
5WRހ0aevC1 +`B8y 5;H;F=5at|FAW4U*v`5uW* )]v3`3Z*ϙer{GxWr%9 .(HtnM^0dIT_B}Q(2+
hL B=[\&L@PgKs&-8 q͘yZjTK`EݛyEe rqJ'ІͱTAʯ쮹12![Ou.`4vq'LK[3_< Ⳡ n US~,~UkMRS:_B}&lXZ 3I ~ Mf*vz*rn4ڢ5+n hr7(Re|e;BRo4E4M p2瓣
nϠ S ! g7jo~l7#flqI?rfvj?6jO?c n-_V[´ \\i!)'"薐+@H| B}&,3g46͕R1ϮF9R ϙ6-w_岽l}xī?\żHi$NGf>πa?~e:Go%Z k5f<̟?Ҋ7i(8'& aBnU&IN1HW+-TT٦ƦFiS?U͕7f'AjWŪ -#re w_ܧJ_
%{JS` Ð/ < Yu"kA~?I̕
)c
W*a?6T3 $l<&n?Y ,[w-_+;O`("f?M&kظ a?]2,k(bO %!ȇ:|SS$aOa?5|FOa?5t6¾OQ;b< [KScS6 L)ӿmtuQjXZX=<;F4` (_nhג^BxzzaQ8#W y-D
ۤ7x`GA݆K}
~;?C\yβؓA683w' NtsΜ;oM3:5㒭^FɆi/ '6-L|:U-M*`Voh HH}Essrm棲mvdm7:U$l+az$_b8#A#[_$y ojUa^VzwqvPB
fNRVٱf7@ Y)! M@TFz -(d#@B(hRkƸbn6A { @7qHuC>hMS
U y{j'pJ-NhRZ+f9Ďkh3Bx5D &
@R aǵMn,U_մq8ģI+Z6P
憘| q{TfR%ö"s
ep7nvwriElVp gf
8wsY2f 0oowpihE B)Y7P
aJzy%5iR
A !KMT&prAԐWM5^HtR (XK|o;ײiho7s ?eE 7ˀIU3gsf<IrfE8!L;=?[h- ΛA
/ȯHĔZ{M3ϋ+J4W]m b")3HrOzT QʉeJFV pјvCD$bKn&
nS_
~,ޣx.[ پ7=a |zT~ )GP_:ңBn&> K-CAGx*784!]Pϣ ݡ^@rQP? CWx?;T.{С^g=
&CÁep#|W@xπ{7
BWp!qnsבvz[ Y
OmG8
=r8u泥0Rw{3 "] yCl?B1vh;S ppyL?@>ҍ70^ v:rQQ {ԣ>{ڣ>)3~ &Cáp#|φOAz?!n)}?'?9ҎQӚwȈ
H~HK\A o著-"쾟 ߛK!Bl H;yf hDmi͛f]M Mk%a;TZu A uh HvCux&CÁ+p#|e!:1aWǶU$N1%&yݷt!-POOv=gaU:5#ZfqÛ"F<Cv715k5#,ʍ좳 ﯝ`ɔ.u)` %~ cuy֯8oi ʗ!_C0R^&ջe>Gqb` D[L\nWv9Vtm8v X.G ̾|c3:Xo$rQ5[h(:b#*:jEm BVχrfD͂s2 ,5aͧe^ % 9<
F
-^!% dt,ef{;\ [=̚Y)U.Vqb9|
2V0l n: Vs}_ԶV"`pÜm{#Zx:])Qȣzn1d}K$x8p
FFY}3ˎ en'D 'D%+0WܺY*d_ӕz^]6z慙aysUXa/P%Dp6K >,5 f| Cw)G Q~S+;E'({߅Qv攟A1O>Ő"MKՀk
vڶ{ Hv_.x9:Eɍ'!K#],Q|],!,4rxel&w]h oA^DK`rQ:0ET?~sYʫc` r)
!>xi l?ΛsgoJl ld Ղ̧,Fu2gfBZMJm( 3 J,T4sȨ *Դ1KF5w F5׀w!UV#P=}R*Y9VQ3ϲQ^~NxH vK% 9d :2hyͱKS
\RhJ9s&?|Ŵ?iZ =!N
%7 T*ْsy|Jr}}8
S@9PD-ށ,uwP`57_Ә~66t2UA N :Gay!_(OrBV?($C6VbޖS
l?̀rͥɟ"I6?O"a$%HʱΉV˦#ӶK&La CUW=yqC<6>J {H'jXD# "YŸdZBx.ZcC{S C W֖7oZՓA#kڅF
U PԦ)=潗ebՄ] p/d}73N~ ғb_ܣ
0J~=x?@ ؙ?}A~шH"P_n-zk_IxN+' ̊6D8dR`J0d9t3.@576q@F- B0L/B[(? 2r W#% r;4I;T۾ʈF1fOGP,:*O! MUfH3De
J veo[<ۢ7xx.,0. <]rm brxRq ϩs.;D;T/QC[LM)p zR!CJIL/T#?cSffe G!KM%~ iRn KkT"8L B>SIB)S<e ׀ KX͗ KMފ9C[T: ;lyn_4Ch~ YAvX0>+tB1 @Zt+t(1 ̦Xg!K+]/o6.vDz&s[l # BMw K
; J!G<# +D$QZ ob]& {9i#AVgZH(a~azǘ
$ѿІzg6Xh=!.퐥֢ % yF&ۖ=;{Uߤ
%;AtVB;x0]Ԕ
=C.(_44qd}{pݣO>/a#e3yOv߿$ m7~e aG5~G͝[;"xZƎx\O: Y5gUf}_/9%M?ME&Wc*݅ O%K,NAf`# M8yf/^|UYR_5M7eHْTG f[G C<4.; ,WIjGa t60˶Ef~E%0 YnK]$IEwP $`;(^ N
YBDq7d9 @+D
fPr@}>IV
߸.(,V| &5oC{\}#f9?Z)mfUMV 4Sf
,vх-ކLZ H %!iQ1f.Yjm0eB%L6u_oCE\]U\S\6K¬OEdWv i˧ H̷C%JuY< [bB_Z@ˢFn ]/{)gg/7+jF BJX٫Z5#rhcعQ,d^Zt_Єljk'It K Sǁ $e&7A.&
B>^
LFㆮ7`!ˇ Z(WZ*s]4Z1!N-%w7t_hB& KEuidːOo }atChp bs1dz_1 RGŕt %/! 9L>ʾݙ z'좳k*2 AHdi' 7@ xlOM
Yne%9 ( gk!>d a=D]TIl!K5SE47e. =jMsإ-J άo/95Aˈgx̂1lc6 ~Svn1xmܵ]hI t_7P1fts##wsTD/] B#ݐw+kBj֨.ӁxL7a~(~Y]쿍1.F"rKCK6; opc 5`zC_Y3MCyFAM!⨓x\Oj TjTܧgW!_ͮ # 2|Oڑ#J<9̨ vvx v ne3jG( n# P ILu
^>l
;d|xjH䜰
cqq CΠ!z!7q x _jhcw; A}1# | C>8 29 `7 J F3/FW JÌ 9' n$^I%N J>8 =p@c#r:b+WkQr@. p@{cF%>: u}I% 9. P3l 8R5P= f'9a
: h p?d&MRr(fmf{ WYW5:̞3 uvBs- x >L Ah*,xNȺ%G(J]F MrqO7o ?B;-濉 FW[LJCS%93e
jDCမX'
!6(* _
sc'1btP --}ȟ(ao o t@| wB l#% >Znh}8cyOm %C?zŮ~B5dmt{8TUy1Q,óU-|Ep]8llP"< L|fx O[0Jʪ:m9b^c
M-znՕz%ۓ8MDO?cᜣP%Pb?%,w C4F<*JnhB6t6پ-%zqS(0z@J,=(1ʼە\ R}(7pl/Lp?dyL2j; {Ϸ(B}D'
Em Mt8# tY RUuŘ Nxﵡ, qі(
3Mh d/!als`r!ɰ
݆Ņz,`"% .*"q,7)' B5'yCZz6
=x!,4u \*/ _D:4.R= ɪosB}=ݸ0ZVǢ>XYo8CWM<.pWMMyՇz&V'^+-5l!)d?[ֈ3
ߢRj "9 j( s'_v͜1>~v[F7! F7#(fo.I)d:p' }
r-z%;]. {/Dd
R EeKMK{ ~L8<`jQt~A;ؒLgq]lQۦ8ēFN@Zm4^jpgsih__Xp*<1 GwO Sl)I/|
| 2]kh
b
lH wA[۵ C`*xܬ\X/{'Ӑ/ҋ BA7 NHށ|"C x51~p<5\S" ć
x: 5ee Us=ewY=M_NLue\O q|.eA5ZnXG`GT:]Z]etBntGhBwf0q6;
dͳ splP' ?Y(dx>%O Eٽ:V O;EoFe. E9:tve>JKfK!Ey1`ɳٹh[E@8a^9Kp ALn
#$Պ{"G
D\DkHϡφ( mSF? 3m9[1U9(wG>)*%'59 6ֆU'!n{#M(8*KP_p,"Ym5{ðki$ry[;R}ح@P bU՜0q88ɒ[[ Jc V =X!,S^`U8
0?ۦ<DWWiy"|%9U7hfQl^
S*2hd77s,grDx 9q^)sh)SU+MeUmѝ4度m+4hE
Y!V ߝ
D㑛HLus^m)(%Ck
n(&v)R:-1*ZC-iEA0 T:ȈmR-/vCmO[c-3kiV̶qM]c:
Gxpc, V R♋u+ҢTZ[v*;bDo.זW
%̷MX{tY,R|Ov Zj -<;Ens)= z8JP? bIPx8JcO^E{GRbmp⋤+aKvccDd =%wo1
/cH8ނ)^{^8
v>T*vN9iygKWOUvk'XA:z ]'֣MQ %y ApW 4|KlAsZcaŬZ@)t1|W4O "Oo=0tY_T!5B=`%r Wv؉^6F"tQkF+l!~h-:ʾی0^jVa бly_^u Ix$d_C/e5c\naj55*ft72tX47W+Z5גhuBf|>U% |^#G 1x
&q(
\ia
O-,Gˢ6OF\p(U0gK!>cK܍ik0kZ\7b]O(l),;%*BɴDq |ȍ)OOG6Fݰ/l>mRGM+0cٙEv9CgU"m(WC 5^fXqJp dؕRJۀGǔ4M4q2n5."{ $5L[0+>U6m~xKKǔ|Ot 1*Z[{`-[y~H&$E?Y k1j2].r 3 q^Ac^)J: dDs?bJ»"YC71 f_Yf<d
4JlW*f̱JcpNcLX|;r(zo$=1ԷS-9a֭\LD>8lv,, -W`/Yˎ[;J 5 $ K) l9e u/,9ZH/[x>u1)iXZ71Mdo-*?z XDi / ;=]A#YC4ܞiՃ=l\sY$X >dBn)oɄYއ[{ ګk!*/RX8p *TXy)aH`A/"0K | ɒT}j}Ԋ^FDi aKROKlRv$2v]W!1 fRrnv0z`7^JKRכZQo JMZ_̀;h&QIRX"'[+'('F)JJ 5w=N[?Œ/XҋM;|&7>5?/ &)
p
8Lzb@RgY6y?;\MA7Z Zf} _(tkS뵚g>[訄hVGGiiɲ9]BoW̗¹ \\S
!G{fgX^VƪV 7{G̚g}c-A fM0&ĹY+^
[-|w|lw~Ì
ٽ2
KǫbI%5;/ B}{J ig,ڜ1\ HKd 4:| >q*v 囗lKGnj*6oӉLf3e!SL]5_'f̧~I1 c!<
g,b+KͶ0"x ?Ȕ)E!B}śJ$,njvNU~vFQSԝT\p#
n --KiI4l5$<
Gu4lt4lowaڰ͍F!lؐ?v !,ݞhc͐9lH82@ fs暙7:\ DE^e&}?x}_F ,\0'ڟ61Ka_rfE؝^qp^#Kkwjk;;40Ya, }co̫fhdy
mM,t0~~$Ɵl$1ZYYlwU>d( UR? ?_5q ],߮ nTG X 3e D8 ,*=3 (2|J<-cWO}IE*_o3}F֙3xt z\Uh%\_aS |Jpb}7~Y
o{xfU:bDz
zO Θ)ASԠtɻ$ZCۗd{{#Ym^I"8 Yܿ0 0 ==9Q F2yK1ϭ N9 V DO1_].~
vk]_]Hk#j:p7BjS(~ FAF!XZD`/p_$gqpJqh;_JqC=F(AtU#n@*T7=ʎ0 gp^vR %?! M*َF!>2w28iv( U3rEЮ%ga%/d퀶Q?=㐥ZuNPNj~0a2=+usC<ڪ z Q,Q c:gyd 0anC1
5c$|KϔbMp -S5xm,(%ϣs) |@hzƄ |HHiFUJƖVVkRg bv]lC6ʃg^V>$3ű\}ufXRqq ѤwPI /[C CebBbB`{%LklkUm;'F: 4Nq:O v=g* 8S
ģoAj4-Pc6Q4]z 'S[N<](v폳KE/o`sl
:΄
4YGdKIQaAv5"32 _x݄;::G' E͊!ϫSbJv`9e?/HiPi&-E9Q]-8ē5
fGmCW,j IGm/+trϡzb8vó3Ss+֯hVuq9NBo
ƲIަobπ!j>e\͚x7n1FׁO ?QfvBЦi;
~t'Lh1a r Y5ܦ0 Tbiz('&Ns;1mcvP !J%tۜ5b5vu1Xѡn0=R,%:YхvÏ ]I F Zw%IESc^[cx[ha p ;<,*cjƅ5|J8Y%Ұ$M
˒
K+9(2 y[J veQ7ȘJv !ggGaGZM9h2Y11 QBֈd*Cх>. =;pzdM;[xaE T o)7,]J3\"Y
?=9Yv".MB')[Fb7[UT:O,5$.'g!K⪊s˨elk"C#2 Kϱd#BǒAe]tZM\Lp d&.fT\;Sý KK ? m,7BK/3ː/++RE
2)̲ g\ssV%E}dJc{v1Z$=Nz>Bf$p6N\ @;bm<zWrMgw
b\qΨ8>P^vZi
4T念{)+fFx YnXLD
Q9&_؞O[9J ix-5=aƨajc9lbrxaBSq3Շ "׃a;F@ٔڞfchOtuNZ wYc.:U9)Ήk Bֈ 0>t"p#֨>`?=\>^Ԣ ;ՎQQ|]G"ܭR^Bp+d}9
ղXc(S6 Kyb) ځFedap'd+
à I @>1 |Ep Y-`-gVx3Q rS b5a K _KTBc*n 8Y=4fŔDc& 6};GL-|^:GQ
6_W̼p&N{
Kw
Zqb,w+p'do2r[5<Y؈bC 6HyL('έK-1 \gi Pd3&` f_,M`
sNFT/h7
4o{iD8 K
sB[tp Z̕~c;Qf@Z PTQ1Ǵk{ѷ iGEUW1u!e §!fY5RJʹ x T06=BOrGJZH y+2[8=V
6gzd}ࣽpc%V}SW#wCޭo BBŵ@nEB 6SNwRz 8y* K]?Oܮҳ+~sxtL drz:כSm9K}g+ <Yjxc]7 R TV mkAV?$ީPG M4ŝħԉ8p
rJs 1k Σ1{$W &? O~w,TMձv-Xީt, S7X xCC
'+AZV RW]6RqcO;* 8 y@2,2p
rJ]KxYERa
)t,Tqk[1N6oV}Cs:!K
m oM: *! Mo(ՃȪl-̅AŷqG[xV.!}{1JW'ZKs=a"%A Yj tP3Cq~B^$_Q*BV(Mwt=vґDkns)rbe,r%f^ : dl9j#< YjeuDgO wlP g fs]Oz&`nA'b,CѸwpXs v@]
<{"N; h{6wBNij%YiS᎕!ih&1 aGAևe{,p$ "y5 EDB?n-Տ
azZ$TGBktFBD UQm"],rLOUpdi N#ãجdjqZW-N#NiTF`jqZ j%laFEqڇh&1v<
v-1 g _ \%k㓳K`2L&.h K>55 δY`嚳[\+\Ԝ`/:d L Aًg鲂``e!צF|4_k;vT|xҦQF
1Q ˟s{ FwF(Inj]-bēp[a&$d^,[;3g9 R{9':ل Gd枇 *Na-ȷNEw|%J#`;AFЊ7N\7̙}% d] }; &"| wF7aU7(%+9svʮp7NBK6*r>cr+ik,Wvi=
v0% kD1QS}쮵8\x3_~p-筼 |'OA>Lft9}x@Q活ΔnùD~'½uV&K } $;!]sQ-ƓhbDr_ !BI
އ=Ar4`0/ a/dzևD*_Bk iMe B آU(yGV \-90lq5r}ɛA;G.HM$ K8
yŎ;Pc89˞59gZtB^Whf!g[髿$ͱ; ݿ*\7CެPWЀl8;|rSteĿdWkCr
m ʎQ> ̹ޘfyR)VMfыL01YgrK[
>`GY}nKG?xj}t_nSD"ۯ! u]W3P3fwML ~@wD8N\
D/wֺG}ns]4%0ǯk_9~զu5ͯ b:M5͵^`!one ee *e V6E?U0dFѥخ-|y "%[Mb?DZu!B8Ĭa!Ey\T hz{JD`ϩS?KE
lr9>A~tq'p/d b*Kg/B}
sGV|A
m&}6I~&~[f5rjPɵLKC?Ff^0`l IQ>VAF6\i"s xe5_K($
+:ʰi,fY w)泂6J5]xb[^S= ʇJ4W9A` HT!7YdbdMr*Axl |@c;JX+ |Pـ^s9`%ECwE81d Lw/Q[X4<PQN;`a=FeiA S?a%˥eU
<(CeѢ D$
@p +l0gLmқA_45q"Mt wCMmGY=?d
!P^ .^|! 5e!_TVxy* x %e lCa~D:Afڬ#6 s 8yC C nP#QrESxe ~['p -ͷUZ^. HMh:Dس:=p2 5R!{`?!ilC
UdFv 7;(9e.ͣ93li] &Y26ˆNקe!+5zpc4į^8ë;>-nF2o ֧!_e7B>T { 7k#Q_~-l|Jh쏕
e/ܖFA "ce.~~@[Z+s/}מ.>Q~p 3m#z Z R+uKmp3xQV6FP-wg*R%dxm:&>7 K9L1?MM ChC<4gH *Wet#H!Iį?873Z:88 *8QOmLN0
4i?ai߷^~UI &^ m2
U'ZӌFvљ-
_4JP-b5XC_l0Wsspy.rrºfwWl,rƽeś[ԸA(߸ڤF~ƈG͑]- hmgfs_Ɔ
[;X;;d | ^nˎWK85D d^mOyYoaV`rY7N)e1̂?~I$ ~?سe k#Ku P6ZuW+EE8!r%*W4 d
Ws_O4`^;8q{;rO?б
dU <v;6wd :k01 |
x>9 f:| | ^ I av-3OJ7 ]xJ5y3 ^6TsveBw"z gn 4 މN̚qmgf9o
*B:ϙ4b[Pk Ӊ7"0&IF˯TIަ bEd
熠 Z30A^m=Adzͦ&˽V,s✝it4+.>*$ڸq#ȏ :iU
'
b3`͚E_p̝uzj\OBU^|>aVN8yBY+Ex\ނu'E V; wh'tk8uJ?G T8#xg`GhCTLRD 9 ͜4^[8xaK΅m |%N@x ?CcNò`:U$
&F0Z%炒fptżr{=kA^Jb0};
s$knK}%4=
>
`W?^rb&6r|N 7s+(7܅vuDXIj#Ucx8/ٹ4!D.%ECڟ+w6ϯJe əEflDґ Mx %muoܱ ħhY Wmvd͝Zw?bwP |n13(ל
*84s[4d7֝uuTuxr
>A '+j ņik\Y> NOÄc|uF@q_%|0
4j5ЕID :dU61; uqeT%~v կZ~W-n'NTF`jqq;C鸽n` NɣhP]&P1P;n;l$c'b(dUoUT-C qG,yˣ+얘gӍGnټDiV`8S- a6Oh=+M-6;x%7P16g/y nIպz
o#UvjQo}43b.Mb HO]}^Ƚ M;T6` d|@{2);)t//5*byx ~){T*y>rƴhgs8fy~py|Όp56y;ڲY`x%kJ8f,oXUJ ʼp7y [xQ˹*mX\t=Wv K\a Td1A4]p'〫ﱩpQN4=0!T[Y?OD_^|EUލ+_ب5 a7N1o;_NT6pGZN?+h,h={2qۓs'c=nBF my=):7uK })Ra7}XҼF_Bn1oϰ~ev g7Â[CG O ~~m>X\i]g'zCe)vg79k/4nΈVF~g;`5,&
YȟmS!y Czʄhಮ#`G M$NA+2>1w/-HCڜUϧHΈ| {#9TakQZq'u yAxòY 9NG!LeB}~dwVpX"pQ5K`ժYi
*Cٕzh}Xn19]+J y6ZZtz
-*~++`uޫxmC"snٚn%i2״ Ծ ,_C|iA̋ LBԙᓧsGN2tмY H:Wl~m7\ؠʬ:2G
Zr WÉKVqtp}`LnvΝɻl.|XV?~v|hj^{7j hhŜi.,τ5V{oc# /6:c+ZPaQV
oLƦM}_VO/HƹGeԪ"{0ի+a<$|
TEI;S6v`bӪ <)QB oJ_)TfZ)7A{bl^DXcTV- Ѥm^:LF
Bޛ;O *~?xt54klh&5_^q]k:4՚MA;TcͅZ)2oΰSLM~8atqh#*f#,a9ZNсc +
;A
Pj uiu~nkp?d)U?|
J(x v/l8D AfD2"1Il"
:ysYTȥqISQC ;PldQQCA?](I9GibM욅dXn͢KD8>He/83? fu* {T}(_[YzW+U1(:F=GRi|ô/ZV ABzXO 2*7%
SO% 8ēFN/B.[80x]I)Z'{ F 5aҋ|۲W[<|:; [>T xi쫚?β0VxMxpd!m{{X5nC& gI-) F@ iPqGգh +!K/iSMLo@j._Ut
K&6d*Y:<-ǐ ;7!kT[!Kubj>H
q yTYĈ C2:
zGi*ѺY*K/"k 7f'5VFB>=S˨hji[w!̬ҸR is u jnT]
֤
\qҦ)3!3!D
Zہ 2k~ki<>yi9=Exy
݅vll)\'L {3gr fbFJ>T ěgL Db,gfxW
c,䬖68F@x [1à ͏T'3UC[ oXet
uz
ChbMSa,c8* gkh s"xxUOhCi/ǐf
uko߅,A 409ēFNCVH[bF62WgmQ ί sݢf%h2S}-=
/N#:`T"r
> r.ʲg{ cĨgf#;+ < NJF"4MNLp \FzE<.s6Mŝ^1_Da8 YjâxOށeeg FV6cRE$0 9 )<5h3F.z`^z rnc lgm[F'{!K6u <&G #%eGC
## Usage
``` r
library(dplyr)
starwars %>%
filter(species == "Droid")
#> # A tibble: 6 × 14
#> name height mass hair_color skin_color eye_color birth_year sex gender
#>