Struct DynamicRealVector 

pub struct DynamicRealVector { /* private fields */ }

Variable-length real-valued vector genome

This genome type represents optimization problems where the solution dimension can vary. Useful for problems like:

• Neural network architecture search (variable hidden layer sizes)
• Variable-length feature selection
• Adaptive-dimensional optimization

Implementations

impl DynamicRealVector

pub fn new( genes: Vec<f64>, min_length: usize, max_length: usize, ) -> Result<Self, GenomeError>

Create a new dynamic real vector with the given genes and length constraints

pub fn with_defaults(genes: Vec<f64>) -> Self

Create with default length constraints (1 to usize::MAX)

pub fn zeros( dimension: usize, min_length: usize, max_length: usize, ) -> Result<Self, GenomeError>

Create a zero-filled vector of the given dimension

pub fn min_length(&self) -> usize

Get the minimum allowed length

pub fn max_length(&self) -> usize

Get the maximum allowed length

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

Get the underlying vector

pub fn as_vec(&self) -> &Vec<f64>

Get a reference to the genes

pub fn norm(&self) -> f64

Calculate Euclidean norm

pub fn norm_squared(&self) -> f64

Calculate squared Euclidean norm

pub fn push(&mut self, gene: f64) -> Result<(), GenomeError>

Add a gene to the end (if within bounds)

pub fn pop(&mut self) -> Result<f64, GenomeError>

Remove the last gene (if within bounds)

pub fn insert(&mut self, index: usize, gene: f64) -> Result<(), GenomeError>

Insert a gene at a specific position

pub fn remove(&mut self, index: usize) -> Result<f64, GenomeError>

Remove a gene at a specific position

pub fn can_grow(&self) -> bool

Check if a gene can be added

pub fn can_shrink(&self) -> bool

Check if a gene can be removed

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

Element-wise addition (requires same length)

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

Element-wise subtraction (requires same length)

pub fn scale(&self, scalar: f64) -> Self

Scalar multiplication

pub fn try_generate<R: Rng>( rng: &mut R, bounds: &MultiBounds, ) -> Result<Self, GenomeError>

Fallibly generate a random variable-length vector from bounds.

bounds.dimension() is interpreted as the maximum length (minimum length 1) and the per-dimension [min, max] intervals bound the sampled gene values. Returns Err(GenomeError::InvalidStructure) for empty (0-dimension) bounds, which cannot yield a valid non-empty genome — this replaces the previous panic on the inverted range 1..=0.

pub fn generate_with_len<R: Rng>( rng: &mut R, min_length: usize, max_length: usize, value_bounds: &MultiBounds, ) -> Result<Self, GenomeError>

Generate a random variable-length vector with explicit length bounds.

This is the honest constructor for random generation: the length is sampled uniformly from [min_length, max_length] and each gene is sampled from the corresponding entry of value_bounds (falling back to the first entry when the sampled length exceeds the number of provided bounds). Unlike EvolutionaryGenome::generate, it does not overload a MultiBounds’ dimension as a length.

Trait Implementations

impl Clone for DynamicRealVector

fn clone(&self) -> DynamicRealVector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DynamicRealVector

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DynamicRealVector

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EvolutionaryGenome for DynamicRealVector

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

Generate a random variable-length vector.

bounds.dimension() is interpreted as the maximum length (minimum length 1); the per-dimension [min, max] intervals bound the sampled gene values. For empty (0-dimension) bounds there is nothing to sample, so this degrades gracefully to an empty genome instead of panicking on an inverted gen_range(1..=0). Use try_generate if you want that degenerate case reported as an error, or generate_with_len for explicit length bounds.

type Allele = f64

The allele type for individual genes

type Phenotype = Vec<f64>

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 PartialEq for DynamicRealVector

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

Equality operator ==.

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

Inequality operator !=.

impl RealValuedGenome for DynamicRealVector

fn genes(&self) -> &[f64]

Get the genes as a slice of f64 values

fn genes_mut(&mut self) -> &mut [f64]

Get the genes as a mutable slice of f64 values

fn from_genes(genes: Vec<f64>) -> Result<Self, GenomeError>

Create from a vector of genes

fn apply_bounds(&mut self, bounds: &MultiBounds)

Apply bounds to all genes

impl Serialize for DynamicRealVector

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 DynamicRealVector

impl TraceGenome for DynamicRealVector

Available on crate feature ppl only.

fn to_trace(&self) -> Trace

Convert DynamicRealVector to Fugue trace.

Stores genes at "<trace_prefix()>#i" and metadata at “meta#min_length”, “meta#max_length” and “meta#length”. The gene address prefix is taken from trace_prefix so that the prefix advertised by the trait and the prefix actually written can never diverge.

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

Reconstruct DynamicRealVector from Fugue trace.

fn trace_prefix() -> &'static str

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