创建一个新的因子/变量，其水平基于原始因子水平的“N”个连续出现

Question

I've started a new project with a bunch of data management I've never had to do before, and I seemingly lack the skills or the appropriate search terms to find an example. I have a very large data set with a grouping variable and a binary event variable. It can be generalized to a working example as:

library('data.table')
grp <- c("a", "a", "a", "a", "a", "a", "a", "b", "b", "b", "b", "b")
v1 <- c(1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1)
test<-data.frame(grp,v1)
test

   grp v1
1    a  1
2    a  0
3    a  0
4    a  1
5    a  1
6    a  1
7    a  1
8    b  1
9    b  0
10   b  0
11   b  0
12   b  1

I've been using data.table to label streaks of "v1" within unique levels of "grp" as events with a new ordinal numeric factor "event":

setDT(test)
test<-test[, .(v1 = v1, event = rleidv(v1)), by=grp]

    grp v1 event
 1:   a  1     1
 2:   a  0     2
 3:   a  0     2
 4:   a  1     3
 5:   a  1     3
 6:   a  1     3
 7:   a  1     3
 8:   b  1     1
 9:   b  0     2
10:   b  0     2
11:   b  0     2
12:   b  1     3

In the actual data set some of these "grp" specific events are very long and I need to break them up into smaller, variable, n - limited events. For example, my desired output for a new variable "sub.event" with n = 2 is:

> test
    grp v1 event sub.event
 1:   a  1     1         1
 2:   a  0     2         2
 3:   a  0     2         2
 4:   a  1     3         3
 5:   a  1     3         3
 6:   a  1     3         4
 7:   a  1     3         4
 8:   b  1     1         1
 9:   b  0     2         2
10:   b  0     2         2
11:   b  0     2         3
12:   b  1     3         4

I've been pulling my hair out trying to figure out a way to do this. It seems simple enough that I must be missing something obvious. To help facilitate, the original variables can be concatenated into new variables before determining the n -limited "sub.event".

Thanks in advance for all your help.

Answer 1

Here is a method that works with chaining.

setDT(test)[, new := rep(1:0, length.out=.N), by=.(grp, rleid(v1))][,
              new := cumsum(new), by=grp]

The first chain returns a vector of 1s and 0s repeating the length of the grp- rleid pair. The next link in the chain sums this up with cumsum by grp.

this returns

test
    grp v1 new
 1:   a  1   1
 2:   a  0   2
 3:   a  0   2
 4:   a  1   3
 5:   a  1   3
 6:   a  1   4
 7:   a  1   4
 8:   b  1   1
 9:   b  0   2
10:   b  0   2
11:   b  0   3
12:   b  1   4

Note that as written, it doesn't automatically extend to n > 2. However, the piece that produces it, 1:0 could be written rep(c(1L, rep(0L, n)), length.out=.N) where n+1 is the number of repeated values that you'd want.

In this case, the code would look like

test[, new := rep(c(1L, rep(0L, 2L)), length.out=.N), by=.(grp, rleid(v1))][,
       new := cumsum(new), by=grp]

Answer 2

Somewhat roundabout:

# make counters within v1, grp
test[, v0 := rep(1:.N, each=2, length.out=.N), by=.(rleid(grp, v1))]

# make overall counters
test[, v := .GRP, by=rleid(grp, v1, v0)]

# difference per grp
test[, v := v - first(v) + 1L, by=grp]

# drop internal counter
test[, v0 := NULL ]

    grp v1 v
 1:   a  1 1
 2:   a  0 2
 3:   a  0 2
 4:   a  1 3
 5:   a  1 3
 6:   a  1 4
 7:   a  1 4
 8:   b  1 1
 9:   b  0 2
10:   b  0 2
11:   b  0 3
12:   b  1 4