view release on metacpan or  search on metacpan

README  view on Meta::CPAN

            }

        The `next()' method returns an arrayref to the next tuple, if any,
        or `undef' if the sequence is exhausted.

        Memory usage is minimal, no recursion and no stacks are involved.

    *   In list context subroutines slurp the entire set of tuples. This
        behaviour is offered for convenience, but take into account that the
        resulting array may be really huge:

            my @all_combinations = combinations(\@data, $k);

  permutations(\@data)

    The permutations of `@data' are all its reorderings. For example, the
    permutations of `@data = (1, 2, 3)' are:

        (1, 2, 3)
        (1, 3, 2)
        (2, 1, 3)
        (2, 3, 1)
        (3, 1, 2)
        (3, 2, 1)

    The number of permutations of `n' elements is:

        n! = 1,                  if n = 0
        n! = n*(n-1)*...*1,      if n > 0

    See some values at http://www.research.att.com/~njas/sequences/A000142.

  circular_permutations(\@data)

    The circular permutations of `@data' are its arrangements around a
    circle, where only relative order of elements matter, rather than their
    actual position. Think possible arrangements of people around a circular
    table for dinner according to whom they have to their right and left, no
    matter the actual chair they sit on.

    For example the circular permutations of `@data = (1, 2, 3, 4)' are:

        (1, 2, 3, 4)
        (1, 2, 4, 3)
        (1, 3, 2, 4)
        (1, 3, 4, 2)
        (1, 4, 2, 3)
        (1, 4, 3, 2)

    The number of circular permutations of `n' elements is:

            n! = 1,                      if 0 <= n <= 1
        (n-1)! = (n-1)*(n-2)*...*1,      if n > 1

    See a few numbers in a comment of
    http://www.research.att.com/~njas/sequences/A000142.

  derangements(\@data)

    The derangements of `@data' are those reorderings that have no element
    in its original place. In jargon those are the permutations of `@data'
    with no fixed points. For example, the derangements of `@data = (1, 2,
    3)' are:

        (2, 3, 1)
        (3, 1, 2)

    The number of derangements of `n' elements is:

        d(n) = 1,                       if n = 0
        d(n) = n*d(n-1) + (-1)**n,      if n > 0

    See some values at http://www.research.att.com/~njas/sequences/A000166.

  complete_permutations(\@data)

    This is an alias for `derangements', documented above.

  variations(\@data, $k)

    The variations of length `$k' of `@data' are all the tuples of length
    `$k' consisting of elements of `@data'. For example, for `@data = (1, 2,
    3)' and `$k = 2':

        (1, 2)
        (1, 3)
        (2, 1)
        (2, 3)
        (3, 1)
        (3, 2)

    For this to make sense, `$k' has to be less than or equal to the length
    of `@data'.

    Note that

        permutations(\@data);

    is equivalent to

        variations(\@data, scalar @data);

    The number of variations of `n' elements taken in groups of `k' is:

        v(n, k) = 1,                        if k = 0
        v(n, k) = n*(n-1)*...*(n-k+1),      if 0 < k <= n

  variations_with_repetition(\@data, $k)

    The variations with repetition of length `$k' of `@data' are all the
    tuples of length `$k' consisting of elements of `@data', including
    repetitions. For example, for `@data = (1, 2, 3)' and `$k = 2':

        (1, 1)
        (1, 2)
        (1, 3)
        (2, 1)
        (2, 2)
        (2, 3)
        (3, 1)
        (3, 2)