neco-expr 0.2.0

exact expression graphs with certified floating-point approximations
Documentation
use crate::evaluate::{evaluate_reachable, EvaluationRunError};
use crate::float::FloatError;
use crate::{
    Assignments, AtomStore, CertifiedF64, ConsumerId, EvaluationCache, ExprGraph, ExprId,
    IsolationCache, PrecisionRequirements, ResolveError, ResolvedValues, StorageError,
};

#[derive(Debug, Eq, PartialEq)]
pub struct Resolver;

impl Resolver {
    pub const fn new() -> Self {
        Self
    }

    pub fn resolve_all(
        &self,
        graph: &ExprGraph,
        atoms: &AtomStore,
        requirements: &PrecisionRequirements,
        assignments: &Assignments,
    ) -> Result<(EvaluationCache, IsolationCache, ResolvedValues), ResolveError> {
        let mut evaluation = EvaluationCache::new();
        let mut isolation = IsolationCache::new();
        let mut resolved = ResolvedValues::new();

        for &(consumer, bits) in requirements.entries() {
            let result = match assignments.get(consumer) {
                None => Err(ResolveError::MissingAssignment { consumer }),
                Some(expr) if graph.get(expr).is_none() => {
                    Err(ResolveError::UnknownExprId { consumer, expr })
                }
                Some(expr) => resolve_consumer(
                    consumer,
                    expr,
                    bits,
                    graph,
                    atoms,
                    &mut evaluation,
                    &mut isolation,
                )
                .map_err(ResolveError::Storage)?,
            };
            insert_consumer_result(&mut resolved, consumer, result)?;
        }
        Ok((evaluation, isolation, resolved))
    }
}

impl Default for Resolver {
    fn default() -> Self {
        Self::new()
    }
}

fn insert_consumer_result(
    resolved: &mut ResolvedValues,
    consumer: ConsumerId,
    result: Result<CertifiedF64, ResolveError>,
) -> Result<(), ResolveError> {
    resolved
        .insert(consumer, result)
        .map_err(ResolveError::Storage)
}

fn resolve_consumer(
    consumer: ConsumerId,
    expr: ExprId,
    bits: crate::AbsoluteBits,
    graph: &ExprGraph,
    atoms: &AtomStore,
    evaluation: &mut EvaluationCache,
    isolation: &mut IsolationCache,
) -> Result<Result<CertifiedF64, ResolveError>, StorageError> {
    let value = match evaluate_reachable(expr, graph, atoms, evaluation) {
        Ok(value) => value,
        Err(EvaluationRunError::UnknownExpr(expr)) => {
            return Ok(Err(ResolveError::UnknownExprId { consumer, expr }));
        }
        Err(EvaluationRunError::UnknownAtom { expr, atom }) => {
            return Ok(Err(ResolveError::UnknownAtomId { expr, atom }));
        }
        Err(EvaluationRunError::Evaluation(error)) => {
            return Ok(Err(local_evaluation_error(error)));
        }
        Err(EvaluationRunError::Storage(error)) => return Err(error),
    };
    match CertifiedF64::resolve(&value, expr, bits, isolation) {
        Ok(value) => Ok(Ok(value)),
        Err(FloatError::OutOfRange) => Ok(Err(ResolveError::FloatOutOfRange { consumer, expr })),
        Err(FloatError::Bigint(error) | FloatError::EnclosureBigint { error, .. }) => {
            Ok(Err(ResolveError::Bigint(error)))
        }
        Err(FloatError::Algnum(error) | FloatError::EnclosureAlgnum { error, .. }) => {
            Ok(Err(ResolveError::Algnum(error)))
        }
        Err(FloatError::Storage(error)) => Err(error),
    }
}

fn local_evaluation_error(error: crate::EvalError) -> ResolveError {
    ResolveError::Evaluation(error)
}