use super::e_variable::{ACTION_EPSILON, log_phi};
use super::reward::RewardSchedule;
const FLOOR_MARGIN_NATS: f64 = 50.0;
pub(crate) fn estimate_ops(horizon: u64, wealth_grid_size: usize, action_grid_size: usize) -> u128 {
horizon as u128 * wealth_grid_size as u128 * action_grid_size as u128
}
pub(crate) struct WealthGrid {
floor: f64,
log_threshold: f64,
size: usize,
step: f64,
}
impl WealthGrid {
pub(crate) fn new(alpha: f64, size: usize) -> Self {
debug_assert!(
size >= 2,
"wealth_grid_size must be >= 2 (validated by caller)"
);
let log_threshold = (1.0 / alpha).ln();
let floor = log_threshold - FLOOR_MARGIN_NATS;
let step = (log_threshold - floor) / (size - 1) as f64;
Self {
floor,
log_threshold,
size,
step,
}
}
pub(crate) fn log_threshold(&self) -> f64 {
self.log_threshold
}
pub(crate) fn size(&self) -> usize {
self.size
}
pub(crate) fn step(&self) -> f64 {
self.step
}
pub(crate) fn point(&self, i: usize) -> f64 {
self.floor + self.step * i as f64
}
pub(crate) fn interpolate(&self, values: &[f64], w: f64) -> f64 {
debug_assert_eq!(values.len(), self.size);
debug_assert!(
w < self.log_threshold,
"caller must route >= threshold to R(t) directly"
);
if w <= self.floor {
return values[0];
}
let pos = (w - self.floor) / self.step;
let i = (pos.floor() as usize).min(self.size - 2);
let frac = (pos - i as f64).clamp(0.0, 1.0);
values[i] * (1.0 - frac) + values[i + 1] * frac
}
pub(crate) fn nearest_index(&self, w: f64) -> usize {
if w <= self.floor {
return 0;
}
if w >= self.log_threshold {
return self.size - 1;
}
(((w - self.floor) / self.step).round() as usize).min(self.size - 1)
}
}
pub(crate) fn action_grid(size: usize) -> Vec<f64> {
debug_assert!(
size >= 2,
"action_grid_size must be >= 2 (validated by caller)"
);
let lo = ACTION_EPSILON;
let hi = 1.0 - ACTION_EPSILON;
(0..size)
.map(|i| lo + (hi - lo) * i as f64 / (size - 1) as f64)
.collect()
}
fn successor_value(grid: &WealthGrid, next_values: &[f64], w_successor: f64, r_next: f64) -> f64 {
if w_successor >= grid.log_threshold() {
r_next
} else {
grid.interpolate(next_values, w_successor)
}
}
pub(crate) struct MaximizeResult {
pub(crate) policy: Vec<Vec<u32>>,
pub(crate) planned_value: f64,
}
pub(crate) fn maximize(
p0: f64,
p1: f64,
reward: &RewardSchedule,
grid: &WealthGrid,
actions: &[f64],
) -> MaximizeResult {
let horizon = reward.horizon();
let size = grid.size();
let mut next = vec![0.0; size];
let mut policy = vec![Vec::new(); horizon as usize];
let gro_action_index = actions
.iter()
.enumerate()
.min_by(|(_, a), (_, b)| (**a - p1).abs().total_cmp(&(**b - p1).abs()))
.map(|(i, _)| i as u32)
.unwrap_or(0);
for t in (0..horizon).rev() {
let r_next = reward.at(t + 1);
let mut current = vec![0.0; size];
let mut current_policy = vec![0u32; size];
for wi in 0..size {
let w = grid.point(wi);
let seed_action = actions[gro_action_index as usize];
let seed_value = {
let w_success = w + log_phi(seed_action, p0, true);
let w_failure = w + log_phi(seed_action, p0, false);
let v_success = successor_value(grid, &next, w_success, r_next);
let v_failure = successor_value(grid, &next, w_failure, r_next);
p1 * v_success + (1.0 - p1) * v_failure
};
let mut best_value = seed_value;
let mut best_action_index = gro_action_index;
for (ai, &a) in actions.iter().enumerate() {
let w_success = w + log_phi(a, p0, true);
let w_failure = w + log_phi(a, p0, false);
let v_success = successor_value(grid, &next, w_success, r_next);
let v_failure = successor_value(grid, &next, w_failure, r_next);
let value = p1 * v_success + (1.0 - p1) * v_failure;
if value > best_value {
best_value = value;
best_action_index = ai as u32;
}
}
current[wi] = best_value;
current_policy[wi] = best_action_index;
}
policy[t as usize] = current_policy;
next = current;
}
let planned_value = grid.interpolate(&next, 0.0);
MaximizeResult {
policy,
planned_value,
}
}
pub(crate) fn evaluate_fixed_action(
p0: f64,
p1: f64,
reward: &RewardSchedule,
grid: &WealthGrid,
action: f64,
) -> f64 {
let horizon = reward.horizon();
let size = grid.size();
let mut next = vec![0.0; size];
let w_success_delta = log_phi(action, p0, true);
let w_failure_delta = log_phi(action, p0, false);
for t in (0..horizon).rev() {
let r_next = reward.at(t + 1);
let mut current = vec![0.0; size];
for (wi, slot) in current.iter_mut().enumerate() {
let w = grid.point(wi);
let v_success = successor_value(grid, &next, w + w_success_delta, r_next);
let v_failure = successor_value(grid, &next, w + w_failure_delta, r_next);
*slot = p1 * v_success + (1.0 - p1) * v_failure;
}
next = current;
}
grid.interpolate(&next, 0.0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn action_grid_stays_strictly_inside_unit_interval() {
let grid = action_grid(11);
assert_eq!(grid.len(), 11);
assert!(grid[0] > 0.0 && grid[0] < 1.0);
assert!(grid[grid.len() - 1] > 0.0 && grid[grid.len() - 1] < 1.0);
assert!(grid.windows(2).all(|w| w[1] > w[0]));
}
#[test]
fn wealth_grid_interpolation_is_exact_on_grid_points() {
let grid = WealthGrid::new(0.05, 50);
let values: Vec<f64> = (0..grid.size()).map(|i| i as f64 * 2.0).collect();
for i in 0..grid.size() {
let w = grid.point(i);
assert!((grid.interpolate(&values, w) - values[i]).abs() < 1e-9);
}
}
#[test]
fn wealth_grid_interpolation_is_linear_between_points() {
let grid = WealthGrid::new(0.05, 10);
let values: Vec<f64> = (0..grid.size()).map(|i| i as f64).collect();
let midpoint = (grid.point(3) + grid.point(4)) / 2.0;
assert!((grid.interpolate(&values, midpoint) - 3.5).abs() < 1e-9);
}
#[test]
fn wealth_grid_clamps_below_floor() {
let grid = WealthGrid::new(0.05, 10);
let values: Vec<f64> = (0..grid.size()).map(|i| i as f64).collect();
assert_eq!(grid.interpolate(&values, grid.floor - 100.0), values[0]);
}
#[test]
fn evaluate_fixed_action_stays_within_reward_bounds() {
let reward = RewardSchedule::HardDeadline { deadline: 50 };
let grid = WealthGrid::new(0.05, 100);
let value = evaluate_fixed_action(0.5, 0.55, &reward, &grid, 0.55);
assert!((0.0..=1.0).contains(&value));
}
#[test]
fn maximize_planned_value_is_at_least_gro_fixed_action_value() {
let reward = RewardSchedule::HardDeadline { deadline: 50 };
let grid = WealthGrid::new(0.05, 100);
let actions = action_grid(101);
let bellman = maximize(0.5, 0.55, &reward, &grid, &actions);
let gro = evaluate_fixed_action(0.5, 0.55, &reward, &grid, 0.55);
assert!(bellman.planned_value >= gro - 1e-9);
}
#[test]
fn ties_in_a_doomed_state_default_to_the_gro_action_not_the_grid_endpoint() {
let p0 = 0.5;
let p1 = 0.55;
let reward = RewardSchedule::HardDeadline { deadline: 1 };
let grid = WealthGrid::new(0.05, 50);
let actions = action_grid(41);
let result = maximize(p0, p1, &reward, &grid, &actions);
let chosen = actions[result.policy[0][0] as usize];
assert!(
(chosen - p1).abs() < 1e-6,
"chosen={chosen}, expected p1={p1}"
);
}
}