A view of some combinations over a base collections.

This view generates some combinations and permutations on a collection.

By default, the generated sequences are combinations:

• each sequence has a length of `repeat`
• elements are in sorted order (see `are_sorted` for details)
• no repeated element (see `are_unique` for details)
``````var xs = [1, 2, 3]
var cxs = new CombinationCollection[Int](xs, 2)
assert cxs.length == 3
assert cxs.to_a == [[1,2], [1,3], [2,3]]``````

Other kind of combinations can be generated by tweaking the attributes `are_sorted` and `are_unique`.

• for permutation:
``````cxs.are_sorted = false
cxs.are_unique = true
assert cxs.length == 6
assert cxs.to_a == [[1,2], [1,3], [2,1], [2,3], [3,1], [3,2]]``````
• for combinations with replacement:
``````cxs.are_sorted = true
cxs.are_unique = false
assert cxs.length == 6
assert cxs.to_a == [[1,1], [1,2], [1,3], [2,2], [2,3], [3,3]]``````
• for product:
``````cxs.are_sorted = false
cxs.are_unique = false
assert cxs.length == 9
assert cxs.to_a == [[1,1], [1,2], [1,3], [2,1], [2,2], [2,3], [3,1], [3,2], [3,3]]``````

However, in the last case, a faster alternative is to use `CartesianCollection`:

``````var cp = new CartesianCollection[Int]([xs] * 2)
assert cp.to_a == cxs.to_a``````

As seen in the examples, the patterns of the generated sequences produce a lexicographical order.

Because it is a generator, it is memory-efficient and the sequences are created only when needed.

Note: because it is a view, changes on the base collection are reflected on the view.

``````assert xs.pop == 3
cxs.are_sorted = true
cxs.are_unique = true
assert cxs.to_a == [[1,2]]``````

Introduced properties

fun are_sorted: Bool

combinations :: CombinationCollection :: are_sorted

Are the elements in the generated sequences sorted?
fun are_sorted=(are_sorted: Bool)

combinations :: CombinationCollection :: are_sorted=

Are the elements in the generated sequences sorted?
fun are_unique: Bool

combinations :: CombinationCollection :: are_unique

Are the element in the generated sequence unique?
fun are_unique=(are_unique: Bool)

combinations :: CombinationCollection :: are_unique=

Are the element in the generated sequence unique?
fun collection: Collection[E]

combinations :: CombinationCollection :: collection

The base collection used to generate the sequences.
protected fun collection=(collection: Collection[E])

combinations :: CombinationCollection :: collection=

The base collection used to generate the sequences.
init defaultinit(collection: Collection[E], repeat: Int)

combinations :: CombinationCollection :: defaultinit

fun repeat: Int

combinations :: CombinationCollection :: repeat

The maximum length of each generated sequence.
protected fun repeat=(repeat: Int)

combinations :: CombinationCollection :: repeat=

The maximum length of each generated sequence.

Redefined properties

redef type SELF: CombinationCollection[E]

combinations \$ CombinationCollection :: SELF

Type of this instance, automatically specialized in every class
redef init init

combinations \$ CombinationCollection :: init

combinations \$ CombinationCollection :: iterator

Get a new iterator on the collection.
redef fun length: Int

combinations \$ CombinationCollection :: length

Number of items in the collection.

All properties

fun !=(other: nullable Object): Bool

core :: Object :: !=

Have `self` and `other` different values?
fun ==(other: nullable Object): Bool

core :: Object :: ==

Have `self` and `other` the same value?
type CLASS: Class[SELF]

core :: Object :: CLASS

The type of the class of self.
type CONCURRENT: ConcurrentCollection[E]

core :: Collection :: CONCURRENT

Type of the concurrent variant of this collection
type SELF: Object

core :: Object :: SELF

Type of this instance, automatically specialized in every class
fun are_sorted: Bool

combinations :: CombinationCollection :: are_sorted

Are the elements in the generated sequences sorted?
fun are_sorted=(are_sorted: Bool)

combinations :: CombinationCollection :: are_sorted=

Are the elements in the generated sequences sorted?
fun are_unique: Bool

combinations :: CombinationCollection :: are_unique

Are the element in the generated sequence unique?
fun are_unique=(are_unique: Bool)

combinations :: CombinationCollection :: are_unique=

Are the element in the generated sequence unique?
protected fun class_factory(name: String): CLASS

core :: Object :: class_factory

Implementation used by `get_class` to create the specific class.
fun class_name: String

