use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use datumesh_core::{lexical, Arg, Cell, CellRef, FunctionDescriptor, Scalar, Type};
use crate::check::{check_args, check_no_slice};
use crate::engine::{Engine, STORED};
use crate::error::{EngineError, StoreError};
use crate::eval::{Done, Req};
use crate::runtime::{Budget, Pattern, SlicePattern};
use crate::slice::cells_slice;
const MAX_OVERRIDES: usize = 64;
#[derive(Clone, Debug, Default)]
pub struct Overrides {
items: Vec<Override>,
}
#[derive(Clone, Debug)]
enum Override {
Value { cell: CellRef, value: Scalar },
Slice { slice: CellRef, add: Vec<(CellRef, Scalar)>, remove: Vec<CellRef> },
}
impl Overrides {
pub fn new() -> Overrides {
Overrides::default()
}
pub fn value(mut self, cell: CellRef, value: Scalar) -> Overrides {
self.items.push(Override::Value { cell, value });
self
}
pub fn slice(mut self, slice: CellRef, add: Vec<(CellRef, Scalar)>, remove: Vec<CellRef>) -> Overrides {
self.items.push(Override::Slice { slice, add, remove });
self
}
pub fn len(&self) -> usize {
self.items.len()
}
pub fn is_empty(&self) -> bool {
self.items.is_empty()
}
}
#[derive(Clone, Debug)]
pub struct Solve {
vary: CellRef,
target: CellRef,
equals: Scalar,
lo: Scalar,
hi: Scalar,
}
impl Solve {
pub fn new(vary: CellRef, target: CellRef, equals: Scalar, lo: Scalar, hi: Scalar) -> Solve {
Solve { vary, target, equals, lo, hi }
}
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub struct ScenarioAnswer {
pub cell: Cell,
pub ty: Type,
pub value: Scalar,
pub asof: String,
pub overrides: Vec<ScenarioOverride>,
pub solved: Option<(Cell, Scalar)>,
}
#[non_exhaustive]
#[derive(Clone, Debug, PartialEq)]
pub enum ScenarioOverride {
Value {
cell: Cell,
value: Scalar,
},
Slice {
slice: Cell,
add: Vec<(Cell, Scalar)>,
remove: Vec<Cell>,
},
}
impl ScenarioOverride {
pub fn id(&self) -> String {
match self {
ScenarioOverride::Value { cell, .. } => cell.id(),
ScenarioOverride::Slice { slice, .. } => slice.id(),
}
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Scope {
pub(crate) values: HashMap<String, (Cell, Scalar)>,
pub(crate) slices: HashMap<String, SliceOverride>,
pub(crate) affected: HashSet<String>,
}
#[derive(Clone, Debug)]
pub(crate) struct SliceOverride {
pub(crate) add: Vec<(Cell, Scalar)>,
pub(crate) remove: HashSet<String>,
}
impl Scope {
pub(crate) fn with_value(&self, cell: Cell, value: Scalar) -> Scope {
let mut s = self.clone();
s.affected.insert(cell.function_name());
s.values.insert(cell.id(), (cell, value));
s
}
}
impl Engine {
pub fn whatif(
&self,
cell: &CellRef,
asof: Option<&str>,
overrides: &Overrides,
solve: Option<&Solve>,
) -> Result<ScenarioAnswer, EngineError> {
let now = self.clock.now();
let a = asof.or(cell.asof.as_deref()).unwrap_or(&now).to_string();
lexical::check_instant(&a, "$.asof").map_err(EngineError::Invalid)?;
check_no_slice(&cell.args)?;
if overrides.len() > MAX_OVERRIDES {
return Err(EngineError::Override("E_CANON_LIMIT".into()));
}
let Some((fn_hash, desc)) = self.function_as_of(&cell.ns, &cell.fn_name, &a)? else {
return Err(EngineError::NotCovered { fault: None });
};
let target = cell.resolve(&fn_hash).map_err(EngineError::Invalid)?;
check_args(&target, &desc).map_err(EngineError::Invalid)?;
let (scope, list) = self.build_scope(overrides, &a)?;
let scope = Arc::new(scope);
let budget = Budget::with_work(self.fuel, self.work_limit);
let ty = desc.signature.returns.ty;
let (value, solved) = match solve {
None => (self.scope_value(&target, &desc, &a, &now, &scope, &budget)?, None),
Some(s) => self.solve(s, &target, &desc, &a, &now, &scope, &budget)?,
};
Ok(ScenarioAnswer { cell: target, ty, value, asof: a, overrides: list, solved })
}
fn function_as_of(
&self,
ns: &str,
fn_name: &str,
asof: &str,
) -> Result<Option<(String, Arc<FunctionDescriptor>)>, EngineError> {
let name = format!("{ns}/{fn_name}");
let Some(hash) = self.store.resolve_name(&name, asof).map_err(|e| StoreError::new("resolve_name", e))? else {
return Ok(None);
};
Ok(self.descriptor_of(&hash)?.map(|d| (hash, d)))
}
fn resolve_cell(&self, c: &CellRef, asof: &str) -> Result<(Cell, Arc<FunctionDescriptor>), EngineError> {
check_no_slice(&c.args)?;
let Some((hash, desc)) = self.function_as_of(&c.ns, &c.fn_name, asof)? else {
return Err(EngineError::NameUnresolved { fn_name: format!("{}/{}", c.ns, c.fn_name), asof: asof.into() });
};
let cell = c.resolve(&hash).map_err(EngineError::Invalid)?;
check_args(&cell, &desc).map_err(EngineError::Invalid)?;
Ok((cell, desc))
}
fn build_scope(&self, overrides: &Overrides, asof: &str) -> Result<(Scope, Vec<ScenarioOverride>), EngineError> {
let refused = |code: &str| EngineError::Override(code.to_string());
let mut scope = Scope::default();
let mut list = Vec::new();
for o in &overrides.items {
match o {
Override::Value { cell, value } => {
let (c, desc) = self.resolve_cell(cell, asof)?;
if value.ty() != desc.signature.returns.ty {
return Err(refused("E_CANON_TYPE"));
}
let id = c.id();
if scope.values.contains_key(&id) {
return Err(refused("E_CANON_ARG_DUPLICATE"));
}
scope.affected.insert(c.function_name());
scope.values.insert(id, (c.clone(), value.clone()));
list.push(ScenarioOverride::Value { cell: c, value: value.clone() });
}
Override::Slice { slice, add, remove } => {
let Some((hash, desc)) = self.function_as_of(&slice.ns, &slice.fn_name, asof)? else {
return Err(EngineError::NameUnresolved {
fn_name: format!("{}/{}", slice.ns, slice.fn_name),
asof: asof.into(),
});
};
let fn_name = format!("{}/{}", slice.ns, slice.fn_name);
if desc.lang != STORED {
return Err(refused("E_SLICE_MEMBER"));
}
let pattern: SlicePattern = slice
.args
.iter()
.map(|(k, a)| {
let p = match a {
Arg::Value(v) => Pattern::Value(v.clone()),
Arg::Slice => Pattern::Open,
};
(k.clone(), p)
})
.collect();
let s = cells_slice(&fn_name, &hash, &desc, &pattern).map_err(EngineError::Invalid)?;
let sid = s.id().to_string();
if scope.slices.contains_key(&sid) {
return Err(refused("E_CANON_ARG_DUPLICATE"));
}
let slice_cell = slice.resolve(&hash).map_err(EngineError::Invalid)?;
let mut adds: Vec<(Cell, Scalar)> = Vec::with_capacity(add.len());
for (c, v) in add {
let cell = c.resolve(&hash).map_err(EngineError::Invalid)?;
check_args(&cell, &desc).map_err(EngineError::Invalid)?;
if cell.function_name() != fn_name {
return Err(refused("E_SLICE_MEMBER"));
}
adds.push((cell, v.clone()));
}
let mut removes: Vec<Cell> = Vec::with_capacity(remove.len());
for c in remove {
let cell = c.resolve(&hash).map_err(EngineError::Invalid)?;
check_args(&cell, &desc).map_err(EngineError::Invalid)?;
if cell.function_name() != fn_name {
return Err(refused("E_SLICE_MEMBER"));
}
removes.push(cell);
}
let mut add_ids = HashSet::new();
for (c, _) in &adds {
if !add_ids.insert(c.id()) {
return Err(refused("E_CANON_ARG_DUPLICATE"));
}
}
let mut remove_ids = HashSet::new();
for c in &removes {
if !remove_ids.insert(c.id()) {
return Err(refused("E_CANON_ARG_DUPLICATE"));
}
}
if adds.iter().any(|(c, _)| remove_ids.contains(&c.id())) {
return Err(refused("E_SLICE_MEMBER"));
}
let members: HashSet<String> = self
.store
.slice_values(&s, asof)
.map_err(|e| StoreError::new("slice_values", e))?
.into_iter()
.map(|v| v.version.cell_id)
.collect();
for c in &removes {
if !matches(&pattern, c) || !members.contains(&c.id()) {
return Err(refused("E_SLICE_MEMBER"));
}
}
for (c, v) in &adds {
if !matches(&pattern, c) || members.contains(&c.id()) {
return Err(refused("E_SLICE_MEMBER"));
}
if v.ty() != desc.signature.returns.ty {
return Err(refused("E_CANON_TYPE"));
}
scope.values.insert(c.id(), (c.clone(), v.clone()));
}
scope.affected.insert(fn_name);
scope.slices.insert(sid, SliceOverride { add: adds.clone(), remove: remove_ids });
let mut add_sorted = adds;
add_sorted.sort_by_key(|(c, _)| c.id());
removes.sort_by_key(|c| c.id());
list.push(ScenarioOverride::Slice { slice: slice_cell, add: add_sorted, remove: removes });
}
}
}
list.sort_by_key(|o| o.id());
Ok((scope, list))
}
fn scope_value(
&self,
target: &Cell,
desc: &Arc<FunctionDescriptor>,
asof: &str,
now: &str,
scope: &Arc<Scope>,
budget: &Budget,
) -> Result<Scalar, EngineError> {
if let Some((_, v)) = scope.values.get(&target.id()) {
return Ok(v.clone());
}
let mut req = Req::scoped(self, asof, now, scope.clone(), budget);
match req.scope_run(target.clone(), desc.clone())? {
Done::Value(a) => Ok(a.value.clone()),
Done::Fault(f) => Err(EngineError::NotCovered { fault: Some(f.fault) }),
Done::NotCovered | Done::Unsigned(..) => Err(EngineError::NotCovered { fault: None }),
}
}
#[allow(clippy::too_many_arguments)]
fn solve(
&self,
s: &Solve,
target: &Cell,
desc: &Arc<FunctionDescriptor>,
asof: &str,
now: &str,
scope: &Arc<Scope>,
budget: &Budget,
) -> Result<(Scalar, Option<(Cell, Scalar)>), EngineError> {
let (vary, vary_desc) = self.resolve_cell(&s.vary, asof)?;
let (solve_target, solve_desc) = self.resolve_cell(&s.target, asof)?;
let number = Type::Number;
if vary_desc.signature.returns.ty != number
|| solve_desc.signature.returns.ty != number
|| [&s.equals, &s.lo, &s.hi].iter().any(|x| x.ty() != number)
{
return Err(EngineError::Override("E_CANON_TYPE".into()));
}
let result = (|| {
let num = |x: &Scalar| -> f64 { x.lexical().parse().unwrap_or(f64::NAN) };
let (eq, lo, hi) = (num(&s.equals), num(&s.lo), num(&s.hi));
if lo > hi {
return Err(EngineError::WhatifNoSolution);
}
let trial = |x: f64| -> Result<(Scalar, Arc<Scope>), EngineError> {
let text = decimal15(x).ok_or(EngineError::WhatifNoSolution)?;
let value = Scalar::from_lexical(number, &text).map_err(|_| EngineError::WhatifNoSolution)?;
Ok((value.clone(), Arc::new(scope.with_value(vary.clone(), value))))
};
let f = |x: f64| -> Result<f64, EngineError> {
let (_, sc) = trial(x)?;
let v = self.scope_value(&solve_target, &solve_desc, asof, now, &sc, budget)?;
Ok(num(&v) - eq)
};
let flo = f(lo)?;
let x = if flo == 0.0 {
lo
} else {
let fhi = f(hi)?;
if fhi == 0.0 {
hi
} else {
if (flo < 0.0) == (fhi < 0.0) {
return Err(EngineError::WhatifNoSolution);
}
let (mut a, mut fa, mut b, mut fb) = (lo, flo, hi, fhi);
loop {
let mid = a + (b - a) / 2.0;
if mid <= a || mid >= b {
break if fa.abs() <= fb.abs() { a } else { b };
}
let fm = f(mid)?;
if fm.abs() <= 1e-12 * eq.abs().max(1.0)
|| (b - a).abs() <= 1e-12 * a.abs().max(b.abs()).max(1.0)
{
break mid;
}
if (fm < 0.0) == (fa < 0.0) {
a = mid;
fa = fm;
} else {
b = mid;
fb = fm;
}
}
}
};
let (value, sc) = trial(x)?;
let v = self.scope_value(target, desc, asof, now, &sc, budget)?;
Ok((v, Some((vary.clone(), value))))
})();
match result {
Err(EngineError::BudgetExceeded { .. } | EngineError::WorkExceeded { .. }) => {
Err(EngineError::WhatifNoSolution)
}
other => other,
}
}
}
pub(crate) fn scoped_hash(id: &str, value: &Scalar) -> String {
datumesh_core::sha256_hex(format!("scenario {id} {} {}", value.ty().as_str(), value.lexical()).as_bytes())
}
fn matches(pattern: &SlicePattern, cell: &Cell) -> bool {
pattern.iter().all(|(k, p)| match (cell.args.get(k), p) {
(Some(Arg::Value(v)), Pattern::Value(pv)) => v == pv,
(Some(Arg::Value(_)), Pattern::Open) => true,
_ => false,
})
}
fn decimal15(x: f64) -> Option<String> {
if !x.is_finite() {
return None;
}
if x == 0.0 {
return Some("0".into());
}
let text = format!("{:.14e}", x.abs());
let (mantissa, exp) = text.split_once('e')?;
let exp: i64 = exp.parse().ok()?;
let digits: String = mantissa.chars().filter(char::is_ascii_digit).collect();
let digits = digits.trim_end_matches('0');
let mut out = String::new();
if x < 0.0 {
out.push('-');
}
if exp >= 0 {
let int_len = usize::try_from(exp).ok()? + 1;
if digits.len() <= int_len {
out.push_str(digits);
out.extend(std::iter::repeat_n('0', int_len - digits.len()));
} else {
out.push_str(&digits[..int_len]);
out.push('.');
out.push_str(&digits[int_len..]);
}
} else {
out.push_str("0.");
out.extend(std::iter::repeat_n('0', usize::try_from(-exp - 1).ok()?));
out.push_str(digits);
}
(out.len() <= 128).then_some(out)
}
#[cfg(test)]
mod tests {
use super::decimal15;
#[test]
fn decimals_are_canonical() {
assert_eq!(decimal15(3.0).as_deref(), Some("3"));
assert_eq!(decimal15(-0.5).as_deref(), Some("-0.5"));
assert_eq!(decimal15(0.0).as_deref(), Some("0"));
assert_eq!(decimal15(1e-5).as_deref(), Some("0.00001"));
assert_eq!(decimal15(120.0).as_deref(), Some("120"));
assert_eq!(decimal15(2f64.sqrt()).as_deref(), Some("1.4142135623731"));
}
}