use crate::error::{BarracudaError, Result};
#[derive(Debug, Clone, Copy)]
pub struct PenaltyConfig {
pub min_penalty: f64,
pub max_penalty: f64,
pub safety_margin: f64,
pub use_log: bool,
}
impl Default for PenaltyConfig {
fn default() -> Self {
Self {
min_penalty: 1e6,
max_penalty: 1e12,
safety_margin: 10.0,
use_log: true,
}
}
}
impl PenaltyConfig {
#[must_use]
pub fn with_min(mut self, min: f64) -> Self {
self.min_penalty = min;
self
}
#[must_use]
pub fn with_margin(mut self, margin: f64) -> Self {
self.safety_margin = margin;
self
}
}
#[derive(Debug, Clone)]
pub struct AdaptivePenalty {
pub raw_penalty: f64,
pub penalty: f64,
pub feasible_max: f64,
pub feasible_min: f64,
pub feasible_mean: f64,
pub n_feasible: usize,
}
impl AdaptivePenalty {
#[must_use]
pub fn apply(&self, constraint_violation: f64) -> f64 {
self.penalty * (1.0 + constraint_violation.abs())
}
}
pub fn adaptive_penalty(feasible_values: &[f64], config: PenaltyConfig) -> Result<AdaptivePenalty> {
if feasible_values.is_empty() {
let raw_penalty = config.min_penalty;
let penalty = if config.use_log {
raw_penalty.ln_1p()
} else {
raw_penalty
};
return Ok(AdaptivePenalty {
raw_penalty,
penalty,
feasible_max: f64::NEG_INFINITY,
feasible_min: f64::INFINITY,
feasible_mean: 0.0,
n_feasible: 0,
});
}
let valid: Vec<f64> = feasible_values
.iter()
.filter(|v| v.is_finite())
.copied()
.collect();
if valid.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "No finite feasible values provided".to_string(),
});
}
let n = valid.len();
let feasible_max = valid.iter().copied().fold(f64::NEG_INFINITY, f64::max);
let feasible_min = valid.iter().copied().fold(f64::INFINITY, f64::min);
let feasible_mean = valid.iter().sum::<f64>() / n as f64;
let raw_penalty = (feasible_max.abs() * config.safety_margin)
.max(config.min_penalty)
.min(config.max_penalty);
let penalty = if config.use_log {
let target = feasible_max * config.safety_margin;
raw_penalty.max(target.exp_m1()).ln_1p()
} else {
raw_penalty
};
Ok(AdaptivePenalty {
raw_penalty,
penalty,
feasible_max,
feasible_min,
feasible_mean,
n_feasible: n,
})
}
pub fn adaptive_penalty_mad(
values: &[f64],
config: PenaltyConfig,
mad_multiplier: f64,
) -> Result<AdaptivePenalty> {
if values.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "values cannot be empty".to_string(),
});
}
let mut valid: Vec<f64> = values.iter().filter(|v| v.is_finite()).copied().collect();
if valid.is_empty() {
return Err(BarracudaError::InvalidInput {
message: "No finite values provided".to_string(),
});
}
valid.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let n = valid.len();
let median = if n.is_multiple_of(2) {
f64::midpoint(valid[n / 2 - 1], valid[n / 2])
} else {
valid[n / 2]
};
let mut deviations: Vec<f64> = valid.iter().map(|v| (v - median).abs()).collect();
deviations.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let mad = if n.is_multiple_of(2) {
f64::midpoint(deviations[n / 2 - 1], deviations[n / 2])
} else {
deviations[n / 2]
};
let threshold = mad_multiplier.mul_add(mad, median);
let feasible: Vec<f64> = valid.iter().filter(|&&v| v <= threshold).copied().collect();
adaptive_penalty(&feasible, config)
}
pub fn penalized_objective<F, G>(
objective: F,
constraints: G,
penalty: &AdaptivePenalty,
) -> impl Fn(&[f64]) -> f64
where
F: Fn(&[f64]) -> f64,
G: Fn(&[f64]) -> f64,
{
let penalty_val = penalty.penalty;
move |x: &[f64]| {
let violation = constraints(x);
if violation <= 0.0 {
objective(x)
} else {
penalty_val * (1.0 + violation)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_adaptive_penalty_basic() {
let feasible = vec![5.0, 10.0, 3.0, 8.0];
let result = adaptive_penalty(&feasible, PenaltyConfig::default()).unwrap();
assert_eq!(result.n_feasible, 4);
assert!((result.feasible_max - 10.0).abs() < 1e-10);
assert!((result.feasible_min - 3.0).abs() < 1e-10);
assert!(result.penalty > result.feasible_max);
}
#[test]
fn test_adaptive_penalty_empty() {
let result = adaptive_penalty(&[], PenaltyConfig::default()).unwrap();
assert_eq!(result.n_feasible, 0);
assert!(result.raw_penalty >= 1e6);
}
#[test]
fn test_penalty_apply() {
let feasible = vec![5.0, 10.0];
let result = adaptive_penalty(&feasible, PenaltyConfig::default()).unwrap();
let p1 = result.apply(0.1);
let p2 = result.apply(0.5);
assert!(p2 > p1);
}
#[test]
fn test_penalty_exceeds_feasible() {
let feasible = vec![5.0, 10.0, 15.0];
let result = adaptive_penalty(&feasible, PenaltyConfig::default()).unwrap();
let penalized = result.apply(0.0);
assert!(penalized > result.feasible_max);
}
#[test]
fn test_adaptive_penalty_mad() {
let values = vec![5.0, 8.0, 3.0, 1e10, 7.0, 1e10, 6.0];
let result = adaptive_penalty_mad(&values, PenaltyConfig::default(), 5.0).unwrap();
assert!(result.n_feasible <= 5);
assert!(result.feasible_max < 1e10);
}
#[test]
fn test_penalty_config() {
let config = PenaltyConfig::default().with_min(1e4).with_margin(5.0);
assert!((config.min_penalty - 1e4).abs() < 1e-10);
assert!((config.safety_margin - 5.0).abs() < 1e-10);
}
}