Add permutations with length determined by a const parameter

[starblue]

No description provided.

[chrisbouchard]

It would be great if the const versions of these methods could avoid heap allocations and just allocate the array. E.g., here we could do something like

Suggested change

	ConstPermutation((0..N).collect::<Vec<_>>().try_into().unwrap())
	let mut storage = [0; N];
	for i in 0..N {
	storage[i] = i;
	}
	Self(storage)

[chrisbouchard]

I don't think we need T: Debug. Maybe this was left over from debugging?

[chrisbouchard]

What would you think of implementing MulAssign for ConstPermutation? Then I think this could be written iteratively using exponentiation by squaring to avoid creating multiple intermediate arrays — which, since they're stored on the stack, could result in a stack overflow much more quickly than with Box<[usize]> in Permutation.

Suggested change

	if exp == 0 {
	ConstPermutation::identity()
	} else if exp == 1 {
	self.clone()
	} else if exp % 2 == 0 {
	self.square().pow(exp / 2)
	} else {
	self * self.pow(exp - 1)
	}
	let mut result = Self::identity();
	let mut term = self.clone();
	while exp > 0 {
	if exp % 2 == 1 {
	result *= term;
	}
	term *= term;
	exp /= 2;
	}
	return result;

[chrisbouchard]

And for what it's worth, MulAssign could be implemented space-efficiently using permute_in_place from #3.

impl<const N: usize> ops::MulAssign<ConstPermutation<N>> for ConstPermutation<N> {
    fn mul_assign(&mut self, rhs: ConstPermutation<N>) {
        rhs.permute_in_place(&mut self.0);
    }
}

[chrisbouchard]

Is this just permute?

Suggested change

	let mut map = [0; N];
	for i in 0..N {
	map[i] = other.apply(self.apply(i));
	}
	ConstPermutation(map)
	ConstPermutation(other.permute(&self.0))

[chrisbouchard]

Huh, I actually had no idea that [T; N]: Copy when T: Copy.

[chrisbouchard]

I think this could just be

Suggested change

	let mut seen = (0..n).map(|_| false).collect::<Vec<_>>();
	let mut seen = vec![false; n];

[chrisbouchard]

Since this is an unsigned value, I think we can just check

Suggested change

	if (0..n).contains(&e) {
	if e < n {

[chrisbouchard]

Though see my other suggestion about early return.

[chrisbouchard]

Actually, since this can't be a valid permutation if it contains an out-of-bounds index, we could return immediately.

Suggested change

	if (0..n).contains(&e) {
	seen[e] = true;
	}
	if e >= n {
	return false;
	}
	seen[e] = true;

[chrisbouchard]

Should these uses be joined into a single group?

[chrisbouchard]

I think we could reuse identity to make this

Suggested change

	ConstPermutation(
	(0..N)
	.map(|k| {
	if k == i {
	j
	} else if k == j {
	i
	} else {
	k
	}
	})
	.collect::<Vec<_>>()
	.try_into()
	.unwrap(),
	)
	let mut result = Self::identity();
	result.0.swap(i, j);
	result