dplyr/ 0000755 0001762 0000144 00000000000 14200434032 011374 5 ustar ligges users dplyr/NAMESPACE 0000644 0001762 0000144 00000027656 14177162131 012646 0 ustar ligges users # Generated by roxygen2: do not edit by hand
S3method("$<-",grouped_df)
S3method("[",fun_list)
S3method("[",grouped_df)
S3method("[",rowwise_df)
S3method("[<-",grouped_df)
S3method("[<-",rowwise_df)
S3method("[[<-",grouped_df)
S3method("names<-",grouped_df)
S3method("names<-",rowwise_df)
S3method(add_count,data.frame)
S3method(add_count,default)
S3method(anti_join,data.frame)
S3method(arrange,data.frame)
S3method(arrange_,data.frame)
S3method(arrange_,tbl_df)
S3method(as.data.frame,grouped_df)
S3method(as.tbl,data.frame)
S3method(as.tbl,tbl)
S3method(as_tibble,grouped_df)
S3method(as_tibble,rowwise_df)
S3method(auto_copy,data.frame)
S3method(cbind,grouped_df)
S3method(collapse,data.frame)
S3method(collect,data.frame)
S3method(common_by,"NULL")
S3method(common_by,character)
S3method(common_by,default)
S3method(common_by,list)
S3method(compute,data.frame)
S3method(copy_to,DBIConnection)
S3method(copy_to,src_local)
S3method(count,data.frame)
S3method(default_missing,data.frame)
S3method(default_missing,default)
S3method(distinct,data.frame)
S3method(distinct_,data.frame)
S3method(distinct_,grouped_df)
S3method(distinct_,tbl_df)
S3method(do,"NULL")
S3method(do,data.frame)
S3method(do,grouped_df)
S3method(do,rowwise_df)
S3method(do_,"NULL")
S3method(do_,data.frame)
S3method(do_,grouped_df)
S3method(do_,rowwise_df)
S3method(dplyr_col_modify,data.frame)
S3method(dplyr_col_modify,grouped_df)
S3method(dplyr_col_modify,rowwise_df)
S3method(dplyr_reconstruct,data.frame)
S3method(dplyr_reconstruct,grouped_df)
S3method(dplyr_reconstruct,rowwise_df)
S3method(dplyr_row_slice,data.frame)
S3method(dplyr_row_slice,grouped_df)
S3method(dplyr_row_slice,rowwise_df)
S3method(filter,data.frame)
S3method(filter,ts)
S3method(filter_,data.frame)
S3method(filter_,tbl_df)
S3method(filter_bullets,"dplyr:::filter_incompatible_size")
S3method(filter_bullets,"dplyr:::filter_incompatible_type")
S3method(filter_bullets,default)
S3method(format,src_local)
S3method(full_join,data.frame)
S3method(group_by,data.frame)
S3method(group_by_,data.frame)
S3method(group_by_,rowwise_df)
S3method(group_by_drop_default,default)
S3method(group_by_drop_default,grouped_df)
S3method(group_data,data.frame)
S3method(group_data,grouped_df)
S3method(group_data,rowwise_df)
S3method(group_data,tbl_df)
S3method(group_indices,data.frame)
S3method(group_indices_,data.frame)
S3method(group_indices_,grouped_df)
S3method(group_indices_,rowwise_df)
S3method(group_keys,data.frame)
S3method(group_map,data.frame)
S3method(group_modify,data.frame)
S3method(group_modify,grouped_df)
S3method(group_nest,data.frame)
S3method(group_nest,grouped_df)
S3method(group_size,data.frame)
S3method(group_split,data.frame)
S3method(group_split,grouped_df)
S3method(group_split,rowwise_df)
S3method(group_trim,data.frame)
S3method(group_trim,grouped_df)
S3method(group_vars,data.frame)
S3method(groups,data.frame)
S3method(inner_join,data.frame)
S3method(intersect,data.frame)
S3method(left_join,data.frame)
S3method(mutate,data.frame)
S3method(mutate_,data.frame)
S3method(mutate_,tbl_df)
S3method(mutate_bullets,"dplyr:::error_incompatible_combine")
S3method(mutate_bullets,"dplyr:::mutate_constant_recycle_error")
S3method(mutate_bullets,"dplyr:::mutate_incompatible_size")
S3method(mutate_bullets,"dplyr:::mutate_mixed_null")
S3method(mutate_bullets,"dplyr:::mutate_not_vector")
S3method(mutate_bullets,default)
S3method(n_groups,data.frame)
S3method(nest_by,data.frame)
S3method(nest_by,grouped_df)
S3method(nest_join,data.frame)
S3method(print,all_vars)
S3method(print,any_vars)
S3method(print,dplyr_sel_vars)
S3method(print,fun_list)
S3method(print,location)
S3method(print,src)
S3method(pull,data.frame)
S3method(rbind,grouped_df)
S3method(recode,character)
S3method(recode,factor)
S3method(recode,numeric)
S3method(relocate,data.frame)
S3method(rename,data.frame)
S3method(rename_,data.frame)
S3method(rename_,grouped_df)
S3method(rename_with,data.frame)
S3method(right_join,data.frame)
S3method(rows_delete,data.frame)
S3method(rows_insert,data.frame)
S3method(rows_patch,data.frame)
S3method(rows_update,data.frame)
S3method(rows_upsert,data.frame)
S3method(rowwise,data.frame)
S3method(rowwise,grouped_df)
S3method(same_src,data.frame)
S3method(sample_frac,data.frame)
S3method(sample_frac,default)
S3method(sample_n,data.frame)
S3method(sample_n,default)
S3method(select,data.frame)
S3method(select,list)
S3method(select_,data.frame)
S3method(select_,grouped_df)
S3method(semi_join,data.frame)
S3method(setdiff,data.frame)
S3method(setequal,data.frame)
S3method(slice,data.frame)
S3method(slice_,data.frame)
S3method(slice_,tbl_df)
S3method(slice_head,data.frame)
S3method(slice_max,data.frame)
S3method(slice_min,data.frame)
S3method(slice_sample,data.frame)
S3method(slice_tail,data.frame)
S3method(src_tbls,src_local)
S3method(summarise,data.frame)
S3method(summarise,grouped_df)
S3method(summarise,rowwise_df)
S3method(summarise_,data.frame)
S3method(summarise_,tbl_df)
S3method(summarise_bullets,"dplyr:::error_incompatible_combine")
S3method(summarise_bullets,"dplyr:::summarise_incompatible_size")
S3method(summarise_bullets,"dplyr:::summarise_mixed_null")
S3method(summarise_bullets,"dplyr:::summarise_unsupported_type")
S3method(summarise_bullets,default)
S3method(tally,data.frame)
S3method(tbl,DBIConnection)
S3method(tbl,src_local)
S3method(tbl_ptype,default)
S3method(tbl_sum,grouped_df)
S3method(tbl_sum,rowwise_df)
S3method(tbl_vars,data.frame)
S3method(transmute,data.frame)
S3method(transmute_,data.frame)
S3method(ungroup,data.frame)
S3method(ungroup,grouped_df)
S3method(ungroup,rowwise_df)
S3method(union,data.frame)
S3method(union_all,data.frame)
S3method(union_all,default)
export("%>%")
export(.data)
export(across)
export(add_count)
export(add_count_)
export(add_row)
export(add_rownames)
export(add_tally)
export(add_tally_)
export(all_equal)
export(all_of)
export(all_vars)
export(anti_join)
export(any_of)
export(any_vars)
export(arrange)
export(arrange_)
export(arrange_all)
export(arrange_at)
export(arrange_if)
export(as.tbl)
export(as_data_frame)
export(as_label)
export(as_tibble)
export(auto_copy)
export(bench_tbls)
export(between)
export(bind_cols)
export(bind_rows)
export(c_across)
export(case_when)
export(changes)
export(check_dbplyr)
export(coalesce)
export(collapse)
export(collect)
export(combine)
export(common_by)
export(compare_tbls)
export(compare_tbls2)
export(compute)
export(contains)
export(copy_to)
export(count)
export(count_)
export(cumall)
export(cumany)
export(cume_dist)
export(cummean)
export(cur_column)
export(cur_data)
export(cur_data_all)
export(cur_group)
export(cur_group_id)
export(cur_group_rows)
export(current_vars)
export(data_frame)
export(data_frame_)
export(db_analyze)
export(db_begin)
export(db_commit)
export(db_create_index)
export(db_create_indexes)
export(db_create_table)
export(db_data_type)
export(db_desc)
export(db_drop_table)
export(db_explain)
export(db_has_table)
export(db_insert_into)
export(db_list_tables)
export(db_query_fields)
export(db_query_rows)
export(db_rollback)
export(db_save_query)
export(db_write_table)
export(dense_rank)
export(desc)
export(dim_desc)
export(distinct)
export(distinct_)
export(distinct_all)
export(distinct_at)
export(distinct_if)
export(distinct_prepare)
export(do)
export(do_)
export(dplyr_col_modify)
export(dplyr_reconstruct)
export(dplyr_row_slice)
export(ends_with)
export(enexpr)
export(enexprs)
export(enquo)
export(enquos)
export(ensym)
export(ensyms)
export(eval_tbls)
export(eval_tbls2)
export(everything)
export(explain)
export(expr)
export(failwith)
export(filter)
export(filter_)
export(filter_all)
export(filter_at)
export(filter_if)
export(first)
export(frame_data)
export(full_join)
export(funs)
export(funs_)
export(glimpse)
export(group_by)
export(group_by_)
export(group_by_all)
export(group_by_at)
export(group_by_drop_default)
export(group_by_if)
export(group_by_prepare)
export(group_cols)
export(group_data)
export(group_indices)
export(group_indices_)
export(group_keys)
export(group_map)
export(group_modify)
export(group_nest)
export(group_rows)
export(group_size)
export(group_split)
export(group_trim)
export(group_vars)
export(group_walk)
export(grouped_df)
export(groups)
export(id)
export(ident)
export(if_all)
export(if_any)
export(if_else)
export(inner_join)
export(intersect)
export(is.grouped_df)
export(is.src)
export(is.tbl)
export(is_grouped_df)
export(lag)
export(last)
export(last_col)
export(lead)
export(left_join)
export(location)
export(lst)
export(lst_)
export(make_tbl)
export(matches)
export(min_rank)
export(mutate)
export(mutate_)
export(mutate_all)
export(mutate_at)
export(mutate_each)
export(mutate_each_)
export(mutate_if)
export(n)
export(n_distinct)
export(n_groups)
export(na_if)
export(near)
export(nest_by)
export(nest_join)
export(new_grouped_df)
export(new_rowwise_df)
export(nth)
export(ntile)
export(num_range)
export(one_of)
export(order_by)
export(percent_rank)
export(progress_estimated)
export(pull)
export(quo)
export(quo_name)
export(quos)
export(recode)
export(recode_factor)
export(relocate)
export(rename)
export(rename_)
export(rename_all)
export(rename_at)
export(rename_if)
export(rename_vars)
export(rename_vars_)
export(rename_with)
export(right_join)
export(row_number)
export(rows_delete)
export(rows_insert)
export(rows_patch)
export(rows_update)
export(rows_upsert)
export(rowwise)
export(same_src)
export(sample_frac)
export(sample_n)
export(select)
export(select_)
export(select_all)
export(select_at)
export(select_if)
export(select_var)
export(select_vars)
export(select_vars_)
export(semi_join)
export(setdiff)
export(setequal)
export(show_query)
export(slice)
export(slice_)
export(slice_head)
export(slice_max)
export(slice_min)
export(slice_sample)
export(slice_tail)
export(sql)
export(sql_escape_ident)
export(sql_escape_string)
export(sql_join)
export(sql_select)
export(sql_semi_join)
export(sql_set_op)
export(sql_subquery)
export(sql_translate_env)
export(src)
export(src_df)
export(src_local)
export(src_mysql)
export(src_postgres)
export(src_sqlite)
export(src_tbls)
export(starts_with)
export(summarise)
export(summarise_)
export(summarise_all)
export(summarise_at)
export(summarise_each)
export(summarise_each_)
export(summarise_if)
export(summarize)
export(summarize_)
export(summarize_all)
export(summarize_at)
export(summarize_each)
export(summarize_each_)
export(summarize_if)
export(sym)
export(syms)
export(tally)
export(tally_)
export(tbl)
export(tbl_df)
export(tbl_nongroup_vars)
export(tbl_ptype)
export(tbl_sum)
export(tbl_vars)
export(tibble)
export(top_frac)
export(top_n)
export(transmute)
export(transmute_)
export(transmute_all)
export(transmute_at)
export(transmute_if)
export(tribble)
export(type_sum)
export(ungroup)
export(union)
export(union_all)
export(validate_grouped_df)
export(validate_rowwise_df)
export(vars)
export(with_groups)
export(with_order)
export(wrap_dbplyr_obj)
import(rlang)
import(vctrs, except = data_frame)
importFrom(R6,R6Class)
importFrom(generics,intersect)
importFrom(generics,setdiff)
importFrom(generics,setequal)
importFrom(generics,union)
importFrom(glue,glue)
importFrom(glue,glue_collapse)
importFrom(glue,glue_data)
importFrom(lifecycle,deprecated)
importFrom(magrittr,"%>%")
importFrom(methods,is)
importFrom(pillar,format_glimpse)
importFrom(pillar,glimpse)
importFrom(stats,lag)
importFrom(stats,setNames)
importFrom(stats,update)
importFrom(tibble,add_row)
importFrom(tibble,as_data_frame)
importFrom(tibble,as_tibble)
importFrom(tibble,data_frame)
importFrom(tibble,data_frame_)
importFrom(tibble,frame_data)
importFrom(tibble,is_tibble)
importFrom(tibble,lst)
importFrom(tibble,lst_)
importFrom(tibble,new_tibble)
importFrom(tibble,tbl_sum)
importFrom(tibble,tibble)
importFrom(tibble,tribble)
importFrom(tibble,type_sum)
importFrom(tibble,view)
importFrom(tidyselect,all_of)
importFrom(tidyselect,any_of)
importFrom(tidyselect,contains)
importFrom(tidyselect,ends_with)
importFrom(tidyselect,everything)
importFrom(tidyselect,last_col)
importFrom(tidyselect,matches)
importFrom(tidyselect,num_range)
importFrom(tidyselect,one_of)
importFrom(tidyselect,starts_with)
importFrom(utils,head)
importFrom(utils,tail)
useDynLib(dplyr, .registration = TRUE)
dplyr/LICENSE 0000644 0001762 0000144 00000000052 14121112104 012371 0 ustar ligges users YEAR: 2013-2019
COPYRIGHT HOLDER: RStudio
dplyr/README.md 0000644 0001762 0000144 00000014334 14176716423 012703 0 ustar ligges users
# dplyr
[](https://cran.r-project.org/package=dplyr)
[](https://github.com/tidyverse/dplyr/actions?workflow=R-CMD-check)
[](https://app.codecov.io/gh/tidyverse/dplyr?branch=main)
## Overview
dplyr is a grammar of data manipulation, providing a consistent set of
verbs that help you solve the most common data manipulation challenges:
- `mutate()` adds new variables that are functions of existing
variables
- `select()` picks variables based on their names.
- `filter()` picks cases based on their values.
- `summarise()` reduces multiple values down to a single summary.
- `arrange()` changes the ordering of the rows.
These all combine naturally with `group_by()` which allows you to
perform any operation “by group”. You can learn more about them in
`vignette("dplyr")`. As well as these single-table verbs, dplyr also
provides a variety of two-table verbs, which you can learn about in
`vignette("two-table")`.
If you are new to dplyr, the best place to start is the [data
transformation chapter](https://r4ds.had.co.nz/transform.html) in R for
data science.
## Backends
In addition to data frames/tibbles, dplyr makes working with other
computational backends accessible and efficient. Below is a list of
alternative backends:
- [dtplyr](https://dtplyr.tidyverse.org/): for large, in-memory
datasets. Translates your dplyr code to high performance
[data.table](https://rdatatable.gitlab.io/data.table/) code.
- [dbplyr](https://dbplyr.tidyverse.org/): for data stored in a
relational database. Translates your dplyr code to SQL.
- [sparklyr](https://spark.rstudio.com): for very large datasets
stored in [Apache Spark](https://spark.apache.org).
## Installation
``` r
# The easiest way to get dplyr is to install the whole tidyverse:
install.packages("tidyverse")
# Alternatively, install just dplyr:
install.packages("dplyr")
```
### Development version
To get a bug fix or to use a feature from the development version, you
can install the development version of dplyr from GitHub.
``` r
# install.packages("devtools")
devtools::install_github("tidyverse/dplyr")
```
## Cheat Sheet
## 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
#>
#> 1 C-3PO 167 75 gold yellow 112 none masculi…
#> 2 R2-D2 96 32 white, blue red 33 none masculi…
#> 3 R5-D4 97 32 white, red red NA none masculi…
#> 4 IG-88 200 140 none metal red 15 none masculi…
#> 5 R4-P17 96 NA none silver, red red, blue NA none feminine
#> # … with 1 more row, and 5 more variables: homeworld , species ,
#> # films , vehicles , starships
starwars %>%
select(name, ends_with("color"))
#> # A tibble: 87 × 4
#> name hair_color skin_color eye_color
#>
#> 1 Luke Skywalker blond fair blue
#> 2 C-3PO gold yellow
#> 3 R2-D2 white, blue red
#> 4 Darth Vader none white yellow
#> 5 Leia Organa brown light brown
#> # … with 82 more rows
starwars %>%
mutate(name, bmi = mass / ((height / 100) ^ 2)) %>%
select(name:mass, bmi)
#> # A tibble: 87 × 4
#> name height mass bmi
#>
#> 1 Luke Skywalker 172 77 26.0
#> 2 C-3PO 167 75 26.9
#> 3 R2-D2 96 32 34.7
#> 4 Darth Vader 202 136 33.3
#> 5 Leia Organa 150 49 21.8
#> # … with 82 more rows
starwars %>%
arrange(desc(mass))
#> # A tibble: 87 × 14
#> name height mass hair_color skin_color eye_color birth_year sex gender
#>
#> 1 Jabba De… 175 1358 green-tan… orange 600 herm… mascu…
#> 2 Grievous 216 159 none brown, wh… green, y… NA male mascu…
#> 3 IG-88 200 140 none metal red 15 none mascu…
#> 4 Darth Va… 202 136 none white yellow 41.9 male mascu…
#> 5 Tarfful 234 136 brown brown blue NA male mascu…
#> # … with 82 more rows, and 5 more variables: homeworld , species ,
#> # films , vehicles , starships
starwars %>%
group_by(species) %>%
summarise(
n = n(),
mass = mean(mass, na.rm = TRUE)
) %>%
filter(
n > 1,
mass > 50
)
#> # A tibble: 8 × 3
#> species n mass
#>
#> 1 Droid 6 69.8
#> 2 Gungan 3 74
#> 3 Human 35 82.8
#> 4 Kaminoan 2 88
#> 5 Mirialan 2 53.1
#> # … with 3 more rows
```
## Getting help
If you encounter a clear bug, please file an issue with a minimal
reproducible example on
[GitHub](https://github.com/tidyverse/dplyr/issues). For questions and
other discussion, please use
[community.rstudio.com](https://community.rstudio.com/) or the
[manipulatr mailing list](https://groups.google.com/d/forum/manipulatr).
------------------------------------------------------------------------
Please note that this project is released with a [Contributor Code of
Conduct](https://dplyr.tidyverse.org/CODE_OF_CONDUCT). By participating
in this project you agree to abide by its terms.
dplyr/data/ 0000755 0001762 0000144 00000000000 14151641776 012331 5 ustar ligges users dplyr/data/starwars.rda 0000644 0001762 0000144 00000006633 14121112104 014646 0 ustar ligges users BZh91AY&SY e@$2[W@FH}f Ws$ GA`jTF
4D2jd2 0ɦѠ @C@ 4SzP&
h m5 4 =@ UMjb
2bi FFh ɦ h
i h4Q)S'iM
4
&#LFC0FC&
C10&#F2d$HM
Sjf&&j)zzi444 @4 h4
G75hT sG'}šZYϧa ̈˕$v5^rWb ̒@?SLbII 8Iv$^UHB$ ,$ H } rgn`h8 .Ǫb C .H5T$ܲMC-e T\ܛrE.of&|I!ҐO <55wa[nVҟ+L}j7hYfӗֻp0qn
r}:Bu m$v@܆ZYM]WViFtd,c^D!('4&}UYNP+-Tz{ ,MN2)H\,#g;>Z,H[Z^ك|.s2$[V*R3ifr ѷUaF;ZgȤ'vpq9 BN$!갊I0 B@H ΉAa
H;Ԁr PX,DEEAV((*AAB,"1XAd&ߧ"\EˡY+50 (yB>&'0URzZGZ|Ҥ+J=.rqpz7O9LUvNY[
jdx60ET`=9TFdžY`8fM'CغHQRU)נȨYfHe¥)ͮoUƻt-5& 0$6"@/HK3@ )Dʍ]Cێ h8aX+4P9fh0 u[뫙4rSg" ^eD$@: 3lE $"T? a+CB`z>w9wK `YϞLaMF Seȍ 09T# A IIU J
|B6% 5&0P& 0@&:vdЄס 7ebGV& 6h=SJtw9 u)<'$b5Bc*?C1@h&/ Z R! W(c1PZ"Q)KϞ uN$~d"");V戥] '8+eZ"c&/ӱWͥ&Id2 7@L3YPjNt7F4 ۨR.ъ4 +u hF h!}H+|K`s8TZ2Ѵ@)!v)@
h@r 58$yNCqID aG'A.B{$X)$AaD
@:ʱhdOLI# g?~OaSB3bL$]Eid|66?>z OBbm94b\vNZ`{X)t%wU8$& mn q+W :Gzm"*kps /Nђ ͦBaDU UY\3m坷 6צAx%*`A9f.d3*;I5-=܉Qfg $MJP#I4 N
chٌ=C7(aIBRi"W6:q&%1H1:/~|&iyBH ㅲn
0 Yv "JۈWP˸g*xƲbm bYE,@8kBK{\8cpr+ȑx>
]äjl
"P gYh/<^& ʮзL8
p\]je-MSʠEU! 1@MQ 9.E2w-11ët85FuH{Ъ
"k=o" ʂX$eAPRX $L}0<@16g_ޠQr;sMp`T`bS#mTڢS,hwW洑vHEH; ƶ~*~X|͑d2Uqt^ʛxodz-$!Y=dR 3PN t{dถ1|EDQ` @euNS t)=t|q_?Rek 29C[ªaa~$ 䖇RZ
]SˠFJj%Lpn!I$Lw%1sU#A>ab5+gEo;fЕ
] A"@R .-?[kѮC9|ՙƵQG]9D@>tI?;b@"<Ӑ`2^Acrr,&y7id#Ed`30D&^.nJQĞZHy*e
koޅUA[(> ?dI/#aAi Đ]B@gk( dplyr/data/band_instruments2.rda 0000644 0001762 0000144 00000000322 14121112104 016426 0 ustar ligges users BZh91AY&SYH, s2h P@ޠ@ U?M=#b1iƚ
2h 414`R' 4
" WEU2؋%aX+ }KIm~cu̥P A#8L}6yE*1˘(kK7!F)7UրIz!/)
(RȲ }MV ث:ʻO=M2(4&, oH)&Z X5? Z"(H8[Ԁ dplyr/data/storms.rda 0000644 0001762 0000144 00000133126 14151641776 014356 0 ustar ligges users BZh91AY&SYrHsEDH1 A$EDLd`=}{ 'z)}l\6n@uqg㜏-km'= ]^δn۶S[e 픻j-*W@5*]
=@( R /` AP
P ޭ仡üسOL | ^S$
(Nx 5<4.
@ ; 9(JHE}<"=RA@J@J }N i=H$Ks zO
Z@ pb t @ {0=
8+
|cqNsdoQ! "hЈbOzdjm=)*4 PGM 4oR <
4i F4h4 5J6=@ԁ?R~&4b12
2zO 1
hh =R A= ѵ H{SL h 5)!F*za?T?E6Qↀh
i
F ѡOOQM5&f2dhb44 ?ٿ&ч]r:\9ۛ[Ts mI+dm
96*66N*Z@ `xnV.ak*A(j.aRE躢AZE囕抢VXZa兖A
yHQ;? ?1?MQTJ_Rm@>!>EUЧP~TT_(ORI,`WB'ؑO(> I'/Q_ᔧ*EGOHT9Bؐ]"?HgwV
,L /D@ďLR0C,15J3>XO=na!PU)hBR"{f B*-Pn3(Y\ LIN Ktgz.So%;Yāܙ DzM=c 금Nz$
O[FhI_/qu
L:\փ9U<|LW`%ZIJ\ NkCLL<%x[2DDm^^HΫ Hsu ) Ki4T)b#]% HÍU5 y5y
ͱK GhJPDuz OV,i?? ;<^kYtec< LphtPB PRv r T)YGׅ_7:%۷:;u5s6u3cNm[Se^8wNNb uxWk*[ײa_u&L1Q(F>mfN(U Ӄ 2xVȶ;ju\]n[OVU֎ɴu-XY:'X\\f.iCNbmMD<1 ]c6[U;[ljm^PlE̪esH*mCaJWZX6uNئ#Sh4U+_v6b6j,գ`QTZ`[)fک&-l+lCdllmiMMS
[PTڛ!m*i#*aMuNe bm"jCe" cюw9l[Fj**mF6l#e2[[%
PSbچl6SeFmQMFVe+iF`G\z7:[+`3Kh[ R+`֊-mjڍ3TvXWm.[yiϣgRBx!&X
T6ONu^N'n ^9[6N;\#iW}G|4SD5@`e$W5^2ڧNKuغư:6/I<\6?+ sǧfzA7P'I
`nK"J|z#Zʾh{I?|$$+=AwY;Ry;K<}w=\7|W
uBo jEB?O wr?;z[W$~ (<TOIbzsp'[ ApZ'~kM_vQ6_ p^Xyc=95fxs, IHuY$ iP L$ a6uhwԮ#\Ԏ̆;r^4DݵSj-^:&GP<38ɚ.Rmv̖mKbsR:öG4*KSIU"]:uBc}G2%+O,Z bNK#cSdvԹ﨎N]a<^Mbג&(AQ܈QAɱy<{ WyGZxz)Hig@с?&x
l52/k^US~\/4 WU<[= z9Fxnlhۖƹr\˩2,wvߜ fhV}/Vٕv͕ydyd{ VJOQ SѡEWI#z35XXlX!Hb7*+sœ5{jކz}ǰ?JGo0ؔ`#ڹծXzryd;Zl ?jye*x=s<ke ^;͙Sc#ӗ}Glօ9 Y
3H XWkgttzk @NxI**X5[ 8,7zJUm6"Dwz2]{986!Cw:ˌڮڹr fFM ?7 @ll=Z>S Ni㍆Dy+b9LT{
ٕ;bZڏ=/>^\FCS H6Cd=6ح٦N|r]o km_ KZ>հsS? kVL1kkn^|sMfd+7O^_^'mxc>|[%m[k^P6- m^̝I*@QAa $@ Mh-X_ ܭ c>=,,!G¸l'| 9׳Kc)ګѩ!yduX;6h4QF=x捙G7~ߟ~IxgڣӗFl\#hŢM[j(vIΕ9RaO_ O^SS -'Ua㷫Ċ͍Tց:WTHPP}SuJh^cjWpNlX^Mn4bx[i6u-}f );&'|̆IUXؐH7+6x >բ]Wy\ʽ:fz|q=xw;DEKhe}^[m2 _թ-e+Z jtJAɮj6sLF nө1PKJwOnf$9egNjv0ز Nx`E1>m{5m#d4hHIkWV` H9Bs'Nd``Tjg3#g+ :Y9x)1ƾnx7nj'QW+6*py&F^F
* -'7lFC/N^yie6$X5} h d} SWپ9>wѩs UԾĂ-E$QZK܈dN"2
hHp] NGU|]Kߔ/=Z!j,lAu[۩ ^>G哾ڋӤ2jig\ᴳ#a2v֮cydZ;=Z'0+Эxk_^4HXaDY`P
wԎz|2KϖU߮I6m}U+[MF0Tb5|M6)|_v _^W|2ڗ`ut9ёשٔ
*<5p;Вe"0x!C'Sψ[߃6|ue nfNmlںĠH_}
$HWC9%Ywד[MvxmR?~ǣʼn ^OST;`xrs+W$uO ]^Bٶ0ö*;km啲znI Bi&N߀N˨&}J} M{_5{ku\ νwty+=bԟ_} 5ѡzu/<`ړenh
;R>V: } t^cSd&ا
OU玴qՕysm')&m^?FDUFVTkFVZ4h,h*LZJQcR[lFj-h
[6[X6ţmhZ1[Eclj5bEljQ#T[cTThFM&MXѣX6V(XQZ1md4[IEhƳ\#lEQbhՍ+F-TQlUmEQVmETlh Xֳ,ZMFQ6mF4hشbMbŶMcQ-b#TXIEQʴTX%UDhبՋc1[ЕcXh
Q*s̫eŢj-En[Qck\cRFnUVܭj-nX6mIb櫚*FkDXŻ4Q (,2lTQ%X,mQF6LLlAccQIhk5% -͊
Εskʍ9r03gvʹ6,m1[6m\Fۦh\͍nb5PcRE]cˎ[b\bѺ[FsS6ۑ-wurܮZZK\6ܹm`G-5FwFܴ%FʹrtŢXͮlEFXh6wq[j-m mmQsj
ssQW7)75W5Z3QsN5sFh16.sc[sE-cr4mr9rƣ[rѢѫrlbJ*ձb6Z-s\b-G
Sbu֍[QFZ܋kr,EJ7*ʹFNDѬDc\ы\ۛErۛ!mZەF6XnXr泺ܹMѢE&;+whŷ6#W#V]"k`Z;ٖb(-IF(*#lccE֊*6رb6+F1j4j6梣d9smW6b-sZƴh
XesWw\Q&kFc4DZ.mwj4QAX1)6.rԉbS6#lb0`Ei#kMɊ4[ tL*-QŤj,SMœ 4PPQF.ZV6湈ṵr6-dJ1l[hk6**#5ERhUʣZb16J6Nmr\c
Z6Ecc2]A,nh܃F1X#h0hH,mlc$mMd1h&nEd`F,#i*F5h,i6M66(
lV2m[ƍE nhڍ36lٴlm
~4*~fB@h1!2"i*:.=g^kkfX[>]5\̥77AyMC#{u~/rM E5XblEF2/jTy D U2LW\ ]6N[I$܌ 6i% Qٻɦfn6K=\h1vjY@p(qا4`~B+ɵ+(vyWQ[':MJn/*:!N3mOmvW~sj>H|kSvτ~t( !(R?TShJVF!Z :)'Z Jt3)Ľjc}r$ܩ@7ͤ j }vy3φ..AS]CDQ&T#ȰXl
fFĠqUjTh ?RKF P0u089+LP ~2.W9Gx0:w^_NVon Ͼu=+^X`cWrE[If%"̤I崱^}|mMu:]^u]w~q8[Z/%OF 4l&jM =eEН
\Khh
Ts+\*Es.")21H"\TEuOErU25҈#Cp CP]uBBԭ @W$$̉MJSE t=7$+u<$*S#Ar!Hgopr]\f5 %= H13\\y]fyyC$,"IpO*"OTQ-B,K(C$P#B%zzU I"+fy4+ՇF=0IgS5*$A,T O=RQWO4J45u3uȣBG5L2C"7>[rf5E6N"vٝ_0N:es4ҧX ast]'^ӜɪۅlN) K}gI;Zm^=-shi*'b ` tȮ\or9 ny.Ȟ\rprW{9*hu^l[sUԝe
iBB:?
1v/q ֔
% ڳ+vQNzG"lG̭X)ig
ѝ"TM(YbGFDE$ONT^(`$M=!6ʺMvb,B 6$tsScJ/KRd^dBKD CED!5cSҦטKO& dzdnLdLϮWsޗIWUM490b[?R ~,&#X"
}Hr| AD &5fa"ď>05Ƭk%XKf ҅Yzno M9brl OH
$=aʒ),Yll^zcחDi*ŘZ߅61
s
2ss7+\L%
4@H"
t_vJKvQOZb:GT[p/ɭ#4U<*!'ʫŒs$ k'@|ݼ]v793Z]0c~`L
7!w nfQ-ҔИdV|qESC{|8_e&y<$rU8(> le-0Zh`+5FKZ,,&FMa145i4aXjV-5{e'!q1-&F,ȵd4j1,5UU4aԙhZhZc(JjaZ-+ Hłѕ40ԙ`IRVV$łj,_V>3z9ߑ]`l<[6;Zլ!SP̋Hj8%xpt.Z8DkfES
8YT-KsG>
~
R2#| ć?Ih
Y3ʁQ9Z*"NroHxI'H ϮAշbv2 'Z ~u{>WI ߤ.mSFUujTjj͘)(4XV-Z5\h_smF&ks[ׇ9ZܪX֣kAQsrµs^%y3Ċmm|{ļ
&i*!AvDpme3yA q6.5˞HugJ'nσ*qiw6MjVVrmz_6ztW=g
ͱcdF Իm ^\v\eqE8"5$bo.É4/"&^O;iE3-.|Ϛݼm˵f">>r*o>||%טr u=BhԵAhљZaE [2Tw*x td&*MI|#R+2l TO)KCK66m )Ga:QTGI䢺Dv;T<0[#` \.]yȝK.Ew JU-A܆.q')p&I "iGbyj+ 5!d!$c Izhٛbdz>Ny1IQk;dtΫu*~E]4h+%M00 H3. ӻ 3̥) =U /
t*qW Fe *
`65*:X){@Lu}RK ;2km}f^; /ݽ1Pݦ7qL/ NUp}aX^pfN(¢a
pIUI3L*o~)a{k1Ewwscj̶i?OBlWfyS_7eE~1%WUEe E)ڋ]''QBFxW: ӑLD'Y P]JM'Up8+QsT}2}<Kj'؟%:8eX%OZ$w(zqN!R`* Qwb~5 n&; 66:ػͶǗuoGƽ ^ݽ*'=W+\KǾ0/bVc sb"?bʝn ^, 'R"4NOq}jԵ_"!p\^{6GrxSWS9;ujv}EҝRugB'SW)/j}O*<< |^KJnpѸsʞ
=^;y; 2DQ_ SԿFU_ЊIJ$hYHH!t^߮ݪ'IȭTOTWdGԁ'I
g>~ܣY%a},
AU~j DԽ>I> SRj#OS@_` "} USc1)\CE "T%
&)vFU?DQ .%ui pQZivt^݉}I_"^z(WzD|-_:r{?[tT
N\|znnW.NwwJ].)6BmV] K yx$;JyiIʑ'#je.bl
_m ~2ֈWD|9MWE> ~8lqV
9 n(BG5f9
Ir=mG )x~OD"JvzW=bEH~
tIU_{C > %# }4xy }Ax!WK@_g9m8̓CUm.a.h.j4l+$2C]uE Q liJ }6JT(# G`a {T.aH$Ņ(Ĥatc9B1K"5.tjboZJJl[|1z3xU
^#1VOsɭI[eRS|ݮ*a_] , E wuov7ܣ;)rmW U{y_CybA6-=郟gv7C7w Ӣӵ vҥ{VQop*bE*[`kj(
g a_KPxHRl>(¿3p
2ƐT7y
raz_C愨hyP
wn~h|?2P/I'=U-A@/ZW>ʓاi"/?QjUju 9ʗP9@ꎧEut)>JA_-UJy U?T|
/ 5ӖʣE K?0'QOJE/T ~7 oyd ߏI(NU]锑{Ȼ }^/YL
WJ/rURO~:_+KA'Wnix_IO}qKʪ}0RGi}?UMқ6ڧ!1XBDr 'REqRr''jP˶}wN];u]t9^J87%Y;|}~IT@>'%?"'j9mK.\ z@Tz_YwJzQ%< Sr }rJX(H|%O/QS|WJ@5U JPt+TtOG(+clrCu}zP1.;ҝ7)>u
.m!RTPQE""oW{^◬UׯJ1 ~ሧqi
}/{B! _/~T =뫖J+"O[wT~j><~xa~;X}ֲaW/R'bx"JxQ^!ih$i9U]E8#$TO~5rǫr-Q7&釬C/UmGn\ K uR(E;k^_"^"Wi!%{ˆ^n ]N1`cFSz!] c2%jB\ګJ]YF
Ch7!y5BEbװOhã^,ux'8p9iRc ~n(^Na88b<%ӹ+-\κE;^ʺGLc/P}u]j{,#aP$5 rחawuٱ^ T0t膍Y n]dz H̦kjt5 CRTnLmՖAfCN.
رcZŚaV\ ae58euSemacgm)[=mKΞKl6cJA
Sv5]lFENŝ",JNYV'vaM#0fYMLf-NpԤ$Ztqic[Nd
fvgi2j3A8MFh;FSݙ *YHB͜g2QJsi6 &j&BnV31fJEJ[dXQpݷ
g V-rldxgmlg8%mэꍥU] BSTHb"Cm6& ]6M\EG5[a-4 Uuۅ\Ħ3;vmm:R:RhL1tWZ 6 S.Ì$6b"&{$Nζd5 84ZsjU-2SgPN76]lA&--Q1J-#䑣4:79 rjuwIYTLēɫLkIɅU]:vR"=iE2i"n'} 0bbK(00|)}4lR{%+1LjP MmJ`Պ{ȫҫxbLnlz݅&Q&/%!dy)+<A겧Q]mb$V$]XΒ}smkɠb2OoH)!PPRmA_^Wxs^,o .s^
Tչ mMېYPbÇ.L%Xē5#$gb|
;N
a*%`,pxS< RY*|% RJ.c60C7ڼ}hƪ1*kkmF6EhձZaM6Yf iMC¤D4i42ii
c(LB%2SH a "d"ҘPk402̒f0J)"4"$̈́H
i)
!jBI04bƔI3DXaF0%IaDI4DQIEHJ%")JD$d4ҙ)LLf2 Q H1fК̘1Lf3 #MMe F fR,FfѤ"Ii651i46LIFJ`i5͒KI*L&b&`D6K($
Qd2h"0hC6dIFH$MEFJFLJ6($2kS60cb#"b4QIcITb&6 ,SHLbь4i@XԘؒ!Pm&hhX"Ťbƈ&ѓTE5kES(64lآU*1Ib&2Ech6$hc%5)3F&l6Eb)$(R#ƶb&)2I6ME%k"6UتI5fTl'I'zQW{|wۮr6,
EaL Z0Bux#FF'm`J
T}<wT?/dI䨉QD맸tS^zo)O_a|OF⯋~xO!o_T=:' yȟ[zǓyzHaXE zm^|蚾^<]H#=zMH({_n*Eۻ71H?f{1*jBt01A"[Ief2C|k=)}rN ~{Փ/Bzs[]UΏ8y]_?GUk㶯 G6ּ%
e"Zi)pJ w["E9iTˈ'ؓ bB|(:R|o\>#eoC[{m_!v (JG^]zk<%z
2ɜ 0~~{ Ҁ Dt ZJ jJkhVmh" ۺ5]u]ۻI\4PJJ(*@/cT1
$$D(KO:u8G]5Ufж4mV: RSS֓*B B4Ti FFH F=M4=@j 4zGh i=FF"! ҙ?SD< i 4 y)"
&"!
hD@ BLP&&jdih4
h @h4 4 @44h
4 ښdzA$
P M =M @ zڀSM
A@hC@hzAjSFq%$='}
KG0u_ոMO1]>'Iڧ>wcтM\=/M߰~}]vKｏp̰ G>ui+ֿ+G/o_} ߊͷAc7ox N ۞Y^x>]s|}^{m9icuUg}L뿩*|öy>%U:s~mt\/Fc|^㜢bJvf3Ӻ;eyKLu;Pgkϑ 0 PY`,Ub(@Y TT`YI "*)",$,EU((0U1"Ed #I YTQAdEX, "(őb)Db` )E) *E*,E R
)dXD`)"1!PFEPXXB P+!R*RAAEda
"R
%dR D X,$Y R**ȰQB)RPU ,HUR,V"AB,E1E
H,F#XXE#djDAD`*X,Y"AB E #
6ʀUd(XEARA@)X,bŒ,P "( -T,T*U`EʒQYB+$P-!14,¼hsJ! )PQba''$
XJV XE I*
, F26lY\J BCLdE
b`b@[VE"*"dVJ+`"@ 1%@ЊE!PHDd
T+$Y%HUI+Y
堰1TɈr
HmQh) R(T XBAAH%"Ԁ X$Y"°+ X"*,(mDT@@+H%%I+) QT Rk Y` @ lXA
AkVX"+"%EE$hT+%IY REU
,@,X ,PD*`J2*Y*6ŀaPj,VH6T
0UR1!c%`BQH0()(,
T"B,"*Vb
X ))+ U+!XVJʕam$IR)ZV(,+(FY
QJ`*ĀZAZY!PZTYȪe`XPYPHU B`"
H)T Db0XEQF*b
)$Q`*X"EUXA`i* (dYX-aU$AXX,"QTB#YVP%HBH *IP%aQ @
V@*%JDh\H(SiL+$:ETE* +RRf(T555$Ԭ!YDd+"UAT-Ɍ"IS)
0P*"VA)*V *
dX "-(Yc"֫bEZ RTX(Vk)RQ+*H*VAaiBVTBm$,"ŃlV(
<amBڵ+P+ Y%-)*TXKlPRXPQ[EPX
-'3AP"Ă@PQAb"1AkF,E-ւEkX*4aZ5 (l""d`ňIB
@+(,E _=E!z>Ł,ҔcFalX)Dc1PQf%[U`&f
Ab T) +ҍAkUbҫ`V RVJ*
5,(BZX
2JmTTDE"Em,V2`UUV1DQ1DVTEUTV"(\!z[8sLaYZYRJJȵ
-KjV"TZŨ@0` $" YJŕ-jV,Q-)YV$ꕌLVԁXI 0$ 1XTGk%`- XmiE 12dRc[h
bV*,(ĎfLE P%QV1!RTDʔ
2,G0UTR*EHq2pL"& :l3E4 ]h + vUb:@Y'g,g=2b (*dY U 19Jv:ҿ6j8ł2gt$>#nrkUN4 XۙBmQU)X*.!X*'m?P;g;gO6Mh0JR(C'[khL
f53J9
TmBXƜzuї.2e hVq:f!( '9W*
}-_gu CjDg\ OD-M̨.08S| CO
11`@$sKns8lp\@ 9F` w}
0)N&4ڸm5K 8Q;[r19{|3TFj *)TFJbă%g s (٨2)72ޫV +vrMi 2DPFE
9lbV(wl-ONjO ;tCRvⳚr̔ʹ"KYFjKܡN7d1R%d;e_w
1@ԆTPMu1l=ҲtghT
feZr`(S_ aYF)
O,qR)
{S|*(OD gPY-
*dMfqP-OO]_,5B3[XQ<3R u,
٪˯k}E(za^
j_k
{$֕0\Iw@|[=ye=Oa{J ['n橋 Ju12_ry(,Y۞|uN;RX,5*/QbzC=ԬxMDmDQ U ڱEbIOd( w 08-SW9|-DghL 7vL24JV P S{͆5Q!ctS۳;>ҩ}ݵOUL"e;ETN[U T[
W%eV,otQEQ֫Q˔j 2J0X V,ʱyjV
.$j$eTH A10]²M$ ˺jKmZQt
!m(Tǎi+ #X$fڐ)idJ5ȉզ5[1XDTB`l"Xфʈa0VjTZ4 @3b֊{f _^]
e ;|S涪ږvar.6އ1,-j+l mV>)r-)k01ȡlP%kqHlFmmE2A 7nhxQGYs=M73Zp9Wc)U-eP5. y2C488u+zp6 ~13mea(TY+ חk-&%-rIi$
CZn轱eN^P-*i^RDQvEAf!c2CKڴ/3J X(§Tsa7
XU#d RUPUFp`oc* e #Ôxo ̨SҐi3 ]:f( &Wn JT獕tXJqe"4h[Mqﾘ`zZm(,E
1FKQ4+%jiP|z`ِ bK`s(aeQgv]MuSyL6Zb WR&(]m*9BfDPQJԨ M2*`f#pn#%y ;LD\n LPXB1E&jCS! {a mqԱ^378>zǤQ3e1Ak:^хK]*>m 7
>hT8w,)UﻮkxTJ H8
u`%XAxD*0f9U<&"Emt8v龿%8)8cq"ΚZRaOJUaZwJi='VcY
^LbO)+;|3U8eE*j,Lj(mZ%o&dmi{ˊDX#yy/w9US]A.&hX߮ U\צ+\:M*g 1X qF"N[ET-Rf1W좊5n2a£1FQ'x}(κsv h8RJ~q}B.x e*Mƅq57)]clvS^RVC P
[NxEm[Vͣ M0R0 2"WuJ,G7%pTT+,Q
)S XE`3EQx]v1[Ղ gs> q]\k[ %
Q"rBT&"mH`@!mj Wͬ9nPR֕ F'Uc ah[E26$J53w,7\3t.2/_(jqz%r>sVm,t ft]h(OOGb";1\@ {¦-uh,PG#=Ԩ/YUfҩZCXUTkVj3]t 3p7w4mS |;LfG9>-mFhf)ZFM48B3y ip@j >+3q[
ڹD@kuX[O bfV⢜n4(գ\ adm-G*
xgxlJ,REci01Dqxؑ6 : *& QȉUE
"pOUX7LDKB \?xA'͑"왇/sȺD89UPM1<+--5lk7rE
~MMr58ؘ 9:i
˘q*0TM<"m>HXT G)!D3a Jxؠ3Yn&:u- *QyUɻWRc!e)Pl r"̳9︳i)hBh¼^Qm(Q-\mЧTcXL),28Pf X&7Lh]VytUX90)bT}h_ޤ&1"7FD
0*pҘF
2<^, 'YС^]\G3eɮfeuCYYw
CV-CΨR(+ڝ ~\;25S U喌r0cZSv̈́u{
@٬l(%90##gu jm Qgߵ.6m#N D.S4tMc9|Ĩod}UKvSU`N5bF#B`h[/Gn3xɮ0ֈ1Gs){K17(bW
Բ Qѝ҉{xοk+xؒ v Ƕ٘)Փ`eS-`s3yi].'O Vbԯ"6G"%W 'EeƲbQbۀdUTb#c퉋 ( ,6ԾmU`EWк;2Ydki .e@%%2Ü; DnBYvYV/X3jeL]3MQcyd:--Zٗ&
AD$2赠|K 0xr=ʄsU0-즹9}LP :(cm3rs*$?صUBBMbn71q<ޞfUv=νyM, )iJ+Q6'rcrE%5yGe$y"54cqXq4O &Q}1'kB r CRpGOcr }Zybb3!="ˀ]|eէnCd2";Mk>ç
+Y 4r9z{b>$IZ甹8"H)JiUj
q5#=WV:g72HT,j0$@Ϥ-^ZYAf 2R "ͦx͵$h|Y"Gb~7_jd&E# ۤAt#aRѵ`.>:q
ԭ!M.<+RO
MmF)d&W}Em(M .f-em{:7sZ(%G]1ïHiTf\AKx
!3 F;2XȠ/[$Z&@U
*S.Tz( }4(t4:@"
v ڻm/oNuPqv Aej&QȂ;R9R<"'%cq
HCq01
{w Gu!-ySQ5f7't2nGj^EȤt f3`۽#3 6|l 9
`O{N&- COLh]dEƔ=/ xxlwܚB07km: BF"PC@_i{߱g*>HfCcz[ fbPLj)*/a\Qakd+TW0 *O%`cMVZҌj !+ FܒQ5 vf%a+ $fQz~@rR320"8:RӈGPAu!1 B{uv.|zw.gh3[\7[?)JW{<DT 'ҵ?߳ctC z01/iqy;W
o S<~?gϰ9yYU9}O-j2-5f߀;ȿ~?m" :tQx|nam᧕DDwqM]zsy7ۓj8\LًÌOOG<3 9NqGߥ^\NZoצkvᏠ` Z[zoJWj*' >'kB#jg|N2x #6f0翲r('GqyVϖ,H)}|2ᖄcůVm]oaA˗0G卷[ wg폆7]\B :=><|lY[4nb%=
^Ær:_^=6Ӓ!4/^y[ &;z|>wSd_ǚ 3;,9e?gW fD p0>=DL~moT8j*eg8?
7n qzq:{龃IWuφ7M8&}*ΝYMgV n M Hؓ3&Y Wm[Ʒ0Л^To˞@DaϘdFI GVh'S= <ǞevĉQ]E | N 7?
&-i
5Ppf7R.V9T0Mt+uw]D-;> I5f.nj3;g,%
m^r:yNAj˪Z/7WC܊b m;Uη죮2n{6[x˸|0yOEfe gf]fM[!Fk
2ZeE;
WRu÷ A\ɸͮ!#jkꩫF- .j'ުdj"s 0®ͳww? _{g/1ͣ\.3!(_l\>sW̉J;BluX@ҪU%ժV)<}/]=VuϚd6ߎ6년7< 3<=7װpX߇瞷gi *Ng
L1fokW`##b8
СEԯ TWe j[ fk=/% ħpdgU-Yֲ`e64 7G3T>
6^mnEhNgt0}O-1xvȊL[\!͔9 ۖ* A űzQfTs㾵Nһx~Ҝ~A JUa.3%8CFjc~0YPNMK#ő4 6MU'xbiUHR&b esYFr*ī كYcft4"[Ub [YFjpk5eKgJ\[tz(S Neb O96r_Q
!i>-Zs#)=əbצW7Sߏ[sEp)])zRtףSw!q"mdC4 \.t1ڻ% F0hOvʋ*75 % hgem۵\
zSDוֹ(((W,4 ,7ae yAݫ5(nnݝޙچ
R2C
LK[U]J# ԟG9Sr Y{%-R|\E:qUa˶n!i <ߺx= zϝq՜f+`.2L0vdU6q.\ȕ읍 UhCV.f,[7QhNlmj(o^FnGTUN.ØũJPκt7%t $.T&^hӝi/b!ewM%GL ).vHzfLRɄN/`:Hu&¶źa<H뽖E3W3Q!LPYw*;
U CiEt[ʡ&fc\j6l2Y04m[{ph qP$еm-EB`]#U]j< 7gv,u*fM61
8q
ڵYf\R.N̡plծdUG5x5z/@ɂc*[KuZ0RΊnP)s^^{]68CsdJ3$G+yKڬBJfr.:^u+iZ&SysbF H*o:T)&Bc|^"~k[[U
1#4;BPÇ$ L̯Q
-N2Hbi6lRf{ffո1St$k+0 %Ž-Z qLWZ6h =iAa\ 굘Ch oŝA'̝
> }+}ޕV˩8F4Mnb8O0
[1
$:r-6WQ1m;赯ܪ`83q"
5 x [eL8|c3D
[R뤞me,2'7QuZexi *5{;OTRڕS|EV&2IDÔ@])8uF,jAg71&o
uroɯ}Vϼ0 [y# b&y-{H"%Sl íUsr^rPC6+)y}i?=>BF'r aNLEFij %D=vmcmt`RFT>t;}F܃ $gaGXa`UdB![
W5ar$(b4$#+9 <ґ[TXg,}s'Aܛ6U.8Wvαxf.L se#<99vUvj*m
ڑRʫ[k䆆-OatAm ̬EbZpsuzns{k>Y 0CBaTA PzjiV\Fٝ,Fm*j9 |M5EgJj\_;ޭy̫uJ QN [W-E IZ&V8+ՎWcDZJn:rUR%V#= #ӳ5[ B@@A#mjd ]ɁW"q&i-ݒ/1f ër1plgH(8$OK
-*vյ鵎ܷ+*iJPKү-rJWnq[p|)S>Js")iJ,4jǬw(Z okƩf /-?4P p> d*Xvy3.C9BMᠬF| =ffup`VQh2
=ǀ 9d0Jf i[܅o/O Lbu^B (40[ o" O4
h(R>ᓠ^(PD( V0) Z;9 {j=2E[ U)旯AB49(B0
aFU&QB
zWY/8@jDY"vE{hOy64E&8] Q 6nzxo_Xra7t*G?7B_7c=V(68=PhX^1^+$PL_ 1 еO "]COAomE"vDSmRQ#sA_B;:%jє &"`I2Xo ؽ& ԧ@ͪ6JgT5 peDHL᠍1
ηtezWYo , 2UIOk ~cP,>syh^w%x 7l:uzk >P[V$<]KPbPM4|ξ/]|n6"iB+b BC`,B2#|s@'h|YVN܁˂{8sڼ.;#b11_y86W 17*
u?%AE: i}^t{}ٷϟөDE~,( y`TH$R (Jd
("%
-!@U(Q@Q
+F)=y[|Y38qiŶT
JtU?^>}Q7s`27R» Nau-)1 #EkRI9`)jdvSo%@mG谝},G-:mq9.kD 1COG raQr" Tzٹ]'֎6! b:
Qm`E8q SڔS^"N"wrsJ @@Pe%ua m~X ]aՂ{ׁ3)\BW@ &l sH uDJY`mAAd()xT$v LH|$<ۭ ;ad}1NuaХ ՕI^-\ؗA6
I
J bB[&VLFFWZiAϛ !!l ?BHODJY$ =RDSD8L.C8DPֆM
2(@5a!ឬ t'T@*H&iׄ+Nꄨ5; ɖCSȴX;u%*J&Sw ŇI"$ZVUUFIƾΓ4mk#_lac ]##2I)S% ˖fBBf,JV
lMbMl0kb-:)fmyc1n|~d~˝J@ R8e+a<)!Ѻ{I=v.JxSPb
uL֕Nb#bj-Uƫexc>uHNJ\k\x~WK{Tz(3T;jW ؊Mg?J/vmm&# Or
9|r
ҢCre ;0 4!
I!PP1wK9 (:Y,VTJvJ$6D
A C@<3MZH(B H= 3X@@6FI82IPV(HG$ PG"D ,P J@ 0P !
dpSEE[8` 0*`0 4J#TJ@W:H#%(R RA, E0)E)A@A
U" ҀI aPXA*I@D0*i2r@(Ṳ(&T"c!%A0:.p!F dplyr/data/band_instruments.rda 0000644 0001762 0000144 00000000302 14121112104 016342 0 ustar ligges users BZh91AY&SY> 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 14176714177 012176 5 ustar ligges users dplyr/man/glimpse.Rd 0000644 0001762 0000144 00000001763 14151641776 014131 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/reexport-tibble.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 14121112104 014251 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 00000006116 14121112104 013565 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{tally}
\alias{add_count}
\alias{add_tally}
\title{Count observations by group}
\usage{
count(x, ..., wt = NULL, sort = FALSE, name = NULL)
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[=dplyr_data_masking]{data-masking}}> Variables to group by.}
\item{wt}{<\code{\link[=dplyr_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 error, and require you to specify the name.}
\item{.drop}{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). Deprecated in
\code{add_count()} since it didn'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)
# 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 14151641776 015454 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/do.Rd 0000644 0001762 0000144 00000003737 14174551644 013075 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[=summarise]{summarise()}} (which can now produce multiple rows and multiple columns),
\code{\link[=nest_by]{nest_by()}} (which creates a \link{rowwise} tibble of nested data),
and \code{\link[=across]{across()}} (which allows you to access the data for the "current" group).
}
\examples{
# do() with unnamed arguments becomes summarise()
# . becomes across()
by_cyl <- mtcars \%>\% group_by(cyl)
by_cyl \%>\% do(head(., 2))
# ->
by_cyl \%>\% summarise(head(across(), 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 \%>\% summarise(broom::tidy(mod))
\dontshow{\}) # examplesIf}
}
\keyword{internal}
dplyr/man/bind.Rd 0000644 0001762 0000144 00000005543 14151641776 013405 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/bind.r
\name{bind}
\alias{bind}
\alias{bind_rows}
\alias{bind_cols}
\title{Efficiently bind multiple data frames by row and column}
\usage{
bind_rows(..., .id = NULL)
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.
When row-binding, columns are matched by name, and any missing
columns will be filled with NA.
When column-binding, rows are matched by position, so all data
frames must have the same number of rows. To match by value, not
position, see \link{mutate-joins}.}
\item{.id}{Data frame identifier.
When \code{.id} is supplied, a new column of identifiers is
created to link each row to its original data frame. The labels
are taken from the named arguments to \code{bind_rows()}. When a
list of data frames is supplied, the labels are taken from the
names of the list. If no names are found a numeric sequence is
used instead.}
\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{
\code{bind_rows()} and \code{bind_cols()} return the same type as
the first input, either a data frame, \code{tbl_df}, or \code{grouped_df}.
}
\description{
This is an efficient implementation of the common pattern of
\code{do.call(rbind, dfs)} or \code{do.call(cbind, dfs)} for binding many
data frames into one.
}
\details{
The output of \code{bind_rows()} will contain a column if that column
appears in any of the inputs.
}
\examples{
one <- starwars[1:4, ]
two <- starwars[9:12, ]
# You can supply data frames as arguments:
bind_rows(one, two)
# The contents of lists are spliced automatically:
bind_rows(list(one, two))
bind_rows(split(starwars, starwars$homeworld))
bind_rows(list(one, two), list(two, one))
# In addition to data frames, you can supply vectors. In the rows
# direction, the vectors represent rows and should have inner
# names:
bind_rows(
c(a = 1, b = 2),
c(a = 3, b = 4)
)
# You can mix vectors and data frames:
bind_rows(
c(a = 1, b = 2),
tibble(a = 3:4, b = 5:6),
c(a = 7, b = 8)
)
# 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(one, two), .id = "id")
bind_rows(list(a = one, b = two), .id = "id")
bind_rows("group 1" = one, "group 2" = two, .id = "groups")
# Columns don't need to match when row-binding
bind_rows(tibble(x = 1:3), tibble(y = 1:4))
# Row sizes must be compatible when column-binding
try(bind_cols(tibble(x = 1:3), tibble(y = 1:2)))
# Even with 0 columns
try(bind_cols(tibble(x = 1:3), tibble()))
bind_cols(one, two)
bind_cols(list(one, two))
}
dplyr/man/top_n.Rd 0000644 0001762 0000144 00000003606 14151641776 013606 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 00000004311 14151641776 014730 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)
arrange_at(.tbl, .vars, .funs = list(), ..., .by_group = FALSE)
arrange_if(.tbl, .predicate, .funs = list(), ..., .by_group = 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{.by_group}{If \code{TRUE}, will sort first by grouping variable. Applies to
grouped data frames only.}
\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[=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, across())
arrange_all(df, desc)
# ->
arrange(df, across(everything(), desc))
}
\keyword{internal}
dplyr/man/group_trim.Rd 0000644 0001762 0000144 00000002153 14151641776 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/summarise.Rd 0000644 0001762 0000144 00000013111 14151641776 014464 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 to fewer rows}
\usage{
summarise(.data, ..., .groups = NULL)
summarize(.data, ..., .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[=dplyr_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 vector of length \code{n}, e.g. \code{quantile()}.
\item A data frame, to add multiple columns from a single expression.
}}
\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".
}
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 will have one (or more) rows 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()}}, \code{\link[=quantile]{quantile()}}
\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())
# dplyr 1.0.0 allows to summarise to more than one value:
mtcars \%>\%
group_by(cyl) \%>\%
summarise(qs = quantile(disp, c(0.25, 0.75)), prob = c(0.25, 0.75))
# You use a data frame to create multiple columns so you can wrap
# this up into a function:
my_quantile <- function(x, probs) {
tibble(x = quantile(x, probs), probs = probs)
}
mtcars \%>\%
group_by(cyl) \%>\%
summarise(my_quantile(disp, c(0.25, 0.75)))
# 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 ?dplyr_data_masking
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()}
}
\concept{single table verbs}
dplyr/man/group_nest.Rd 0000644 0001762 0000144 00000004166 14151641776 014656 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{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 00000002314 14121112104 014277 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.dev/}, 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 00000021712 14176717554 013751 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/select.R
\name{select}
\alias{select}
\title{Subset 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). You can also use predicate functions like \link{is.numeric} to select
variables based on their properties.
\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.
}
These 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.
}
These helpers select variables from 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.
}
This helper selects variables with a 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
#> # ... with 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
#> # ... with 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
#> # ... with 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
#> # ... with 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
#> # ... with 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
#> # ... with 83 more rows, and 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
#> # ... with 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
#> # ... with 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
#> # ... with 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
#> # ... with 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
#> # ... with 146 more rows
}\if{html}{\out{
}}
}
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{rename}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/tbl_df.Rd 0000644 0001762 0000144 00000001017 14151641776 013713 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/bench_compare.Rd 0000644 0001762 0000144 00000003541 14151641776 015252 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-bench-compare.r
\name{bench_compare}
\alias{bench_compare}
\alias{bench_tbls}
\alias{compare_tbls}
\alias{compare_tbls2}
\alias{eval_tbls}
\alias{eval_tbls2}
\title{Evaluate, compare, benchmark operations of a set of srcs.}
\usage{
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)
}
\arguments{
\item{tbls, tbls_x, tbls_y}{A list of \code{\link[=tbl]{tbl()}}s.}
\item{op}{A function with a single argument, called often with each
element of \code{tbls}.}
\item{\dots}{For \code{compare_tbls()}: additional parameters passed on the
\code{compare()} function
For \code{bench_tbls()}: additional benchmarks to run.}
\item{times}{For benchmarking, the number of times each operation is
repeated.}
\item{ref}{For checking, a data frame to test results against. If not
supplied, defaults to the results from the first \code{src}.}
\item{compare}{A function used to compare the results. Defaults to
\code{equal_data_frame} which ignores the order of rows and columns.}
}
\value{
\code{eval_tbls()}: a list of data frames.
\code{compare_tbls()}: an invisible \code{TRUE} on success, otherwise
an error is thrown.
\code{bench_tbls()}: an object of class
\code{\link[microbenchmark:microbenchmark]{microbenchmark::microbenchmark()}}
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
These functions are deprecated because we now believe that you're
better of performing the comparisons directly, yourself, in order to
generate more informative test failures.
}
\keyword{internal}
dplyr/man/nth.Rd 0000644 0001762 0000144 00000003062 14121112104 013223 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 = default_missing(x))
first(x, order_by = NULL, default = default_missing(x))
last(x, order_by = NULL, default = default_missing(x))
}
\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).
If a double is supplied, it will be silently truncated.}
\item{order_by}{An optional vector used to determine the order}
\item{default}{A default value to use if the position does not exist in
the input. This is guessed by default for base vectors, where a
missing value of the appropriate type is returned, and for lists, where
a \code{NULL} is return.
For more complicated objects, you'll need to supply this value.
Make sure it is the same type as \code{x}.}
}
\value{
A single value. \code{[[} is used to do the subsetting.
}
\description{
These are straightforward wrappers around \code{\link{[[}}. The main
advantage is that you can provide an optional secondary vector that defines
the ordering, and provide a default value to use when the input is shorter
than expected.
}
\examples{
x <- 1:10
y <- 10:1
first(x)
last(y)
nth(x, 1)
nth(x, 5)
nth(x, -2)
nth(x, 11)
last(x)
# Second argument provides optional ordering
last(x, y)
# These functions always return a single value
first(integer())
}
dplyr/man/same_src.Rd 0000644 0001762 0000144 00000000623 14121112104 014226 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 00000002677 14121112104 014113 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 = NA, order_by = NULL, ...)
lead(x, n = 1L, default = NA, order_by = NULL, ...)
}
\arguments{
\item{x}{Vector of values}
\item{n}{Positive integer of length 1, giving the number of positions to
lead or lag by}
\item{default}{Value used for non-existent rows. Defaults to \code{NA}.}
\item{order_by}{Override the default ordering to use another vector or column}
\item{...}{Needed for compatibility with lag generic.}
}
\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 for non-existing rows, use `default`
lag(1:5)
lag(1:5, default = 0)
lead(1:5)
lead(1:5, default = 6)
# If 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 00000003221 14151641776 014007 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 11,859 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 storm category (estimated from wind speed.
-1 = Tropical Depression, 0 = Tropical Storm)}
\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)}
\item{hurricane_force_diameter}{Diameter (in nautical miles) of the area experiencing hurricane strength winds (64 knots or above)}
}
}
\usage{
storms
}
\description{
This data is a subset of 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-2020, measured every six hours
during the lifetime of a storm.
}
\examples{
# show a plot of the storm paths
if (requireNamespace("ggplot2", quietly = TRUE)) {
library(ggplot2)
ggplot(storms) +
aes(x=long, y=lat, color=paste(year, name)) +
geom_path() +
guides(color='none') +
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 14121112104 014434 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 00000012157 14151641776 013745 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[=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 14121112104 013223 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 14121112104 013362 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/select_vars.Rd 0000644 0001762 0000144 00000001514 14151641776 014775 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/deprec-tidyselect.R
\name{select_vars}
\alias{select_vars}
\alias{rename_vars}
\alias{select_var}
\alias{current_vars}
\title{Select variables}
\usage{
select_vars(vars = chr(), ..., include = chr(), exclude = chr())
rename_vars(vars = chr(), ..., strict = TRUE)
select_var(vars, var = -1)
current_vars(...)
}
\description{
\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}
These functions now live in the tidyselect package as
\code{\link[tidyselect:vars_select]{tidyselect::vars_select()}}, \code{\link[tidyselect:vars_select]{tidyselect::vars_rename()}} and
\code{\link[tidyselect:vars_pull]{tidyselect::vars_pull()}}.
}
\keyword{internal}
dplyr/man/dplyr-package.Rd 0000644 0001762 0000144 00000001656 14121112104 015164 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@rstudio.com} (\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})
}
Other contributors:
\itemize{
\item RStudio [copyright holder, funder]
}
}
\keyword{internal}
dplyr/man/arrange.Rd 0000644 0001762 0000144 00000005557 14154654644 014116 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/arrange.R
\name{arrange}
\alias{arrange}
\title{Arrange rows by column values}
\usage{
arrange(.data, ..., .by_group = 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[=dplyr_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.}
}
\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{Locales}{
The sort order for character vectors will depend on the collating sequence
of the locale in use: see \code{\link[=locales]{locales()}}.
}
\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 ?dplyr_data_masking for more details
tidy_eval_arrange <- function(.data, var) {
.data \%>\%
arrange({{ var }})
}
tidy_eval_arrange(mtcars, mpg)
# use across() access select()-style semantics
iris \%>\% arrange(across(starts_with("Sepal")))
iris \%>\% arrange(across(starts_with("Sepal"), desc))
}
\seealso{
Other single table verbs:
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/nest_by.Rd 0000644 0001762 0000144 00000006765 14151641776 014143 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\preformatted{df \%>\%
group_by(x, y) \%>\%
summarise(data = list(cur_data())) \%>\%
rowwise()
}
If you want to unnest a nested data frame, you can either use
\code{tidyr::unnest()} or take advantage of \code{summarise()}s multi-row behaviour:\preformatted{nested \%>\%
summarise(data)
}
}
\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 \%>\% summarise(broom::tidy(model))
\dontshow{\}) # examplesIf}
# Note that you can also summarise to unnest the data
models \%>\% summarise(data)
}
\keyword{internal}
dplyr/man/rowwise.Rd 0000644 0001762 0000144 00000005325 14121112104 014135 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 summary
params \%>\%
rowwise(sim) \%>\%
summarise(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)))
}
\seealso{
\code{\link[=nest_by]{nest_by()}} for a convenient way of creating rowwise data frames
with nested data.
}
dplyr/man/dplyr_extending.Rd 0000644 0001762 0000144 00000011115 14151641776 015660 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 modify columns. A \code{NULL} value should remove
an existing column.}
\item{template}{Template 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.
\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()}, \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()}.
\code{transmute()} does the same then uses 1d \code{[} to select the columns.
\item \code{summarise()} works similarly to \code{mutate()} but the data modified by
\code{dplyr_col_modify()} comes from \code{group_data()}.
\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()}
coerces \code{x} to a tibble, modify the rows, then uses \code{dplyr_reconstruct()}
to convert back to the same type as \code{x}.
\item \code{nest_join()} uses \code{dplyr_col_modify()} to cast the key variables to
common type and add the nested-df that \code{y} becomes.
\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 these generics and
you'll need to provide methods directly.
}
\keyword{internal}
dplyr/man/if_else.Rd 0000644 0001762 0000144 00000002604 14121112104 014041 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}
\usage{
if_else(condition, true, false, missing = NULL)
}
\arguments{
\item{condition}{Logical vector}
\item{true, false}{Values to use for \code{TRUE} and \code{FALSE} values of
\code{condition}. They must be either the same length as \code{condition},
or length 1. They must also be the same type: \code{if_else()} checks that
they have the same type and same class. All other attributes are
taken from \code{true}.}
\item{missing}{If not \code{NULL}, will be used to replace missing
values.}
}
\value{
Where \code{condition} is \code{TRUE}, the matching value from
\code{true}, where it's \code{FALSE}, the matching value from \code{false},
otherwise \code{NA}.
}
\description{
Compared to the base \code{\link[=ifelse]{ifelse()}}, this function is more strict.
It checks that \code{true} and \code{false} are the same type. This
strictness makes the output type more predictable, and makes it somewhat
faster.
}
\examples{
x <- c(-5:5, NA)
if_else(x < 0, NA_integer_, x)
if_else(x < 0, "negative", "positive", "missing")
# Unlike ifelse, if_else preserves types
x <- factor(sample(letters[1:5], 10, replace = TRUE))
ifelse(x \%in\% c("a", "b", "c"), x, factor(NA))
if_else(x \%in\% c("a", "b", "c"), x, factor(NA))
# Attributes are taken from the `true` vector,
}
dplyr/man/tbl.Rd 0000644 0001762 0000144 00000000634 14121112104 013215 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/cumall.Rd 0000644 0001762 0000144 00000002644 14121112104 013714 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 14121112104 014551 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 14151641776 015121 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 00000002224 14151641776 015564 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{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[=dplyr_data_masking]{?dplyr_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 00000002174 14121112104 013410 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 include/exclude
in mutate/summarise. You can use same specifications as in \code{\link[=select]{select()}}.
If missing, defaults to all non-grouping variables.}
}
\description{
\code{vars()} was 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.
This helper is intended to provide equivalent semantics to
\code{\link[=select]{select()}}. It is used for instance in scoped summarising and
mutating verbs (\code{\link[=mutate_at]{mutate_at()}} and \code{\link[=summarise_at]{summarise_at()}}).
Note that verbs accepting a \code{vars()} specification also accept a
numeric vector of 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 00000005126 14151641776 015137 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[=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, across())
distinct_at(df, vars(x,y))
# ->
distinct(df, across(c(x, y)))
distinct_if(df, is.numeric)
# ->
distinct(df, across(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 00000006005 14121112104 016266 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/doc-params.R
\name{dplyr_data_masking}
\alias{dplyr_data_masking}
\title{Argument type: data-masking}
\description{
This page describes the \verb{} argument modifier which
indicates that the argument uses tidy evaluation with \strong{data masking}.
If you've never heard of tidy evaluation before, start with
\code{vignette("programming")}.
}
\section{Key terms}{
The primary motivation for tidy evaluation in dplyr is that it provides
\strong{data masking}, which blurs the distinction between two types of variables:
\itemize{
\item \strong{env-variables} are "programming" variables and live in an environment.
They are usually created with \verb{<-}. Env-variables can be any type of R
object.
\item \strong{data-variables} are "statistical" variables and live in a data frame.
They usually come from data files (e.g. \code{.csv}, \code{.xls}), or are created by
manipulating existing variables. Data-variables live inside data frames,
so must be vectors.
}
}
\section{General usage}{
Data masking allows you to refer to variables in the "current" data frame
(usually supplied in the \code{.data} argument), without any other prefix.
It's what allows you to type (e.g.) \code{filter(diamonds, x == 0 & y == 0 & z == 0)}
instead of \code{diamonds[diamonds$x == 0 & diamonds$y == 0 & diamonds$z == 0, ]}.
}
\section{Indirection}{
The main challenge of data masking arises when you introduce some
indirection, i.e. instead of directly typing the name of a variable you
want to supply it in a function argument or character vector.
There are two main cases:
\itemize{
\item If you want the user to supply the variable (or function of variables)
in a function argument, embrace the argument, e.g. \code{filter(df, {{ var }})}.\preformatted{dist_summary <- function(df, var) \{
df \%>\%
summarise(n = n(), min = min(\{\{ var \}\}), max = max(\{\{ var \}\}))
\}
mtcars \%>\% dist_summary(mpg)
mtcars \%>\% group_by(cyl) \%>\% dist_summary(mpg)
}
\item If you have the column name as a character vector, use the \code{.data}
pronoun, e.g. \code{summarise(df, mean = mean(.data[[var]]))}.\preformatted{for (var in names(mtcars)) \{
mtcars \%>\% count(.data[[var]]) \%>\% print()
\}
lapply(names(mtcars), function(var) mtcars \%>\% count(.data[[var]]))
}
}
}
\section{Dot-dot-dot (...)}{
When this modifier is applied to \code{...}, there is one other useful technique
which solves the problem of creating a new variable with a name supplied by
the user. Use the interpolation syntax from the glue package: \code{"{var}" := expression}. (Note the use of \verb{:=} instead of \code{=} to enable this syntax).\preformatted{var_name <- "l100km"
mtcars \%>\% mutate("\{var_name\}" := 235 / mpg)
}
Note that \code{...} automatically provides indirection, so you can use it as is
(i.e. without embracing) inside a function:\preformatted{grouped_mean <- function(df, var, ...) \{
df \%>\%
group_by(...) \%>\%
summarise(mean = mean(\{\{ var \}\}))
\}
}
}
\keyword{internal}
dplyr/man/mutate_all.Rd 0000644 0001762 0000144 00000015526 14151641776 014622 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[=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:\preformatted{data \%>\% mutate_at(vars(-group_cols(), ...), myoperation)
}
Or remove \code{group_vars()} from the character vector of column names:\preformatted{nms <- setdiff(nms, group_vars(data))
data \%>\% mutate_at(vars, myoperation)
}
\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.
}
\section{Life cycle}{
The functions are maturing, because the naming scheme and the
disambiguation algorithm are subject to change in dplyr 0.9.0.
}
\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 00000010433 14151641776 014454 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, ...)
}
\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 00000004153 14121112104 013703 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_with(iris, toupper)
rename_with(iris, toupper, starts_with("Petal"))
rename_with(iris, ~ tolower(gsub(".", "_", .x, fixed = TRUE)))
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{mutate}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/sql.Rd 0000644 0001762 0000144 00000000706 14121112104 013233 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 00000005652 14151641776 014270 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{
by_cyl <- mtcars \%>\% group_by(cyl)
# sample_n() -> slice_sample() ----------------------------------------------
sample_n(mtcars, 10)
sample_n(mtcars, 50, replace = TRUE)
sample_n(mtcars, 10, weight = mpg)
# Changes:
# * explicitly name the `n` argument,
# * the `weight` argument is now `weight_by`.
slice_sample(mtcars, n = 10)
slice_sample(mtcars, n = 50, replace = TRUE)
slice_sample(mtcars, n = 10, weight_by = mpg)
# 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()
# sample_frac() -> slice_sample() -------------------------------------------
sample_frac(mtcars)
sample_frac(mtcars, replace = TRUE)
# Changes:
# * use prop = 1 to randomly sample all rows
slice_sample(mtcars, prop = 1)
slice_sample(mtcars, prop = 1, replace = TRUE)
}
\keyword{internal}
dplyr/man/mutate.Rd 0000644 0001762 0000144 00000017454 14151641776 013774 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}
\alias{transmute}
\title{Create, modify, and delete columns}
\usage{
mutate(.data, ...)
\method{mutate}{data.frame}(
.data,
...,
.keep = c("all", "used", "unused", "none"),
.before = NULL,
.after = NULL
)
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[=dplyr_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{.keep}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#experimental}{\figure{lifecycle-experimental.svg}{options: alt='[Experimental]'}}}{\strong{[Experimental]}}
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}{\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, 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 For \code{mutate()}:
\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 For \code{transmute()}:
\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{
\code{mutate()} adds new variables and preserves existing ones;
\code{transmute()} adds new variables and drops existing ones.
New variables overwrite existing variables of the same name.
Variables can be removed 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:\preformatted{starwars \%>\%
select(name, mass, species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
}
With the grouped equivalent:\preformatted{starwars \%>\%
select(name, mass, species) \%>\%
group_by(species) \%>\%
mutate(mass_norm = mass / mean(mass, na.rm = TRUE))
}
The former normalises \code{mass} by the global average whereas the
latter normalises by the averages within species levels.
}
\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{mutate()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("mutate")}.
\item \code{transmute()}: \Sexpr[stage=render,results=rd]{dplyr:::methods_rd("transmute")}.
}
}
\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.
# Experimental: you can override with `.before` or `.after`
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.
# Experimental: You can override with `.keep`
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") # same as transmute()
# 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 ?dplyr_data_masking
}
\seealso{
Other single table verbs:
\code{\link{arrange}()},
\code{\link{filter}()},
\code{\link{rename}()},
\code{\link{select}()},
\code{\link{slice}()},
\code{\link{summarise}()}
}
\concept{single table verbs}
dplyr/man/na_if.Rd 0000644 0001762 0000144 00000002322 14121112104 013504 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 NA}
\usage{
na_if(x, y)
}
\arguments{
\item{x}{Vector to modify}
\item{y}{Value to replace with NA}
}
\value{
A modified version of \code{x} that replaces any values that
are equal to \code{y} with 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() 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 mutate 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.
\code{\link[=recode]{recode()}} to more generally replace values.
}
dplyr/man/check_dbplyr.Rd 0000644 0001762 0000144 00000001577 14144435746 015125 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 14121112104 014205 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 00000006336 14121112104 014431 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 = FALSE, name = NULL, ...)
\method{nest_join}{data.frame}(x, y, by = NULL, copy = FALSE, keep = FALSE, name = 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 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 by different variables on \code{x} and \code{y}, use a named vector.
For example, \code{by = c("a" = "b")} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a vector with length > 1.
For example, \code{by = c("a", "b")} will match \code{x$a} to \code{y$a} and \code{x$b} to
\code{y$b}. Use a named vector to match different variables in \code{x} and \code{y}.
For example, \code{by = c("a" = "b", "c" = "d")} will match \code{x$a} to \code{y$b} and
\code{x$c} to \code{y$d}.
To perform a cross-join, generating all combinations of \code{x} and \code{y},
use \code{by = character()}.}
\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 join keys from both \code{x} and \code{y} be preserved in the
output?}
\item{name}{The name of the list column nesting joins create.
If \code{NULL} the name of \code{y} is used.}
\item{...}{Other parameters passed onto methods.}
}
\description{
\code{nest_join()} returns all rows and columns in \code{x} with a new nested-df column
that contains all matches from \code{y}. When there is no match, the list column
is a 0-row tibble.
}
\details{
In some sense, a \code{nest_join()} is the most fundamental join since you can
recreate the other joins from it:
\itemize{
\item \code{inner_join()} is a \code{nest_join()} plus \code{\link[tidyr:nest]{tidyr::unnest()}}
\item \code{left_join()} \code{nest_join()} plus \code{unnest(.drop = FALSE)}.
\item \code{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{anti_join()} is a \code{nest_join()} plus a \code{filter()} where you check 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{
band_members \%>\% nest_join(band_instruments)
}
\seealso{
Other joins:
\code{\link{filter-joins}},
\code{\link{mutate-joins}}
}
\concept{joins}
dplyr/man/pull.Rd 0000644 0001762 0000144 00000004076 14176476366 013455 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 00000007516 14121112104 015047 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 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 by different variables on \code{x} and \code{y}, use a named vector.
For example, \code{by = c("a" = "b")} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a vector with length > 1.
For example, \code{by = c("a", "b")} will match \code{x$a} to \code{y$a} and \code{x$b} to
\code{y$b}. Use a named vector to match different variables in \code{x} and \code{y}.
For example, \code{by = c("a" = "b", "c" = "d")} will match \code{x$a} to \code{y$b} and
\code{x$c} to \code{y$d}.
To perform a cross-join, generating all combinations of \code{x} and \code{y},
use \code{by = character()}.}
\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 \code{NA} and \code{NaN} values match one another?
The default, \code{"na"}, treats two \code{NA} or \code{NaN} values as equal, like
\code{\%in\%}, \code{\link[=match]{match()}}, \code{\link[=merge]{merge()}}.
Use \code{"never"} to always treat two \code{NA} or \code{NaN} values as different, like
joins for database sources, similarly to \code{merge(incomparables = FALSE)}.}
}
\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 = "name")
# This is good practice in production code
}
\seealso{
Other joins:
\code{\link{mutate-joins}},
\code{\link{nest_join}()}
}
\concept{joins}
dplyr/man/group_by_all.Rd 0000644 0001762 0000144 00000006060 14151641776 015142 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[=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(across())
# Group by variables selected with a predicate:
group_by_if(iris, is.factor)
# ->
iris \%>\% group_by(across(where(is.factor)))
# Group by variables selected by name:
group_by_at(mtcars, vars(vs, am))
# ->
mtcars \%>\% group_by(across(c(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 00000013300 14151641776 013720 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{
This 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. For logical vectors, use \code{\link[=if_else]{if_else()}}. For
more complicated criteria, use \code{\link[=case_when]{case_when()}}.
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. See the \href{https://forcats.tidyverse.org/}{forcats}
package for more tools for working with factors and their levels.
\code{recode()} is questioning because the arguments are in the wrong order.
We have \code{new <- old}, \code{mutate(df, new = old)}, and \code{rename(df, new = old)}
but \code{recode(x, old = new)}. We don't yet know how to fix this problem, but
it's likely to involve creating a new function then retiring or deprecating
\code{recode()}.
}
\examples{
# For character values, recode values with named arguments only. Unmatched
# values are unchanged.
char_vec <- sample(c("a", "b", "c"), 10, replace = TRUE)
recode(char_vec, a = "Apple")
recode(char_vec, a = "Apple", b = "Banana")
# Use .default as replacement for unmatched values. Note that NA and
# replacement values need to be of the same type. For more information, see
# https://adv-r.hadley.nz/vectors-chap.html#missing-values
recode(char_vec, a = "Apple", b = "Banana", .default = NA_character_)
# Throws an error as NA is logical, not character.
try(recode(char_vec, a = "Apple", b = "Banana", .default = NA))
# Use a named character vector for unquote splicing with !!!
level_key <- c(a = "apple", b = "banana", c = "carrot")
recode(char_vec, !!!level_key)
# For numeric values, named arguments can also be used
num_vec <- c(1:4, NA)
recode(num_vec, `2` = 20L, `4` = 40L)
# Or if you don't name the arguments, recode() matches by position.
# (Only works for numeric vector)
recode(num_vec, "a", "b", "c", "d")
# .x (position given) looks in (...), then grabs (... value at position)
# so if nothing at position (here 5), it uses .default or NA.
recode(c(1,5,3), "a", "b", "c", "d", .default = "nothing")
# Note that if the replacements are not compatible with .x,
# unmatched values are replaced by NA and a warning is issued.
recode(num_vec, `2` = "b", `4` = "d")
# use .default to change the replacement value
recode(num_vec, "a", "b", "c", .default = "other")
# use .missing to replace missing values in .x
recode(num_vec, "a", "b", "c", .default = "other", .missing = "missing")
# For factor values, use only named replacements
# and supply default with levels()
factor_vec <- factor(c("a", "b", "c"))
recode(factor_vec, a = "Apple", .default = levels(factor_vec))
# Use recode_factor() to create factors with levels ordered as they
# appear in the recode call. The levels in .default and .missing
# come last.
recode_factor(num_vec, `1` = "z", `2` = "y", `3` = "x")
recode_factor(num_vec, `1` = "z", `2` = "y", `3` = "x",
.default = "D")
recode_factor(num_vec, `1` = "z", `2` = "y", `3` = "x",
.default = "D", .missing = "M")
# When the input vector is a compatible vector (character vector or
# factor), it is reused as default.
recode_factor(letters[1:3], b = "z", c = "y")
recode_factor(factor(letters[1:3]), b = "z", c = "y")
# Use a named character vector to recode factors with unquote splicing.
level_key <- c(a = "apple", b = "banana", c = "carrot")
recode_factor(char_vec, !!!level_key)
}
\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/mutate-joins.Rd 0000644 0001762 0000144 00000015631 14121112104 015056 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 = FALSE
)
\method{inner_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE,
na_matches = c("na", "never")
)
left_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE
)
\method{left_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE,
na_matches = c("na", "never")
)
right_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE
)
\method{right_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE,
na_matches = c("na", "never")
)
full_join(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = FALSE
)
\method{full_join}{data.frame}(
x,
y,
by = NULL,
copy = FALSE,
suffix = c(".x", ".y"),
...,
keep = 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 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 by different variables on \code{x} and \code{y}, use a named vector.
For example, \code{by = c("a" = "b")} will match \code{x$a} to \code{y$b}.
To join by multiple variables, use a vector with length > 1.
For example, \code{by = c("a", "b")} will match \code{x$a} to \code{y$a} and \code{x$b} to
\code{y$b}. Use a named vector to match different variables in \code{x} and \code{y}.
For example, \code{by = c("a" = "b", "c" = "d")} will match \code{x$a} to \code{y$b} and
\code{x$c} to \code{y$d}.
To perform a cross-join, generating all combinations of \code{x} and \code{y},
use \code{by = character()}.}
\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?}
\item{na_matches}{Should \code{NA} and \code{NaN} values match one another?
The default, \code{"na"}, treats two \code{NA} or \code{NaN} values as equal, like
\code{\%in\%}, \code{\link[=match]{match()}}, \code{\link[=merge]{merge()}}.
Use \code{"never"} to always treat two \code{NA} or \code{NaN} values as different, like
joins for database sources, similarly to \code{merge(incomparables = FALSE)}.}
}
\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 For \code{inner_join()}, a subset of \code{x} rows.
For \code{left_join()}, all \code{x} rows.
For \code{right_join()}, a subset of \code{x} rows, followed by unmatched \code{y} rows.
For \code{full_join()}, all \code{x} rows, followed by unmatched \code{y} rows.
\item For all joins, rows will be duplicated if one or more rows in \code{x} matches
multiple rows in \code{y}.
\item Output columns include all \code{x} columns and all \code{y} columns. If columns in
\code{x} and \code{y} have the same name (and aren't included in \code{by}), \code{suffix}es are
added to disambiguate.
\item Output columns included in \code{by} are coerced to common type across
\code{x} and \code{y}.
\item Groups are taken from \code{x}.
}
}
\description{
The mutating joins add columns from \code{y} to \code{x}, matching rows based on the
keys:
\itemize{
\item \code{inner_join()}: includes all rows in \code{x} and \code{y}.
\item \code{left_join()}: includes all rows in \code{x}.
\item \code{right_join()}: includes all rows in \code{y}.
\item \code{full_join()}: includes all rows in \code{x} or \code{y}.
}
If a row in \code{x} matches multiple rows in \code{y}, all the rows in \code{y} will be returned
once for each matching row in \code{x}.
}
\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 = "name")
# This is good practice in production code
# Use a named `by` if the join variables have different names
band_members \%>\% full_join(band_instruments2, by = c("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 = c("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)
# 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{filter-joins}},
\code{\link{nest_join}()}
}
\concept{joins}
dplyr/man/src_tbls.Rd 0000644 0001762 0000144 00000000766 14121112104 014255 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 00000006256 14151641776 014610 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[=across]{across()}} 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 00000005633 14121112104 016162 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 the 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 Indirection section. 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.
}
These 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.
}
These helpers select variables from 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.
}
This helper selects variables with a 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 you want the user 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 14176714175 014602 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 00000003235 14151641776 013440 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[=dplyr_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 00000001001 14121112104 014557 0 ustar ligges users % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/distinct.R
\name{n_distinct}
\alias{n_distinct}
\title{Efficiently count the number of unique values in a set of vectors}
\usage{
n_distinct(..., na.rm = FALSE)
}
\arguments{
\item{\dots}{vectors of values}
\item{na.rm}{if \code{TRUE} missing values don't count}
}
\description{
This is a faster and more concise equivalent of \code{length(unique(x))}
}
\examples{
x <- sample(1:10, 1e5, rep = TRUE)
length(unique(x))
n_distinct(x)
}
dplyr/man/explain.Rd 0000644 0001762 0000144 00000003113 14144435746 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 14174552625 014077 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 14151641776 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 00000002316 14151641776 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{union_all}
\title{Set operations}
\usage{
union_all(x, y, ...)
}
\arguments{
\item{x, y}{objects to perform set function on (ignoring order)}
\item{...}{These dots are for future extensions and must be empty.}
}
\description{
These functions override the set functions provided in base to make them
generic so that efficient versions for data frames and other tables can be
provided. The default methods call the base versions. Beware that
\code{intersect()}, \code{union()} and \code{setdiff()} remove duplicates.
}
\examples{
mtcars$model <- rownames(mtcars)
first <- mtcars[1:20, ]
second <- mtcars[10:32, ]
intersect(first, second)
union(first, second)
setdiff(first, second)
setdiff(second, first)
union_all(first, second)
setequal(mtcars, mtcars[32:1, ])
# Handling of duplicates:
a <- data.frame(column = c(1:10, 10))
b <- data.frame(column = c(1:5, 5))
# intersection is 1 to 5, duplicates removed (5)
intersect(a, b)
# union is 1 to 10, duplicates removed (5 and 10)
union(a, b)
# set difference, duplicates removed (10)
setdiff(a, b)
# union all does not remove duplicates
union_all(a, b)
}
dplyr/man/with_order.Rd 0000644 0001762 0000144 00000000735 14121112104 014604 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 14121112104 013353 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 00000001567 14151641776 016037 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,
...,
caller_env = caller_env(2),
.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 14121112104 013606 5 ustar ligges users dplyr/man/figures/lifecycle-defunct.svg 0000644 0001762 0000144 00000001704 14121112104 017716 0 ustar ligges users dplyr/man/figures/lifecycle-maturing.svg 0000644 0001762 0000144 00000001706 14121112104 020116 0 ustar ligges users dplyr/man/figures/logo.png 0000644 0001762 0000144 00000130477 14121112104 015270 0 ustar ligges users PNG
IHDR ޫh gAMA a cHRM z& u0 ` : pQ< bKGD pHYs .# .#x?v tIME %6m: IDATxw u
qrL A1%R {-Qea}zAmIk[,۲ )" D:zg{gzf@ 7/\ g:T=Usιsc |!RJUq"|RI)7Ӈz
mo{)%B]_Rv!f _w/clo`<(xa)^/x +_E!D}{;}*A;} 1+pH)_UUqbY1fZ{266i;}ZQ'.{7^v; EQR~DJN[GE_B㪪d2#<ӧxuAp=rPU] /
!&O !VUqMfF^/).' l0aZ]RߑRU{\.G0UUk11!GǤ\.Ƿ^˨| {fq7 R3Rj{iavv.hnn.fY((^X| -oy EQueWWA< gllIRT nwQ DG }t2lXT ([Rd2 %T ===lZ YBP1@2ea =zdPRۀߖR 8Oi,,,pEuTVikk5>N
! (?u].L"i( u}Rʶj3cp8\s솎jc_k| |l;QU,tH) 5)+ L2>>8d!t: Ng9B楔hv9clۈ
RMCiBfaddp8%Z!kBg !
$5M[ֶO*.64l6X#RߒR> O,..rE`qF(
Z,Br-:7wqـff9 [R~E)eWh4ett
ǹjA^o,Y!DAx9>Z\6-i@Ҕ]R)&&&#Hy\.p >.rIJyo.pw)%RJ; L,###Be; !
AV$Q)EI_ƍenLnTZόsx".WUU::: 8"
带iکqlvE1o@^Zd~BbX!M;}:5ncSz;!ħRJ.'6 =z_Jn 5OA:fjjQbNʆx ^!![2ee TV)]q= 4y.^Ҷǹ6\.װr->
|TQK)hd22U/
qErz \q ~1 ,KTl BfYV.AeE^[J2gǙX#jx^nnvzzzPl6g?Y}نe#!>\ƵW7HWW)(`Eu
5v+ﾛ]vaX
fUUygg>e
_B|LJ
!Dd=3ۺvo$\6
X53D"033nn6nF~pcR(
\.@=66V1:sss,//S-BmX.'q[ef;O399k* 2kd2 o]bA1|\/ѣG?1z;pO~ S*qŚe~xX,Fss3RJq:* wݻwhii! Y^^.hE!n:@ @{{{ၘNfrrrCx<ΩSaxxueB|xTQ>Sv7 | MӄH)?KJYoiiD`0H?RJ|2ம.1zޙ$Ϝ9C2$ 288Ossr\ݍn(p ' o*QgNx,LX'>y7_x ր
## 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
#>