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