simple_equation_inversion 1.0.1

A Rust library for solving linear equations and invertible function chains.
Documentation
use alloc::boxed::Box;
use alloc::rc::Rc;
use core::fmt;

use crate::element::Element;
use crate::unknown::Unknown;

/// The internal representation of an element in an equation tree.
#[derive(Clone)]
pub enum ElementKind {
    /// A known numerical constant value.
    Known(f64),

    /// An unknown variable with an affine scale and offset: `factor * x + offset`.
    Variable {
        factor: f64,
        unknown: Unknown,
        offset: f64,
    },

    /// A transformation applied to an element: `factor * transform(inner) + offset`.
    Transformed {
        factor: f64,
        transform: Rc<dyn crate::transform::Transform>,
        inner: Box<Element>,
        offset: f64,
    },
}

impl fmt::Debug for ElementKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Known(val) => write!(f, "Known({val})"),
            Self::Variable {
                factor,
                unknown,
                offset,
            } => f
                .debug_struct("Variable")
                .field("factor", factor)
                .field("status", &unknown.get_status())
                .field("offset", offset)
                .finish(),
            Self::Transformed {
                factor,
                transform,
                inner,
                offset,
            } => f
                .debug_struct("Transformed")
                .field("factor", factor)
                .field("transform", &transform.name())
                .field("inner", inner)
                .field("offset", offset)
                .finish(),
        }
    }
}