Merge pull request #68 from r-lib/item-spacing

roxygen2-style argument spacing

man/all.equal.integer64.Rd

@@ -17,22 +17,29 @@
 }
 \arguments{
   \item{target}{ a vector of 'integer64' or an object that can be coerced with \code{\link{as.integer64}} }
+
   \item{current}{ a vector of 'integer64' or an object that can be coerced with \code{\link{as.integer64}} }
+
   \item{tolerance}{numeric \eqn{\ge} 0.  Differences smaller than
     \code{tolerance} are not reported.  The default value is close to
     \code{1.5e-8}.}
+
   \item{scale}{\code{NULL} or numeric > 0, typically of length 1 or
     \code{length(target)}.  See \sQuote{Details}.}
+
   \item{countEQ}{logical indicating if the \code{target == current}
     cases should be counted when computing the mean (absolute or
     relative) differences.  The default, \code{FALSE} may seem
     misleading in cases where \code{target} and \code{current} only
     differ in a few places; see the extensive example.}
+
   \item{formatFUN}{a \code{\link{function}} of two arguments,
     \code{err}, the relative, absolute or scaled error, and
     \code{what}, a character string indicating the \emph{kind} of error;
     maybe used, e.g., to format relative and absolute errors differently.}
+
   \item{...}{further arguments are ignored}
+
   \item{check.attributes}{logical indicating if the
     \code{\link{attributes}} of \code{target} and \code{current}
     (other than the names) should be compared.}

man/as.character.integer64.Rd

@@ -29,7 +29,9 @@
 }
 \arguments{
   \item{x}{ an integer64 vector }
+
   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
+
   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{

man/as.data.frame.integer64.Rd

@@ -8,6 +8,7 @@
 }
 \arguments{
   \item{x}{ an integer64 vector }
+
   \item{...}{ passed to NextMethod \code{\link{as.data.frame}} after removing the 'integer64' class attribute }
 }
 \value{

man/as.integer64.character.Rd

@@ -35,7 +35,9 @@
 }
 \arguments{
   \item{x}{ an atomic vector }
+
   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
+
   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{

man/benchmark64.Rd

@@ -18,17 +18,23 @@ optimizer64(nsmall = 2^16, nbig = 2^25, timefun = repeat.time
 }
 \arguments{
   \item{nsmall}{ size of smaller vector }
+
   \item{nbig}{ size of larger bigger vector }
+
   \item{timefun}{ a function for timing such as \code{\link[bit]{repeat.time}} or \code{\link{system.time}} }
+
   \item{what}{
  a vector of names of high-level functions
 }
+
   \item{uniorder}{
  one of the order parameters that are allowed in \code{\link{unique.integer64}} and \code{\link{unipos.integer64}}
 }
+
   \item{taborder}{
  one of the order parameters that are allowed in \code{\link{table.integer64}}
 }
+
   \item{plot}{
  set to FALSE to suppress plotting
 }

man/bit64-package.Rd

@@ -26,13 +26,21 @@
 }
 \arguments{
   \item{length}{ length of vector using \code{\link{integer}} }
+
   \item{x}{ an integer64 vector }
+
   \item{object}{ an integer64 vector }
+
   \item{value}{ an integer64 vector of values to be assigned }
+
   \item{quote}{ logical, indicating whether or not strings should be printed with surrounding quotes. }
+
   \item{vec.len}{ see \code{\link[utils]{str}} }
+
   \item{give.head}{ see \code{\link[utils]{str}} }
+
   \item{give.length}{ see \code{\link[utils]{str}} }
+
   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{

man/bit64S3.Rd

@@ -54,11 +54,15 @@
   \item{x}{
     integer64 vector: the values to be matched, optionally carrying a cache created with \code{\link{hashcache}}
 }
+
   \item{table}{
     integer64 vector: the values to be matched against, optionally carrying a cache created with \code{\link{hashcache}} or \code{\link{sortordercache}}
 }
+
   \item{from}{ scalar denoting first element of sequence }
+
   \item{to}{ scalar denoting last element of sequence }
+
   \item{...}{ ignored }
 }
 \value{

man/c.integer64.Rd

@@ -14,6 +14,7 @@
 }
 \arguments{
   \item{...}{ two or more arguments coerced to 'integer64' and passed to \code{\link{NextMethod}} }
+
   \item{recursive}{ logical. If \code{recursive = TRUE}, the function recursively descends through lists (and pairlists) combining all their elements into a vector. }
 }
 \value{

man/cache.Rd

@@ -28,18 +28,23 @@ remcache(x)
   \item{x}{
   an integer64 vector (or a cache object in case of \code{print.cache})
 }
+
   \item{which}{
   A character naming the object to be retrieved from the cache or to be stored in the cache
 }
+
   \item{value}{
   An object to be stored in the cache
 }
+
   \item{all.names}{
   passed to \code{\link{ls}} when listing the cache content
 }
+
   \item{pattern}{
   passed to \code{\link{ls}} when listing the cache content
 }
+
   \item{...}{
     ignored
 }

man/cumsum.integer64.Rd

@@ -20,8 +20,11 @@
 }
 \arguments{
   \item{x}{ an atomic vector of class 'integer64'}
+
   \item{lag}{ see \code{\link{diff}} }
+
   \item{differences}{ see \code{\link{diff}} }
+
   \item{...}{ ignored }
 }
 \value{

man/duplicated.integer64.Rd

@@ -6,13 +6,17 @@
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
+
   \item{incomparables}{ignored}
+
   \item{nunique}{
     NULL or the number of unique values (including NA). Providing \code{nunique} can speed-up matching when \code{x} has no cache. Note that a wrong nunique can cause undefined behaviour up to a crash.
 }
+
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
+
   \item{...}{ignored}
 }
 \value{

man/extract.replace.integer64.Rd

@@ -17,8 +17,11 @@
 }
 \arguments{
   \item{x}{ an atomic vector }
+
   \item{i}{ indices specifying elements to extract }
+
   \item{value}{ an atomic vector with values to be assigned }
+
   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{

man/format.integer64.Rd

@@ -59,12 +59,18 @@
 }
 \arguments{
   \item{x}{ an atomic vector of class 'integer64'}
+
   \item{base}{ an atomic scalar (we save 50\% log-calls by not allowing a vector base) }
+
   \item{digits}{ integer indicating the number of decimal places (round) or significant digits (signif) to be used.
                  Negative values are allowed (see \code{\link{round}}) }
+
   \item{justify}{ should it be right-justified (the default), left-justified, centred or left alone. }
+
   \item{center}{ see \code{\link{scale}} }
+
   \item{scale}{  see \code{\link{scale}} }
+
   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{

man/hashcache.Rd

@@ -19,18 +19,23 @@ ordercache(x, has.na = NULL, stable = NULL, optimize = "time")
   \item{x}{
         an atomic vector (note that currently only integer64 is supported)
 }
+
   \item{nunique}{ giving \emph{correct} number of unique elements can help reducing the size of the hashmap }
+
   \item{has.na}{
 boolean scalar defining whether the input vector might contain \code{NA}s. If we know we don't have NAs, this may speed-up.
 \emph{Note} that you risk a crash if there are unexpected \code{NA}s with \code{has.na=FALSE}
 }
+
   \item{stable}{
 boolean scalar defining whether stable sorting is needed. Allowing non-stable may speed-up.
 }
+
   \item{optimize}{
 by default ramsort optimizes for 'time' which requires more RAM,
 set to 'memory' to minimize RAM requirements and sacrifice speed
 }
+
   \item{...}{
         passed to \code{\link{hashmap}}
 }

man/hashmap.Rd

@@ -83,13 +83,21 @@ hashmaptab(x, ...)
 }
 \arguments{
   \item{x}{ an integer64 vector }
+
   \item{hashmap}{ an object of class 'hashmap' i.e. here 'cache_integer64' }
+
   \item{minfac}{ minimum factor by which the hasmap has more elements compared to the data \code{x}, ignored if \code{hashbits} is given directly }
+
   \item{hashbits}{ length of hashmap is \code{2^hashbits} }
+
   \item{cache}{ an optional \code{\link{cache}} object into which to put the hashmap (by default a new cache is created)}
+
   \item{nunique}{ giving \emph{correct} number of unique elements can help reducing the size of the hashmap }
+
   \item{nomatch}{ the value to be returned if an element is not found in the hashmap }
+
   \item{keep.order}{ determines order of results and speed: \code{FALSE} (the default) is faster and returns in the (pseudo)random order of the hash function, \code{TRUE} returns in the order of first appearance in the original data, but this requires extra work }
+
   \item{...}{ further arguments, passed from generics, ignored in methods }
 }
 \value{

man/identical.integer64.Rd

@@ -12,12 +12,19 @@
 \arguments{
   \item{x}{ atomic vector of class 'integer64' }
   \item{y}{ atomic vector of class 'integer64' }
+
   \item{num.eq}{ see \code{\link{identical}} }
+
   \item{single.NA}{ see \code{\link{identical}} }
+
   \item{attrib.as.set}{ see \code{\link{identical}} }
+
   \item{ignore.bytecode}{ see \code{\link{identical}} }
+
   \item{ignore.environment}{ see \code{\link{identical}} }
+
   \item{ignore.srcref}{ see \code{\link{identical}} }
+
   \item{extptr.as.ref}{ see \code{\link{identical}} }
 }
 \value{

man/is.sorted.integer64.Rd

@@ -22,6 +22,7 @@
   \item{x}{
     some object
     }
+
   \item{...}{
     ignored
     }

man/keypos.Rd

@@ -9,9 +9,11 @@ keypos(x, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
+
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
+
   \item{...}{ignored}
 }
 \value{

man/match.integer64.Rd

@@ -13,18 +13,23 @@
   \item{x}{
     integer64 vector: the values to be matched, optionally carrying a cache created with \code{\link{hashcache}}
 }
+
   \item{table}{
     integer64 vector: the values to be matched against, optionally carrying a cache created with \code{\link{hashcache}} or \code{\link{sortordercache}}
 }
+
   \item{nomatch}{
   the value to be returned in the case when no match is found. Note that it is coerced to integer.
 }
+
   \item{nunique}{
     NULL or the number of unique values of table (including NA). Providing \code{nunique} can speed-up matching when \code{table} has no cache. Note that a wrong nunique can cause undefined behaviour up to a crash.
 }
+
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
+
   \item{...}{
 ignored
 }

man/plusclass.Rd

@@ -11,6 +11,7 @@
 }
 \arguments{
   \item{class}{ NULL or a character vector of class attributes }
+
   \item{whichclass}{ the (single) class name to add or remove from the class vector  }
 }
 \value{

man/prank.Rd

@@ -9,9 +9,11 @@
 }
 \arguments{
   \item{x}{a integer64 vector}
+
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
+
   \item{...}{ignored}
 }
 \value{

man/qtile.Rd

@@ -24,22 +24,29 @@
 }
 \arguments{
   \item{x}{a integer64 vector}
+
   \item{object}{a integer64 vector}
+
   \item{probs}{
         numeric vector of probabilities with values in [0,1] - possibly containing \code{NA}s
 }
+
   \item{names}{
     logical; if \code{TRUE}, the result has a \code{names} attribute. Set to \code{FALSE} for speedup with many probs.
 }
+
   \item{type}{
     an integer selecting the quantile algorithm, currently only 0 is supported, see details
 }
+
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
+
   \item{na.rm}{
     logical; if \code{TRUE}, any \code{NA} and \code{NaN}'s are removed from \code{x} before the quantiles are computed.
 }
+
   \item{...}{ignored}
 }
 \value{