Function for chunked range index

creates a sequence of range indexes using a syntax not completely unlike 'seq'

chunks(
  from = NULL,
  to = NULL,
  by = NULL,
  length.out = NULL,
  along.with = NULL,
  overlap = 0L,
  method = c("bbatch", "seq"),
  maxindex = NA
)

Arguments

from

the starting value of the sequence.

to

the (maximal) end value of the sequence.

by

increment of the sequence

length.out

desired length of the sequence.

along.with

take the length from the length of this argument.

overlap

number of values to overlap (will lower the starting value of the sequence, the first range becomes smaller

method

default 'bbatch' will try to balance the chunk size, see bbatch(), 'seq' will create chunks like seq()

maxindex

passed to ri()

Value

returns a named list of ri() objects representing chunks of subscripts

See also

generic chunk(), ri(), seq(), bbatch()

Author

Jens Oehlschlägel

Examples

  chunks(1, 100, by=30)
#> $`1:25`
#> range index (ri) from 1 to 25 maxindex NA 
#> 
#> $`26:50`
#> range index (ri) from 26 to 50 maxindex NA 
#> 
#> $`51:75`
#> range index (ri) from 51 to 75 maxindex NA 
#> 
#> $`76:100`
#> range index (ri) from 76 to 100 maxindex NA 
#> 
  chunks(1, 100, by=30, method="seq")
#> $`1:30`
#> range index (ri) from 1 to 30 maxindex NA 
#> 
#> $`31:60`
#> range index (ri) from 31 to 60 maxindex NA 
#> 
#> $`61:90`
#> range index (ri) from 61 to 90 maxindex NA 
#> 
#> $`91:100`
#> range index (ri) from 91 to 100 maxindex NA 
#> 
   if (FALSE) { # \dontrun{
require(foreach)
m <- 10000
k <- 1000
n <- m*k
message("Four ways to loop from 1 to n. Slowest foreach to fastest chunk is 1700:1
on a dual core notebook with 3GB RAM\n")
z <- 0L;
print(k*system.time({it <- icount(m); foreach (i = it) %do% { z <- i; NULL }}))
z

z <- 0L
print(system.time({i <- 0L; while (i < n) {i <- i + 1L; z <- i}}))
z

z <- 0L
print(system.time(for (i in 1:n) z <- i))
z

z <- 0L; n <- m*k;
print(system.time(for (ch in chunks(1, n, by=m)) {for (i in ch[1]:ch[2]) z <- i}))
z

message("Seven ways to calculate sum(1:n).
 Slowest foreach to fastest chunk is 61000:1 on a dual core notebook with 3GB RAM\n")
print(k*system.time({it <- icount(m); foreach (i = it, .combine="+") %do% { i }}))

z <- 0;
print(k*system.time({it <- icount(m); foreach (i = it) %do% { z <- z + i; NULL }}))
z

z <- 0; print(system.time({i <- 0L;while (i < n) {i <- i + 1L; z <- z + i}})); z

z <- 0; print(system.time(for (i in 1:n) z <- z + i)); z

print(system.time(sum(as.double(1:n))))

z <- 0; n <- m*k
print(system.time(for (ch in chunks(1, n, by=m)) {for (i in ch[1]:ch[2]) z <- z + i}))
z

z <- 0; n <- m*k
print(system.time(for (ch in chunks(1, n, by=m)) {z <- z + sum(as.double(ch[1]:ch[2]))}))
z
   } # }