@@ -1,7 +1,7 @@ #' Number of dimensions #' Number of dimensions of an array or vector #' -#' @param x array +#' @param x array #' @keywords internal dims <- function(x) length(amv_dim(x)) R/dimensions.r @@ -1,4 +1,5 @@ #' Call function with arguments in array or data frame, returning a data frame +#' #' Call a multi-argument function with values taken from columns of an data frame or array, and combine results into a data frame #' #' The \code{m*ply} functions are the \code{plyr} version of \code{mapply}, @@ -17,6 +18,7 @@ #' @param ... other arguments passed on to \code{.fun} #' @param .progress name of the progress bar to use, see \code{\link{create_progress_bar}} #' @return a data frame +#' @examples #' mdply(data.frame(mean = 1:5, sd = 1:5), rnorm, n = 2) #' mdply(expand.grid(mean = 1:5, sd = 1:5), rnorm, n = 2) #' mdply(cbind(mean = 1:5, sd = 1:5), rnorm, n = 5) R/ply-mapply.r @@ -2,18 +2,27 @@ \alias{a_ply} \title{Split array, apply function, and discard results...} \usage{a_ply(.data, .margins, .fun, ..., .progress="none", .print=FALSE)} -\description{Split array, apply function, and discard results -For each slice of an array, apply function and discard results} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits matrices, -arrays and data frames by dimensions and discards the output. This is -useful for functions that you are calling purely for their side effects like -display plots and saving output.} + +\description{ + Split array, apply function, and discard results For each slice of an + array, apply function and discard results +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits matrices, arrays and data frames by dimensions and + discards the output. This is useful for functions that you are + calling purely for their side effects like display plots and saving + output. +} \keyword{manip} -\arguments{\item{.data}{matrix, array or data frame to be processed} -\item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.print}{automatically print each result? (default: \code{FALSE})}} +\arguments{ + \item{.data}{matrix, array or data frame to be processed} + \item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.print}{automatically print each result? (default: \code{FALSE})} +} man/a_ply.Rd @@ -2,27 +2,37 @@ \alias{aaply} \title{Split array, apply function, and return results in an array...} \usage{aaply(.data, .margins, .fun, ..., .progress="none", .drop=TRUE)} -\description{Split array, apply function, and return results in an array -For each slice of an array, apply function then combine results into an array} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits matrices, -arrays and data frames by dimensions and combines the result into an array. -If there are no results, then this function will return a vector of length 0 (\code{vector()}). -This function is very similar to \code{\link{apply}}, except that it will -always return an array, and when the function returns >1 d data structures, -those dimensions are added on to the highest dimensions, rather than the -lowest dimensions. This makes \code{aaply} idempotent, so that -\code{apply(input, X, identity)} is equivalent to \code{aperm(input, X)}.} +\description{ + Split array, apply function, and return results in an array For each + slice of an array, apply function then combine results into an array +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits matrices, arrays and data frames by dimensions and + combines the result into an array. If there are no results, then this + function will return a vector of length 0 (\code{vector()}). + + This function is very similar to \code{\link{apply}}, except that it + will always return an array, and when the function returns >1 d data + structures, those dimensions are added on to the highest dimensions, + rather than the lowest dimensions. This makes \code{aaply} + idempotent, so that \code{apply(input, X, identity)} is equivalent to + \code{aperm(input, X)}. +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions)} -\arguments{\item{.data}{matrix, array or data frame to be processed} -\item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}}} +\arguments{ + \item{.data}{matrix, array or data frame to be processed} + \item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}} +} \examples{dim(ozone) aaply(ozone, 1, mean) aaply(ozone, 1, mean, .drop = FALSE) man/aaply.Rd @@ -2,18 +2,28 @@ \alias{adply} \title{Split array, apply function, and return results in a data frame...} \usage{adply(.data, .margins, .fun, ..., .progress="none")} -\description{Split array, apply function, and return results in a data frame -For each slice of an array, apply function then combine results into a data frame} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits matrices, -arrays and data frames by dimensions and combines the result into a data -frame. If there are no results, then this function will return a data frame -with zero rows and columns (\code{data.frame()}).} + +\description{ + Split array, apply function, and return results in a data frame For + each slice of an array, apply function then combine results into a + data frame +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits matrices, arrays and data frames by dimensions and + combines the result into a data frame. If there are no results, then + this function will return a data frame with zero rows and columns + (\code{data.frame()}). +} \keyword{manip} \value{a data frame} -\arguments{\item{.data}{matrix, array or data frame to be processed} -\item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{matrix, array or data frame to be processed} + \item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} man/adply.Rd @@ -2,23 +2,31 @@ \alias{alply} \title{Split array, apply function, and return results in a list...} \usage{alply(.data, .margins, .fun, ..., .progress="none")} -\description{Split array, apply function, and return results in a list -For each slice of an array, apply function then combine results into a list} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits matrices, -arrays and data frames by dimensions and combines the result into a list. -If there are no results, then this function will return a list of length 0 -(\code{list()}). -\code{alply} is somewhat similar to \code{\link{apply}} for cases where the -results are not atomic.} +\description{ + Split array, apply function, and return results in a list For each + slice of an array, apply function then combine results into a list +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits matrices, arrays and data frames by dimensions and + combines the result into a list. If there are no results, then this + function will return a list of length 0 (\code{list()}). + + \code{alply} is somewhat similar to \code{\link{apply}} for cases + where the results are not atomic. +} \keyword{manip} \value{list of results} -\arguments{\item{.data}{matrix, array or data frame to be processed} -\item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{matrix, array or data frame to be processed} + \item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns, and so on for higher dimensions} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} \examples{alply(ozone, 3, quantile) alply(ozone, 3, function(x) table(round(x)))} man/alply.Rd @@ -2,7 +2,11 @@ \alias{amv_dim} \title{Dimensions...} \usage{amv_dim(x)} -\description{Dimensions -Consistent dimensions for vectors, matrices and arrays.} + +\description{ + Dimensions Consistent dimensions for vectors, matrices and arrays. +} \keyword{internal} -\arguments{\item{x}{array, matrix or vector}} +\arguments{ + \item{x}{array, matrix or vector} +} man/amv_dim.Rd @@ -2,10 +2,17 @@ \alias{amv_dimnames} \title{Dimension names...} \usage{amv_dimnames(x)} -\description{Dimension names -Consistent dimnames for vectors, matrices and arrays.} -\details{Unlike \code{\link{dimnames}} no part of the output will ever be -null. If a component of dimnames is omitted, \code{amv_dimnames} -will return an integer sequence of the appropriate length.} + +\description{ + Dimension names Consistent dimnames for vectors, matrices and arrays. +} + +\details{ + Unlike \code{\link{dimnames}} no part of the output will ever be + null. If a component of dimnames is omitted, \code{amv_dimnames} + will return an integer sequence of the appropriate length. +} \keyword{internal} -\arguments{\item{x}{array, matrix or vector}} +\arguments{ + \item{x}{array, matrix or vector} +} man/amv_dimnames.Rd @@ -2,14 +2,22 @@ \alias{arrange} \title{Order a data frame by its colums.} \usage{arrange(df, ...)} -\description{Order a data frame by its colums.} -\details{This function completes triad subsetting, transforming and ordering triad -with a function that works in a similar way to \code{\link{subset}} and -\code{\link{transform}} but for reordering a data frame by its columns. -This saves a lot of typing!} + +\description{ + Order a data frame by its colums. +} + +\details{ + This function completes triad subsetting, transforming and ordering + triad with a function that works in a similar way to + \code{\link{subset}} and \code{\link{transform}} but for reordering a + data frame by its columns. This saves a lot of typing! +} \keyword{manip} -\arguments{\item{df}{data frame to reorder} -\item{...}{expressions evaluated in the context of \code{df} and then fed -to \code{\link{order}}}} +\arguments{ + \item{df}{data frame to reorder} + \item{...}{expressions evaluated in the context of \code{df} and then fed +to \code{\link{order}}} +} \examples{mtcars[with(mtcars, order(cyl, disp)), ] arrange(mtcars, cyl, disp)} man/arrange.Rd @@ -2,12 +2,21 @@ \alias{as.data.frame.function} \title{Make a function return a data frame...} \usage{\method{as.data.frame}{function} (x, row.names, optional, ...)} -\description{Make a function return a data frame -Create a new function that returns the existing function wrapped in a data.frame} -\details{This is useful when calling \code{*dply} functions with a function that -returns a vector, and you want the output in rows, rather than columns} + +\description{ + Make a function return a data frame Create a new function that + returns the existing function wrapped in a data.frame +} + +\details{ + This is useful when calling \code{*dply} functions with a function + that returns a vector, and you want the output in rows, rather than + columns +} \keyword{manip} -\arguments{\item{x}{function to make return a data frame} -\item{row.names}{necessary to match the generic, but not used} -\item{optional}{necessary to match the generic, but not used} -\item{...}{necessary to match the generic, but not used}} +\arguments{ + \item{x}{function to make return a data frame} + \item{row.names}{necessary to match the generic, but not used} + \item{optional}{necessary to match the generic, but not used} + \item{...}{necessary to match the generic, but not used} +} man/as.data.frame.function.Rd @@ -2,8 +2,13 @@ \alias{as.list.split} \title{Convert split list to regular list...} \usage{\method{as.list}{split} (x, ...)} -\description{Convert split list to regular list -Strip off label related attributed to make a strip list as regular list} + +\description{ + Convert split list to regular list Strip off label related attributed + to make a strip list as regular list +} \keyword{internal} -\arguments{\item{x}{object to convert to a list} -\item{...}{unused}} +\arguments{ + \item{x}{object to convert to a list} + \item{...}{unused} +} man/as.list.split.Rd @@ -1,13 +1,20 @@ \name{as.quoted} \title{Convert input to quoted variables...} \usage{as.quoted(x)} -\description{Convert input to quoted variables -Convert characters, formulas and calls to quoted .variables} -\details{This method is called by default on all plyr functions that take a -\code{.variables} argument, so that equivalent forms can be used anywhere. -Currently conversions exist for character vectors, formulas and -call objects.} +\description{ + Convert input to quoted variables Convert characters, formulas and + calls to quoted .variables +} + +\details{ + This method is called by default on all plyr functions that take a + \code{.variables} argument, so that equivalent forms can be used + anywhere. + + Currently conversions exist for character vectors, formulas and call + objects. +} \value{a list of quoted variables} \seealso{\code{\link{.}}} \alias{as.quoted.call} @@ -18,6 +25,8 @@ call objects.} \alias{as.quoted.numeric} \alias{c.quoted} \alias{as.quoted} -\arguments{\item{x}{input to quote}} +\arguments{ + \item{x}{input to quote} +} \examples{as.quoted(c("a", "b", "log(d)")) as.quoted(a ~ b + log(d))} man/as.quoted.Rd @@ -2,7 +2,12 @@ \alias{as_df} \title{Convert list to data frame...} \usage{as_df(output)} -\description{Convert list to data frame -Works like cbind, but crams everything into a column} + +\description{ + Convert list to data frame Works like cbind, but crams everything + into a column +} \keyword{internal} -\arguments{\item{output}{output list to turn into a data frame}} +\arguments{ + \item{output}{output list to turn into a data frame} +} man/as_df.Rd @@ -1,16 +1,23 @@ \name{colwise} \title{Column-wise function.} \usage{colwise(.fun, .cols=true)} -\description{Column-wise function. -Turn a function that operates on a vector into a function that operates -column-wise on a data.frame.} -\details{\code{catcolwise} and \code{numcolwise} provide version that only operate -on discrete and numeric variables respectively.} + +\description{ + Column-wise function. Turn a function that operates on a vector into + a function that operates column-wise on a data.frame. +} + +\details{ + \code{catcolwise} and \code{numcolwise} provide version that only + operate on discrete and numeric variables respectively. +} \alias{colwise} \alias{catcolwise} \alias{numcolwise} -\arguments{\item{.fun}{function} -\item{.cols}{either function that tests columns for inclusion, or a quoted object giving which columns to process}} +\arguments{ + \item{.fun}{function} + \item{.cols}{either function that tests columns for inclusion, or a quoted object giving which columns to process} +} \examples{# Count number of missing values nmissing <- function(x) sum(is.na(x)) man/colwise.Rd @@ -2,8 +2,12 @@ \alias{compact} \title{Compact list...} \usage{compact(l)} -\description{Compact list -Remove all NULL entries from a list} + +\description{ + Compact list Remove all NULL entries from a list +} \keyword{manip} \keyword{internal} -\arguments{\item{l}{list}} +\arguments{ + \item{l}{list} +} man/compact.Rd @@ -2,28 +2,35 @@ \alias{create_progress_bar} \title{Create progress bar...} \usage{create_progress_bar(name="none")} -\description{Create progress bar -Create progress bar object from text string.} -\details{Progress bars give feedback on how apply step is proceeding. This -is mainly useful for long running functions, as for short functions, the -time taken up by splitting and combining may be on the same order (or -longer) as the apply step. Additionally, for short functions, the time -needed to update the progress bar can significantly slow down the process. -For the trivial examples below, using the tk progress bar slows things down -by a factor of a thousand. -Note the that progress bar is approximate, and if the time taken by -individual function applications is highly non-uniform it may not be very -informative of the time left. +\description{ + Create progress bar Create progress bar object from text string. +} -There are currently four types of progress bar: "none", "text", "tk", and -"win". See the individual documentation for more details. In plyr -functions, these can either be specified by name, or you can create the -progress bar object yourself if you want more control over its apperance. -See the examples.} +\details{ + Progress bars give feedback on how apply step is proceeding. This is + mainly useful for long running functions, as for short functions, the + time taken up by splitting and combining may be on the same order (or + longer) as the apply step. Additionally, for short functions, the + time needed to update the progress bar can significantly slow down + the process. For the trivial examples below, using the tk progress + bar slows things down by a factor of a thousand. + + Note the that progress bar is approximate, and if the time taken by + individual function applications is highly non-uniform it may not be + very informative of the time left. + + There are currently four types of progress bar: "none", "text", "tk", + and "win". See the individual documentation for more details. In + plyr functions, these can either be specified by name, or you can + create the progress bar object yourself if you want more control over + its apperance. See the examples. +} \seealso{\code{\link{progress_none}}, \code{\link{progress_text}}, \code{\link{progress_tk}}, \code{\link{progress_win}}} \keyword{utilities} -\arguments{\item{name}{type of progress bar to create}} +\arguments{ + \item{name}{type of progress bar to create} +} \examples{l_ply(1:1000, identity, .progress = "none") l_ply(1:1000, identity, .progress = "tk") l_ply(1:1000, identity, .progress = "text") man/create_progress_bar.Rd @@ -2,18 +2,26 @@ \alias{d_ply} \title{Split data frame, apply function, and discard results...} \usage{d_ply(.data, .variables, .fun, ..., .progress="none", .print=FALSE)} -\description{Split data frame, apply function, and discard results -For each subset of a data frame, apply function and discard results} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits data frames -by variable and discards the output. This is useful for functions that you -are calling purely for their side effects like display plots and saving -output.} + +\description{ + Split data frame, apply function, and discard results For each subset + of a data frame, apply function and discard results +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits data frames by variable and discards the output. + This is useful for functions that you are calling purely for their + side effects like display plots and saving output. +} \keyword{manip} -\arguments{\item{.data}{data frame to be processed} -\item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.print}{automatically print each result? (default: \code{FALSE})}} +\arguments{ + \item{.data}{data frame to be processed} + \item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.print}{automatically print each result? (default: \code{FALSE})} +} man/d_ply.Rd @@ -2,24 +2,34 @@ \alias{daply} \title{Split data frame, apply function, and return results in an array...} \usage{daply(.data, .variables, .fun, ..., .progress="none", .drop=TRUE)} -\description{Split data frame, apply function, and return results in an array -For each subset of data frame, apply function then combine results into an array} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits data frames -by variable and combines the result into an array. If there are no results, -then this function will return a vector of length 0 (\code{vector()}). -\code{daply} with a function that operates column-wise is similar to -\code{\link{aggregate}}.} +\description{ + Split data frame, apply function, and return results in an array For + each subset of data frame, apply function then combine results into + an array +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits data frames by variable and combines the result into + an array. If there are no results, then this function will return a + vector of length 0 (\code{vector()}). + + \code{daply} with a function that operates column-wise is similar to + \code{\link{aggregate}}. +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions)} -\arguments{\item{.data}{data frame to be processed} -\item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}}} +\arguments{ + \item{.data}{data frame to be processed} + \item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}} +} \examples{daply(baseball, .(year), nrow) # Several different ways of summarising by variables that should not be man/daply.Rd @@ -2,29 +2,38 @@ \alias{ddply} \title{Split data frame, apply function, and return results in a data frame...} \usage{ddply(.data, .variables, .fun, ..., .progress="none", .drop=TRUE)} -\description{Split data frame, apply function, and return results in a data frame -For each subset of a data frame, apply function then combine results into a data frame} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits data frames -by variables and combines the result into a data frame. If there are no -results, then this function will return a data frame with zero rows and -columns (\code{data.frame()}). -The most unambiguous behaviour is achieved when \code{.fun} returns a -data frame - in that case pieces will be combined with -\code{\link{rbind.fill}}. If \code{.fun} returns an atomic vector of fixed -length, it will be \code{rbind}ed together and converted to a data frame. -Any other values will result in an error.} +\description{ + Split data frame, apply function, and return results in a data frame + For each subset of a data frame, apply function then combine results + into a data frame +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits data frames by variables and combines the result into + a data frame. If there are no results, then this function will + return a data frame with zero rows and columns (\code{data.frame()}). + + The most unambiguous behaviour is achieved when \code{.fun} returns a + data frame - in that case pieces will be combined with + \code{\link{rbind.fill}}. If \code{.fun} returns an atomic vector of + fixed length, it will be \code{rbind}ed together and converted to a + data frame. Any other values will result in an error. +} \keyword{manip} \value{a data frame} -\arguments{\item{.data}{data frame to be processed} -\item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} -\item{.fun}{function to apply to each piece} -\item{.drop}{should combinations of variables that do not appear in the +\arguments{ + \item{.data}{data frame to be processed} + \item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} + \item{.fun}{function to apply to each piece} + \item{.drop}{should combinations of variables that do not appear in the data be preserved (FALSE) or dropped (TRUE, default)} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} \examples{ddply(baseball, .(year), "nrow") ddply(baseball, .(lg), c("nrow", "ncol")) man/ddply.Rd @@ -2,8 +2,13 @@ \alias{defaults} \title{Set defaults...} \usage{defaults(x, y)} -\description{Set defaults -Convient method for combining a list of values with their defaults.} + +\description{ + Set defaults Convient method for combining a list of values with + their defaults. +} \keyword{manip} -\arguments{\item{x}{list of values} -\item{y}{defaults}} +\arguments{ + \item{x}{list of values} + \item{y}{defaults} +} man/defaults.Rd @@ -2,7 +2,11 @@ \alias{dims} \title{Number of dimensions...} \usage{dims(x)} -\description{Number of dimensions -Number of dimensions of an array or vector} + +\description{ + Number of dimensions Number of dimensions of an array or vector +} \keyword{internal} -\arguments{\item{x}{array}} +\arguments{ + \item{x}{array} +} man/dims.Rd @@ -2,25 +2,35 @@ \alias{dlply} \title{Split data frame, apply function, and return results in a list...} \usage{dlply(.data, .variables, .fun, ..., .progress="none", .drop=TRUE)} -\description{Split data frame, apply function, and return results in a list -For each subset of a data frame, apply function then combine results into a list} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits data frames -by variables and combines the result into a list. If there are no results, -then this function will return a list of length 0 (\code{list()}). -\code{dlply} is similar to \code{\link{by}} except that the results are -returned in a different format.} +\description{ + Split data frame, apply function, and return results in a list For + each subset of a data frame, apply function then combine results into + a list +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits data frames by variables and combines the result into + a list. If there are no results, then this function will return a + list of length 0 (\code{list()}). + + \code{dlply} is similar to \code{\link{by}} except that the results + are returned in a different format. +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions)} -\arguments{\item{.data}{data frame to be processed} -\item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.drop}{should combinations of variables that do not appear in the -data be preserved (FALSE) or dropped (TRUE, default)}} +\arguments{ + \item{.data}{data frame to be processed} + \item{.variables}{variables to split data frame by, as quoted variables, a formula or character vector} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.drop}{should combinations of variables that do not appear in the +data be preserved (FALSE) or dropped (TRUE, default)} +} \examples{linmod <- function(df) lm(rbi ~ year, data = transform(df, year = year - min(year))) models <- dlply(baseball, .(id), linmod) models[[1]] man/dlply.Rd @@ -2,11 +2,19 @@ \alias{each} \title{Aggregate multiple functions into a single function...} \usage{each(...)} -\description{Aggregate multiple functions into a single function -Combine multiple functions to a single function returning a named vector of outputs} -\details{Each function should produce a single number as output} + +\description{ + Aggregate multiple functions into a single function Combine multiple + functions to a single function returning a named vector of outputs +} + +\details{ + Each function should produce a single number as output +} \keyword{manip} -\arguments{\item{...}{functions to combine}} +\arguments{ + \item{...}{functions to combine} +} \examples{each(min, max)(1:10) each("min", "max")(1:10) each(c("min", "max"))(1:10) man/each.Rd @@ -3,7 +3,10 @@ \title{Evaluate a quoted list of variables...} \usage{eval.quoted(exprs, envir=parent.frame(), enclos=if (is.list(envir) || is.pairlist(envir)) parent.frame() else baseenv())} -\description{Evaluate a quoted list of variables -Evaluates quoted variables in specified environment} + +\description{ + Evaluate a quoted list of variables Evaluates quoted variables in + specified environment +} \value{a list} \keyword{internal} man/eval.quoted.Rd @@ -2,14 +2,19 @@ \alias{failwith} \title{Fail with...} \usage{failwith(default, f, quiet=FALSE)} -\description{Fail with -Modify a function so that it returns a default value when there is an error.} + +\description{ + Fail with Modify a function so that it returns a default value when + there is an error. +} \value{a function} \seealso{\code{\link{try_default}}} \keyword{debugging} -\arguments{\item{default}{default value} -\item{f}{function} -\item{quiet}{all error messages be suppressed?}} +\arguments{ + \item{default}{default value} + \item{f}{function} + \item{quiet}{all error messages be suppressed?} +} \examples{f <- function(x) if (x == 1) stop("Error!") else 1 \dontrun{ f(1) man/failwith.Rd @@ -1,10 +1,14 @@ \name{get-split} \title{Subset splits...} \usage{\method{[}{split} (x, i, ...)} -\description{Subset splits -Subset splits, ensuring that labels keep matching} + +\description{ + Subset splits Subset splits, ensuring that labels keep matching +} \keyword{internal} \alias{[.split} -\arguments{\item{x}{split object} -\item{i}{index} -\item{...}{unused}} +\arguments{ + \item{x}{split object} + \item{i}{index} + \item{...}{unused} +} man/get-split.Rd @@ -1,20 +1,29 @@ \name{icanhasnext} \title{Add has next functionality to any iterator...} \usage{icanhasnext(iterator)} -\description{Add has next functionality to any iterator} -\details{The iterator package relies of catching \code{StopIteration} errors -to detect when iteration is complete. This function wraps any interator -with an iterator that additionally provides a boolean \code{hasNext} method -which reports whether or not the iterator has another element. This -simplifies programming as you can use a simple while loop, instead of -needing a \code{tryCatch} to detect completion.} + +\description{ + Add has next functionality to any iterator +} + +\details{ + The iterator package relies of catching \code{StopIteration} errors + to detect when iteration is complete. This function wraps any + interator with an iterator that additionally provides a boolean + \code{hasNext} method which reports whether or not the iterator has + another element. This simplifies programming as you can use a simple + while loop, instead of needing a \code{tryCatch} to detect + completion. +} \keyword{internal} \alias{end_iteration} \alias{iteration_has_ended} \alias{new_iterator} \alias{is.iterator} \alias{icanhasnext} -\arguments{\item{iterator}{iterator to add \code{hasNext} capability to}} +\arguments{ + \item{iterator}{iterator to add \code{hasNext} capability to} +} \examples{if (require("iterators")) { it <- icanhasnext(icount(3)) while(it$hasNext()) print(it$nextElem()) man/icanhasnext.Rd @@ -1,13 +1,17 @@ \name{indexed_array} \title{An indexed array...} \usage{indexed_array(env, index)} -\description{An indexed array -Create a indexed array, a space efficient way of indexing into a large -array.} + +\description{ + An indexed array Create a indexed array, a space efficient way of + indexing into a large array. +} \keyword{internal} \alias{indexed_array} \alias{[[.indexed_array} \alias{names.indexed_array} \alias{length.indexed_array} -\arguments{\item{env}{environment containing data frame} -\item{index}{list of indices}} +\arguments{ + \item{env}{environment containing data frame} + \item{index}{list of indices} +} man/indexed_array.Rd @@ -1,8 +1,11 @@ \name{indexed_df} \title{An indexed list...} \usage{indexed_df(env, index)} -\description{An indexed list -Create a indexed list, a space efficient way of indexing into a large data frame} + +\description{ + An indexed list Create a indexed list, a space efficient way of + indexing into a large data frame +} \keyword{internal} \alias{indexed_df} \alias{length.indexed} @@ -11,5 +14,7 @@ Create a indexed list, a space efficient way of indexing into a large data frame \alias{[[.indexed_df} \alias{[.indexed} \alias{print.indexed} -\arguments{\item{env}{environment containing data frame} -\item{index}{list of indices}} +\arguments{ + \item{env}{environment containing data frame} + \item{index}{list of indices} +} man/indexed_df.Rd @@ -2,10 +2,15 @@ \alias{is.discrete} \title{Determine if a vector is discrete...} \usage{is.discrete(x)} -\description{Determine if a vector is discrete -A discrete vector is a factor or a character vector} + +\description{ + Determine if a vector is discrete A discrete vector is a factor or a + character vector +} \keyword{internal} -\arguments{\item{x}{vector to test}} +\arguments{ + \item{x}{vector to test} +} \examples{is.discrete(1:10) is.discrete(c("a", "b", "c")) is.discrete(factor(c("a", "b", "c")))} man/is.discrete.Rd @@ -2,6 +2,8 @@ \alias{is.formula} \title{Is a formula?} \usage{is.formula(x)} -\description{Is a formula? -Checks if argument is a formula} + +\description{ + Is a formula? Checks if argument is a formula +} \keyword{internal} man/is.formula.Rd @@ -2,18 +2,26 @@ \alias{join} \title{Join two data frames together.} \usage{join(x, y, by=intersect(names(x), names(y)), type="left")} -\description{Join two data frames together.} -\details{Unlike merge, preserves the order of x no matter what join type is used. -If needed, rows from y will be added to the bottom. -Join is about four times faster than merge, but it achieves this speed -by being less flexible, and is design for the types of problems where you -would use a sql join.} +\description{ + Join two data frames together. +} + +\details{ + Unlike merge, preserves the order of x no matter what join type is + used. If needed, rows from y will be added to the bottom. + + Join is about four times faster than merge, but it achieves this + speed by being less flexible, and is design for the types of problems + where you would use a sql join. +} \keyword{manip} -\arguments{\item{x}{data frame} -\item{y}{data frame} -\item{by}{character vector of variable names to join by} -\item{type}{type of join: left (default), right, inner or full.}} +\arguments{ + \item{x}{data frame} + \item{y}{data frame} + \item{by}{character vector of variable names to join by} + \item{type}{type of join: left (default), right, inner or full.} +} \examples{first <- ddply(baseball, "id", summarise, first = min(year)) system.time(b2 <- merge(baseball, first, by = "id", all.x = TRUE)) system.time(b3 <- join(baseball, first, by = "id"))} man/join.Rd @@ -2,9 +2,13 @@ \alias{join.keys} \title{Join keys...} \usage{join.keys(x, y, by)} -\description{Join keys -Given two data frames, create a unique key for each row.} + +\description{ + Join keys Given two data frames, create a unique key for each row. +} \keyword{internal} -\arguments{\item{x}{data frame} -\item{y}{data frame} -\item{by}{character vector of variable names to join by}} +\arguments{ + \item{x}{data frame} + \item{y}{data frame} + \item{by}{character vector of variable names to join by} +} man/join.keys.Rd @@ -2,16 +2,25 @@ \alias{l_ply} \title{Split list, apply function, and discard results...} \usage{l_ply(.data, .fun, ..., .progress="none", .print=FALSE)} -\description{Split list, apply function, and discard results -For each element of a list, apply function and discard results} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits lists by -elements and discards the output. This is useful for functions that you are -calling purely for their side effects like display plots and saving output.} + +\description{ + Split list, apply function, and discard results For each element of a + list, apply function and discard results +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits lists by elements and discards the output. This is + useful for functions that you are calling purely for their side + effects like display plots and saving output. +} \keyword{manip} -\arguments{\item{.data}{list to be processed} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.print}{automatically print each result? (default: \code{FALSE})}} +\arguments{ + \item{.data}{list to be processed} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.print}{automatically print each result? (default: \code{FALSE})} +} man/l_ply.Rd @@ -2,25 +2,34 @@ \alias{laply} \title{Split list, apply function, and return results in an array...} \usage{laply(.data, .fun, ..., .progress="none", .drop=TRUE)} -\description{Split list, apply function, and return results in an array -For each element of a list, apply function then combine results into an array} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits lists by -elements and combines the result into an array. If there are no results, -then this function will return a vector of length 0 (\code{vector()}). -\code{laply} is very similar in spirit to \code{\link{sapply}} except that -it will always return an array, and the output is transposed with respect -\code{sapply} - each element of the list corresponds to a column, not a -row.} +\description{ + Split list, apply function, and return results in an array For each + element of a list, apply function then combine results into an array +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits lists by elements and combines the result into an + array. If there are no results, then this function will return a + vector of length 0 (\code{vector()}). + + \code{laply} is very similar in spirit to \code{\link{sapply}} except + that it will always return an array, and the output is transposed + with respect \code{sapply} - each element of the list corresponds to + a column, not a row. +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions)} -\arguments{\item{.data}{input list} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}}} +\arguments{ + \item{.data}{input list} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}} +} \examples{laply(baseball, is.factor) # cf ldply(baseball, is.factor) man/laply.Rd @@ -2,23 +2,32 @@ \alias{ldply} \title{Split list, apply function, and return results in a data frame...} \usage{ldply(.data, .fun, ..., .progress="none")} -\description{Split list, apply function, and return results in a data frame -For each element of a list, apply function then combine results into a data frame} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits lists by -elements and combines the result into a data frame. If there are no -results, then this function will return a data frame with zero rows and -columns (\code{data.frame()}). -The most unambiguous behaviour is achieved when \code{.fun} returns a -data frame - in that case pieces will be combined with -\code{\link{rbind.fill}}. If \code{.fun} returns an atomic vector of fixed -length, it will be \code{rbind}ed together and converted to a data frame. -Any other values will result in an error.} +\description{ + Split list, apply function, and return results in a data frame For + each element of a list, apply function then combine results into a + data frame +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits lists by elements and combines the result into a data + frame. If there are no results, then this function will return a + data frame with zero rows and columns (\code{data.frame()}). + + The most unambiguous behaviour is achieved when \code{.fun} returns a + data frame - in that case pieces will be combined with + \code{\link{rbind.fill}}. If \code{.fun} returns an atomic vector of + fixed length, it will be \code{rbind}ed together and converted to a + data frame. Any other values will result in an error. +} \keyword{manip} \value{a data frame} -\arguments{\item{.data}{list to be processed} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{list to be processed} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} man/ldply.Rd @@ -2,13 +2,21 @@ \alias{liply} \title{Experimental iterator based version of llply.} \usage{liply(.iterator, .fun, ...)} -\description{Experimental iterator based version of llply.} -\details{Because iterators do not have known length, \code{liply} starts by -allocating an output list of length 50, and then doubles that length -whenever it runs out of space. This gives O(n ln n) performance rather -than the O(n ^ 2) performance from the naive strategy of growing the list -each time.} + +\description{ + Experimental iterator based version of llply. +} + +\details{ + Because iterators do not have known length, \code{liply} starts by + allocating an output list of length 50, and then doubles that length + whenever it runs out of space. This gives O(n ln n) performance + rather than the O(n ^ 2) performance from the naive strategy of + growing the list each time. +} \keyword{manip} -\arguments{\item{.iterator}{iterator object} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}}} +\arguments{ + \item{.iterator}{iterator object} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} +} man/liply.Rd @@ -2,9 +2,14 @@ \alias{list_to_array} \title{List to array...} \usage{list_to_array(res, labels, .drop=FALSE)} -\description{List to array -Reduce/simplify a list of homogenous objects to an array} + +\description{ + List to array Reduce/simplify a list of homogenous objects to an + array +} \keyword{internal} -\arguments{\item{res}{list of input data} -\item{labels}{a data frame of labels, one row for each element of res} -\item{.drop}{should extra dimensions be dropped (TRUE) or preserved (FALSE)}} +\arguments{ + \item{res}{list of input data} + \item{labels}{a data frame of labels, one row for each element of res} + \item{.drop}{should extra dimensions be dropped (TRUE) or preserved (FALSE)} +} man/list_to_array.Rd @@ -2,8 +2,13 @@ \alias{list_to_dataframe} \title{List to data frame...} \usage{list_to_dataframe(res, labels)} -\description{List to data frame -Reduce/simplify a list of homogenous objects to a data frame} + +\description{ + List to data frame Reduce/simplify a list of homogenous objects to a + data frame +} \keyword{internal} -\arguments{\item{res}{list of input data} -\item{labels}{a data frame of labels, one row for each element of res}} +\arguments{ + \item{res}{list of input data} + \item{labels}{a data frame of labels, one row for each element of res} +} man/list_to_dataframe.Rd @@ -2,7 +2,12 @@ \alias{list_to_vector} \title{List to vector...} \usage{list_to_vector(res)} -\description{List to vector -Reduce/simplify a list of homogenous objects to a vector} + +\description{ + List to vector Reduce/simplify a list of homogenous objects to a + vector +} \keyword{internal} -\arguments{\item{res}{list of input data}} +\arguments{ + \item{res}{list of input data} +} man/list_to_vector.Rd @@ -2,25 +2,34 @@ \alias{llply} \title{Split list, apply function, and return results in a list...} \usage{llply(.data, .fun, ..., .progress="none", .inform=FALSE)} -\description{Split list, apply function, and return results in a list -For each element of a list, apply function then combine results into a list} -\details{All plyr functions use the same split-apply-combine strategy: they split the -input into simpler pieces, apply \code{.fun} to each piece, and then combine -the pieces into a single data structure. This function splits lists by -elements and combines the result into a list. If there are no results, then -this function will return a list of length 0 (\code{list()}). -\code{llply} is equivalent to \code{\link{lapply}} except that it will -preserve labels and can display a progress bar.} +\description{ + Split list, apply function, and return results in a list For each + element of a list, apply function then combine results into a list +} + +\details{ + All plyr functions use the same split-apply-combine strategy: they + split the input into simpler pieces, apply \code{.fun} to each piece, + and then combine the pieces into a single data structure. This + function splits lists by elements and combines the result into a + list. If there are no results, then this function will return a list + of length 0 (\code{list()}). + + \code{llply} is equivalent to \code{\link{lapply}} except that it + will preserve labels and can display a progress bar. +} \keyword{manip} \value{list of results} -\arguments{\item{.data}{list to be processed} -\item{.fun}{function to apply to each piece} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.inform}{produce informative error messages? This is turned off by +\arguments{ + \item{.data}{list to be processed} + \item{.fun}{function to apply to each piece} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.inform}{produce informative error messages? This is turned off by by default because it substantially slows processing speed, but is very -useful for debugging}} +useful for debugging} +} \examples{llply(llply(mtcars, round), table) llply(baseball, summary) # Examples from ?lapply man/llply.Rd @@ -2,17 +2,28 @@ \alias{m_ply} \title{Call function with arguments in array or data frame, discarding results...} \usage{m_ply(.data, .fun, ..., .progress="none")} -\description{Call function with arguments in array or data frame, discarding results -Call a multi-argument function with values taken from columns of an data frame or array, and discard results} -\details{The \code{m*ply} functions are the \code{plyr} version of \code{mapply}, -specialised according to the type of output they produce. These functions -are just a convenient wrapper around \code{a*ply} with \code{margins = 1} -and \code{.fun} wrapped in \code{\link{splat}}. -This function combines the result into a list. If there are no results, -then this function will return a list of length 0 (\code{list()}).} +\description{ + Call function with arguments in array or data frame, discarding + results Call a multi-argument function with values taken from columns + of an data frame or array, and discard results +} + +\details{ + The \code{m*ply} functions are the \code{plyr} version of + \code{mapply}, specialised according to the type of output they + produce. These functions are just a convenient wrapper around + \code{a*ply} with \code{margins = 1} and \code{.fun} wrapped in + \code{\link{splat}}. + + This function combines the result into a list. If there are no + results, then this function will return a list of length 0 + (\code{list()}). +} \keyword{manip} -\arguments{\item{.data}{matrix or data frame to use as source of arguments} -\item{.fun}{function to be called with varying arguments} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{matrix or data frame to use as source of arguments} + \item{.fun}{function to be called with varying arguments} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} man/m_ply.Rd @@ -2,21 +2,32 @@ \alias{maply} \title{Call function with arguments in array or data frame, returning an array...} \usage{maply(.data, .fun, ..., .progress="none")} -\description{Call function with arguments in array or data frame, returning an array -Call a multi-argument function with values taken from columns of an data frame or array, and combine results into an array} -\details{The \code{m*ply} functions are the \code{plyr} version of \code{mapply}, -specialised according to the type of output they produce. These functions -are just a convenient wrapper around \code{a*ply} with \code{margins = 1} -and \code{.fun} wrapped in \code{\link{splat}}. -This function combines the result into an array. If there are no results, -then this function will return a vector of length 0 (\code{vector()}).} +\description{ + Call function with arguments in array or data frame, returning an + array Call a multi-argument function with values taken from columns + of an data frame or array, and combine results into an array +} + +\details{ + The \code{m*ply} functions are the \code{plyr} version of + \code{mapply}, specialised according to the type of output they + produce. These functions are just a convenient wrapper around + \code{a*ply} with \code{margins = 1} and \code{.fun} wrapped in + \code{\link{splat}}. + + This function combines the result into an array. If there are no + results, then this function will return a vector of length 0 + (\code{vector()}). +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions) maply(cbind(mean = 1:5, sd = 1:5), rnorm, n = 5) maply(cbind(1:5, 1:5), rnorm, n = 5) maply(expand.grid(mean = 1:5, sd = 1:5), rnorm, n = 5)} -\arguments{\item{.data}{matrix or data frame to use as source of arguments} -\item{.fun}{function to be called with varying arguments} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{matrix or data frame to use as source of arguments} + \item{.fun}{function to be called with varying arguments} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} man/maply.Rd @@ -2,22 +2,34 @@ \alias{mdply} \title{Call function with arguments in array or data frame, returning a data frame...} \usage{mdply(.data, .fun, ..., .progress="none")} -\description{Call function with arguments in array or data frame, returning a data frame -Call a multi-argument function with values taken from columns of an data frame or array, and combine results into a data frame} -\details{The \code{m*ply} functions are the \code{plyr} version of \code{mapply}, -specialised according to the type of output they produce. These functions -are just a convenient wrapper around \code{a*ply} with \code{margins = 1} -and \code{.fun} wrapped in \code{\link{splat}}. -This function combines the result into a data frame. If there are no -results, then this function will return a data frame with zero rows and -columns (\code{data.frame()}).} +\description{ + Call function with arguments in array or data frame, returning a data + frame +} + +\details{ + Call a multi-argument function with values taken from columns of an + data frame or array, and combine results into a data frame + + The \code{m*ply} functions are the \code{plyr} version of + \code{mapply}, specialised according to the type of output they + produce. These functions are just a convenient wrapper around + \code{a*ply} with \code{margins = 1} and \code{.fun} wrapped in + \code{\link{splat}}. + + This function combines the result into a data frame. If there are no + results, then this function will return a data frame with zero rows + and columns (\code{data.frame()}). +} \keyword{manip} -\value{a data frame -mdply(data.frame(mean = 1:5, sd = 1:5), rnorm, n = 2) +\value{a data frame} +\arguments{ + \item{.data}{matrix or data frame to use as source of arguments} + \item{.fun}{function to be called with varying arguments} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} +\examples{mdply(data.frame(mean = 1:5, sd = 1:5), rnorm, n = 2) mdply(expand.grid(mean = 1:5, sd = 1:5), rnorm, n = 2) mdply(cbind(mean = 1:5, sd = 1:5), rnorm, n = 5)} -\arguments{\item{.data}{matrix or data frame to use as source of arguments} -\item{.fun}{function to be called with varying arguments} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} man/mdply.Rd @@ -2,21 +2,32 @@ \alias{mlply} \title{Call function with arguments in array or data frame, returning a list...} \usage{mlply(.data, .fun, ..., .progress="none")} -\description{Call function with arguments in array or data frame, returning a list -Call a multi-argument function with values taken from columns of an data frame or array, and combine results into a list} -\details{The \code{m*ply} functions are the \code{plyr} version of \code{mapply}, -specialised according to the type of output they produce. These functions -are just a convenient wrapper around \code{a*ply} with \code{margins = 1} -and \code{.fun} wrapped in \code{\link{splat}}. -This function combines the result into a list. If there are no results, -then this function will return a list of length 0 (\code{list()}).} +\description{ + Call function with arguments in array or data frame, returning a list + Call a multi-argument function with values taken from columns of an + data frame or array, and combine results into a list +} + +\details{ + The \code{m*ply} functions are the \code{plyr} version of + \code{mapply}, specialised according to the type of output they + produce. These functions are just a convenient wrapper around + \code{a*ply} with \code{margins = 1} and \code{.fun} wrapped in + \code{\link{splat}}. + + This function combines the result into a list. If there are no + results, then this function will return a list of length 0 + (\code{list()}). +} \keyword{manip} \value{list of results} -\arguments{\item{.data}{matrix or data frame to use as source of arguments} -\item{.fun}{function to be called with varying arguments} -\item{...}{other arguments passed on to \code{.fun}} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.data}{matrix or data frame to use as source of arguments} + \item{.fun}{function to be called with varying arguments} + \item{...}{other arguments passed on to \code{.fun}} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} \examples{mlply(cbind(1:4, 4:1), rep) mlply(cbind(1:4, times = 4:1), rep) man/mlply.Rd @@ -2,6 +2,10 @@ \alias{names.quoted} \title{Compute names of quoted variables...} \usage{\method{names}{quoted} (x)} -\description{Compute names of quoted variables -Figure out names of quoted variables, using specified names if they exist, otherwise using \code{\link{make.names}} on the values.} + +\description{ + Compute names of quoted variables Figure out names of quoted + variables, using specified names if they exist, otherwise using + \code{\link{make.names}} on the values. +} \keyword{internal} man/names.quoted.Rd @@ -2,8 +2,13 @@ \alias{ninteraction} \title{Numerical interaction...} \usage{ninteraction(.variables, drop=FALSE)} -\description{Numerical interaction -A purely numerical interaction function that powers \code{aaply}.} + +\description{ + Numerical interaction A purely numerical interaction function that + powers \code{aaply}. +} \keyword{internal} -\arguments{\item{.variables}{list of variables} -\item{drop}{drop unusued factor levels?}} +\arguments{ + \item{.variables}{list of variables} + \item{drop}{drop unusued factor levels?} +} man/ninteraction.Rd @@ -2,7 +2,12 @@ \alias{nunique} \title{Number of unique values...} \usage{nunique(x)} -\description{Number of unique values -Calculate number of unique values of a variable as efficiently as possible.} + +\description{ + Number of unique values Calculate number of unique values of a + variable as efficiently as possible. +} \keyword{internal} -\arguments{\item{x}{vector}} +\arguments{ + \item{x}{vector} +} man/nunique.Rd @@ -2,6 +2,9 @@ \alias{print.quoted} \title{Print quoted variables...} \usage{\method{print}{quoted} (x, ...)} -\description{Print quoted variables -Display the \code{\link{str}}ucture of quoted variables} + +\description{ + Print quoted variables Display the \code{\link{str}}ucture of quoted + variables +} \keyword{internal} man/print.quoted.Rd @@ -2,8 +2,12 @@ \alias{print.split} \title{Print split...} \usage{\method{print}{split} (x, ...)} -\description{Print split -Don't print labels, so it appears like a regular list} + +\description{ + Print split Don't print labels, so it appears like a regular list +} \keyword{internal} -\arguments{\item{x}{object to print} -\item{...}{unused}} +\arguments{ + \item{x}{object to print} + \item{...}{unused} +} man/print.split.Rd @@ -1,9 +1,14 @@ \name{progress_none} \alias{progress_none} \title{Null progress bar...} -\description{Null progress bar -A progress bar that does nothing} -\details{This the default progress bar used by plyr functions. It's very simple to -understand - it does nothing!} + +\description{ + Null progress bar A progress bar that does nothing +} + +\details{ + This the default progress bar used by plyr functions. It's very + simple to understand - it does nothing! +} \keyword{internal} \examples{l_ply(1:100, identity, .progress = "none")} man/progress_none.Rd @@ -2,12 +2,20 @@ \alias{progress_text} \title{Text progress bar...} \usage{progress_text(style=3, ...)} -\description{Text progress bar -A textual progress bar} -\details{This progress bar displays a textual progress bar that works on all -platforms. It is a thin wrapper around the built-in -\code{\link{setTxtProgressBar}} and can be customised in the same way.} -\arguments{\item{style}{style of text bar, see Details section of \code{\link{txtProgressBar}}} -\item{...}{other arugments passed on to \code{\link{txtProgressBar}}}} + +\description{ + Text progress bar A textual progress bar +} + +\details{ + This progress bar displays a textual progress bar that works on all + platforms. It is a thin wrapper around the built-in + \code{\link{setTxtProgressBar}} and can be customised in the same + way. +} +\arguments{ + \item{style}{style of text bar, see Details section of \code{\link{txtProgressBar}}} + \item{...}{other arugments passed on to \code{\link{txtProgressBar}}} +} \examples{l_ply(1:1000, identity, .progress = "text") l_ply(1:1000, identity, .progress = progress_text(char = "-"))} man/progress_text.Rd @@ -2,13 +2,21 @@ \alias{progress_tk} \title{Graphical progress bar, powered by Tk...} \usage{progress_tk(title="plyr progress", label="Working...", ...)} -\description{Graphical progress bar, powered by Tk -A graphical progress bar displayed in a Tk window} -\details{This graphical progress will appear in a separate window.} + +\description{ + Graphical progress bar, powered by Tk A graphical progress bar + displayed in a Tk window +} + +\details{ + This graphical progress will appear in a separate window. +} \seealso{\code{\link[tcltk]{tkProgressBar}} for the function that powers this progress bar} -\arguments{\item{title}{window title} -\item{label}{progress bar label (inside window)} -\item{...}{other arguments passed on to \code{\link[tcltk]{tkProgressBar}}}} +\arguments{ + \item{title}{window title} + \item{label}{progress bar label (inside window)} + \item{...}{other arguments passed on to \code{\link[tcltk]{tkProgressBar}}} +} \examples{l_ply(1:1000, identity, .progress = "tk") l_ply(1:1000, identity, .progress = progress_tk(width=400)) l_ply(1:1000, identity, .progress = progress_tk(label=""))} man/progress_tk.Rd @@ -2,12 +2,20 @@ \alias{progress_win} \title{Graphical progress bar, powered by Windows...} \usage{progress_win(title="plyr progress", ...)} -\description{Graphical progress bar, powered by Windows -A graphical progress bar displayed in a separate window} -\details{This graphical progress only works on Windows.} + +\description{ + Graphical progress bar, powered by Windows A graphical progress bar + displayed in a separate window +} + +\details{ + This graphical progress only works on Windows. +} \seealso{\code{\link[utils]{winProgressBar}} for the function that powers this progress bar} -\arguments{\item{title}{window title} -\item{...}{other arguments passed on to \code{\link[utils]{winProgressBar}}}} +\arguments{ + \item{title}{window title} + \item{...}{other arguments passed on to \code{\link[utils]{winProgressBar}}} +} \examples{if(exists("winProgressBar")) { l_ply(1:1000, identity, .progress = "win") l_ply(1:1000, identity, .progress = progress_win(title="Working...")) man/progress_win.Rd @@ -2,9 +2,13 @@ \alias{quickdf} \title{Quick data frame.} \usage{quickdf(list)} -\description{Quick data frame. -Experimental version of \code{\link{as.data.frame}} that converts a -list to a data frame, but doesn't do any checks to make sure it's a -valid format. Much faster.} + +\description{ + Quick data frame. Experimental version of \code{\link{as.data.frame}} + that converts a list to a data frame, but doesn't do any checks to + make sure it's a valid format. Much faster. +} \keyword{internal} -\arguments{\item{list}{list to convert to data frame}} +\arguments{ + \item{list}{list to convert to data frame} +} man/quickdf.Rd @@ -1,24 +1,32 @@ \name{quoted} \title{Quote variables...} \usage{.(...)} -\description{Quote variables -Create a list of unevaluated expressions for later evaluation} -\details{This function is similar to \code{\link{~}} in that it is used to -capture the name of variables, not their current value. This is used -throughout plyr to specify the names of variables (or more complicated -expressions). -Similar tricks can be performed with \code{\link{substitute}}, but when -functions can be called in multiple ways it becomes increasingly tricky -to ensure that the values are extracted from the correct frame. Substitute -tricks also make it difficult to program against the functions that use -them, while the \code{quoted} class provides -\code{\link{as.quoted.character}} to convert strings to the appropriate -data structure.} +\description{ + Quote variables Create a list of unevaluated expressions for later + evaluation +} + +\details{ + This function is similar to \code{\link{~}} in that it is used to + capture the name of variables, not their current value. This is used + throughout plyr to specify the names of variables (or more + complicated expressions). + + Similar tricks can be performed with \code{\link{substitute}}, but + when functions can be called in multiple ways it becomes increasingly + tricky to ensure that the values are extracted from the correct + frame. Substitute tricks also make it difficult to program against + the functions that use them, while the \code{quoted} class provides + \code{\link{as.quoted.character}} to convert strings to the + appropriate data structure. +} \value{list of symbol and language primitives} \alias{.} \alias{quoted} -\arguments{\item{...}{unevaluated expressions to be recorded. Specify names if you want the set the names of the resultant variables}} +\arguments{ + \item{...}{unevaluated expressions to be recorded. Specify names if you want the set the names of the resultant variables} +} \examples{.(a, b, c) .(first = a, second = b, third = c) .(a ^ 2, b - d, log(c)) man/quoted.Rd @@ -2,15 +2,23 @@ \alias{r_ply} \title{Replicate expression and discard results...} \usage{r_ply(.n, .expr, .progress="none", .print=FALSE)} -\description{Replicate expression and discard results -Evalulate expression n times then discard results} -\details{This function runs an expression multiple times, discarding the results. -This function is equivalent to \code{\link{replicate}}, but never returns -anything} + +\description{ + Replicate expression and discard results Evalulate expression n times + then discard results +} + +\details{ + This function runs an expression multiple times, discarding the + results. This function is equivalent to \code{\link{replicate}}, but + never returns anything +} \keyword{manip} -\arguments{\item{.n}{number of times to evaluate the expression} -\item{.expr}{expression to evaluate} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.print}{automatically print each result? (default: \code{FALSE})}} +\arguments{ + \item{.n}{number of times to evaluate the expression} + \item{.expr}{expression to evaluate} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.print}{automatically print each result? (default: \code{FALSE})} +} \examples{r_ply(10, plot(runif(50))) r_ply(25, hist(runif(1000)))} man/r_ply.Rd @@ -2,19 +2,27 @@ \alias{raply} \title{Replicate expression and return results in a array...} \usage{raply(.n, .expr, .progress="none", .drop=TRUE)} -\description{Replicate expression and return results in a array -Evalulate expression n times then combine results into an array} -\details{This function runs an expression multiple times, and combines the -result into a data frame. If there are no results, then this function -returns a vector of length 0 (\code{vector(0)}). -This function is equivalent to \code{\link{replicate}}, but will always -return results as a vector, matrix or array.} + +\description{ + Replicate expression and return results in a array Evalulate + expression n times then combine results into an array +} + +\details{ + This function runs an expression multiple times, and combines the + result into a data frame. If there are no results, then this + function returns a vector of length 0 (\code{vector(0)}). This + function is equivalent to \code{\link{replicate}}, but will always + return results as a vector, matrix or array. +} \keyword{manip} \value{if results are atomic with same type and dimensionality, a vector, matrix or array; otherwise, a list-array (a list with dimensions)} -\arguments{\item{.n}{number of times to evaluate the expression} -\item{.expr}{expression to evaluate} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} -\item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}}} +\arguments{ + \item{.n}{number of times to evaluate the expression} + \item{.expr}{expression to evaluate} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} + \item{.drop}{should extra dimensions of length 1 be dropped, simplifying the output. Defaults to \code{TRUE}} +} \examples{raply(100, mean(runif(100))) raply(100, each(mean, var)(runif(100))) man/raply.Rd @@ -2,11 +2,19 @@ \alias{rbind.fill} \title{Combine objects by row, filling in missing columns.} \usage{rbind.fill(...)} -\description{Combine objects by row, filling in missing columns. -\code{rbind}s a list of data frames filling missing columns with NA.} -\details{This is an enhancement to \code{\link{rbind}} which adds in columns -that are not present in all inputs, accepts a list of data frames, and -operates substantially faster} + +\description{ + Combine objects by row, filling in missing columns. \code{rbind}s a + list of data frames filling missing columns with NA. +} + +\details{ + This is an enhancement to \code{\link{rbind}} which adds in columns + that are not present in all inputs, accepts a list of data frames, + and operates substantially faster +} \keyword{manip} -\arguments{\item{...}{data frames to row bind together}} +\arguments{ + \item{...}{data frames to row bind together} +} \examples{rbind.fill(mtcars[c("mpg", "wt")], mtcars[c("wt", "cyl")])} man/rbind.fill.Rd @@ -2,18 +2,27 @@ \alias{rdply} \title{Replicate expression and return results in a data frame...} \usage{rdply(.n, .expr, .progress="none")} -\description{Replicate expression and return results in a data frame -Evalulate expression n times then combine results into a data frame} -\details{This function runs an expression multiple times, and combines the -result into a data frame. If there are no results, then this function -returns a data frame with zero rows and columns (\code{data.frame()}). -This function is equivalent to \code{\link{replicate}}, but will always -return results as a data frame.} + +\description{ + Replicate expression and return results in a data frame Evalulate + expression n times then combine results into a data frame +} + +\details{ + This function runs an expression multiple times, and combines the + result into a data frame. If there are no results, then this + function returns a data frame with zero rows and columns + (\code{data.frame()}). This function is equivalent to + \code{\link{replicate}}, but will always return results as a data + frame. +} \keyword{manip} \value{a data frame} -\arguments{\item{.n}{number of times to evaluate the expression} -\item{.expr}{expression to evaluate} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.n}{number of times to evaluate the expression} + \item{.expr}{expression to evaluate} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} \examples{rdply(20, mean(runif(100))) rdply(20, each(mean, var)(runif(100))) rdply(20, data.frame(x = runif(2)))} man/rdply.Rd @@ -2,7 +2,11 @@ \alias{reduce_dim} \title{Reduce dimensions...} \usage{reduce_dim(x)} -\description{Reduce dimensions -Remove extraneous dimensions} + +\description{ + Reduce dimensions Remove extraneous dimensions +} \keyword{internal} -\arguments{\item{x}{array}} +\arguments{ + \item{x}{array} +} man/reduce_dim.Rd @@ -2,16 +2,25 @@ \alias{rlply} \title{Replicate expression and return results in a list...} \usage{rlply(.n, .expr, .progress="none")} -\description{Replicate expression and return results in a list -Evalulate expression n times then combine results into a list} -\details{This function runs an expression multiple times, and combines the -result into a list. If there are no results, then this function will return -a list of length 0 (\code{list()}). This function is equivalent to -\code{\link{replicate}}, but will always return results as a list.} + +\description{ + Replicate expression and return results in a list Evalulate + expression n times then combine results into a list +} + +\details{ + This function runs an expression multiple times, and combines the + result into a list. If there are no results, then this function will + return a list of length 0 (\code{list()}). This function is + equivalent to \code{\link{replicate}}, but will always return results + as a list. +} \keyword{manip} \value{list of results} -\arguments{\item{.n}{number of times to evaluate the expression} -\item{.expr}{expression to evaluate} -\item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}}} +\arguments{ + \item{.n}{number of times to evaluate the expression} + \item{.expr}{expression to evaluate} + \item{.progress}{name of the progress bar to use, see \code{\link{create_progress_bar}}} +} \examples{mods <- rlply(100, lm(y ~ x, data=data.frame(x=rnorm(100), y=rnorm(100)))) hist(laply(mods, function(x) summary(x)$r.squared))} man/rlply.Rd @@ -2,12 +2,19 @@ \alias{splat} \title{`Splat' arguments to a function...} \usage{splat(flat)} -\description{`Splat' arguments to a function -Wraps a function in do.call} -\details{This is useful when you want to pass a function a row of data frame or -array, and don't want to manually pull it apart in your function.} + +\description{ + `Splat' arguments to a function Wraps a function in do.call +} + +\details{ + This is useful when you want to pass a function a row of data frame + or array, and don't want to manually pull it apart in your function. +} \value{a function} -\arguments{\item{flat}{function to splat}} +\arguments{ + \item{flat}{function to splat} +} \examples{hp_per_cyl <- function(hp, cyl, ...) hp / cyl splat(hp_per_cyl)(mtcars[1,]) splat(hp_per_cyl)(mtcars) man/splat.Rd @@ -2,8 +2,13 @@ \alias{split_labels} \title{Generate labels for split data frame...} \usage{split_labels(splits, drop)} -\description{Generate labels for split data frame -Create data frame giving labels for split data frame.} + +\description{ + Generate labels for split data frame Create data frame giving labels + for split data frame. +} \keyword{internal} -\arguments{\item{list}{of variables to split up by} -\item{whether}{all possible combinations should be considered, or only those present in the data}} +\arguments{ + \item{list}{of variables to split up by} + \item{whether}{all possible combinations should be considered, or only those present in the data} +} man/split_labels.Rd @@ -2,21 +2,29 @@ \alias{splitter_a} \title{Split an array by...} \usage{splitter_a(data, .margins=1)} -\description{Split an array by .margins -Split a 2d or higher data structure into lower-d pieces based} -\details{This is the workhorse of the \code{a*ply} functions. Given a >1 d -data structure (matrix, array, data.frame), it splits it into pieces -based on the subscripts that you supply. Each piece is a lower dimensional -slice. -The margins are specified in the same way as \code{\link{apply}}, but -\code{splitter_a} just splits up the data, while \code{apply} also -applies a function and combines the pieces back together. This function -also includes enough information to recreate the split from attributes on -the list of pieces.} +\description{ + Split an array by .margins Split a 2d or higher data structure into + lower-d pieces based +} + +\details{ + This is the workhorse of the \code{a*ply} functions. Given a >1 d + data structure (matrix, array, data.frame), it splits it into pieces + based on the subscripts that you supply. Each piece is a lower + dimensional slice. + + The margins are specified in the same way as \code{\link{apply}}, but + \code{splitter_a} just splits up the data, while \code{apply} also + applies a function and combines the pieces back together. This + function also includes enough information to recreate the split from + attributes on the list of pieces. +} \value{a list of lower-d slices, with attributes that record split details} -\arguments{\item{data}{>1d data structure (matrix, data.frame or array)} -\item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns}} +\arguments{ + \item{data}{>1d data structure (matrix, data.frame or array)} + \item{.margins}{a vector giving the subscripts to split up \code{data} by. 1 splits up by rows, 2 by columns and c(1,2) by rows and columns} +} \examples{splitter_a(mtcars, 1) splitter_a(mtcars, 2) man/splitter_a.Rd @@ -2,22 +2,30 @@ \alias{splitter_d} \title{Split a data frame by variables...} \usage{splitter_d(data, .variables, drop=TRUE)} -\description{Split a data frame by variables -Split a data frame into pieces based on variable contained in that data frame} -\details{This is the workhorse of the \code{d*ply} functions. Based on the variables -you supply, it breaks up a single data frame into a list of data frames, -each containing a single combination from the levels of the specified -variables. -This is basically a thin wrapper around \code{\link{split}} which -evaluates the variables in the context of the data, and includes enough -information to reconstruct the labelling of the data frame after -other operations.} +\description{ + Split a data frame by variables Split a data frame into pieces based + on variable contained in that data frame +} + +\details{ + This is the workhorse of the \code{d*ply} functions. Based on the + variables you supply, it breaks up a single data frame into a list of + data frames, each containing a single combination from the levels of + the specified variables. + + This is basically a thin wrapper around \code{\link{split}} which + evaluates the variables in the context of the data, and includes + enough information to reconstruct the labelling of the data frame + after other operations. +} \seealso{\code{\link{.}} for quoting variables, \code{\link{split}}} \value{a list of data.frames, with attributes that record split details} -\arguments{\item{data}{data frame} -\item{.variables}{a \link{quoted} list of variables, a formula, or character vector} -\item{drop}{drop unnused factor levels?}} +\arguments{ + \item{data}{data frame} + \item{.variables}{a \link{quoted} list of variables, a formula, or character vector} + \item{drop}{drop unnused factor levels?} +} \examples{splitter_d(mtcars, .(cyl)) splitter_d(mtcars, .(vs, am)) splitter_d(mtcars, .(am, vs)) man/splitter_d.Rd @@ -1,17 +1,25 @@ \name{summarise} \title{Summarise a data frame.} \usage{summarise(.data, ...)} -\description{Summarise a data frame. -Create a new data frame that summarises an existing data frame.} -\details{Summarise works in an analagous way to transform, except instead of adding -columns to an existing data frame, it creates a new one. This is -particularly useful in conjunction with \code{\link{ddply}} as it makes it -easy to perform group-wise summaries.} + +\description{ + Summarise a data frame. Create a new data frame that summarises an + existing data frame. +} + +\details{ + Summarise works in an analagous way to transform, except instead of + adding columns to an existing data frame, it creates a new one. This + is particularly useful in conjunction with \code{\link{ddply}} as it + makes it easy to perform group-wise summaries. +} \keyword{manip} \alias{summarise} \alias{summarize} -\arguments{\item{.data}{the data frame to be summarised} -\item{...}{further arguments of the form var = value}} +\arguments{ + \item{.data}{the data frame to be summarised} + \item{...}{further arguments of the form var = value} +} \examples{summarise(baseball, duration = max(year) - min(year), nteams = length(unique(team))) man/summarise.Rd @@ -2,8 +2,13 @@ \alias{true} \title{Function that always returns true...} \usage{true(...)} -\description{Function that always returns true} + +\description{ + Function that always returns true +} \value{\code{TRUE}} \keyword{internal} \seealso{\code{\link{colwise}} which uses it} -\arguments{\item{...}{all input ignored}} +\arguments{ + \item{...}{all input ignored} +} man/true.Rd @@ -1,13 +1,22 @@ \name{try_default} \title{Try, with default in case of error.} \usage{try_default(expr, default, quiet=FALSE)} -\description{Try, with default in case of error. -\code{try_default} wraps try so that it returns a default value in the case of error.} -\details{\code{tryNULL} provides a useful special case when dealing with lists.} + +\description{ + Try, with default in case of error. \code{try_default} wraps try so + that it returns a default value in the case of error. +} + +\details{ + \code{tryNULL} provides a useful special case when dealing with + lists. +} \alias{try_default} \alias{tryNULL} \keyword{internal} \seealso{\code{\link{tryapply}}} -\arguments{\item{expr}{expression to try} -\item{default}{default value in case of error} -\item{quiet}{should errors be printed (TRUE) or ignored (FALSE, default)}} +\arguments{ + \item{expr}{expression to try} + \item{default}{default value in case of error} + \item{quiet}{should errors be printed (TRUE) or ignored (FALSE, default)} +} man/try_default.Rd @@ -2,6 +2,8 @@ \alias{tryapply} \title{Apply with built in try...} \usage{tryapply(list, fun, ...)} -\description{Apply with built in try -Uses compact, lapply and tryNULL} + +\description{ + Apply with built in try Uses compact, lapply and tryNULL +} \keyword{internal} man/tryapply.Rd @@ -2,7 +2,11 @@ \alias{unrowname} \title{Un-rowname...} \usage{unrowname(x)} -\description{Un-rowname -Strip rownames from an object} + +\description{ + Un-rowname Strip rownames from an object +} \keyword{internal} -\arguments{\item{x}{data frame}} +\arguments{ + \item{x}{data frame} +} man/unrowname.Rd dec35fe0757a58dc5a376cf12ce221d713e41fc4 hadley h.wickham@gmail.com http://github.com/hadley/plyr/commit/2686e4f9d64eda02c5dfc3bb17b2dda6dbac15a5 2686e4f9d64eda02c5dfc3bb17b2dda6dbac15a5 2009-09-15T07:20:33-07:00 2009-09-15T07:16:48-07:00 More human readable man pages. (And fix some mdply probs) 342513a9e2441ed1d3ccd73150f3604ba4236f2f hadley h.wickham@gmail.com