simple_equation_inversion 1.0.1

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

use crate::error::Error;

#[derive(Clone, Debug, PartialEq)]
pub struct Unknown {
    pub status: Rc<RefCell<Result<(), Error>>>,
    pub unknown: Rc<RefCell<f64>>,
}

impl Unknown {
    pub(crate) fn new() -> Self {
        Unknown {
            status: Rc::new(RefCell::new(Ok(()))),
            unknown: Rc::new(RefCell::new(0.)),
        }
    }

    pub(crate) fn new_with_value(unknown: Rc<RefCell<f64>>) -> Self {
        Unknown {
            status: Rc::new(RefCell::new(Ok(()))),
            unknown,
        }
    }

    pub fn get_status(&self) -> Result<(), Error> {
        self.status.borrow().clone()
    }

    pub fn set_status(&self, status: Result<(), Error>) {
        let current = self.status.borrow().clone();
        *self.status.borrow_mut() = current.and(status);
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[allow(unused_imports)]
    use alloc::format;
    #[allow(unused_imports)]
    use alloc::string::ToString;

    #[test]
    fn test_unknown_default_initialization() {
        let u = Unknown::new();
        assert_eq!(u.get_status(), Ok(()));
        assert_eq!(*u.unknown.borrow(), 0.0);
    }

    #[test]
    fn test_unknown_new_with_value() {
        let cell = Rc::new(RefCell::new(12.5));
        let u = Unknown::new_with_value(cell.clone());
        assert_eq!(u.get_status(), Ok(()));
        assert_eq!(*u.unknown.borrow(), 12.5);

        // Mutating cell directly reflects in Unknown
        *cell.borrow_mut() = 99.0;
        assert_eq!(*u.unknown.borrow(), 99.0);
    }

    #[test]
    fn test_unknown_shared_cell_mutation() {
        let u1 = Unknown::new();
        let u2 = u1.clone();

        *u1.unknown.borrow_mut() = 42.0;
        assert_eq!(*u2.unknown.borrow(), 42.0);

        u2.set_status(Err(Error::DivisionByZero));
        assert_eq!(u1.get_status(), Err(Error::DivisionByZero));
    }

    #[test]
    fn test_unknown_error_latching_ok_does_not_clear() {
        let u = Unknown::new();
        assert_eq!(u.get_status(), Ok(()));

        // Set an error
        u.set_status(Err(Error::DivisionByZero));
        assert_eq!(u.get_status(), Err(Error::DivisionByZero));

        // Subsequent Ok(()) must NOT clear the existing error
        u.set_status(Ok(()));
        assert_eq!(u.get_status(), Err(Error::DivisionByZero));
    }

    #[test]
    fn test_unknown_error_latching_first_error_kept() {
        let u = Unknown::new();

        u.set_status(Err(Error::SquareForbidden));
        assert_eq!(u.get_status(), Err(Error::SquareForbidden));

        // Subsequent error must NOT overwrite the first error encountered
        u.set_status(Err(Error::UnknownInDenominator));
        assert_eq!(u.get_status(), Err(Error::SquareForbidden));
    }

    #[test]
    fn test_unknown_partial_eq() {
        let cell1 = Rc::new(RefCell::new(5.0));
        let cell2 = Rc::new(RefCell::new(5.0));
        let cell3 = Rc::new(RefCell::new(6.0));

        let u1 = Unknown::new_with_value(cell1);
        let u2 = Unknown::new_with_value(cell2);
        let u3 = Unknown::new_with_value(cell3);

        assert_eq!(u1, u2);
        assert_ne!(u1, u3);

        u1.set_status(Err(Error::NoUnknown));
        assert_ne!(u1, u2);
    }
}