Class flint is a virtual class representing vectors of any
FLINT C type. The C type is
determined by the class attribute and interfaced exactly using R's
external pointer type.
.xDataan external pointer. The protected field is an integer vector of
length 1 or 2 storing the object length whose size is 32 or 64
bits depending on the ABI; see flintABI. The
pointer field contains the address of a block of allocated memory
of size greater than or equal to the object length times the size
of the FLINT C type. It is a null pointer if
and only if the object length is zero.
Methods for initialize set a finalizer on
.xData (see reg.finalizer) to ensure that
allocated memory is freed before .xData is itself freed by
the garbage collector.
namesa character vector of length 0, indicating that the object is unnamed, or of length equal to the object length. A corollary is that objects whose length exceeds the maximum length of a character vector cannot have names.
[signature(x = "ANY", i = "flint", j = "missing", drop = "missing"):
signature(x = "flint", i = "ANY", j = "missing", drop = "missing"):
signature(x = "flint", i = "flint", j = "missing", drop = "missing"):
return a traditional vector or a flint vector containing
the elements of x indexed by i (the
“subscript”). The subscript can be missing, NULL,
logical, integer, double, character, ulong,
slong, fmpz, or
fmpq. Methods for signatures with
x = "flint" signal an error for NA and out of bounds
subscripts, as the C types interfaced by flint
vectors have no representation for missing values. Note that
[ does not perform S4 dispatch if its first
positional argument is not an S4 object. If it is known that
i is a flint vector and not known whether x
is a flint vector, then consider programming defensively
by calling [ as `[`(i = i, x = x) rather than
as x[i].
[<-signature(x = "ANY", i = "ANY", j = "missing", value = "flint"):
signature(x = "ANY", i = "flint", j = "missing", value = "ANY"):
signature(x = "ANY", i = "flint", j = "missing", value = "flint"):
signature(x = "flint", i = "ANY", j = "missing", value = "ANY"):
signature(x = "flint", i = "ANY", j = "missing", value = "flint"):
signature(x = "flint", i = "flint", j = "missing", value = "ANY"):
signature(x = "flint", i = "flint", j = "missing", value = "flint"):
return the traditional vector or flint vector obtained by
replacing the elements of x indexed by i (the
“subscript”) with elements of value, which are
recycled as necessary. The subscript can be missing, NULL,
logical, integer, double, character, ulong,
slong, fmpz, or
fmpq. The class of the return value is
determined following strict rules from the classes of x and
value, which are promoted to the value class as necessary.
If the value class is a subclass of flint, then an error is
signaled for NA and out of bounds subscripts, as the
C types interfaced by flint vectors have no
representation for missing values. Note that [<-
does not perform S4 dispatch if its first positional argument is
not an S4 object. If it is known that i is a flint
vector and not known whether x is a flint vector,
then consider calling [<- as
`[`(i = i, x = x) <- value rather than as
x[i] <- value. If it known that value is a
flint vector and not known whether x or i is
a flint vector, then consider doing something like
x <- `[<-`(value = value, x = x, i = i).
[[signature(x = "ANY", i = "ANY", j = "missing", value = "flint"):
signature(x = "ANY", i = "flint", j = "missing", value = "ANY"):
signature(x = "ANY", i = "flint", j = "missing", value = "flint"):
signature(x = "flint", i = "ANY", j = "missing", value = "ANY"):
signature(x = "flint", i = "ANY", j = "missing", value = "flint"):
signature(x = "flint", i = "flint", j = "missing", value = "ANY"):
signature(x = "flint", i = "flint", j = "missing", value = "flint"):
similar to [<-, with differences as documented in
Extract.
all.equalsignature(x = "ANY", y = "flint"):
signature(x = "flint", y = "ANY"):
signature(x = "flint", y = "flint"):
returns either TRUE, indicating that there is no meaningful
difference between x and y, or a character vector
describing differences. The implementation (including optional
arguments) is adapted from all.equal.numeric, hence
see its documentation. Notably, comparison of objects
inheriting from different subclasses of virtual class flint
and comparison with objects (typically atomic vectors) coercible
to virtual class flint are supported with
check.class = FALSE. See flintIdentical for
much more strict comparison objects inheriting from flint.
anyDuplicatedsignature(x = "flint"):
returns anyDuplicated(mtfrm(x), ...).
as.raw, as.logical, as.integer, as.numeric, as.complexsignature(x = "flint"):
returns the value of as.vector(x, mode = *). Methods for
as.vector must be defined for subclasses of flint.
Note that as.double dispatches internally the method for
as.numeric, so there is no method for as.double;
see also as.numeric, section ‘S4 Methods’.
as.matrix, as.array, as.Date, as.POSIXct, as.POSIXltsignature(x = "flint"):
coerces the argument with as.vector and dispatches.
as.data.framesignature(x = "flint"):
this method is a copy of as.data.frame.vector. It
enables the construction of data frames containing flint
vectors using as.data.frame and functions that call it such
as data.frame and cbind.data.frame.
csignature(x = "flint"):
returns c.flint(x, ...), the concatenation of the
arguments. Function c.flint is exported to work around the
fact that c(x, ...) dispatches only on x.
coercesignature(from = "ANY", to = "flint"):
coerces atomic (except character) vectors from to the most
specific subclass of flint whose range contains the range
of typeof(from).
cutsignature(x = "flint"):
returns
findInterval(x=x, vec=breaks, left.open=right, rightmost.closed=include.lowest),
hence see below. The behaviour is consistent with the default
method for cut with argument labels set to
FALSE, provided that breaks is sorted and no element
of x is out of bounds.
duplicatedsignature(x = "flint"):
returns duplicated(mtfrm(x), ...).
findIntervalreturns a ulong vector of length equal to the
length of x, following the documented behaviour of the
base function, hence see findInterval. A
caveat is that an error is signaled if x contains
NaN, because ulong has no representation for R's
missing value NA_integer_.
is.na<-signature(x = "flint"):
returns the value of x after x[value] <- na,
where na is an NA of integer, double,
or complex type, depending on the class of x.
lengthsignature(x = "flint"):
returns flintLength(x, exact = FALSE).
length<-signature(x = "flint"):
returns a flint vector of length given by the second
argument value. The first min(length(x), value)
elements are copied from x and the remaining elements are
initialized to zero.
matchsignature(x = "ANY", table = "flint"):
signature(x = "flint", table = "ANY"):
signature(x = "flint", table = "flint"):
returns an integer vector matching x to table after
coercing to a common class then “match transforming” with
mtfrm. The behaviour is parallel to that of the
default method, hence see match.
mtfrmsignature(x = "flint"):
returns format(x, base = 62L, digits = 0L), a character
vector representing the elements of x exactly in base 62
(chosen over smaller bases to reduce the number of characters in
the output); see also format-methods.
namessignature(x = "flint"):
returns the value of the names slot or NULL,
NULL if the names slot has zero length.
names<-signature(x = "flint", value = "NULL"):
returns x with names slot set to a character vector
of length zero.
names<-signature(x = "flint", value = "character"):
returns x with names slot set to value.
Attributes of value are stripped.
NA_character_ are appended to value if its
length is less than the length of x. An error is signaled
if its length is greater.
printsignature(x = "flint"):
prints format(x) without quotes and returns x
invisibly. The output has a header listing the class and length
of x and the address stored by its .xData slot. If
the output might be differenced by Rdiff,
then one can set optional argument Rdiff to TRUE to
indicate that the address should be formatted as
<pointer: 0x...> rather than as 0x..., as the longer
format is recognized and ignored by Rdiff.
The default value NULL is equivalent to
getOption("flint.Rdiff", FALSE). For greater control over
output, consider doing print(format(x, ...), ...)
instead of print(x, ...).
quantilesignature(x = "flint"):
returns a flint vector containing sample quantiles computed
according to additional arguments probs and type;
see quantile. Currently, an error is is signaled
for x of length zero and x containing NaN.
repsignature(x = "flint"):
repeats x (or elements of x) according to optional
arguments times, length.out, and each. The
behaviour is parallel to that of the internal default method,
hence see rep. One difference is that
rep(0-length, length.out=nonzero) signals an
error, because the underlying C types have no
representation for missing values.
rep.int, rep_lensignature(x = "flint"):
analogues of rep(x, times=) and
rep(x, length.out=) not preserving names, faster than
rep when x has names.
seqsignature(... = "flint"):
generates flint vectors whose elements are equally spaced.
This method is dispatched by calls to seq or seq.int
in which the first positional argument is a flint vector.
Accepted usage is any of
seq(length.out=)
seq(length.out=, by=)
seq(from=, to=)
seq(from=, to=, by=)
seq(from=, to=, length.out=)
seq(from=, by=, length.out=)
seq(to=, by=, length.out=)where length.out=n and along.with=x are equivalent
for x of length n. Good users name all arguments.
sequencesignature(nvec = "flint"):
returns the concatenation of
seq(from = from[i], by = by[i], length.out = nvec[i])
after recycling arguments nvec, from, and by
to a common length.
showsignature(object = "flint"):
prints format(object) and returns NULL
invisibly.
summarysignature(object = "flint"):
returns a flint vector containing the minimum, first
quartile, median, mean, third quartile, maximum, and (if nonzero)
the number of NaN, unless object is complex
(inherits from acf or
acb) or x has error bounds (inherits
from arb or acb) or
optional argument triple is TRUE, in which case the
value is just flintTriple() with names.
uniquesignature(x = "flint"):
returns x[!duplicated(x, ...)].
Methods are on purpose not defined for generic functions whose
default methods correctly handle objects inheriting from virtual class
flint, typically by calling other generic functions for
which methods are defined. Examples are
as.character, as.list, diff,
rev, seq.int, sort, and
split.
The nonvirtual subclasses:
ulong, slong,
fmpz, fmpq,
mag,
arf, acf,
arb, and acb.
showClass("flint")
showMethods(classes = "flint")
Run the code above in your browser using DataLab