Functions to create permutation objects. `permutation`

is a
virtual class.

```
word(M)
permutation(x)
is.permutation(x)
cycle(x)
is.word(x)
is.cycle(x)
as.word(x,n=NULL)
as.cycle(x)
cycle2word(x,n=NULL)
char2cycle(char)
cyc_len(n)
shift_cycle(n)
# S3 method for word
as.matrix(x,...)
```

M

In function `word()`

, a matrix with rows corresponding
to permutations in word form

x

See details

n

In functions `as.word()`

and `cycle2word()`

, the
size of the word to return; in function `cyc_len()`

, the length
of the cycle to return

char

In function `char2cycle()`

a character vector which
is coerced to a cycle object

...

Further arguments passed to `as.matrix()`

Returns a `cycle`

object or a `word object`

Functions `word()`

and `cycle()`

are rather formal functions
which make no attempt to coerce their arguments into sensible forms.
The user should use `permutation()`

, which detects the form of the
input and dispatches to `as.word()`

or `as.cycle()`

, which
are much more user-friendly.

Functions `word()`

and `cycle()`

are the only functions in the
package which assign class `word`

or `cycle`

to an
object.

A *word* is a matrix whose rows correspond to permutations in word
format.

A cycle is a list whose elements correspond to permutations in
cycle form. A `cycle`

object comprises elements which are
informally dubbed ‘cyclists’. A cyclist is a list of integer
vectors corresponding to the cycles of the permutation.

Function `cycle2word()`

converts cycle objects to word objects.

Function `shift_cycle()`

is a convenience wrapper for
`as.cycle(seq_len(n))`

; `cyc_len()`

is a synonym.

It is a very common error (at least, it is for me) to use `cycle()`

when you meant `as.cycle()`

.

The print method is sensitive to the value of option
‘`print_word_as_cycle`

’, documented at `print.Rd`

.

Function `as.matrix.word()`

coerces a vector of permutations in word form to
a matrix, each row of which is a word. To get a permutation matrix (that is, a
square matrix of ones and zeros with exactly one entry of 1 in each row and each column),
use `perm_matrix()`

.

# NOT RUN { word(matrix(1:8,7,8)) # default print method displays cycle form cycle(list(list(c(1,8,2),c(3,6)),list(1:2, 4:8))) char2cycle(c("(1,4)(6,7)","(3,4,2)(8,19)", "(56)","(12345)(78)","(78)")) jj <- c(4,2,3,1) as.word(jj) as.cycle(jj) as.cycle(1:2)*as.cycle(1:8) == as.cycle(1:8)*as.cycle(1:2) # FALSE! x <- rperm(10,7) y <- rperm(10,7) as.cycle(commutator(x,y)) cycle(sapply(seq_len(9),cyc_len)) # }