simple_equation_inversion 1.0.1

A Rust library for solving linear equations and invertible function chains.
Documentation
use alloc::string::String;
use core::fmt;

#[derive(Clone, Debug, PartialEq)]
pub enum Error {
    NoUnknown,
    SeveralUnknown,
    DivisionByZero,
    SquareForbidden,
    UnknownInDenominator,
    TransformError {
        transform: String,
        stage: String,
        value: f64,
        message: String,
    },
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Error::NoUnknown => write!(f, "No unknown variable found in equation"),
            Error::SeveralUnknown => {
                write!(f, "Multiple unknown variables found (only 1 supported)")
            }
            Error::DivisionByZero => write!(f, "Division by zero"),
            Error::SquareForbidden => write!(
                f,
                "Non-linear multiplication (quadratic term x^2 forbidden)"
            ),
            Error::UnknownInDenominator => {
                write!(f, "Unknown variable in denominator is forbidden")
            }
            Error::TransformError {
                transform,
                stage,
                value,
                message,
            } => {
                write!(
                    f,
                    "Transform '{transform}' failed during {stage} on value {value}: {message}"
                )
            }
        }
    }
}

impl core::error::Error for Error {}

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

    #[test]
    fn test_error_display_formatting() {
        assert_eq!(
            format!("{}", Error::NoUnknown),
            "No unknown variable found in equation"
        );
        assert_eq!(
            format!("{}", Error::SeveralUnknown),
            "Multiple unknown variables found (only 1 supported)"
        );
        assert_eq!(format!("{}", Error::DivisionByZero), "Division by zero");
        assert_eq!(
            format!("{}", Error::SquareForbidden),
            "Non-linear multiplication (quadratic term x^2 forbidden)"
        );
        assert_eq!(
            format!("{}", Error::UnknownInDenominator),
            "Unknown variable in denominator is forbidden"
        );
        let transform_err = Error::TransformError {
            transform: "my_fn".to_string(),
            stage: "inverse".to_string(),
            value: 42.0,
            message: "domain error".to_string(),
        };
        assert_eq!(
            format!("{transform_err}"),
            "Transform 'my_fn' failed during inverse on value 42: domain error"
        );
    }
}