├── .DS_Store ├── .Rbuildignore ├── .gitignore ├── .travis.yml ├── DESCRIPTION ├── LICENSE ├── NAMESPACE ├── R ├── quantiles.R ├── tab.R └── tabcount.R ├── README.md ├── cran-comments.md ├── man ├── quantiles.Rd ├── tab.Rd └── tabcount.Rd └── tabulator.Rproj /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/skhiggins/tabulator/4c350d7437e6440059b465ac94bcb1f6c361d962/.DS_Store -------------------------------------------------------------------------------- /.Rbuildignore: -------------------------------------------------------------------------------- 1 | <<<<<<< HEAD 2 | ^.*\.Rproj$ 3 | ^\.Rproj\.user$ 4 | ^\.travis\.yml$ 5 | ======= 6 | ^.*\.Rproj$ 7 | ^\.Rproj\.user$ 8 | cran-comments.md 9 | >>>>>>> d12600b8dd9e14f9adfb0482c61cab8e83d45033 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .Rproj.user 2 | .Rhistory 3 | .RData 4 | copy_package.py 5 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | # R for travis: see documentation at https://docs.travis-ci.com/user/languages/r 2 | 3 | language: R 4 | cache: packages 5 | -------------------------------------------------------------------------------- /DESCRIPTION: -------------------------------------------------------------------------------- 1 | Package: tabulator 2 | Title: Efficient Tabulation with Stata-Like Output 3 | Version: 1.0.0 4 | Authors@R: person("Sean", "Higgins", email = "sean.higgins@kellogg.northwestern.edu", role = c("aut", "cre")) 5 | Description: Efficient tabulation with Stata-like output. 6 | For each unique value of the variable, it shows the number of 7 | observations with that value, proportion of observations with that 8 | value, and cumulative proportion, in descending order of frequency. 9 | Accepts data.table, tibble, or data.frame as input. 10 | Efficient with big data: if you give it a data.table, 11 | tab() uses data.table syntax. 12 | Imports: 13 | assertthat, 14 | dplyr, 15 | data.table, 16 | magrittr, 17 | purrr, 18 | rlang, 19 | stats, 20 | stringr, 21 | tibble, 22 | tidyr 23 | Depends: R (>= 3.4.0) 24 | License: MIT + file LICENSE 25 | Encoding: UTF-8 26 | LazyData: true 27 | RoxygenNote: 7.1.1 28 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | YEAR: 2020 2 | COPYRIGHT HOLDER: Sean Higgins 3 | -------------------------------------------------------------------------------- /NAMESPACE: -------------------------------------------------------------------------------- 1 | # Generated by roxygen2: do not edit by hand 2 | 3 | S3method(quantiles,data.frame) 4 | S3method(quantiles,data.table) 5 | S3method(quantiles,tbl_df) 6 | S3method(tab,data.frame) 7 | S3method(tab,data.table) 8 | S3method(tab,tbl_df) 9 | S3method(tabcount,data.frame) 10 | S3method(tabcount,data.table) 11 | S3method(tabcount,tbl_df) 12 | export(quantiles) 13 | export(tab) 14 | export(tabcount) 15 | importFrom(data.table,":=") 16 | importFrom(data.table,.GRP) 17 | importFrom(data.table,.N) 18 | importFrom(data.table,.SD) 19 | importFrom(data.table,data.table) 20 | importFrom(data.table,setcolorder) 21 | importFrom(dplyr,tibble) 22 | importFrom(magrittr,"%>%") 23 | importFrom(stats,quantile) 24 | -------------------------------------------------------------------------------- /R/quantiles.R: -------------------------------------------------------------------------------- 1 | #' Efficient quantiles 2 | #' 3 | #' Produces quantiles of the variables. 4 | #' \code{quantiles} shows quantile values. 5 | #' Efficient with big data: if you give it a \code{data.table}, 6 | #' \code{quantiles} uses \code{data.table} syntax. 7 | #' 8 | #' @usage quantiles(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) 9 | #' 10 | #' @param df A data.table, tibble, or data.frame. 11 | #' @param ... A column or set of columns (without quotation marks). 12 | #' @param probs numeric vector of probabilities with values in [0,1]. 13 | #' @param na.rm logical; if true, any NA and NaN's are removed from x before the quantiles are computed. 14 | #' 15 | #' @return Quantile values. 16 | #' 17 | #' @importFrom data.table data.table 18 | #' @importFrom data.table .SD 19 | #' @importFrom data.table := 20 | #' @importFrom data.table setcolorder 21 | #' @importFrom data.table .GRP 22 | #' @importFrom data.table .N 23 | #' @importFrom magrittr %>% 24 | #' @importFrom dplyr tibble 25 | #' @importFrom stats quantile 26 | #' 27 | #' @examples 28 | #' # data.table 29 | #' library(data.table) 30 | #' library(magrittr) 31 | #' a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 32 | #' a %>% quantiles(varname) 33 | #' 34 | #' # data.table: look at top 10% in more detail 35 | #' a %>% quantiles(varname, probs = seq(0.9, 1, 0.01)) 36 | #' 37 | #' # tibble 38 | #' library(dplyr) 39 | #' b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 40 | #' b %>% quantiles(varname, na.rm = TRUE) 41 | #' 42 | #' @export 43 | quantiles <- function(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) { 44 | UseMethod("quantiles", df) 45 | # to do: add round option like in tab() 46 | } 47 | 48 | #' @export 49 | quantiles.data.table <- function(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) { 50 | p <- . <- NULL 51 | vars <- rlang::enquos(...) %>% purrr::map(rlang::as_name) %>% unlist() 52 | tabbed <- df[, lapply(.SD, function(x) quantile(x, probs = probs, na.rm = na.rm)), 53 | .SDcols = vars] %>% 54 | .[, p := probs] %>% 55 | setcolorder(c("p", vars)) 56 | tabbed[] # make sure it prints 57 | } 58 | 59 | #' @export 60 | quantiles.tbl_df <- function(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) { 61 | p <- q <- NULL 62 | vars <- rlang::enquos(...) 63 | df %>% 64 | dplyr::summarize(p = list(probs), q = list(quantile(!!!vars, probs))) %>% 65 | tidyr::unnest(cols = c(p, q)) 66 | } 67 | 68 | #' @export 69 | quantiles.data.frame <- function(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) { 70 | quantiles.data.table(data.table::as.data.table(df), ..., probs = probs, na.rm = na.rm) 71 | } 72 | 73 | -------------------------------------------------------------------------------- /R/tab.R: -------------------------------------------------------------------------------- 1 | #' Efficient tabulation 2 | #' 3 | #' Produces a tabulation: for each unique group from the variable(s), 4 | #' \code{tab} shows the number of 5 | #' observations with that value, proportion of observations with that 6 | #' value, and cumulative proportion, in descending order of frequency. 7 | #' Accepts data.table, tibble, or data.frame as input. 8 | #' Efficient with big data: if you give it a \code{data.table}, 9 | #' \code{tab} uses \code{data.table} syntax. 10 | #' 11 | #' @usage tab(df, ..., by, round) 12 | #' 13 | #' @param df A data.table, tibble, or data.frame. 14 | #' @param ... A column or set of columns (without quotation marks). 15 | #' @param by A variable by which you want to group observations before tabulating (without quotation marks). 16 | #' @param round An integer indicating the number of digits for proportion and cumulative proportion. 17 | #' 18 | #' @return Tabulation (frequencies, proportion, cumulative proportion) for each unique value of the variables given in \code{...} from \code{df}. 19 | #' 20 | #' @importFrom data.table data.table 21 | #' @importFrom data.table .SD 22 | #' @importFrom data.table := 23 | #' @importFrom data.table setcolorder 24 | #' @importFrom data.table .GRP 25 | #' @importFrom data.table .N 26 | #' @importFrom magrittr %>% 27 | #' @importFrom dplyr tibble 28 | #' @importFrom stats quantile 29 | #' 30 | #' @examples 31 | #' # data.table 32 | #' library(data.table) 33 | #' library(magrittr) 34 | #' a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 35 | #' a %>% tab(varname) 36 | #' 37 | #' # tibble 38 | #' library(dplyr) 39 | #' b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 40 | #' b %>% tab(varname, round = 1) 41 | #' 42 | #' # data.frame 43 | #' c <- data.frame(varname = sample.int(20, size = 1000000, replace = TRUE)) 44 | #' c %>% tab(varname) 45 | #' 46 | #' @export 47 | tab <- function(df, ..., by = NULL, round = 2) { 48 | UseMethod("tab", df) 49 | } 50 | 51 | #' @export 52 | tab.data.table <- function(df, ..., by = NULL, round = 2) { # note ... is the variable names to group by 53 | . <- temp_prop <- prop <- cum_prop <- N <- NULL 54 | dt <- df # in case df has a condition on it 55 | group_by <- rlang::enquos(...) %>% purrr::map(rlang::as_name) %>% unlist() 56 | by__ <- rlang::enexpr(by) 57 | if (!is.null(by__)) { 58 | by_ <- rlang::enexpr(by) %>% rlang::as_name() 59 | 60 | # assert constant values of group_by within by 61 | assertthat::assert_that( 62 | dt[, .GRP, by = c(by_, group_by)][, .N] == 63 | dt[, .GRP, by = by_][, .N] 64 | ) 65 | dt <- dt[, .GRP, by = c(by_, group_by)] 66 | tab.data.table(dt, ..., by = NULL, round = round) # recursive function 67 | } 68 | rowsofdata <- dt[, .N] # faster than nrow() on big data.tables 69 | dt[, .N, by = group_by] %>% 70 | .[, temp_prop := N / rowsofdata] %>% 71 | .[, prop := round(temp_prop, digits = round)] %>% 72 | # sort in descending order by N before cumulative prop 73 | .[order(-N)] %>% 74 | .[, cum_prop := round(cumsum(temp_prop), digits = round)] %>% 75 | # remove temp var 76 | .[, temp_prop := NULL] %>% 77 | # make sure final data.table sorted 78 | .[order(-N)] 79 | } 80 | 81 | #' @export 82 | tab.tbl_df <- function(df, ..., by = NULL, round = 2) { # to check without requiring tibble 83 | N <- temp_prop <- NULL 84 | group_by <- rlang::enquos(...) 85 | by_ <- rlang::enquo(by) 86 | by__ <- rlang::enexpr(by) 87 | if (!is.null(by__)) { 88 | assertthat::assert_that( 89 | df %>% dplyr::distinct(!!by_, !!!group_by) %>% nrow() == 90 | df %>% dplyr::distinct(!!by_) %>% nrow() 91 | ) 92 | df <- df %>% dplyr::distinct(!!by_, !!!group_by, .keep_all = TRUE) 93 | tab.tbl_df(df, ..., by = NULL, round = round) # recursive function 94 | } 95 | rowsofdata <- nrow(df) 96 | df %>% 97 | dplyr::group_by(!!!group_by) %>% # !!! since it's a quosure 98 | dplyr::summarize(N = dplyr::n()) %>% 99 | dplyr::arrange(dplyr::desc(N)) %>% 100 | dplyr::ungroup() %>% 101 | dplyr::mutate( 102 | temp_prop = N / rowsofdata, 103 | prop = round(temp_prop, digits = round), 104 | cum_prop = round(cumsum(temp_prop), digits = round) 105 | ) %>% 106 | dplyr::select(-temp_prop) 107 | } 108 | 109 | #' @export 110 | tab.data.frame <- function(df, ..., by = NULL, round = 2) { # to check without requiring tibble 111 | by__ <- rlang::enexpr(by) 112 | if (!is.null(by__)) { 113 | by_ <- rlang::enquo(by) 114 | tab.data.table(data.table::as.data.table(df), ..., by = !!by_, round = round) 115 | } else { 116 | tab.data.table(data.table::as.data.table(df), ..., by = NULL, round = round) 117 | } 118 | } 119 | 120 | -------------------------------------------------------------------------------- /R/tabcount.R: -------------------------------------------------------------------------------- 1 | #' Count distinct categories 2 | #' 3 | #' Produces a count of unique categories, 4 | #' \code{tabcount} shows the number of 5 | #' unique categories for the selected variable. 6 | #' Accepts data.table, tibble, or data.frame as input. 7 | #' Efficient with big data: if you give it a \code{data.table}, 8 | #' \code{tabcount} uses \code{data.table} syntax. 9 | #' 10 | #' @usage tabcount(df, ...) 11 | #' 12 | #' @param df A data.table, tibble, or data.frame 13 | #' @param ... A column or set of columns (without quotation marks) 14 | #' 15 | #' @return Count of the number of unique groups formed by the variables given in \code{...} from \code{df}. 16 | #' 17 | #' @importFrom data.table data.table 18 | #' @importFrom data.table .SD 19 | #' @importFrom data.table := 20 | #' @importFrom data.table setcolorder 21 | #' @importFrom data.table .GRP 22 | #' @importFrom data.table .N 23 | #' @importFrom magrittr %>% 24 | #' @importFrom dplyr tibble 25 | #' @importFrom stats quantile 26 | #' 27 | #' @examples 28 | #' # data.table 29 | #' library(data.table) 30 | #' library(magrittr) 31 | #' a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 32 | #' a %>% tabcount(varname) 33 | #' 34 | #' # tibble 35 | #' library(dplyr) 36 | #' b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 37 | #' b %>% tabcount(varname) 38 | #' 39 | #' @export 40 | tabcount <- function(df, ...) { # note ... is the variable names to group by 41 | UseMethod("tabcount", df) 42 | } 43 | 44 | #' @export 45 | tabcount.data.table <- function(df, ...) { 46 | group_by <- rlang::enquos(...) %>% purrr::map(rlang::as_name) %>% unlist() 47 | df[, .N, by = group_by][, .N] 48 | } 49 | 50 | #' @export 51 | tabcount.tbl_df <- function(df, ...) { 52 | group_by <- rlang::enquos(...) 53 | df %>% 54 | dplyr::distinct(!!!group_by) %>% # !!! since it's a quosure 55 | nrow() 56 | } 57 | 58 | #' @export 59 | tabcount.data.frame <- function(df, ...) { 60 | tabcount.data.table(data.table::as.data.table(df), ...) 61 | } 62 | 63 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # tabulator 2 | ## Overview 3 | tabulator provides efficient tabulation with big data in R, with Stata-like output. It contains three distinct functions: 4 | 5 | - `tab()` shows, for each unique value of a selected variable, the number of observations, proportion of observations, and cumulative proportion. 6 | - `quantiles()` shows quantile values. 7 | - `tabcount()` shows the number of unique categories for a selected variable. 8 | 9 | All functions work with data frames, data tables, and tibbles. 10 | 11 | ## Installation 12 | 13 | ``` r 14 | # The easiest way to get tabulator is to install from CRAN: 15 | install.packages("tabulator") 16 | 17 | ``` 18 | 19 | ### Development version 20 | 21 | To get a bug fix or to use a feature from the development version, you 22 | can install the development version of tabulator from GitHub. 23 | 24 | ``` r 25 | # install.packages("remotes") 26 | remotes::install_github("skhiggins/tabulator") 27 | ``` 28 | 29 | ## Usage 30 | 31 | ``` r 32 | library(tabulator) 33 | 34 | data(iris) 35 | 36 | iris %>% tab(Sepal.Length) 37 | #> Sepal.Length N prop cum_prop 38 | #> 1: 5.0 10 0.07 0.07 39 | #> 2: 5.1 9 0.06 0.13 40 | #> 3: 6.3 9 0.06 0.19 41 | #> 4: 5.7 8 0.05 0.24 42 | #> 5: 6.7 8 0.05 0.29 43 | #> 6: 5.8 7 0.05 0.34 44 | #> 7: 5.5 7 0.05 0.39 45 | #> 8: 6.4 7 0.05 0.43 46 | #> 9: 4.9 6 0.04 0.47 47 | #> 10: 5.4 6 0.04 0.51 48 | #> 11: 6.0 6 0.04 0.55 49 | #> 12: 6.1 6 0.04 0.59 50 | #> 13: 5.6 6 0.04 0.63 51 | #> 14: 4.8 5 0.03 0.67 52 | #> 15: 6.5 5 0.03 0.70 53 | #> 16: 4.6 4 0.03 0.73 54 | #> 17: 5.2 4 0.03 0.75 55 | #> 18: 6.9 4 0.03 0.78 56 | #> 19: 6.2 4 0.03 0.81 57 | #> 20: 7.7 4 0.03 0.83 58 | #> 21: 4.4 3 0.02 0.85 59 | #> 22: 5.9 3 0.02 0.87 60 | #> 23: 6.8 3 0.02 0.89 61 | #> 24: 7.2 3 0.02 0.91 62 | #> 25: 4.7 2 0.01 0.93 63 | #> 26: 6.6 2 0.01 0.94 64 | #> 27: 4.3 1 0.01 0.95 65 | #> 28: 4.5 1 0.01 0.95 66 | #> 29: 5.3 1 0.01 0.96 67 | #> 30: 7.0 1 0.01 0.97 68 | #> 31: 7.1 1 0.01 0.97 69 | #> 32: 7.6 1 0.01 0.98 70 | #> 33: 7.3 1 0.01 0.99 71 | #> 34: 7.4 1 0.01 0.99 72 | #> 35: 7.9 1 0.01 1.00 73 | #> Sepal.Length N prop cum_prop 74 | 75 | iris %>% tabcount(Sepal.Length) 76 | #> [1] 35 77 | 78 | iris %>% quantiles(Petal.Width) 79 | #> p Petal.Width 80 | #> 1: 0.0 0.10 81 | #> 2: 0.1 0.20 82 | #> 3: 0.2 0.20 83 | #> 4: 0.3 0.40 84 | #> 5: 0.4 1.16 85 | #> 6: 0.5 1.30 86 | #> 7: 0.6 1.50 87 | #> 8: 0.7 1.80 88 | #> 9: 0.8 1.90 89 | #> 10: 0.9 2.20 90 | #> 11: 1.0 2.50 91 | 92 | ``` 93 | 94 | 95 | 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /cran-comments.md: -------------------------------------------------------------------------------- 1 | ## Test environments 2 | * local OS X install, R 3.6.2 3 | * win-builder (devel and release) 4 | 5 | ## R CMD check results 6 | There were no ERRORs, NOTEs or WARNINGs. 7 | 8 | ## Notes 9 | This is the first package submission. -------------------------------------------------------------------------------- /man/quantiles.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/quantiles.R 3 | \name{quantiles} 4 | \alias{quantiles} 5 | \title{Efficient quantiles} 6 | \usage{ 7 | quantiles(df, ..., probs = seq(0, 1, 0.1), na.rm = FALSE) 8 | } 9 | \arguments{ 10 | \item{df}{A data.table, tibble, or data.frame.} 11 | 12 | \item{...}{A column or set of columns (without quotation marks).} 13 | 14 | \item{probs}{numeric vector of probabilities with values in [0,1].} 15 | 16 | \item{na.rm}{logical; if true, any NA and NaN's are removed from x before the quantiles are computed.} 17 | } 18 | \value{ 19 | Quantile values. 20 | } 21 | \description{ 22 | Produces quantiles of the variables. 23 | \code{quantiles} shows quantile values. 24 | Efficient with big data: if you give it a \code{data.table}, 25 | \code{quantiles} uses \code{data.table} syntax. 26 | } 27 | \examples{ 28 | # data.table 29 | library(data.table) 30 | library(magrittr) 31 | a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 32 | a \%>\% quantiles(varname) 33 | 34 | # data.table: look at top 10\% in more detail 35 | a \%>\% quantiles(varname, probs = seq(0.9, 1, 0.01)) 36 | 37 | # tibble 38 | library(dplyr) 39 | b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 40 | b \%>\% quantiles(varname, na.rm = TRUE) 41 | 42 | } 43 | -------------------------------------------------------------------------------- /man/tab.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/tab.R 3 | \name{tab} 4 | \alias{tab} 5 | \title{Efficient tabulation} 6 | \usage{ 7 | tab(df, ..., by, round) 8 | } 9 | \arguments{ 10 | \item{df}{A data.table, tibble, or data.frame.} 11 | 12 | \item{...}{A column or set of columns (without quotation marks).} 13 | 14 | \item{by}{A variable by which you want to group observations before tabulating (without quotation marks).} 15 | 16 | \item{round}{An integer indicating the number of digits for proportion and cumulative proportion.} 17 | } 18 | \value{ 19 | Tabulation (frequencies, proportion, cumulative proportion) for each unique value of the variables given in \code{...} from \code{df}. 20 | } 21 | \description{ 22 | Produces a tabulation: for each unique group from the variable(s), 23 | \code{tab} shows the number of 24 | observations with that value, proportion of observations with that 25 | value, and cumulative proportion, in descending order of frequency. 26 | Accepts data.table, tibble, or data.frame as input. 27 | Efficient with big data: if you give it a \code{data.table}, 28 | \code{tab} uses \code{data.table} syntax. 29 | } 30 | \examples{ 31 | # data.table 32 | library(data.table) 33 | library(magrittr) 34 | a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 35 | a \%>\% tab(varname) 36 | 37 | # tibble 38 | library(dplyr) 39 | b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 40 | b \%>\% tab(varname, round = 1) 41 | 42 | # data.frame 43 | c <- data.frame(varname = sample.int(20, size = 1000000, replace = TRUE)) 44 | c \%>\% tab(varname) 45 | 46 | } 47 | -------------------------------------------------------------------------------- /man/tabcount.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/tabcount.R 3 | \name{tabcount} 4 | \alias{tabcount} 5 | \title{Count distinct categories} 6 | \usage{ 7 | tabcount(df, ...) 8 | } 9 | \arguments{ 10 | \item{df}{A data.table, tibble, or data.frame} 11 | 12 | \item{...}{A column or set of columns (without quotation marks)} 13 | } 14 | \value{ 15 | Count of the number of unique groups formed by the variables given in \code{...} from \code{df}. 16 | } 17 | \description{ 18 | Produces a count of unique categories, 19 | \code{tabcount} shows the number of 20 | unique categories for the selected variable. 21 | Accepts data.table, tibble, or data.frame as input. 22 | Efficient with big data: if you give it a \code{data.table}, 23 | \code{tabcount} uses \code{data.table} syntax. 24 | } 25 | \examples{ 26 | # data.table 27 | library(data.table) 28 | library(magrittr) 29 | a <- data.table(varname = sample.int(20, size = 1000000, replace = TRUE)) 30 | a \%>\% tabcount(varname) 31 | 32 | # tibble 33 | library(dplyr) 34 | b <- tibble(varname = sample.int(20, size = 1000000, replace = TRUE)) 35 | b \%>\% tabcount(varname) 36 | 37 | } 38 | -------------------------------------------------------------------------------- /tabulator.Rproj: -------------------------------------------------------------------------------- 1 | Version: 1.0 2 | 3 | RestoreWorkspace: No 4 | SaveWorkspace: No 5 | AlwaysSaveHistory: Default 6 | 7 | EnableCodeIndexing: Yes 8 | UseSpacesForTab: Yes 9 | NumSpacesForTab: 2 10 | Encoding: UTF-8 11 | 12 | RnwWeave: Sweave 13 | LaTeX: pdfLaTeX 14 | 15 | AutoAppendNewline: Yes 16 | StripTrailingWhitespace: Yes 17 | 18 | BuildType: Package 19 | PackageUseDevtools: Yes 20 | PackageInstallArgs: --no-multiarch --with-keep.source 21 | PackageRoxygenize: rd,collate,namespace 22 | --------------------------------------------------------------------------------