core :: Object :: class_name

The class name of the object.
fun collection: Collection[E]

combinations :: CombinationCollection :: collection

The base collection used to generate the sequences.
protected fun collection=(collection: Collection[E])

combinations :: CombinationCollection :: collection=

The base collection used to generate the sequences.

core :: Collection :: combinations

All `r`-length combinations on self (in same order) without repeated elements.

core :: Collection :: combinations_with_replacement

All `r`-length combination on self (in same order) with repeated elements.
fun count(item: nullable Object): Int

core :: Collection :: count

How many occurrences of `item` are in the collection?
init defaultinit(collection: Collection[E], repeat: Int)

combinations :: CombinationCollection :: defaultinit

init defaultinit

core :: Collection :: defaultinit

init defaultinit

core :: Object :: defaultinit

fun first: E

core :: Collection :: first

Return the first item of the collection
fun get_class: CLASS

core :: Object :: get_class

The meta-object representing the dynamic type of `self`.
fun has(item: nullable Object): Bool

core :: Collection :: has

Is `item` in the collection ?
fun has_all(other: Collection[nullable Object]): Bool

core :: Collection :: has_all

Does the collection contain at least each element of `other`?
fun has_any(other: Collection[nullable Object]): Bool

core :: Collection :: has_any

Does the collection contain at least one element of `other`?
fun has_exactly(other: Collection[nullable Object]): Bool

core :: Collection :: has_exactly

Does the collection contain exactly all the elements of `other`?
fun has_only(item: nullable Object): Bool

core :: Collection :: has_only

Is the collection contain only `item`?
fun hash: Int

core :: Object :: hash

The hash code of the object.
init init

core :: Object :: init

fun inspect: String

core :: Object :: inspect

Developer readable representation of `self`.

Return "CLASSNAME:#OBJECTID".
fun is_empty: Bool

core :: Collection :: is_empty

Is there no item in the collection?
intern fun is_same_instance(other: nullable Object): Bool

core :: Object :: is_same_instance

Return true if `self` and `other` are the same instance (i.e. same identity).
fun is_same_serialized(other: nullable Object): Bool

core :: Object :: is_same_serialized

Is `self` the same as `other` in a serialization context?
intern fun is_same_type(other: Object): Bool

core :: Object :: is_same_type

Return true if `self` and `other` have the same dynamic type.
abstract fun iterator: Iterator[E]

core :: Collection :: iterator

Get a new iterator on the collection.
fun join(separator: nullable Text, last_separator: nullable Text): String

core :: Collection :: join

Concatenate and separate each elements with `separator`.
fun length: Int

core :: Collection :: length

Number of items in the collection.
fun not_empty: Bool

core :: Collection :: not_empty

Alias for `not is_empty`.
intern fun object_id: Int

core :: Object :: object_id

An internal hash code for the object based on its identity.
fun output

core :: Object :: output

Display self on stdout (debug only).
intern fun output_class_name

core :: Object :: output_class_name

Display class name on stdout (debug only).

core :: Collection :: permutations

All `r`-length permutations on self (all possible ordering) without repeated elements.
fun plain_to_s: String

core :: Collection :: plain_to_s

Concatenate elements without separators

core :: Collection :: product

Cartesian product, over `r` times `self`.
fun rand: E

core :: Collection :: rand

Return a random element form the collection
fun repeat: Int

combinations :: CombinationCollection :: repeat

The maximum length of each generated sequence.
protected fun repeat=(repeat: Int)

combinations :: CombinationCollection :: repeat=

The maximum length of each generated sequence.
fun sample(length: Int): Array[E]

core :: Collection :: sample

Return a new array made of (at most) `length` elements randomly chosen.
fun serialization_hash: Int

core :: Object :: serialization_hash

Hash value use for serialization
intern fun sys: Sys

core :: Object :: sys

Return the global sys object, the only instance of the `Sys` class.
fun to_a: Array[E]

core :: Collection :: to_a

Build a new array from a collection
abstract fun to_concurrent: CONCURRENT

core :: Collection :: to_concurrent

Wraps `self` in a thread-safe collection
fun to_counter: Counter[E]

core :: Collection :: to_counter

