Add support for parsing and analysing negative values

README.md

@@ -37,7 +37,7 @@ round_up: true
 less_than_one: ["a * b"] # optional
 greater_than_one: ["c"] # optional
 ```
-- `formula` contains the formula to be analyze
+- `formula` contains the formula to be analyze. All the numeric literals and identifiers are parsed as positive values, use the `-` sign to include negative values in the formula. The negative sign of the base in the exponential operations are ignored.
 - `round_up` determines if the result of the formula should round up or down
 - `less_than_one` is used for the `**` [rules](#rules) *(raw string comparison and sensible to space)*
 - `greater_than_one` is used for the `**` [rules](#rules) *(raw string comparison and sensible to space)*

src/analyzer.rs

@@ -1,4 +1,5 @@
 mod analyze_rounding;
+mod simplify_expr;
 pub mod ast;
 
 use crate::parser::arithmetic;
@@ -13,7 +14,148 @@ pub fn analyze(formula_config: &mut FormulaConfig) -> anyhow::Result<Box<Expr>>
         anyhow::anyhow!("Error occured while parsing the formula {}: {}", formula, e)
     })?;
 
-    analyze_rounding::analyze(&ast, formula_config.round_up, formula_config)?;
+    println!("parsed    : {ast}");
+    let simplified_ast = simplify_expr::simplify_sign(ast);
+    println!("simplified: {simplified_ast}");
 
-    Ok(ast)
+    analyze_rounding::analyze(&simplified_ast, formula_config.round_up, formula_config)?;
+
+    Ok(simplified_ast)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_mul_up() {
+        let mut formula_config = FormulaConfig::new(
+            "a * b".to_string(),
+            true,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a *↑ b)");
+    }
+
+    #[test]
+    fn test_mul_down() {
+        let mut formula_config = FormulaConfig::new(
+            "a * b".to_string(),
+            false,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a *↓ b)");
+    }
+
+    #[test]
+    fn test_div_up() {
+        let mut formula_config = FormulaConfig::new(
+            "a / b".to_string(),
+            true,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a /↑ b)");
+    }
+
+    #[test]
+    fn test_div_down() {
+        let mut formula_config = FormulaConfig::new(
+            "a / b".to_string(),
+            false,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a /↓ b)");
+    }
+
+    #[test]
+    fn test_pow_greater_than_one_up() {
+        let mut formula_config = FormulaConfig::new(
+            "a ** (b * c)".to_string(),
+            true,
+            None,
+            Some(vec!["a".to_string()])
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a ** (b *↑ c))");
+    }
+
+    #[test]
+    fn test_pow_less_than_one_up() {
+        let mut formula_config = FormulaConfig::new(
+            "a ** (b * c)".to_string(),
+            true,
+            Some(vec!["a".to_string()]),
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a ** (b *↓ c))");
+    }
+
+    #[test]
+    fn test_pow_greater_than_one_down() {
+        let mut formula_config = FormulaConfig::new(
+            "a ** (b * c)".to_string(),
+            false,
+            None,
+            Some(vec!["a".to_string()])
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a ** (b *↓ c))");
+    }
+
+    #[test]
+    fn test_pow_less_than_one_down() {
+        let mut formula_config = FormulaConfig::new(
+            "a ** (b * c)".to_string(),
+            false,
+            Some(vec!["a".to_string()]),
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(a ** (b *↑ c))");
+    }
+
+    #[test]
+    fn test_negative() {
+        let mut formula_config = FormulaConfig::new(
+            "-(-(-a * b)) + c".to_string(),
+            true,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(c - (a *↓ b))");
+    }
+
+    #[test]
+    fn test_double_negative() {
+        let mut formula_config = FormulaConfig::new(
+            "-(-(a * b)) + c".to_string(),
+            true,
+            None,
+            None
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "((a *↑ b) + c)");
+    }
+
+    #[test]
+    fn test_negative_exponent() {
+        let mut formula_config = FormulaConfig::new(
+            "a ** (-b * c)".to_string(),
+            true,
+            None,
+            Some(vec!["a".to_string()])
+        );
+        let ast = analyze(&mut formula_config).unwrap().to_string();
+        assert_eq!(ast, "(1 /↑ (a ** (b *↓ c)))");
+    }
+}

src/analyzer/analyze_rounding.rs

@@ -76,20 +76,10 @@ fn handle_pow(
 /// # Returns
 ///
 /// This function returns a `Result` object with an empty Ok value if the operation is successful.
-///
-/// # Example
-///
-/// ```
-/// use analyze_rounding::visit;
-/// use FormulaConfig;
-///
-/// let expr = Expr::Number(5);
-/// let formula_config = FormulaConfig::new();
-/// visit(&expr, true, &formula_config);
-/// ```
 fn visit(expr: &Expr, rounding_direction: bool, formula_config: &mut FormulaConfig) -> Result<()> {
     match expr {
         Expr::Number(_) | Expr::Id(_) | Expr::Error => (),
+        Expr::Negative(nexpr) => visit(nexpr, !rounding_direction, formula_config)?,
         Expr::Op(left, op, right) => {
             let (left_rounding, right_rounding) = match op {
                 Opcode::Add => (rounding_direction, rounding_direction),

src/analyzer/ast.rs

@@ -7,9 +7,11 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub enum Expr {
     /// A numeric literal.
-    Number(i32),
+    Number(u32),
     /// An identifier.
     Id(String),
+    /// An identifier for a negative number
+    Negative(Box<Expr>),
     /// An operation with two operands.
     Op(Box<Expr>, Opcode, Box<Expr>),
     /// An error expression.
@@ -63,6 +65,7 @@ impl Display for Expr {
         match &self {
             Expr::Number(n) => write!(fmt, "{n}"),
             Expr::Id(ref n) => write!(fmt, "{n}"),
+            Expr::Negative(ref n) => write!(fmt, "(-{n})"),
             Expr::Op(ref l, op, ref r) => write!(fmt, "({l} {op} {r})"),
             Expr::Error => write!(fmt, "error"),
         }

src/analyzer/simplify_expr.rs

@@ -0,0 +1,111 @@
+use std::cell::RefCell;
+
+use super::ast::{Expr, Opcode, Rounding};
+
+fn is_negative_value(expr: Box<Expr>) -> (bool, Box<Expr>) {
+    match *expr {
+        Expr::Negative(ne) => match *ne {
+            Expr::Negative(internal) => is_negative_value(internal),
+            _ => (true, ne),
+        }
+        // Need to handle this case separately because in case of nested negatives the 
+        // inner most operation will not be simplified
+        Expr::Op(l, o, r) => {
+            let simplified_internal_expr = simplify_sign(Box::new(Expr::Op(l, o, r)));
+
+            match *simplified_internal_expr {
+                Expr::Negative(ne) => (true, ne),
+                _ => (false, simplified_internal_expr),
+            }
+        },
+        _ => (false, expr),
+    }
+}
+
+fn simplify_add(lnv: (bool, Box<Expr>), rnv: (bool, Box<Expr>)) -> Box<Expr> {
+    let expr = match (lnv.0, rnv.0) {
+        (true, false) => Expr::Op(rnv.1, Opcode::Sub, lnv.1),
+        (true, true) => Expr::Negative(Box::new(Expr::Op(lnv.1, Opcode::Add, rnv.1))),
+        (false, true) => Expr::Op(lnv.1, Opcode::Sub, rnv.1),
+        (false, false) => Expr::Op(lnv.1, Opcode::Add, rnv.1),
+    };
+
+    Box::new(expr)
+}
+
+fn simplify_sub(lnv: (bool, Box<Expr>), rnv: (bool, Box<Expr>)) -> Box<Expr> {
+    let expr = match (lnv.0, rnv.0) {
+        (true, false) => Expr::Negative(Box::new(Expr::Op(lnv.1, Opcode::Add, rnv.1))),
+        (true, true) => Expr::Op(rnv.1, Opcode::Sub, lnv.1),
+        (false, true) => Expr::Op(lnv.1, Opcode::Add, rnv.1),
+        (false, false) => Expr::Op(lnv.1, Opcode::Sub, rnv.1),
+    };
+
+    Box::new(expr)
+}
+
+fn simplify_mul(lnv: (bool, Box<Expr>), rnv: (bool, Box<Expr>), r: RefCell<Rounding>) -> Box<Expr> {
+    let expr = if lnv.0 ^ rnv.0 {
+        Expr::Negative(Box::new(Expr::Op(lnv.1, Opcode::Mul(RefCell::new(Rounding::Init)), rnv.1)))
+    } else {
+        Expr::Op(lnv.1, Opcode::Mul(r), rnv.1)
+    };
+
+    Box::new(expr)
+}
+
+fn simplify_div(lnv: (bool, Box<Expr>), rnv: (bool, Box<Expr>), r: RefCell<Rounding>) -> Box<Expr> {
+    let expr = if lnv.0 ^ rnv.0 {
+        Expr::Negative(Box::new(Expr::Op(lnv.1, Opcode::Div(RefCell::new(Rounding::Init)), rnv.1)))
+    } else {
+        Expr::Op(lnv.1, Opcode::Div(r), rnv.1)
+    };
+
+    Box::new(expr)
+}
+
+fn simplify_pow(lnv: (bool, Box<Expr>), rnv: (bool, Box<Expr>)) -> Box<Expr> {
+    let expr = if rnv.0 {
+        Expr::Op(
+            Box::new(Expr::Number(1)), 
+            Opcode::Div(RefCell::new(Rounding::Init)), 
+            Box::new(Expr::Op(lnv.1, Opcode::Pow, rnv.1))
+        )
+    } else {
+        Expr::Op(lnv.1, Opcode::Pow, rnv.1)
+    };
+
+    Box::new(expr)
+}
+
+/// Simplifies the signs to bring the negative sign from values to the operations
+/// and finally bring it out to the expression level if possible
+/// It also reagganges the addition and substration formula to make them look better
+/// with the sign. For example (-a + b) will be re-arranged to (b - a)
+pub fn simplify_sign(expr: Box<Expr>) -> Box<Expr> {
+    match *expr {
+        Expr::Op(left, op, right) => {
+            let simplified_left = match *left {
+                Expr::Op(..) => simplify_sign(left),
+                _ => left
+            };
+
+            let simplified_right = match *right {
+                Expr::Op(..) => simplify_sign(right),
+                _ => right
+            };
+
+            let lnv = is_negative_value(simplified_left);
+            let rnv = is_negative_value(simplified_right);
+
+            match op {
+                Opcode::Add => simplify_add(lnv, rnv),
+                Opcode::Sub => simplify_sub(lnv, rnv),
+                Opcode::Mul(r) => simplify_mul(lnv, rnv, r),
+                Opcode::Div(r) => simplify_div(lnv, rnv, r),
+                Opcode::Pow => simplify_pow(lnv, rnv),
+            }
+        },
+        _ => expr
+    }
+}

src/parser/arithmetic.lalrpop

@@ -6,15 +6,15 @@ use lalrpop_util::ParseError;
 
 grammar;
 
-Tier<Op,NextTier>: Box<Expr> = {
-    Tier<Op,NextTier> Op NextTier => Box::new(Expr::Op(<>)),
+Tier<Op, NextTier>: Box<Expr> = {
+    Tier<Op, NextTier> Op NextTier => Box::new(Expr::Op(<>)),
     NextTier
 };
 
 pub Expr = Tier<ExprOp, Factor>;
 Factor = Tier<FactorOp, Term>;
 
-ExprOp: Opcode = { // (3)
+ExprOp: Opcode = {
     "+" => Opcode::Add,
     "-" => Opcode::Sub,
 };
@@ -27,12 +27,17 @@ FactorOp: Opcode = {
 
 Term: Box<Expr> = {
     Num => Box::new(Expr::Number(<>)),
+    "-" <Num> => Box::new(Expr::Negative(Box::new(Expr::Number(<>)))),
+
     Id =>  Box::new(Expr::Id(<>)),
+    "-" <Id> => Box::new(Expr::Negative(Box::new(Expr::Id(<>)))),
+
+    "-(" <Expr> ")" => Box::new(Expr::Negative(<>)),
     "(" <Expr> ")"
 };
 
-Num: i32 = {
-    r"[0-9]+" =>? i32::from_str(<>)
+Num: u32 = {
+    r"[0-9]+" =>? u32::from_str(<>)
         .map_err(|_| ParseError::User {
             error: "number is too big"
         })

src/parser/formula_config.rs

@@ -27,6 +27,12 @@ impl Default for FormulaConfig {
     }
 }
 
+impl FormulaConfig {
+    pub fn new(formula: String, round_up: bool, less_than_one: Option<Vec<String>>, greater_than_one: Option<Vec<String>>) -> FormulaConfig {
+        FormulaConfig { formula, round_up, less_than_one, greater_than_one }
+    }
+}
+
 impl FormulaConfig {
     // Add a value to the `less_than_one` list
     pub fn add_less_than_one(&mut self, value: String) {

src/parser/input.rs

@@ -89,7 +89,7 @@ fn find_less_greater_than_one(expr: &Expr, formula_config: &mut FormulaConfig) {
 
 fn visit(expr: &Expr, formula_config: &mut FormulaConfig) {
     match expr {
-        Expr::Number(_) | Expr::Id(_) | Expr::Error => (),
+        Expr::Number(_) | Expr::Id(_) | Expr::Negative(_) | Expr::Error => (),
         Expr::Op(left, op, right) => {
             if let Opcode::Pow = op {
                 // We ignore if the following fail

src/printer/latex_generator.rs

@@ -25,6 +25,7 @@ fn visit(expr: &Expr) -> String {
     match expr {
         Expr::Number(n) => n.to_string(),
         Expr::Id(n) => n.to_string(),
+        Expr::Negative(e) => format!("(-{e})"),
         Expr::Op(left, op, right) => {
             let left_str = visit(left);
             let right_str = visit(right);