Description Usage Arguments Details Value Note Author(s) See Also Examples

This is the enhanced version of `combn`

. There are two groups,
with n1 and n2 elements, respectively. Each time, m1 elements will be randomly chosen
from group 1; and m2 elements will be randomly chosen from group 2. These m1+m2 elements
form one combination. This function generate either all `choose(n1,m1)*choose(n2,m2)`

such combinations or a subset of `R`

of them. A function, possibly identity, is then
applied to each selected combination.

1 2 |

`x` |
group 1 vector for combinations, or positive integer |

`m` |
number of elements to choose from |

`x2` |
group 2 vector for combinations, or positive integer |

`m2` |
number of elements to choose from |

`R` |
the number of combinations to be randomly chosen from all |

`FUN` |
a function to be applied to each chosen combination. When neither |

`simplify` |
logical, indicating if the result should be simplified to an array (typically a matrix);
see |

`sample.method` |
character, specifying how samples should be taken, if not all combinations are generated; possible choices are "diff2", "all", and "replace" for two-group situation, and "replace" and "noReplace" in one-group situation. See Details. |

`try.rest` |
logical, together with |

`...` |
optionally, further arguments to |

This function enhances `combn`

in two ways.
One is to deal with two-group situation, which is commonly seen in real designs;
the other is to choose only a random sample of size `R`

from all possible
combinations to avoid unnecessary computation.

When neither `x2`

nor `m2`

is missing and neither `m=0`

nor `m2=0`

,
the function works in two-group mode. In this situation,

(A) if `sample.method="diff2"`

, `combn2R`

will try to sample `R`

combinations from each
group separately. That is, first sample `R`

combinations from `x`

taken `m`

at a time,
and then sample `R`

combinations from `x2`

taken `m2`

at time. The results are then combined
to give `R`

combinations from the two groups. This sampling method will make the samples as different
from each other as possible. But when `R`

is larger than `min(choose(n1,m1),choose(n2,m2))`

,
it is not possible to get `R`

samples from each group separately. If this happens and `try.rest=FALSE`

,
then `R`

will be reset to `min(choose(n,m),choose(n2,m2))`

and the function works as before;
otherwise, if `try.rest=TRUE`

, then `sample.method`

will be reset to "all" and the function will
try to get `R`

samples from all `choose(n1,m1)*choose(n2,m2)`

combinations (see below).

(B) if `sample.method="all"`

, `combn2R`

will try to sample `R`

samples from all
`choose(n1,m1)*choose(n2,m2)`

combinations directly. This means two samples of size `m+m2`

may have the same sample of size `m`

(or `m2`

) which comes from `x`

(or `x2`

). For
example, if `x=1:3`

, `m=1`

, `x2=4:6`

, `m=2`

and `R=2`

, then it is possible
to get one sample to be `1`

and `4,5`

, but the other sample is `1`

and `5,6`

. That is,
the same sample from `x`

is used in both results. This will not happen when `sample.method='diff2'`

.
However, this will guarantee any two samples of size `m+m2`

will differ in at least one element.

(C) if `sample.method='replace'`

, `combn2R`

will not guarantee the uniqueness of the
`R`

combinations in any way. It is possible to have two exactly the same samples of size
`m+m2`

.

Because the number of possible combinations grows very fast, computational limitations may be reached. In
this case, if `try.rest=TRUE`

, then `sample.method`

will be reset to "replace", which uses the
least computational resources; otherwise, an error will be generated.

When either `x2`

or `m2`

is missing, or one of `m`

and `m2`

is zero,
the function works in one-group mode. In this situation, `sample.method="diff2"`

and
`sample.method="all"`

will be treated the same as `sample.method="noReplace"`

, and `combn2R`

will try to obtain `R`

different combinations from all possible combinations for the non-missing group.
Again, if this fails due to computational limitations, `sample.method`

will be reset to "replace" and
no guarantee will be made to ensure the `R`

combinations are different from each other.

a `list`

or `array`

(in nondegenerate cases), similar to `combn`

.
An attribute `"sample.method"`

will be added to the `list`

or `array`

, which stores the
*actual* sampling method that has been used, which may or may not be the same as specified in the
argument.

Note that the results are *not* necessarily in order, which is a difference from `combn`

.

Long Qu

`combn`

in utils or combinat,

