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}