Skip to main content

neco_expr/
resolve.rs

1use crate::evaluate::{evaluate_reachable, EvaluationRunError};
2use crate::float::FloatError;
3use crate::{
4    Assignments, AtomStore, CertifiedF64, ConsumerId, EvaluationCache, ExprGraph, ExprId,
5    IsolationCache, PrecisionRequirements, ResolveError, ResolvedValues, StorageError,
6};
7
8#[derive(Debug, Eq, PartialEq)]
9pub struct Resolver;
10
11#[allow(clippy::new_without_default)]
12impl Resolver {
13    pub const fn new() -> Self {
14        Self
15    }
16
17    pub fn resolve_all(
18        &self,
19        graph: &ExprGraph,
20        atoms: &AtomStore,
21        requirements: &PrecisionRequirements,
22        assignments: &Assignments,
23    ) -> Result<(EvaluationCache, IsolationCache, ResolvedValues), ResolveError> {
24        let mut evaluation = EvaluationCache::new();
25        let mut isolation = IsolationCache::new();
26        let mut resolved = ResolvedValues::new();
27
28        for &(consumer, bits) in requirements.entries() {
29            let result = match assignments.get(consumer) {
30                None => Err(ResolveError::MissingAssignment { consumer }),
31                Some(expr) if graph.get(expr).is_none() => {
32                    Err(ResolveError::UnknownExprId { consumer, expr })
33                }
34                Some(expr) => resolve_consumer(
35                    consumer,
36                    expr,
37                    bits,
38                    graph,
39                    atoms,
40                    &mut evaluation,
41                    &mut isolation,
42                )
43                .map_err(ResolveError::Storage)?,
44            };
45            insert_consumer_result(&mut resolved, consumer, result)?;
46        }
47        Ok((evaluation, isolation, resolved))
48    }
49}
50
51fn insert_consumer_result(
52    resolved: &mut ResolvedValues,
53    consumer: ConsumerId,
54    result: Result<CertifiedF64, ResolveError>,
55) -> Result<(), ResolveError> {
56    resolved
57        .insert(consumer, result)
58        .map_err(ResolveError::Storage)
59}
60
61#[allow(clippy::too_many_arguments)]
62fn resolve_consumer(
63    consumer: ConsumerId,
64    expr: ExprId,
65    bits: crate::AbsoluteBits,
66    graph: &ExprGraph,
67    atoms: &AtomStore,
68    evaluation: &mut EvaluationCache,
69    isolation: &mut IsolationCache,
70) -> Result<Result<CertifiedF64, ResolveError>, StorageError> {
71    let value = match evaluate_reachable(expr, graph, atoms, evaluation) {
72        Ok(value) => value,
73        Err(EvaluationRunError::UnknownExpr(expr)) => {
74            return Ok(Err(ResolveError::UnknownExprId { consumer, expr }));
75        }
76        Err(EvaluationRunError::UnknownAtom { expr, atom }) => {
77            return Ok(Err(ResolveError::UnknownAtomId { expr, atom }));
78        }
79        Err(EvaluationRunError::Evaluation(error)) => {
80            return Ok(Err(local_evaluation_error(error)));
81        }
82        Err(EvaluationRunError::Storage(error)) => return Err(error),
83    };
84    match CertifiedF64::resolve(&value, expr, bits, isolation) {
85        Ok(value) => Ok(Ok(value)),
86        Err(FloatError::OutOfRange) => Ok(Err(ResolveError::FloatOutOfRange { consumer, expr })),
87        Err(FloatError::Bigint(error)) => Ok(Err(ResolveError::Bigint(error))),
88        Err(FloatError::Algnum(error)) => Ok(Err(ResolveError::Algnum(error))),
89        Err(FloatError::Storage(error)) => Err(error),
90    }
91}
92
93fn local_evaluation_error(error: crate::EvalError) -> ResolveError {
94    ResolveError::Evaluation(error)
95}