1 2 3 4 5 6 7 8 9 10 11 12 13 14 | ```
combn2R(4,2) ### the same as combn(4,2), except an additional attribute
combn2R(1:4*2,2)
combn2R(4,2,5,1)
combn2R(4,2,5,1,FUN=sum)
set.seed(992722)
combn2R(4,2,R=3) ### the same as combnR(4,2,3), except an additional attribute
combn2R(4,2,R=10) ### only 6 combinations possible
combn2R(4,2,5,1,R=8)
combn2R(1:4*2,2,5,1,R=50) ### only 30 combinations possible
combn2R(1:4*2,2,5,1,R=5) ### when considering only one group, there are several common samples.
### no common samples, even considering only one group
combn2R(1:4*2,2,5,1,R=5, sample.method="diff2")
combn2R(1:3*3,1,3,1,R=5, sample.method="replace") ### two pairs of exactly common samples
combn2R(100,3,100,3,R=5, sample.method="all") ### 'all' combinations not feasible (~3e10)
``` |

```
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 1 2 2 3
[2,] 2 3 4 3 4 4
attr(,"sample.method")
[1] "noReplace"
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 2 2 2 4 4 6
[2,] 4 6 8 6 8 8
attr(,"sample.method")
[1] "noReplace"
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14]
[1,] 1 1 1 1 1 1 1 1 1 1 1 1 1 1
[2,] 2 2 2 2 2 3 3 3 3 3 4 4 4 4
[3,] 1 2 3 4 5 1 2 3 4 5 1 2 3 4
[,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26]
[1,] 1 2 2 2 2 2 2 2 2 2 2 3
[2,] 4 3 3 3 3 3 4 4 4 4 4 4
[3,] 5 1 2 3 4 5 1 2 3 4 5 1
[,27] [,28] [,29] [,30]
[1,] 3 3 3 3
[2,] 4 4 4 4
[3,] 2 3 4 5
attr(,"sample.method")
[1] "all"
[1] 4 5 6 7 8 5 6 7 8 9 6 7 8 9 10 6 7 8 9 10 7 8 9 10 11
[26] 8 9 10 11 12
attr(,"sample.method")
[1] "all"
[,1] [,2] [,3]
[1,] 1 2 3
[2,] 3 3 4
attr(,"sample.method")
[1] "noReplace"
[,1] [,2] [,3] [,4] [,5] [,6]
[1,] 1 1 1 2 2 3
[2,] 2 3 4 3 4 4
attr(,"sample.method")
[1] "noReplace"
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8]
[1,] 1 1 1 1 2 2 3 3
[2,] 2 2 3 4 3 4 4 4
[3,] 1 4 4 4 3 3 1 4
attr(,"sample.method")
[1] "all"
[,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13] [,14]
[1,] 2 2 2 2 2 2 2 2 2 2 2 2 2 2
[2,] 4 4 4 4 4 6 6 6 6 6 8 8 8 8
[3,] 1 2 3 4 5 1 2 3 4 5 1 2 3 4
[,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24] [,25] [,26]
[1,] 2 4 4 4 4 4 4 4 4 4 4 6
[2,] 8 6 6 6 6 6 8 8 8 8 8 8
[3,] 5 1 2 3 4 5 1 2 3 4 5 1
[,27] [,28] [,29] [,30]
[1,] 6 6 6 6
[2,] 8 8 8 8
[3,] 2 3 4 5
attr(,"sample.method")
[1] "all"
[,1] [,2] [,3] [,4] [,5]
[1,] 2 4 4 6 6
[2,] 8 6 6 8 8
[3,] 5 4 5 3 4
attr(,"sample.method")
[1] "all"
[,1] [,2] [,3] [,4] [,5]
[1,] 2 2 4 4 6
[2,] 4 6 6 8 8
[3,] 5 1 3 4 2
attr(,"sample.method")
[1] "diff2"
[,1] [,2] [,3] [,4] [,5]
[1,] 6 9 6 6 6
[2,] 3 3 2 2 3
attr(,"sample.method")
[1] "replace"
[,1] [,2] [,3] [,4] [,5]
[1,] 21 26 54 55 55
[2,] 52 50 60 58 59
[3,] 89 54 78 93 62
[4,] 82 20 34 1 31
[5,] 90 50 45 67 65
[6,] 100 55 96 68 90
attr(,"sample.method")
[1] "all"
```

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.