Create and fill up a counter with the elements of `self.
fun to_curlslist: CURLSList

core :: Collection :: to_curlslist

Convert Collection[String] to CURLSList
abstract fun to_jvalue(env: JniEnv): JValue

core :: Object :: to_jvalue

fun to_s: String

core :: Object :: to_s

User readable representation of `self`.
fun to_shuffle: Array[E]

core :: Collection :: to_shuffle

Return a new array made of elements in a random order.

Ancestors

interface Object

core :: Object

The root of the class hierarchy.

Parents

interface Collection[E: nullable Object]

core :: Collection

The root of the collection hierarchy.

Class definitions

combinations \$ CombinationCollection
```# A view of some combinations over a base collections.
#
# This view *generates* some combinations and permutations on a collection.
#
# By default, the generated sequences are combinations:
#
#   * each sequence has a length of `repeat`
#   * elements are in sorted order (see `are_sorted` for details)
#   * no repeated element (see `are_unique` for details)
#
# ~~~~
# var xs = [1, 2, 3]
# var cxs = new CombinationCollection[Int](xs, 2)
# assert cxs.length == 3
# assert cxs.to_a == [[1,2], [1,3], [2,3]]
# ~~~~
#
# Other kind of combinations can be generated by tweaking the attributes `are_sorted` and `are_unique`.
#
# * for permutation:
#
# ~~~~
# cxs.are_sorted = false
# cxs.are_unique = true
# assert cxs.length == 6
# assert cxs.to_a == [[1,2], [1,3], [2,1], [2,3], [3,1], [3,2]]
# ~~~~
#
# * for combinations with replacement:
#
# ~~~~
# cxs.are_sorted = true
# cxs.are_unique = false
# assert cxs.length == 6
# assert cxs.to_a == [[1,1], [1,2], [1,3], [2,2], [2,3], [3,3]]
# ~~~~
#
# * for product:
#
# ~~~~
# cxs.are_sorted = false
# cxs.are_unique = false
# assert cxs.length == 9
# assert cxs.to_a == [[1,1], [1,2], [1,3], [2,1], [2,2], [2,3], [3,1], [3,2], [3,3]]
# ~~~~
#
# However, in the last case, a faster alternative is to use `CartesianCollection`:
#
# ~~~~
# var cp = new CartesianCollection[Int]([xs] * 2)
# assert cp.to_a == cxs.to_a
# ~~~~
#
# As seen in the examples, the patterns of the generated sequences produce a lexicographical order.
#
# Because it is a generator, it is memory-efficient and the sequences are created only when needed.
#
# Note: because it is a view, changes on the base collection are reflected on the view.
#
# ~~~~
# assert xs.pop == 3
# cxs.are_sorted = true
# cxs.are_unique = true
# assert cxs.to_a == [[1,2]]
# ~~~~
class CombinationCollection[E]

# The base collection used to generate the sequences.
var collection: Collection[E]

# The maximum length of each generated sequence.
var repeat: Int

init
do
assert repeat >= 0
end

# Are the elements in the generated sequences sorted?
# Default `true`.
#
# When `true`, the original order is preserved.
#
# Elements are compared by their order in the base collection,
# not by their intrinsic value or comparability.
#
# ~~~~
# var xs = [1, 1, 2]
# var cxs = new CombinationCollection[Int](xs, 2)
# cxs.are_sorted = true
# assert cxs.to_a == [[1,1], [1,2], [1, 2]]
# cxs.are_sorted = false
# assert cxs.to_a == [[1,1], [1,2], [1, 1], [1, 2], [2, 1], [2, 1]]
# ~~~~
var are_sorted = true is writable

# Are the element in the generated sequence unique?
# Default `true`.
#
# When `true`, an element cannot be reused in the same sequence (no replacement).
#
# Elements are distinguished by their order in the base collection,
# not by their intrinsic value or equality.
#
# ~~~~
# var xs = [1, 1, 2]
# var cxs = new CombinationCollection[Int](xs, 2)
# cxs.are_unique = true
# assert cxs.to_a == [[1,1], [1,2], [1, 2]]
# cxs.are_unique = false
# assert cxs.to_a == [[1,1], [1,1], [1,2], [1,1], [1,2], [2,2]]
# ~~~~
var are_unique = true is writable

redef fun length
do
var n = collection.length
if are_unique then
if repeat > n then
return 0
end
if are_sorted then
return n.factorial / repeat.factorial
else
return n.factorial / (n-repeat).factorial
end
else
if are_sorted then
return (n+repeat-1).factorial / repeat.factorial / (n-1).factorial
else
return n ** repeat
end
end
end

redef fun iterator do
return new CombinationIterator[E](self)
end
end
```
lib/combinations/combinations.nit:172,1--311,3