Struct GenomeExperiment 

pub struct GenomeExperiment {
    pub traits: Vec<f64>,
    pub trait_names: Vec<String>,
    pub fitness_scores: HashMap<String, f64>,
    pub overall_fitness: f64,
    pub task_summary: String,
    pub successful: bool,
    pub id: Uuid,
    pub timestamp: DateTime<Utc>,
}

A single genome experiment result

Records the genome traits used, the fitness scores achieved, and metadata about the experiment for later analysis.

Fields

traits: Vec<f64>

The genome traits that were tested (copies of values, not names)

trait_names: Vec<String>

Trait names for reference

fitness_scores: HashMap<String, f64>

Fitness scores by metric name (e.g., “task_completion”: 0.8)

overall_fitness: f64

Overall fitness (0.0-1.0) - weighted average of metrics

task_summary: String

Task description (truncated for storage efficiency)

successful: bool

Whether this was a successful experiment (fitness > threshold)

id: Uuid

Unique identifier for this experiment

timestamp: DateTime<Utc>

Timestamp when experiment was recorded

Implementations

impl GenomeExperiment

pub fn new( genome: &Genome, fitness_scores: HashMap<String, f64>, overall: f64, task: &str, ) -> Self

Create a new genome experiment from a genome and fitness results

Arguments

• genome - The genome that was tested
• fitness_scores - Individual metric scores
• overall - Overall fitness score (0.0-1.0)
• task - Task description (will be truncated to 200 chars)

Example

use vex_core::{Genome, GenomeExperiment};
use std::collections::HashMap;

let genome = Genome::new("Test agent");
let mut scores = HashMap::new();
scores.insert("accuracy".to_string(), 0.85);

let exp = GenomeExperiment::new(&genome, scores, 0.85, "Summarize document");
assert!(exp.successful);

pub fn from_raw( traits: Vec<f64>, trait_names: Vec<String>, overall_fitness: f64, task_summary: &str, ) -> Self

Create from raw values (for deserialization or testing)

pub fn get_trait(&self, name: &str) -> Option<f64>

Get a specific trait value by name

Trait Implementations

impl Clone for GenomeExperiment

fn clone(&self) -> GenomeExperiment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GenomeExperiment

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GenomeExperiment

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GenomeExperiment

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

where __S: Serializer,

Serialize this value into the given Serde serializer.