diff --git a/man/all.equal.integer64.Rd b/man/all.equal.integer64.Rd index 89e7398..02b8923 100644 --- a/man/all.equal.integer64.Rd +++ b/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.} diff --git a/man/as.character.integer64.Rd b/man/as.character.integer64.Rd index a82beea..fd06957 100644 --- a/man/as.character.integer64.Rd +++ b/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{ diff --git a/man/as.data.frame.integer64.Rd b/man/as.data.frame.integer64.Rd index c6770a8..ecd01f0 100644 --- a/man/as.data.frame.integer64.Rd +++ b/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{ diff --git a/man/as.integer64.character.Rd b/man/as.integer64.character.Rd index bf4f4ee..b3f925a 100644 --- a/man/as.integer64.character.Rd +++ b/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{ diff --git a/man/benchmark64.Rd b/man/benchmark64.Rd index 97e60d5..50348f0 100644 --- a/man/benchmark64.Rd +++ b/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 } diff --git a/man/bit64-package.Rd b/man/bit64-package.Rd index 7f5cf05..f5c840d 100644 --- a/man/bit64-package.Rd +++ b/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{ diff --git a/man/bit64S3.Rd b/man/bit64S3.Rd index 76ff841..9dd8833 100644 --- a/man/bit64S3.Rd +++ b/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{ diff --git a/man/c.integer64.Rd b/man/c.integer64.Rd index ed69f55..9357e74 100644 --- a/man/c.integer64.Rd +++ b/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{ diff --git a/man/cache.Rd b/man/cache.Rd index 53a76b3..d53dbac 100644 --- a/man/cache.Rd +++ b/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 } diff --git a/man/cumsum.integer64.Rd b/man/cumsum.integer64.Rd index bd3836c..94c157c 100644 --- a/man/cumsum.integer64.Rd +++ b/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{ diff --git a/man/duplicated.integer64.Rd b/man/duplicated.integer64.Rd index 4c6bd0b..783b849 100644 --- a/man/duplicated.integer64.Rd +++ b/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{ diff --git a/man/extract.replace.integer64.Rd b/man/extract.replace.integer64.Rd index d408ae5..b25fe2e 100644 --- a/man/extract.replace.integer64.Rd +++ b/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{ diff --git a/man/format.integer64.Rd b/man/format.integer64.Rd index 735d962..7754e36 100644 --- a/man/format.integer64.Rd +++ b/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{ diff --git a/man/hashcache.Rd b/man/hashcache.Rd index b1651df..9595da4 100644 --- a/man/hashcache.Rd +++ b/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}} } diff --git a/man/hashmap.Rd b/man/hashmap.Rd index 4b5dd1d..3fdedf7 100644 --- a/man/hashmap.Rd +++ b/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{ diff --git a/man/identical.integer64.Rd b/man/identical.integer64.Rd index 7cc74ff..6df10e2 100644 --- a/man/identical.integer64.Rd +++ b/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{ diff --git a/man/is.sorted.integer64.Rd b/man/is.sorted.integer64.Rd index febfb24..46e2287 100644 --- a/man/is.sorted.integer64.Rd +++ b/man/is.sorted.integer64.Rd @@ -22,6 +22,7 @@ \item{x}{ some object } + \item{...}{ ignored } diff --git a/man/keypos.Rd b/man/keypos.Rd index 91a4be4..818246c 100644 --- a/man/keypos.Rd +++ b/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{ diff --git a/man/match.integer64.Rd b/man/match.integer64.Rd index 51c4e37..ba4ea54 100644 --- a/man/match.integer64.Rd +++ b/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 } diff --git a/man/plusclass.Rd b/man/plusclass.Rd index 2b98b0c..7b22349 100644 --- a/man/plusclass.Rd +++ b/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{ diff --git a/man/prank.Rd b/man/prank.Rd index 2a13c21..9b08128 100644 --- a/man/prank.Rd +++ b/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{ diff --git a/man/qtile.Rd b/man/qtile.Rd index 9514a14..83c2d50 100644 --- a/man/qtile.Rd +++ b/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{ diff --git a/man/ramsort.integer64.Rd b/man/ramsort.integer64.Rd index 5af38d6..ba68478 100644 --- a/man/ramsort.integer64.Rd +++ b/man/ramsort.integer64.Rd @@ -56,34 +56,44 @@ } \arguments{ \item{x}{ a vector to be sorted by \code{\link{ramsort.integer64}} and \code{\link{ramsortorder.integer64}}, i.e. the output of \code{\link{sort.integer64}} } + \item{i}{ integer positions to be modified by \code{\link{ramorder.integer64}} and \code{\link{ramsortorder.integer64}}, default is 1:n, in this case the output is similar to \code{\link{order.integer64}} } + \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{na.last}{ boolean scalar telling ramsort whether to sort \code{NA}s last or first. \emph{Note} that 'boolean' means that there is no third option \code{NA} as in \code{\link{sort}} } + \item{decreasing}{ boolean scalar telling ramsort whether to sort increasing or decreasing } + \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{restlevel}{ number of remaining recursionlevels before \code{quicksort} switches from recursing to \code{shellsort} } + \item{radixbits}{ size of radix in bits } + \item{VERBOSE}{ cat some info about chosen method } + \item{...}{ further arguments, passed from generics, ignored in methods } } \value{ diff --git a/man/rank.integer64.Rd b/man/rank.integer64.Rd index c12706d..7f21ca5 100644 --- a/man/rank.integer64.Rd +++ b/man/rank.integer64.Rd @@ -6,9 +6,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{ diff --git a/man/rep.integer64.Rd b/man/rep.integer64.Rd index 7f0bfc4..94bde65 100644 --- a/man/rep.integer64.Rd +++ b/man/rep.integer64.Rd @@ -8,6 +8,7 @@ } \arguments{ \item{x}{ a vector of 'integer64' to be replicated } + \item{...}{ further arguments passed to \code{\link{NextMethod}} } } \value{ diff --git a/man/runif64.Rd b/man/runif64.Rd index eb29675..fea3d53 100644 --- a/man/runif64.Rd +++ b/man/runif64.Rd @@ -8,8 +8,11 @@ } \arguments{ \item{n}{ length of return vector } + \item{min}{ lower inclusive bound for random numbers } + \item{max}{ upper inclusive bound for random numbers } + \item{replace}{ set to FALSE for sampleing from a finite pool, see \code{\link{sample}} } } \value{ diff --git a/man/seq.integer64.Rd b/man/seq.integer64.Rd index b6974d1..96a4628 100644 --- a/man/seq.integer64.Rd +++ b/man/seq.integer64.Rd @@ -8,10 +8,15 @@ } \arguments{ \item{from}{ integer64 scalar (in order to dispatch the integer64 method of \code{\link{seq}} } + \item{to}{ scalar } + \item{by}{ scalar } + \item{length.out}{ scalar } + \item{along.with}{ scalar } + \item{...}{ ignored } } \value{ diff --git a/man/sort.integer64.Rd b/man/sort.integer64.Rd index d7391a1..12baf14 100644 --- a/man/sort.integer64.Rd +++ b/man/sort.integer64.Rd @@ -13,27 +13,34 @@ } \arguments{ \item{x}{ a vector to be sorted by \code{\link{ramsort.integer64}} and \code{\link{ramsortorder.integer64}}, i.e. the output of \code{\link{sort.integer64}} } + \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{na.last}{ boolean scalar telling ramsort whether to sort \code{NA}s last or first. \emph{Note} that 'boolean' means that there is no third option \code{NA} as in \code{\link{sort}} } + \item{decreasing}{ boolean scalar telling ramsort whether to sort increasing or decreasing } + \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{VERBOSE}{ cat some info about chosen method } + \item{...}{ further arguments, passed from generics, ignored in methods } } \value{ diff --git a/man/sortnut.Rd b/man/sortnut.Rd index db3df4f..ddff05e 100644 --- a/man/sortnut.Rd +++ b/man/sortnut.Rd @@ -145,18 +145,31 @@ sortorderrnk(sorted, order, na.count, ...) } \arguments{ \item{x}{ an \code{\link{integer64}} vector } + \item{sorted}{ a sorted \code{\link{integer64}} vector } + \item{table}{ the original data with original order under the sorted vector } + \item{order}{ an \code{\link{integer}} order vector that turns 'table' into 'sorted' } + \item{nunique}{ number of unique elements, usually we get this from cache or call \code{sortnut} or \code{ordernut} } + \item{nties}{ number of tied values, usually we get this from cache or call \code{sortnut} or \code{ordernut} } + \item{denormalize}{ FALSE returns counts of unique values, TRUE returns each value with its counts } + \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 sorted order, \code{TRUE} returns in the order of first appearance in the original data, but this requires extra work } + \item{probs}{ vector of probabilities in [0..1] for which we seek quantiles } + \item{na.skip.num}{ 0 or the number of \code{NA}s. With 0, \code{NA}s are coded with 1L, with the number of \code{NA}s, these are coded with \code{NA} } + \item{na.count}{ the number of \code{NA}s, needed for this low-level function algorithm } + \item{method}{ see details } + \item{...}{ further arguments, passed from generics, ignored in methods } } \value{ diff --git a/man/sum.integer64.Rd b/man/sum.integer64.Rd index 578a2ea..c86ad0a 100644 --- a/man/sum.integer64.Rd +++ b/man/sum.integer64.Rd @@ -29,7 +29,9 @@ lim.integer64() } \arguments{ \item{...}{ atomic vectors of class 'integer64'} + \item{na.rm}{ logical scalar indicating whether to ignore NAs } + \item{finite}{ logical scalar indicating whether to ignore NAs (just for compatibility with \code{\link{range.default}}) } } \value{ diff --git a/man/table.integer64.Rd b/man/table.integer64.Rd index 003914e..0eae02a 100644 --- a/man/table.integer64.Rd +++ b/man/table.integer64.Rd @@ -16,20 +16,26 @@ table.integer64(... (including character strings), or a list (or data frame) whose components can be so interpreted. (For \code{as.table} and \code{as.data.frame}, arguments passed to specific methods.)} + \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{order}{ By default results are created sorted by "values", or by "counts" } + \item{method}{ NULL for automatic method selection or a suitable low-level method, see details } + \item{return}{ choose the return format, see details } + \item{dnn}{the names to be given to the dimensions in the result (the \emph{dimnames names}).} + \item{deparse.level}{controls how the default \code{dnn} is constructed. See \sQuote{Details}.} } diff --git a/man/tiepos.Rd b/man/tiepos.Rd index c519c7c..099bfcb 100644 --- a/man/tiepos.Rd +++ b/man/tiepos.Rd @@ -9,12 +9,15 @@ tiepos(x, ...) } \arguments{ \item{x}{a vector or a data frame or an array or \code{NULL}.} + \item{nties}{ NULL or the number of tied values (including NA). Providing \code{nties} can speed-up when \code{x} has no cache. Note that a wrong nties 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{ diff --git a/man/unipos.Rd b/man/unipos.Rd index a9d3d8c..3b3cb4a 100644 --- a/man/unipos.Rd +++ b/man/unipos.Rd @@ -10,14 +10,19 @@ unipos(x, incomparables = FALSE, order = c("original","values","any"), ...) } \arguments{ \item{x}{a vector or a data frame or an array or \code{NULL}.} + \item{incomparables}{ignored} + \item{order}{The order in which positions of unique values will be returned, see details} + \item{nunique}{ NULL or the number of unique values (including NA). Providing \code{nunique} can speed-up 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{ diff --git a/man/unique.integer64.Rd b/man/unique.integer64.Rd index 46dc780..fe8ada8 100644 --- a/man/unique.integer64.Rd +++ b/man/unique.integer64.Rd @@ -7,14 +7,19 @@ } \arguments{ \item{x}{a vector or a data frame or an array or \code{NULL}.} + \item{incomparables}{ignored} + \item{order}{The order in which unique values will be returned, see details} + \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{ diff --git a/man/xor.integer64.Rd b/man/xor.integer64.Rd index c0b74a6..d5537b2 100644 --- a/man/xor.integer64.Rd +++ b/man/xor.integer64.Rd @@ -56,8 +56,11 @@ binattr(e1,e2) # for internal use only } \arguments{ \item{e1}{ an atomic vector of class 'integer64'} + \item{e2}{ an atomic vector of class 'integer64'} + \item{x}{ an atomic vector of class 'integer64'} + \item{y}{ an atomic vector of class 'integer64'} } \value{