From 978cde7652ae57a4863e2f000a6b948a44889b6f Mon Sep 17 00:00:00 2001 From: Daniel Date: Wed, 27 Nov 2024 17:41:30 +0100 Subject: [PATCH] Fix inconsitencies in docs (#565) * Fix inconsitencies in docs * Update R/extract_column_names.R Co-authored-by: Etienne Bacher <52219252+etiennebacher@users.noreply.github.com> * update rd (comma) --------- Co-authored-by: Etienne Bacher <52219252+etiennebacher@users.noreply.github.com> --- R/extract_column_names.R | 16 ++++++++++------ man/adjust.Rd | 11 ++++++----- man/assign_labels.Rd | 11 ++++++----- man/categorize.Rd | 11 ++++++----- man/center.Rd | 11 ++++++----- man/convert_na_to.Rd | 11 ++++++----- man/convert_to_na.Rd | 11 ++++++----- man/data_codebook.Rd | 11 ++++++----- man/data_duplicated.Rd | 11 ++++++----- man/data_extract.Rd | 11 ++++++----- man/data_group.Rd | 11 ++++++----- man/data_peek.Rd | 11 ++++++----- man/data_relocate.Rd | 11 ++++++----- man/data_rename.Rd | 11 ++++++----- man/data_replicate.Rd | 11 ++++++----- man/data_separate.Rd | 11 ++++++----- man/data_tabulate.Rd | 11 ++++++----- man/data_to_long.Rd | 11 ++++++----- man/data_unique.Rd | 11 ++++++----- man/data_unite.Rd | 11 ++++++----- man/describe_distribution.Rd | 11 ++++++----- man/extract_column_names.Rd | 16 ++++++++++------ man/labels_to_levels.Rd | 11 ++++++----- man/means_by_group.Rd | 11 ++++++----- man/normalize.Rd | 11 ++++++----- man/ranktransform.Rd | 11 ++++++----- man/recode_values.Rd | 11 ++++++----- man/rescale.Rd | 11 ++++++----- man/reverse.Rd | 11 ++++++----- man/row_count.Rd | 11 ++++++----- man/row_means.Rd | 11 ++++++----- man/slide.Rd | 11 ++++++----- man/standardize.Rd | 11 ++++++----- man/to_factor.Rd | 11 ++++++----- man/to_numeric.Rd | 11 ++++++----- 35 files changed, 218 insertions(+), 177 deletions(-) diff --git a/R/extract_column_names.R b/R/extract_column_names.R index a3d120d3f..b1cb54f35 100644 --- a/R/extract_column_names.R +++ b/R/extract_column_names.R @@ -19,15 +19,16 @@ #' - a vector of negative integers, giving the positions counting from the #' right (e.g., `-1` or `-1:-3`), #' - one of the following select-helpers: `starts_with()`, `ends_with()`, -#' `contains()`, a range using `:` or `regex("")`. `starts_with()`, +#' `contains()`, a range using `:`, or `regex()`. `starts_with()`, #' `ends_with()`, and `contains()` accept several patterns, e.g -#' `starts_with("Sep", "Petal")`. -#' - or a function testing for logical conditions, e.g. `is.numeric()` (or +#' `starts_with("Sep", "Petal")`. `regex()` can be used to define regular +#' expression patterns. +#' - a function testing for logical conditions, e.g. `is.numeric()` (or #' `is.numeric`), or any user-defined function that selects the variables #' for which the function returns `TRUE` (like: `foo <- function(x) mean(x) > 3`), #' - ranges specified via literal variable names, select-helpers (except #' `regex()`) and (user-defined) functions can be negated, i.e. return -#' non-matching elements, when prefixed with a `-`, e.g. `-ends_with("")`, +#' non-matching elements, when prefixed with a `-`, e.g. `-ends_with()`, #' `-is.numeric` or `-(Sepal.Width:Petal.Length)`. **Note:** Negation means #' that matches are _excluded_, and thus, the `exclude` argument can be #' used alternatively. For instance, `select=-ends_with("Length")` (with @@ -48,7 +49,7 @@ #' character string (or a variable containing a character string) and is not #' allowed to be one of the supported select-helpers or a character vector #' of length > 1. `regex = TRUE` is comparable to using one of the two -#' select-helpers, `select = contains("")` or `select = regex("")`, however, +#' select-helpers, `select = contains()` or `select = regex()`, however, #' since the select-helpers may not work when called from inside other #' functions (see 'Details'), this argument may be used as workaround. #' @param verbose Toggle warnings. @@ -131,7 +132,10 @@ #' numeric_mean_35 <- function(x) is.numeric(x) && mean(x, na.rm = TRUE) > 3.5 #' extract_column_names(iris, numeric_mean_35) #' -#' # find range of colum names by range, using character vector +#' # find column names, using range +#' extract_column_names(mtcars, c(cyl:hp, wt)) +#' +#' # find range of column names by range, using character vector #' extract_column_names(mtcars, c("cyl:hp", "wt")) #' #' # rename returned columns for "data_select()" diff --git a/man/adjust.Rd b/man/adjust.Rd index 48b321b8f..c47606ce0 100644 --- a/man/adjust.Rd +++ b/man/adjust.Rd @@ -53,15 +53,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -102,7 +103,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/assign_labels.Rd b/man/assign_labels.Rd index e6fd24252..574730e7b 100644 --- a/man/assign_labels.Rd +++ b/man/assign_labels.Rd @@ -48,15 +48,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -81,7 +82,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/categorize.Rd b/man/categorize.Rd index 90a5e12b7..0fed929de 100644 --- a/man/categorize.Rd +++ b/man/categorize.Rd @@ -99,15 +99,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -142,7 +143,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/center.Rd b/man/center.Rd index 4774020ab..691f10839 100644 --- a/man/center.Rd +++ b/man/center.Rd @@ -82,15 +82,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -133,7 +134,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/convert_na_to.Rd b/man/convert_na_to.Rd index 702e0eb2e..369e3937d 100644 --- a/man/convert_na_to.Rd +++ b/man/convert_na_to.Rd @@ -51,15 +51,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -90,7 +91,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/convert_to_na.Rd b/man/convert_to_na.Rd index fe308d61e..f56fdd7da 100644 --- a/man/convert_to_na.Rd +++ b/man/convert_to_na.Rd @@ -54,15 +54,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -87,7 +88,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/data_codebook.Rd b/man/data_codebook.Rd index d5a542be4..4fcddc1ff 100644 --- a/man/data_codebook.Rd +++ b/man/data_codebook.Rd @@ -44,15 +44,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -94,7 +95,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_duplicated.Rd b/man/data_duplicated.Rd index 88624c8c8..30d8a455d 100644 --- a/man/data_duplicated.Rd +++ b/man/data_duplicated.Rd @@ -30,15 +30,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -63,7 +64,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_extract.Rd b/man/data_extract.Rd index 0b544e710..91b5ee29a 100644 --- a/man/data_extract.Rd +++ b/man/data_extract.Rd @@ -37,15 +37,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -88,7 +89,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_group.Rd b/man/data_group.Rd index 9cb55de5d..c360f7b5e 100644 --- a/man/data_group.Rd +++ b/man/data_group.Rd @@ -34,15 +34,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -67,7 +68,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_peek.Rd b/man/data_peek.Rd index 9524c70ec..5d5e2e18e 100644 --- a/man/data_peek.Rd +++ b/man/data_peek.Rd @@ -37,15 +37,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -70,7 +71,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_relocate.Rd b/man/data_relocate.Rd index 8f360579d..5991691cb 100644 --- a/man/data_relocate.Rd +++ b/man/data_relocate.Rd @@ -54,15 +54,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -89,7 +90,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_rename.Rd b/man/data_rename.Rd index 2859c04d7..3fea0fac4 100644 --- a/man/data_rename.Rd +++ b/man/data_rename.Rd @@ -69,15 +69,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -102,7 +103,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_replicate.Rd b/man/data_replicate.Rd index 5a427d570..0be353c66 100644 --- a/man/data_replicate.Rd +++ b/man/data_replicate.Rd @@ -37,15 +37,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -76,7 +77,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_separate.Rd b/man/data_separate.Rd index 7c951f81c..b85b01916 100644 --- a/man/data_separate.Rd +++ b/man/data_separate.Rd @@ -40,15 +40,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -120,7 +121,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_tabulate.Rd b/man/data_tabulate.Rd index b28a26ede..ac91ead65 100644 --- a/man/data_tabulate.Rd +++ b/man/data_tabulate.Rd @@ -89,15 +89,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -122,7 +123,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_to_long.Rd b/man/data_to_long.Rd index 1c77f764c..3e587c049 100644 --- a/man/data_to_long.Rd +++ b/man/data_to_long.Rd @@ -55,15 +55,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -109,7 +110,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_unique.Rd b/man/data_unique.Rd index a0a70b92a..e0911901d 100644 --- a/man/data_unique.Rd +++ b/man/data_unique.Rd @@ -31,15 +31,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -67,7 +68,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/data_unite.Rd b/man/data_unite.Rd index 369fd33d8..c9893933e 100644 --- a/man/data_unite.Rd +++ b/man/data_unite.Rd @@ -37,15 +37,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -82,7 +83,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/describe_distribution.Rd b/man/describe_distribution.Rd index 80b69e115..4837834ac 100644 --- a/man/describe_distribution.Rd +++ b/man/describe_distribution.Rd @@ -96,15 +96,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -133,7 +134,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/extract_column_names.Rd b/man/extract_column_names.Rd index bb0f9ada8..fe334e22f 100644 --- a/man/extract_column_names.Rd +++ b/man/extract_column_names.Rd @@ -53,15 +53,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -86,7 +87,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} @@ -167,7 +168,10 @@ extract_column_names(iris, starts_with("Sepal"), exclude = contains("Width")) numeric_mean_35 <- function(x) is.numeric(x) && mean(x, na.rm = TRUE) > 3.5 extract_column_names(iris, numeric_mean_35) -# find range of colum names by range, using character vector +# find column names, using range +extract_column_names(mtcars, c(cyl:hp, wt)) + +# find range of column names by range, using character vector extract_column_names(mtcars, c("cyl:hp", "wt")) # rename returned columns for "data_select()" diff --git a/man/labels_to_levels.Rd b/man/labels_to_levels.Rd index 163eb0eaa..c75e2f537 100644 --- a/man/labels_to_levels.Rd +++ b/man/labels_to_levels.Rd @@ -43,15 +43,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -86,7 +87,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/means_by_group.Rd b/man/means_by_group.Rd index 6c06ac3b1..8407263b7 100644 --- a/man/means_by_group.Rd +++ b/man/means_by_group.Rd @@ -61,15 +61,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -94,7 +95,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/normalize.Rd b/man/normalize.Rd index c325e98fe..ecb3a2706 100644 --- a/man/normalize.Rd +++ b/man/normalize.Rd @@ -81,15 +81,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -121,7 +122,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/ranktransform.Rd b/man/ranktransform.Rd index 7046db2b5..44b0052c4 100644 --- a/man/ranktransform.Rd +++ b/man/ranktransform.Rd @@ -49,15 +49,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -82,7 +83,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/recode_values.Rd b/man/recode_values.Rd index 66b7c6e32..11f9cfadc 100644 --- a/man/recode_values.Rd +++ b/man/recode_values.Rd @@ -70,15 +70,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -113,7 +114,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/rescale.Rd b/man/rescale.Rd index 490964777..8d6025a8d 100644 --- a/man/rescale.Rd +++ b/man/rescale.Rd @@ -77,15 +77,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -120,7 +121,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/reverse.Rd b/man/reverse.Rd index 5767908ff..0f33154a4 100644 --- a/man/reverse.Rd +++ b/man/reverse.Rd @@ -55,15 +55,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -98,7 +99,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/row_count.Rd b/man/row_count.Rd index 7bf54fe5f..1a87de609 100644 --- a/man/row_count.Rd +++ b/man/row_count.Rd @@ -33,15 +33,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -76,7 +77,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/row_means.Rd b/man/row_means.Rd index 43d85b5b0..3c859e992 100644 --- a/man/row_means.Rd +++ b/man/row_means.Rd @@ -47,15 +47,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -95,7 +96,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/slide.Rd b/man/slide.Rd index 2950855f4..d68f7e30a 100644 --- a/man/slide.Rd +++ b/man/slide.Rd @@ -44,15 +44,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -87,7 +88,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} diff --git a/man/standardize.Rd b/man/standardize.Rd index fcc8c6ae7..8e8d66867 100644 --- a/man/standardize.Rd +++ b/man/standardize.Rd @@ -155,15 +155,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -201,7 +202,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/to_factor.Rd b/man/to_factor.Rd index d544bdaae..7a500c071 100644 --- a/man/to_factor.Rd +++ b/man/to_factor.Rd @@ -46,15 +46,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -89,7 +90,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.} } diff --git a/man/to_numeric.Rd b/man/to_numeric.Rd index 39f04c3a9..abfcec0d8 100644 --- a/man/to_numeric.Rd +++ b/man/to_numeric.Rd @@ -40,15 +40,16 @@ character vector of variable names including ranges specified via \code{:} \item a vector of negative integers, giving the positions counting from the right (e.g., \code{-1} or \code{-1:-3}), \item one of the following select-helpers: \code{starts_with()}, \code{ends_with()}, -\code{contains()}, a range using \code{:} or \code{regex("")}. \code{starts_with()}, +\code{contains()}, a range using \code{:}, or \code{regex()}. \code{starts_with()}, \code{ends_with()}, and \code{contains()} accept several patterns, e.g -\code{starts_with("Sep", "Petal")}. -\item or a function testing for logical conditions, e.g. \code{is.numeric()} (or +\code{starts_with("Sep", "Petal")}. \code{regex()} can be used to define regular +expression patterns. +\item a function testing for logical conditions, e.g. \code{is.numeric()} (or \code{is.numeric}), or any user-defined function that selects the variables for which the function returns \code{TRUE} (like: \code{foo <- function(x) mean(x) > 3}), \item ranges specified via literal variable names, select-helpers (except \code{regex()}) and (user-defined) functions can be negated, i.e. return -non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with("")}, +non-matching elements, when prefixed with a \code{-}, e.g. \code{-ends_with()}, \code{-is.numeric} or \code{-(Sepal.Width:Petal.Length)}. \strong{Note:} Negation means that matches are \emph{excluded}, and thus, the \code{exclude} argument can be used alternatively. For instance, \code{select=-ends_with("Length")} (with @@ -94,7 +95,7 @@ treated as regular expression. When \code{regex = TRUE}, select \emph{must} be a character string (or a variable containing a character string) and is not allowed to be one of the supported select-helpers or a character vector of length > 1. \code{regex = TRUE} is comparable to using one of the two -select-helpers, \code{select = contains("")} or \code{select = regex("")}, however, +select-helpers, \code{select = contains()} or \code{select = regex()}, however, since the select-helpers may not work when called from inside other functions (see 'Details'), this argument may be used as workaround.}