#[derive(Debug, Clone)]
pub struct CooperationParams {
pub mu_coop: f64,
pub mu_cheat: f64,
pub k_cap: f64,
pub death_rate: f64,
pub k_ai_prod: f64,
pub d_ai: f64,
pub benefit: f64,
pub k_benefit: f64,
pub cost: f64,
pub k_bio: f64,
pub k_bio_ai: f64,
pub dispersal_bonus: f64,
pub d_bio: f64,
}
pub const COOPERATION_N_VARS: usize = 4;
pub const COOPERATION_N_PARAMS: usize = 13;
impl Default for CooperationParams {
fn default() -> Self {
Self {
mu_coop: 0.7,
mu_cheat: 0.75,
k_cap: 1.0,
death_rate: 0.02,
k_ai_prod: 5.0,
d_ai: 1.0,
benefit: 0.3,
k_benefit: 0.5,
cost: 0.05,
k_bio: 1.0,
k_bio_ai: 0.5,
dispersal_bonus: 0.2,
d_bio: 0.3,
}
}
}
impl CooperationParams {
#[must_use]
pub const fn to_flat(&self) -> [f64; COOPERATION_N_PARAMS] {
[
self.mu_coop,
self.mu_cheat,
self.k_cap,
self.death_rate,
self.k_ai_prod,
self.d_ai,
self.benefit,
self.k_benefit,
self.cost,
self.k_bio,
self.k_bio_ai,
self.dispersal_bonus,
self.d_bio,
]
}
#[must_use]
pub fn from_flat(flat: &[f64]) -> Self {
assert!(
flat.len() >= COOPERATION_N_PARAMS,
"need {COOPERATION_N_PARAMS} values"
);
Self {
mu_coop: flat[0],
mu_cheat: flat[1],
k_cap: flat[2],
death_rate: flat[3],
k_ai_prod: flat[4],
d_ai: flat[5],
benefit: flat[6],
k_benefit: flat[7],
cost: flat[8],
k_bio: flat[9],
k_bio_ai: flat[10],
dispersal_bonus: flat[11],
d_bio: flat[12],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_roundtrip() {
let d = CooperationParams::default();
let r = CooperationParams::from_flat(&d.to_flat());
assert!(f64::abs(d.mu_coop - r.mu_coop) < 1e-15);
assert!(f64::abs(d.mu_cheat - r.mu_cheat) < 1e-15);
assert!(f64::abs(d.k_cap - r.k_cap) < 1e-15);
assert!(f64::abs(d.death_rate - r.death_rate) < 1e-15);
assert!(f64::abs(d.k_ai_prod - r.k_ai_prod) < 1e-15);
assert!(f64::abs(d.d_ai - r.d_ai) < 1e-15);
assert!(f64::abs(d.benefit - r.benefit) < 1e-15);
assert!(f64::abs(d.k_benefit - r.k_benefit) < 1e-15);
assert!(f64::abs(d.cost - r.cost) < 1e-15);
assert!(f64::abs(d.k_bio - r.k_bio) < 1e-15);
assert!(f64::abs(d.k_bio_ai - r.k_bio_ai) < 1e-15);
assert!(f64::abs(d.dispersal_bonus - r.dispersal_bonus) < 1e-15);
assert!(f64::abs(d.d_bio - r.d_bio) < 1e-15);
}
#[test]
fn test_flat_length() {
assert_eq!(
CooperationParams::default().to_flat().len(),
COOPERATION_N_PARAMS
);
}
}