future.seed = TRUE
could result in an error
!any(seed_next != seed) is not TRUE
in rare cases.Option future.globals.maxSize
was never passed down
to parallel workers.
The assertion of argument INDEX
of
future_tapply()
would fail with another error in R (<
3.6.0), if INDEX
was incorrect in the first place.
future_tapply()
now accepts data frames as input,
just as tapply()
does in R (>= 4.3.0).
In R (>= 4.3.0), future_tapply(X, INDEX, ...)
now
accepts INDEX
being a formula when X
is a data
frames, just as tapply()
does in R (>= 4.3.0). An error
is produced if used in R (< 4.3.0).
In R (>= 4.3.0), future_by(X, INDICES, ...)
now
accepts INDICES
being a formula when X
is a
data frames, just as by()
does in R (>= 4.3.0). An error
is produced if used in R (< 4.3.0).
%globals%
, %seed%
, and %stdout%
can be used to control the corresponding future.*
arguments, e.g.
y <- future_lapply(1:3, FUN = my_fun) %seed% TRUE
is the
same as
y <- future_lapply(1:3, FUN = my_fun, future.seed = TRUE)
.lapply(X, ...)
,
future_lapply(X, ...)
failed to use method-specific
[[
subsetting, if the class of X
implemented
one. future_mapply()
and other functions had the same
problem. The reason was that when X
is partitioned into
chunks, it would lose the class attribute before subsetting with
[[
.future_eapply()
,
future_lapply()
, future_sapply()
, and
future_vapply()
failed if FUN
was specified as
the name of a function rather than the function object itself,
e.g. future_lapply(1:3, FUN = "sqrt")
.FUN
for
future_by()
as a character string is deprecated, because
base::by()
does not support it. It should be specified as a
function, e.g. FUN = sqrt
and
FUN = `[[`
.future_mapply()
and future_Map()
was
updated to match the new behavior of mapply()
and
Map()
in R (>= 4.2.0), which follows the
“max-or-0-if-any” recycling rule.future.lazy
from all functions.
Regardless of setting it to TRUE or FALSE, futures would be resolved
momentarily and always before the apply returned.citEntry()
in CITATION used argument notes
instead of note
.Add argument future.envir
to all
future_nnn()
functions, which is passed as argument
envir
to future()
.
Add option future.apply.debug
for debugging features
specific to this package. It defaults to option
future.debug
.
getGlobalsAndPackagesXApply()
now avoids
calculating the object size of ...
arguments if option
future.globals.maxSize
is +Inf.f <- function(...) future_lapply(X, function(x) list(...)); f(a=1)
would produce an error on ’unused argument (a = 1)” with the upcoming
release of future 1.22.0.The automatic capturing of conditions can be disabled by
specifying future.conditions = NULL
.
Warnings and errors on using the RNG without specifying
future.seed
are now tailored to the
future.apply package.
future_apply()
gained argument simplify
,
which is added to R-devel (to become R 4.1.0).future_apply(X, FUN, ...)
would pass all
future.*
arguments except future.globals
,
future.packages
, and future.labels
to the
FUN
function instead of processing them locally. This would
often result in the FUN
producing an error on “unused
argument”. It also affected future.seed
not being applied,
which means for some FUN
functions that did not produce
this error, non-reproducible results could have been produced.future_.mapply()
corresponding to
.mapply()
in the base package.future_mapply()
would chunk up MoreArgs
when future.seed = TRUE
.future_nnn()
functions set a label on each
future that reflects the name of the future_nnn()
function
and the index of the chunk, e.g. "future_lapply-3"
. The
format can be controlled by argument future.label
.future_apply()
.future_lapply(X)
and
future_mapply(FUN, X)
would drop names
argument of the returned empty list when
length(X) == 0
.
Package could set .Random.seed
to NULL, instead of
removing it, which in turn would produce a warning on “‘.Random.seed’ is
not an integer vector but of type ‘NULL’, so ignored” when the next
random number generated.
Now future.conditions
defaults to the same as
argument conditions
of future::future()
. If
the latter changes, this package will follow.
Debug messages are now prepended with a timestamp.
future_by()
.Attributes add
and ignore
of argument
future.globals
were ignored although support for them was
added in future (>= 1.10.0).
Validation of L’Ecuyer-CMRG RNG seeds failed in recent R devel.
future.stdout
and
future.conditions
for controlling whether standard output
and conditions (e.g. messages and warnings) produced during the
evaluation of futures should be captured and relayed or not. Standard
output is guaranteed to be relayed in the same order as it would when
using sequential processing. Analogously for conditions. However,
standard output is always relayed before conditions. Errors are always
relayed. Relaying of non-error conditions requires
future (>= 1.11.0).Elements can be processed in random order by setting attribute
ordering
to "random"
of argument
future.chunk.size
or future.scheduling
,
e.g. future.chunk.size = structure(TRUE, ordering = "random")
.
This can help improve load balancing in cases where there is a
correlation between processing time and ordering of the elements. Note
that the order of the returned values is not affected when randomizing
the processing order.
Swapped order of arguments future.lazy
and
future.seed
to be consistent with ditto arguments of
future::future()
.
For list objects X
where
X != as.list(X), future_lapply(X)
did not give the same
result as lapply(X)
. Analogously for
future_vapply(X)
.
future_mapply()
could drop class attribute on
elements iterated over, because .subset()
was used
internally instead of `[`()
. For instance, iteration over
Date
objects were affected.
apply()
, Map()
, replicate()
,
sapply()
, and tapply()
, which are all GPL
(>= 2).Added future_apply()
, future_mapply()
,
and future_Map()
.
Added argument future.chunk.size
as an alternative
to argument future.scheduling
for controlling the average
number of elements processed per future (“chunk”). In R 3.5.0, the
parallel package introduced argument
chunk.size
.
The maximum total size of globals allowed (option
future.globals.maxSize
) per future (“chunk”) is now scaled
up by the number of elements processed by the future (“chunk”) making
the protection approximately invariant to the amount of chunking
(arguments future.scheduling
and
future.chunk.size
).
future_lapply(X, ...)
did not search for globals in
X
.
future_vapply()
did not return the same dimension
names as vapply()
when FUN.VALUE
had no names
but FUN(X[[1]])
had.
future_eapply()
, future_tapply()
,
future_vapply()
, and future_replicate()
.future_lapply(x, ...)
is now much faster and more
memory efficient for large x
vectors because it uses
internal fold()
function that is more efficient (memory and
speed) version of base::Reduce(f, x)
, especially when
length(x)
is large.Added future_sapply()
.
Added future_lapply()
- originally from the
future package.
Created package.