slide

Return a computation made on a vector using a sliding window.

Usage

slide(
  data,
  window.size,
  step,
  from = NULL,
  to = NULL,
  FUN,
  args = NULL,
  boundary = "left",
  parall = FALSE,
  thread.nb = NULL,
  print.count = 100,
  res.path = NULL,
  lib.path = NULL,
  verbose = TRUE,
  safer_check = TRUE
)

Arguments

data: Vector, matrix, table or array of numeric values (mode must be numeric). Inf not allowed. NA will be removed before computation.
window.size: Single numeric value indicating the width of the window sliding across data (in the same unit as data value).
step: Single numeric value indicating the step between each window (in the same unit as data value). Cannot be larger than window.size.
from: Single numeric value of the left boundary of the first sliding window. If NULL, min(data) is used. The first window will strictly have from or min(data) as left boundary.
to: Single numeric value of the right boundary of the last sliding window. If NULL, max(data) is used. Warning: (1) the final last window will not necessary have to|max(data) as right boundary. In fact the last window will be the one that contains to|max(data) for the first time, i.e., min[from|min(data) + window.size + n * step >= to|max(data)]; (2) In fact, the >= in min[from|min(data) + window.size + n * step >= to|max(data)] depends on the boundary argument (>= for "right" and > for "left"); (3) to have the rule (1) but for the center of the last window, use to argument as to = to|max(data) + window.size / 2.
FUN: Function or single character string indicating the name of the function to apply in each window. Example of function: FUN = mean. Example of character string: FUN = "mean".
args: Single character string of additional arguments of FUN (separated by a comma between the quotes). Example args = "na.rm = TRUE" for FUN = mean. Ignored if NULL.
boundary: Either "left" or "right". Indicates if the sliding window includes values equal to left boundary and exclude values equal to right boundary ("left") or the opposite ("right").
parall: Single logical value. Force parallelization ?
thread.nb: Single numeric value indicating the number of threads to use if ever parallelization is required. If NULL, all the available threads will be used. Ignored if parall is FALSE.
print.count: Single integer value. Print a working progress message every print.count during loops. BEWARE: can increase substantially the time to complete the process using a small value, like 10 for instance. Use Inf is no loop message desired.
res.path: Character string indicating the absolute pathway where the parallelization log file will be created if parallelization is used. If NULL, will be created in the R current directory.
lib.path: Character vector specifying the absolute pathways of the directories containing the required packages if not in the default directories. Ignored if NULL.
verbose: Single logical value. Display messages?
safer_check: Single logical value. Perform some "safer" checks (see https://github.com/safer-r)? If TRUE, checkings are performed before main code running: 1) R classical operators (like "<-") not overwritten by another package because of the R scope and 2) required functions and related packages effectively present in local R lybraries. Set to FALSE if this fonction is used inside another "safer" function to avoid pointless multiple checkings.

Value

A data frame containing :

- $left : the left boundary of each window (in the unit of the data argument).

- $right : the right boundary of each window (in the unit of data argument).

- $center : the center of each window (in the unit of data argument).

- $value : the computed value by the fun argument in each window).

Details

WARNINGS

The function uses two strategies, depending on the amout of memory required which depends on the data, window.size and step arguments. The first one uses lapply(), is generally fast but requires lots of memory. The second one uses a parallelized loop. The choice between the two strategies is automatic if parall argument is FALSE, and is forced toward parallelization if parall argument is TRUE.

The parall argument forces the parallelization, which is convenient when the data argument is big, because the lapply() function is sometimes slower than the parallelization.

Always use the env argument when slide() is used inside functions.

Author

Gael Millot <gael.millot@pasteur.fr>

Yushi Han <yushi.han2000@gmail.com>

Haiding Wang <wanghaiding442@gmail.com>

Examples