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 new_unchecked(perm: Vec<usize>) -> Self

Create a permutation from a vector without validation

Safety

The caller must ensure the input is a valid permutation of 0..n

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 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 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 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 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 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 EvolutionaryGenome for Permutation

fn to_trace(&self) -> Trace

Convert Permutation to Fugue trace.

Each position is stored at address “perm#i” where i is the index.

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.

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 generate<R: Rng>(rng: &mut R, bounds: &MultiBounds) -> Self

Generate a random genome within the given bounds

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

Distance metric between two genomes (default: 0.0)

fn trace_prefix() -> &'static str

Get the address prefix used for trace storage (default: “gene”)

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<'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 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 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) -> f64

Get the mutation probability per gene

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) -> f64

Get the mutation probability per gene

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) -> f64

Get the mutation probability per gene

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) -> f64

Get the mutation probability per gene

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) -> f64

Get the mutation probability per gene

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) -> f64

Get the mutation probability per gene

impl PartialEq for Permutation

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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 Eq for Permutation

impl StructuralPartialEq for Permutation