vec2cyclist_single(p)
vec2cyclist_single_cpp(p)
remove_length_one(x)
cyclist2word_single(cyc,n)
nicify_cyclist(x,rm1=TRUE, smallest_first=TRUE)cycle2word_single(), the size of
the permutation to inducenicify_cyclist(),
Boolean, governing whether or not to remove length-1 cycles, and
whether or not to place the smallest element in each cycle first
(non-default values are used by standard_cyclist())A cyclist is a list with elements that are integer vectors corresponding to the cycles of a permutation. This object is informally known as a cyclist, but there is no S3 class corresponding to it.
An object of S3 class cycle is a (possibly named) list of cyclists. NB: there is an unavoidable notational clash here. When considering a single permutation, “cycle” means group-theoretic cycle; when considering R objects, “cycle” means “an R object of class cycle whose elements are permutations written in cycle form”.
The elements of a cyclist are the disjoint cycles. Note the redundancies inherent: firstly, because the cycles commute, their order is immaterial (and a list is ordered); and secondly, the cycles themselves are invariant under cyclic permutation. Heigh ho.
A cyclist may be poorly formed in a number of ways: the cycles may
include repeats, or contain elements which are common to more than one
cycle. Such problems are detected by cycle.valid(). Also, there
are less serious problems: the cycles may include length-one cycles; the
cycles may start with an element that is not the smallest. These issues
are dealt with by nicify_cyclist().
nicify_cyclist() takes a cyclist and puts it in
a nice form but does not alter the permutation. It takes a cyclist
and removes length-one cycles; then orders each cycle so that the
smallest element appears first (that is, it changes (523) to
(235)). It then orders the cycles by the smallest element.
remove_length_one() takes a cyclist and removes
length-one cycles from it.
vec2cyclist_single() converts a vector into a
cyclist. Length-one cycles are discarded.
vec2cyclist_single_cpp() is a placeholder for a
function that is not yet written.
cyclist2word_single() takes a cyclist and returns
a vector corresponding to a single word. The user should use
cycle2word() as it takes a cycle object and returns a word object.
char2cyclist_single() takes a character string
like “(342)(19)” and turns it into a cyclist, in this
case list(c(3,4,2),c(1,9)). This function returns a cyclist
which is not necessarily canonicalized: it might have length-one
cycles, and the cycles themselves might start with the wrong number or
be incorrectly ordered. It attempts to deal with absence of commas in
a sensible way, so “(18,19)(2,5)” is dealt with
appropriately too. The function is insensitive to spaces. Also, one
can give it an argument which does not correspond to a cycle object,
eg char2cyclist_single("(94)(32)(19)(1)". This is OK as far
as it goes (the function does not return an error), but to catch this
kind of error use char2cycle() which calls the validity checks. The user shoud use char2cycle() which executes validity checks
and coerces to a cycle object.
as.cycle,fbin
vec2cyclist_single(c(7,9,3,5,8,6,1,4,2))
char2cyclist_single("(342)(19)")
nicify_cyclist(list(c(4, 6), c(7), c(2, 5, 1), c(8, 3)))
nicify_cyclist(list(c(4, 6), c(7), c(2, 5, 1), c(8, 3)),rm1=TRUE)
cyclist2word_single(list(c(1,4,3),c(7,8)))
Run the code above in your browser using DataLab