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

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 to_trace(&self) -> Trace

Convert DynamicRealVector to Fugue trace.

Stores genes at “gene#i” and metadata at “meta#min_length” and “meta#max_length”.

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

Reconstruct DynamicRealVector from Fugue trace.

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

fn eq(&self, other: &DynamicRealVector) -> 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 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