Finding sequences of identical values

Problem

You want to find sequences of identical values in a vector or factor.

Solution

It is possible to search for sequences of identical values by simply iterating over a vector, but this is very slow in R. A much faster way to find sequences is to use the rle() function.

  1. # Example data
  2. v <- c("A","A","A", "B","B","B","B", NA,NA, "C","C", "B", "C","C","C")
  3. v
  4. #>  [1] "A" "A" "A" "B" "B" "B" "B" NA  NA  "C" "C" "B" "C" "C" "C"
  6. vr <- rle(v)
  7. vr
  8. #> Run Length Encoding
  9. #>   lengths: int [1:7] 3 4 1 1 2 1 3
  10. #>   values : chr [1:7] "A" "B" NA NA "C" "B" "C"

The RLE coded data can be converted back to a vector with inverse.rle().

  1. inverse.rle(vr)
  2. #>  [1] "A" "A" "A" "B" "B" "B" "B" NA  NA  "C" "C" "B" "C" "C" "C"

One issue that might be problematic is that each NA is treated as a run of length 1, even if the NA’s are next to each other. It is possible to work around this by replacing the NA’s with some special designated value. For numeric vectors, Inf or some other number can be used; for character vectors, any string may be used. Of course, the special value must not appear otherwise in the vector.

  1. w <- v
  2. w[is.na(w)] <- "ZZZ"
  3. w
  4. #>  [1] "A"   "A"   "A"   "B"   "B"   "B"   "B"   "ZZZ" "ZZZ" "C"   "C"   "B"   "C"   "C"  
  5. #> [15] "C"
  7. wr <- rle(w)
  8. wr
  9. #> Run Length Encoding
  10. #>   lengths: int [1:6] 3 4 2 2 1 3
  11. #>   values : chr [1:6] "A" "B" "ZZZ" "C" "B" "C"
  13. # Replace the ZZZ's with NA in the RLE-coded data
  14. wr$values[ wr$values=="ZZZ" ] <- NA
  15. wr
  16. #> Run Length Encoding
  17. #>   lengths: int [1:6] 3 4 2 2 1 3
  18. #>   values : chr [1:6] "A" "B" NA "C" "B" "C"
  20. w2 <- inverse.rle(wr)
  21. w2
  22. #>  [1] "A" "A" "A" "B" "B" "B" "B" NA  NA  "C" "C" "B" "C" "C" "C"

Working with factors

Even though factors are basically just integer vectors with some information about levels attached, the rle() function doesn’t work with factors. The solution is to manually convert the factor to an integer vector or a character vector. Using an integer vector is fast and memory-efficient, which may matter for large data sets, but it is difficult to interpret. Using a character vector is slower and requires more memory, but can be much easier to interpret.

  1. # Suppose this is the factor we have to work with
  2. f <- factor(v)
  3. f
  4. #>  [1] A    A    A    B    B    B    B    <NA> <NA> C    C    B    C    C    C   
  5. #> Levels: A B C
  7. # Store the levels in the factor.
  8. # This isn't strictly necessary, but it is useful for preserving order of levels
  9. f_levels <- levels(f)
  10. f_levels
  11. #> [1] "A" "B" "C"
  13. fc <- as.character(f)
  14. fc[ is.na(fc) ] <- "ZZZ"
  15. fc
  16. #>  [1] "A"   "A"   "A"   "B"   "B"   "B"   "B"   "ZZZ" "ZZZ" "C"   "C"   "B"   "C"   "C"  
  17. #> [15] "C"
  19. fr <- rle(fc)
  20. fr
  21. #> Run Length Encoding
  22. #>   lengths: int [1:6] 3 4 2 2 1 3
  23. #>   values : chr [1:6] "A" "B" "ZZZ" "C" "B" "C"
  25. # Replace the ZZZ's with NA in the RLE-coded data
  26. fr$values[ fr$values=="ZZZ" ] <- NA
  27. fr
  28. #> Run Length Encoding
  29. #>   lengths: int [1:6] 3 4 2 2 1 3
  30. #>   values : chr [1:6] "A" "B" NA "C" "B" "C"
  32. # Invert RLE coding and convert back to a factor
  33. f2 <- inverse.rle(fr)
  34. f2 <- factor(f, levels=f_levels)
  35. f2
  36. #>  [1] A    A    A    B    B    B    B    <NA> <NA> C    C    B    C    C    C   
  37. #> Levels: A B C