Efficient Iterator for Permutations and Combinations

Initialize a iterator for permutations or combinations

iterpc(n, r = NULL, labels = NULL, ordered = FALSE, replace = FALSE)

Arguments

n	the length of the input sequence or a vector of frequencies for a multiset.
r	the length of the output sequence. If missing, equals to sum(n).
labels	if missing, natural numbers are used unless n is a table object. In that case, the names of n are used.
ordered	TRUE corresponds to permutation and FALSE corresponds to combinations.
replace	with/without replacement. Default is FALSE.

Value

a permutation/combination iterator

Examples

#1) all combinations of drawing 2 items from {1, 2, 3}
I <- iterpc(5, 2)
getall(I)
#>       [,1] [,2]
#>  [1,]    1    2
#>  [2,]    1    3
#>  [3,]    1    4
#>  [4,]    1    5
#>  [5,]    2    3
#>  [6,]    2    4
#>  [7,]    2    5
#>  [8,]    3    4
#>  [9,]    3    5
#> [10,]    4    5

#2) continuing 1), get combination by combination
I <- iterpc(5, 2)
getnext(I) # return 1,2
#> [1] 1 2
getnext(I) # return 1,3
#> [1] 1 3
getnext(I, 2) # return next 2 results
#>      [,1] [,2]
#> [1,]    1    4
#> [2,]    1    5

#3) 3) all permutations of {1, 2, 3} and use of labels
I <- iterpc(3, labels=c("a", "b", "c"), ordered=TRUE)
getall(I)
#>      [,1] [,2] [,3]
#> [1,] "a"  "b"  "c" 
#> [2,] "a"  "c"  "b" 
#> [3,] "b"  "a"  "c" 
#> [4,] "b"  "c"  "a" 
#> [5,] "c"  "a"  "b" 
#> [6,] "c"  "b"  "a" 

#4) permutations of multiset and
I <- iterpc(c(2, 1, 1), labels=c("a", "b", "c"), ordered=TRUE)
getall(I)
#>       [,1] [,2] [,3] [,4]
#>  [1,] "a"  "a"  "b"  "c" 
#>  [2,] "a"  "a"  "c"  "b" 
#>  [3,] "a"  "b"  "a"  "c" 
#>  [4,] "a"  "b"  "c"  "a" 
#>  [5,] "a"  "c"  "a"  "b" 
#>  [6,] "a"  "c"  "b"  "a" 
#>  [7,] "b"  "a"  "a"  "c" 
#>  [8,] "b"  "a"  "c"  "a" 
#>  [9,] "b"  "c"  "a"  "a" 
#> [10,] "c"  "a"  "a"  "b" 
#> [11,] "c"  "a"  "b"  "a" 
#> [12,] "c"  "b"  "a"  "a" 

#5) combinations with replacement and the use of table as input
x <- c("a","a","b","c")
I <- iterpc(table(x), 3, replace=TRUE)
getall(I)
#>       [,1] [,2] [,3]
#>  [1,]    1    1    1
#>  [2,]    1    1    2
#>  [3,]    1    1    3
#>  [4,]    1    1    4
#>  [5,]    1    2    2
#>  [6,]    1    2    3
#>  [7,]    1    2    4
#>  [8,]    1    3    3
#>  [9,]    1    3    4
#> [10,]    1    4    4
#> [11,]    2    2    2
#> [12,]    2    2    3
#> [13,]    2    2    4
#> [14,]    2    3    3
#> [15,]    2    3    4
#> [16,]    2    4    4
#> [17,]    3    3    3
#> [18,]    3    3    4
#> [19,]    3    4    4
#> [20,]    4    4    4