Struct Permutation 

pub struct Permutation { /* private fields */ }

Permutation genome for ordering problems

Represents a permutation of indices 0..n, commonly used for:

• Traveling Salesman Problem (TSP)
• Job Shop Scheduling
• Vehicle Routing Problems
• Any problem where the solution is an ordering of elements

Implementations

impl Permutation

pub fn new(perm: Vec<usize>) -> Self

Create a new permutation from a vector of indices

Panics

Panics if the input is not a valid permutation of 0..n

pub fn from_vec_unchecked(perm: Vec<usize>) -> Self

Create a permutation from a vector without validating it.

Invariants

The caller must guarantee that perm is a valid permutation of 0..perm.len() — every index in that range appears exactly once. Violating this invariant does not fail here, but corrupts downstream operations that assume it:

• inverse panics with an out-of-bounds index for an out-of-range value, or silently produces a meaningless result for in-range duplicates.
• compose panics on out-of-range indices.

Prefer try_new (or new) unless validity has already been established elsewhere and you need to skip the O(n) re-check. In debug builds this constructor still asserts validity to catch contract violations early.

pub fn try_new(perm: Vec<usize>) -> Result<Self, GenomeError>

Try to create a permutation, returning an error if invalid

pub fn identity(n: usize) -> Self

Create the identity permutation [0, 1, 2, …, n-1]

pub fn random<R: Rng>(n: usize, rng: &mut R) -> Self

Create a random permutation of size n

pub fn generate_with_len<R: Rng>(rng: &mut R, len: usize) -> Self

Generate a random permutation of an explicit length.

This is the honest constructor for random generation: unlike EvolutionaryGenome::generate, which overloads MultiBounds and only reads its dimension count, this takes the permutation length directly. Equivalent to random.

pub fn len(&self) -> usize

Get the length of the permutation

pub fn is_empty(&self) -> bool

Check if the permutation is empty

pub fn get(&self, i: usize) -> Option<usize>

Get the element at index i

pub fn inverse(&self) -> Self

Get the inverse permutation

If perm[i] = j, then inverse[j] = i

pub fn compose(&self, other: &Self) -> Result<Self, GenomeError>

Compose this permutation with another

Returns a permutation where result[i] = other[self[i]]

pub fn swap(&mut self, i: usize, j: usize)

Swap two elements at positions i and j

pub fn reverse_segment(&mut self, start: usize, end: usize)

Reverse a segment from start to end (inclusive)

pub fn insert(&mut self, from: usize, to: usize)

Insert element at position from to position to

pub fn inversions(&self) -> usize

Calculate the number of inversions (disorder measure)

An inversion is a pair (i, j) where i < j but perm[i] > perm[j]. Returns a value in [0, n*(n-1)/2] where 0 means sorted.

pub fn kendall_tau_distance(&self, other: &Self) -> Result<usize, GenomeError>

Calculate Kendall tau distance to another permutation

Counts the number of pairwise disagreements (i.e., pairs that are in different order in the two permutations).

pub fn is_cyclic(&self) -> bool

Check if this is a cyclic permutation (single cycle)

pub fn into_inner(self) -> Vec<usize>

Get the underlying vector

pub fn as_slice(&self) -> &[usize]

Get a reference to the underlying slice

Trait Implementations

impl Clone for Permutation

fn clone(&self) -> Permutation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CrossoverOperator<Permutation> for PmxCrossover

fn crossover<R: Rng>( &self, parent1: &Permutation, parent2: &Permutation, rng: &mut R, ) -> OperatorResult<(Permutation, Permutation)>

Apply crossover to two parents and produce two offspring

fn crossover_probability(&self) -> f64

Get the probability of crossover being applied

impl CrossoverOperator<Permutation> for OxCrossover

fn crossover<R: Rng>( &self, parent1: &Permutation, parent2: &Permutation, rng: &mut R, ) -> OperatorResult<(Permutation, Permutation)>

Apply crossover to two parents and produce two offspring

fn crossover_probability(&self) -> f64

Get the probability of crossover being applied

impl CrossoverOperator<Permutation> for CxCrossover

fn crossover<R: Rng>( &self, parent1: &Permutation, parent2: &Permutation, _rng: &mut R, ) -> OperatorResult<(Permutation, Permutation)>

Apply crossover to two parents and produce two offspring

