Struct CompositeGenome 

pub struct CompositeGenome<A, B>
where
    A: EvolutionaryGenome,
    B: EvolutionaryGenome,
{
    pub first: A,
    pub second: B,
}

A composite genome combining two different genome types

This is useful for problems that require multiple representations, such as:

• Continuous parameters + discrete choices
• Feature selection (binary) + feature weights (continuous)
• Topology (permutation) + parameters (continuous)

Type Parameters

• A: The first genome type
• B: The second genome type

Fields

first: A

First component genome

second: B

Second component genome

Implementations

impl<A, B> CompositeGenome<A, B>

where A: EvolutionaryGenome, B: EvolutionaryGenome,

pub fn new(first: A, second: B) -> Self

Create a new composite genome from two components

pub fn first(&self) -> &A

Get a reference to the first component

pub fn first_mut(&mut self) -> &mut A

Get a mutable reference to the first component

pub fn second(&self) -> &B

Get a reference to the second component

pub fn second_mut(&mut self) -> &mut B

Get a mutable reference to the second component

pub fn into_parts(self) -> (A, B)

Consume and return the components

pub fn map_first<F, C>(self, f: F) -> CompositeGenome<C, B>

where F: FnOnce(A) -> C, C: EvolutionaryGenome,

Map a function over the first component

pub fn map_second<F, C>(self, f: F) -> CompositeGenome<A, C>

where F: FnOnce(B) -> C, C: EvolutionaryGenome,

Map a function over the second component

Trait Implementations

impl<A, B> Clone for CompositeGenome<A, B>

where A: EvolutionaryGenome + Clone, B: EvolutionaryGenome + Clone,

fn clone(&self) -> CompositeGenome<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, B> Debug for CompositeGenome<A, B>

where A: EvolutionaryGenome + Debug, B: EvolutionaryGenome + Debug,

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

Formats the value using the given formatter.

impl<'de, A, B> Deserialize<'de> for CompositeGenome<A, B>

where A: EvolutionaryGenome + Serialize + for<'de2> Deserialize<'de2>, B: EvolutionaryGenome + Serialize + for<'de2> Deserialize<'de2>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A, B> EvolutionaryGenome for CompositeGenome<A, B>

where A: EvolutionaryGenome + Clone + Send + Sync + Serialize + for<'de> Deserialize<'de>, B: EvolutionaryGenome + Clone + Send + Sync + Serialize + for<'de> Deserialize<'de>,

fn to_trace(&self) -> Trace

Convert composite genome to Fugue trace.

Stores dimensions and serialized data for each component.

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

Reconstruct composite genome from Fugue trace.

Note: This is a simplified implementation that may lose some type information. For full fidelity, use serde serialization directly.

type Allele = (<A as EvolutionaryGenome>::Allele, <B as EvolutionaryGenome>::Allele)

The allele type for individual genes

type Phenotype = (<A as EvolutionaryGenome>::Phenotype, <B as EvolutionaryGenome>::Phenotype)

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<A, B> PartialEq for CompositeGenome<A, B>

where A: EvolutionaryGenome + PartialEq, B: EvolutionaryGenome + PartialEq,

fn eq(&self, other: &CompositeGenome<A, B>) -> 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<A, B> Serialize for CompositeGenome<A, B>

where A: EvolutionaryGenome + Serialize + for<'de2> Deserialize<'de2>, B: EvolutionaryGenome + Serialize + for<'de2> Deserialize<'de2>,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A, B> StructuralPartialEq for CompositeGenome<A, B>

where A: EvolutionaryGenome, B: EvolutionaryGenome,