NAME

Math::Permutation - pure Perl implementation of functions related to the permutations

VERSION

Version 0.02

SYNOPSIS

use Math::Permutation;

my $foo = Math::Permutation->cycles([[1,2,6,7], [3,4,5]]);
say $foo->sprint_wrepr;
# "2,6,4,5,3,7,1"
say join ",", $foo->array;
# 2,6,4,5,3,7,1

my $bar = Math::Permutation->unrank(5, 19);
say $bar->sprint_cycles;
# (2 5 4 3)
# Note that there is no canonical cycle representation in this module,
# so each time the output may be slightly different.

my $goo = Math::Permutation->clone($foo);
say $goo->sprint_cycles;
# (1 2 6 7) (4 5 3)

$foo->inverse;
say $foo->sprint_cycles;
# (4 3 5) (1 7 6 2)

$foo->comp($goo);
say $foo->sprint_cycles;
# ()

say $bar->rank; # 19
$bar->prev;
say $bar->rank; # 18
say $goo->rank; # 1264
$goo->nxt;
say $goo->rank; # 1265

say $goo->is_even; # 0
say $goo->sgn;     # -1

use Data::Dump qw/dump/;
say $bar->sprint_wrepr;
dump $bar->matrix;

# "1,4,5,3,2"
# [
#   [1, 0, 0, 0, 0],
#   [0, 0, 0, 0, 1],
#   [0, 0, 0, 1, 0],
#   [0, 1, 0, 0, 0],
#   [0, 0, 1, 0, 0],
# ]

METHODS

INITALIZE/GENERATE NEW PERMUTATION

$p->init($n): Initialize $p with the identity permutation of $n elements.
$p->wrepr([$a, $b, $c, ..., $m]): Initialize $p with word representation of a permutation, a.k.a. one-line form.
$p->tabular([$a, $b, ... , $m], [$pa, $pb, $pc, ..., $pm]): Initialize $p with the rules of a permutation, with input of permutation on the first list, the output of permutation. If the first list is [1..$n], it is often called two-line form, and the second list would be the word representation.
$p->cycles([[$a, $b, $c], [$d, $e], [$f, $g]])
$p->cycles_with_len($n, [[$a, $b, $c], [$d, $e], [$f, $g]]): Initialize $p by the cycle notation. If the length is not specific, the length would be the largest element in the cycles.
$p->unrank($n, $i): Initialize $p referring to the lexicological rank of all $n-permutations. $i must be between 1 and $n!.
$p->random($n): Initialize $p by a randomly selected $n-permutation.

DISPLAY THE PERMUTATION

$p->array(): Return an array showing the permutation.
$p->sprint_wrepr(): Return a string displaying the word representation of $p.
$p->sprint_tabular(): Return a two-line string displaying the tabular form of $p.
$p->sprint_cycles(): Return a string with cycles of $p. One-cycles are omitted.
$p->sprint_cycles_full(): Return a string with cycles of $p. One-cycles are included.

CHECK EQUIVALENCE BETWEEN PERMUTATIONS

$p->eqv($q): Check if the permutation $q is equivalent to $p. Return 1 if yes, 0 otherwise.

CLONE THE PERMUTATION

$p->clone($q): Clone the permutation $q into $p.

MODIFY THE PERMUTATION

$p->swap($i, $j)

Swap the values of $i-th position and $j-th position.

$p->comp($q)

Composition of $p and $q, sometimes called multiplication of the permutations. The resultant is $q $p (first do $p, then do $q).

$p and $q must be permutations of same number of elements.

$p->inverse()

Inverse of $p.

$p->nxt()

The next permutation under the lexicological order of all $n-permutations.

Caveat: may return [].

$p->prev()

The previous permutation under the lexicological order of all $n-permutations.

Caveat: may return [].

PRORERTIES OF THE CURRENT PERMUTATION

$p->sigma($i)

Return what $i is mapped to under $p.

$p->rule()

Return the word representation of $p as a list.

$p->cyc()

Return the cycle representation of $p as a list of list(s).

$p->elems()

Return the length of $p.

$p->rank()

Return the lexicological rank of $p. See $p->unrank($n, $i).

$p->index()

Return the permutation index of $p.

$p->order()

Return the order of $p, i.e. how many times the permutation acts on itself and return the identity permutation.

$p->is_even()

Return whether $p is an even permutation. Return 1 or 0.

$p->is_odd()

Return whether $p is an odd permutation. Return 1 or 0.

$p->sgn()

Return the signature of $p. Return +1 if $p is even, -1 if $p is odd.

Another view is the determinant of the permutation matrix of $p.

$p->inversion()

Return the inversion sequence of $p as a list.

$p->matrix()

Return the permutation matrix of $p.

$p->fixed_points()

Return the list of fixed points of $p.

$p->sqrt()

Caveat: may return undef.

METHODS TO BE INPLEMENTED

longest_increasing()

longest_decreasing()

coxeter_decomposition()

comp( more than one permutations )

reverse()