fn crossover_probability(&self) -> f64

Get the probability of crossover being applied

impl CrossoverOperator<Permutation> for EdgeRecombinationCrossover

fn crossover<R: Rng>( &self, parent1: &Permutation, parent2: &Permutation, rng: &mut R, ) -> OperatorResult<(Permutation, Permutation)>

Apply crossover to two parents and produce two offspring

fn crossover_probability(&self) -> f64

Get the probability of crossover being applied

impl Debug for Permutation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Permutation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Permutation

impl EvolutionaryGenome for Permutation

fn generate<R: Rng>(rng: &mut R, bounds: &MultiBounds) -> Self

Generate a random permutation.

Only bounds.dimension() is consulted — it is the permutation length — and the per-dimension min/max values are ignored. Prefer Permutation::generate_with_len to make the length explicit.

type Allele = usize

The allele type for individual genes

type Phenotype = Vec<usize>

The phenotype or decoded solution type

fn decode(&self) -> Self::Phenotype

Decode genome into phenotype for fitness evaluation

fn dimension(&self) -> usize

Compute dimensionality for adaptive operators

fn distance(&self, other: &Self) -> f64

Distance metric between two genomes.

fn try_distance(&self, other: &Self) -> Result<f64, GenomeError>

Fallible distance metric.

fn as_slice(&self) -> Option<&[Self::Allele]>

Get the genome’s genes as a slice (for numeric genomes)

fn as_mut_slice(&mut self) -> Option<&mut [Self::Allele]>

Get the genome’s genes as a mutable slice (for numeric genomes)

impl From<Permutation> for Vec<usize>

fn from(p: Permutation) -> Self

Converts to this type from the input type.

impl From<Vec<usize>> for Permutation

fn from(perm: Vec<usize>) -> Self

Converts to this type from the input type.

impl Hash for Permutation

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Permutation

type Output = usize

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IntoIterator for Permutation

type Item = usize

The type of the elements being iterated over.

type IntoIter = IntoIter<usize>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a Permutation

type Item = &'a usize

The type of the elements being iterated over.

type IntoIter = Iter<'a, usize>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl MutationOperator<Permutation> for PermutationSwapMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl MutationOperator<Permutation> for InsertMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl MutationOperator<Permutation> for InversionMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl MutationOperator<Permutation> for PermutationScrambleMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl MutationOperator<Permutation> for DisplacementMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl MutationOperator<Permutation> for AdaptivePermutationMutation

fn mutate<R: Rng>(&self, genome: &mut Permutation, rng: &mut R)

Apply mutation to a genome in place

fn mutation_probability(&self) -> Option<f64>

Report the per-gene mutation probability actually applied by this operator.

impl PartialEq for Permutation

fn eq(&self, other: &Permutation) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PermutationGenome for Permutation

fn permutation(&self) -> &[usize]

Get the permutation as a slice

fn permutation_mut(&mut self) -> &mut [usize]

Get the permutation as a mutable slice

fn from_permutation(perm: Vec<usize>) -> Result<Self, GenomeError>

Create from a vector of indices

fn is_valid_permutation(&self) -> bool

Check if the genome represents a valid permutation

impl Serialize for Permutation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Permutation

impl TraceGenome for Permutation

Available on crate feature ppl only.

fn to_trace(&self) -> Trace

Convert Permutation to Fugue trace using the Lehmer-code (rank) encoding: position i stores the rank of perm[i] among the values not yet used at positions < i (a Usize in 0..n-i).

This encoding (rather than storing raw values) is what makes the trace generative: any in-range assignment of ranks decodes to a valid permutation, so a single-site change of one rank is a valid move — the value encoding would make every single-site change a duplicate. It coincides site-for-site with the sequential categorical prior model in crate::inference::prior::PermutationPrior.

fn from_trace(trace: &Trace) -> Result<Self, GenomeError>

Reconstruct Permutation from Fugue trace.

Reads values from addresses “perm#0”, “perm#1”, … until no more are found. A missing address terminates the scan (normal end of the sequence), but an address that is present with the wrong value type is a corrupt trace and yields GenomeError::TypeMismatch rather than silently truncating — which for a permutation is especially dangerous, since a truncated prefix can itself pass the validity check.

fn trace_prefix() -> &'static str

Get the address prefix used for trace storage (default: "gene").