use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{BufReader, BufWriter};
use std::path::Path;
use crate::error::{BarracudaError, Result};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EvaluationRecord {
pub x: Vec<f64>,
pub f: f64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct EvaluationCache {
records: Vec<EvaluationRecord>,
#[serde(skip)]
best_idx: Option<usize>,
}
impl EvaluationCache {
#[must_use]
pub fn new() -> Self {
Self {
records: Vec::new(),
best_idx: None,
}
}
#[must_use]
pub fn with_capacity(capacity: usize) -> Self {
Self {
records: Vec::with_capacity(capacity),
best_idx: None,
}
}
pub fn record(&mut self, x: Vec<f64>, f: f64) {
let idx = self.records.len();
self.records.push(EvaluationRecord { x, f });
match self.best_idx {
None => self.best_idx = Some(idx),
Some(best) => {
if f < self.records[best].f {
self.best_idx = Some(idx);
}
}
}
}
#[must_use]
pub fn len(&self) -> usize {
self.records.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.records.is_empty()
}
#[must_use]
pub fn best_f(&self) -> Option<f64> {
self.best_idx.map(|idx| self.records[idx].f)
}
#[must_use]
pub fn best_x(&self) -> Option<&[f64]> {
self.best_idx.map(|idx| self.records[idx].x.as_slice())
}
#[must_use]
pub fn best(&self) -> Option<&EvaluationRecord> {
self.best_idx.map(|idx| &self.records[idx])
}
#[must_use]
pub fn records(&self) -> &[EvaluationRecord] {
&self.records
}
#[must_use]
pub fn training_data(&self) -> (Vec<Vec<f64>>, Vec<f64>) {
let x_data: Vec<Vec<f64>> = self.records.iter().map(|r| r.x.clone()).collect();
let y_data: Vec<f64> = self.records.iter().map(|r| r.f).collect();
(x_data, y_data)
}
pub fn merge(&mut self, other: &Self) {
for record in &other.records {
self.record(record.x.clone(), record.f);
}
}
pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()> {
let file = File::create(path.as_ref())
.map_err(|e| BarracudaError::Internal(format!("Failed to create cache file: {e}")))?;
let writer = BufWriter::new(file);
serde_json::to_writer_pretty(writer, self)
.map_err(|e| BarracudaError::Internal(format!("Failed to serialize cache: {e}")))?;
Ok(())
}
pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
let file = File::open(path.as_ref())
.map_err(|e| BarracudaError::Internal(format!("Failed to open cache file: {e}")))?;
let reader = BufReader::new(file);
let mut cache: Self = serde_json::from_reader(reader)
.map_err(|e| BarracudaError::Internal(format!("Failed to deserialize cache: {e}")))?;
cache.recompute_best();
Ok(cache)
}
pub fn load_or_new<P: AsRef<Path>>(path: P) -> Self {
match Self::load(&path) {
Ok(cache) => cache,
Err(e) => {
tracing::debug!("EvaluationCache: starting fresh (load failed: {e})");
Self::default()
}
}
}
#[must_use]
pub fn from_training_data(x_data: Vec<Vec<f64>>, y_data: Vec<f64>) -> Self {
let mut cache = Self::with_capacity(x_data.len());
for (x, f) in x_data.into_iter().zip(y_data) {
cache.record(x, f);
}
cache
}
fn recompute_best(&mut self) {
self.best_idx = None;
if self.records.is_empty() {
return;
}
let mut best = 0;
for (i, record) in self.records.iter().enumerate() {
if record.f < self.records[best].f {
best = i;
}
}
self.best_idx = Some(best);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_cache_basic() {
let mut cache = EvaluationCache::new();
assert!(cache.is_empty());
assert_eq!(cache.len(), 0);
assert!(cache.best_f().is_none());
cache.record(vec![1.0, 2.0], 5.0);
assert_eq!(cache.len(), 1);
assert!(!cache.is_empty());
assert_eq!(cache.best_f(), Some(5.0));
}
#[test]
fn test_cache_tracks_best() {
let mut cache = EvaluationCache::new();
cache.record(vec![0.0], 10.0);
cache.record(vec![1.0], 3.0); cache.record(vec![2.0], 7.0);
cache.record(vec![3.0], 15.0);
assert_eq!(cache.best_f(), Some(3.0));
assert_eq!(cache.best_x(), Some(vec![1.0].as_slice()));
}
#[test]
fn test_cache_training_data() {
let mut cache = EvaluationCache::new();
cache.record(vec![1.0, 2.0], 5.0);
cache.record(vec![3.0, 4.0], 7.0);
let (x_data, y_data) = cache.training_data();
assert_eq!(x_data.len(), 2);
assert_eq!(y_data.len(), 2);
assert_eq!(x_data[0], vec![1.0, 2.0]);
assert_eq!(y_data[1], 7.0);
}
#[test]
fn test_cache_merge() {
let mut a = EvaluationCache::new();
a.record(vec![0.0], 10.0);
a.record(vec![1.0], 5.0);
let mut b = EvaluationCache::new();
b.record(vec![2.0], 3.0); b.record(vec![3.0], 8.0);
a.merge(&b);
assert_eq!(a.len(), 4);
assert_eq!(a.best_f(), Some(3.0));
}
#[test]
fn test_cache_with_capacity() {
let cache = EvaluationCache::with_capacity(1000);
assert!(cache.is_empty());
assert_eq!(cache.len(), 0);
}
#[test]
fn test_eval_record_clone() {
let record = EvaluationRecord {
x: vec![1.0, 2.0, 3.0],
f: 42.0,
};
let cloned = record;
assert_eq!(cloned.x, vec![1.0, 2.0, 3.0]);
assert_eq!(cloned.f, 42.0);
}
#[test]
fn test_from_training_data() {
let x_data = vec![vec![1.0, 2.0], vec![3.0, 4.0], vec![0.0, 0.0]];
let y_data = vec![5.0, 7.0, 0.0];
let cache = EvaluationCache::from_training_data(x_data, y_data);
assert_eq!(cache.len(), 3);
assert_eq!(cache.best_f(), Some(0.0)); assert_eq!(cache.best_x(), Some(vec![0.0, 0.0].as_slice()));
}
#[test]
fn test_save_load_roundtrip() {
let mut cache = EvaluationCache::new();
cache.record(vec![1.0, 2.0], 5.0);
cache.record(vec![3.0, 4.0], 2.0); cache.record(vec![5.0, 6.0], 8.0);
let tmp = tempfile::NamedTempFile::new().expect("Failed to create temp file");
let temp_path = tmp.path().to_str().expect("non-UTF-8 path");
cache.save(temp_path).expect("Failed to save");
let loaded = EvaluationCache::load(temp_path).expect("Failed to load");
assert_eq!(loaded.len(), 3);
assert_eq!(loaded.best_f(), Some(2.0));
assert_eq!(loaded.best_x(), Some(vec![3.0, 4.0].as_slice()));
}
#[test]
fn test_load_or_new_nonexistent() {
let cache = EvaluationCache::load_or_new("/nonexistent/path/cache.json");
assert!(cache.is_empty());
}
#[test]
fn test_load_or_new_existing() {
let mut original = EvaluationCache::new();
original.record(vec![1.0], 42.0);
let tmp = tempfile::NamedTempFile::new().expect("Failed to create temp file");
let temp_path = tmp.path().to_str().expect("non-UTF-8 path");
original.save(temp_path).expect("Failed to save");
let loaded = EvaluationCache::load_or_new(temp_path);
assert_eq!(loaded.len(), 1);
assert_eq!(loaded.best_f(), Some(42.0));
}
#[test]
fn test_serialization_format() {
let mut cache = EvaluationCache::new();
cache.record(vec![1.0, 2.0], 5.0);
let json = serde_json::to_string(&cache).expect("Failed to serialize");
assert!(json.contains("1.0"));
assert!(json.contains("2.0"));
assert!(json.contains("5.0"));
}
#[test]
fn test_recompute_best_on_load() {
let mut cache = EvaluationCache::new();
cache.record(vec![0.0], 100.0);
cache.record(vec![1.0], 1.0); cache.record(vec![2.0], 50.0);
let tmp = tempfile::NamedTempFile::new().expect("Failed to create temp file");
let temp_path = tmp.path().to_str().expect("non-UTF-8 path");
cache.save(temp_path).expect("Failed to save");
let loaded = EvaluationCache::load(temp_path).expect("Failed to load");
assert_eq!(loaded.best_f(), Some(1.0));
assert_eq!(loaded.best_x(), Some(vec![1.0].as_slice()));
}
}