Merge pull request #1 from 0xb-s/add-equation-solver

Add equation solver

Cargo.toml

@@ -10,3 +10,5 @@ edition = "2021"
 
 [[example]]
 name = "foo"
+[[example]]
+name = "bar"

examples/bar.rs

@@ -0,0 +1,21 @@
+use math::solver::solve_equation;
+
+fn main() {
+    let equations = vec![
+        "2x + 3 = 7",
+        "x/0 = 5",
+        "x^2 - 4 = 0",
+        "x^3 - 1 = 0",
+        "5 = 5",
+        "3 = 7",
+        "x^4 + 1 = 0",
+    ];
+
+    for equation_str in equations {
+        println!("\nSolving Equation: {}", equation_str);
+        match solve_equation(equation_str) {
+            Ok(solution) => println!("Solution: {}", solution),
+            Err(e) => println!("Error: {}", e),
+        }
+    }
+}

src/ast.rs

@@ -1,11 +1,46 @@
 // src/ast.rs
-
-#[derive(Debug, Clone)]
+use std::fmt;
+use std::ops::Div;
+#[derive(Debug, Clone, PartialEq)]
 pub enum Expr {
     Number(f64),
     Variable(String),
     Add(Box<Expr>, Box<Expr>),
     Sub(Box<Expr>, Box<Expr>),
     Mul(Box<Expr>, Box<Expr>),
     Div(Box<Expr>, Box<Expr>),
+    Pow(Box<Expr>, Box<Expr>),
+    Undefined,
+}
+
+impl Div for Expr {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        match (self, rhs) {
+            (Expr::Mul(ll, lr), Expr::Mul(rl, rr)) if *ll == *rl => Expr::Div(lr, rr),
+
+            (l, r) => Expr::Div(Box::new(l), Box::new(r)),
+        }
+    }
+}
+impl fmt::Display for Expr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Expr::Number(n) => {
+                if n.fract() == 0.0 {
+                    write!(f, "{}", n.round())
+                } else {
+                    write!(f, "{}", n)
+                }
+            }
+            Expr::Variable(var) => write!(f, "{}", var),
+            Expr::Add(lhs, rhs) => write!(f, "({} + {})", lhs, rhs),
+            Expr::Sub(lhs, rhs) => write!(f, "({} - {})", lhs, rhs),
+            Expr::Mul(lhs, rhs) => write!(f, "({} * {})", lhs, rhs),
+            Expr::Div(lhs, rhs) => write!(f, "({} / {})", lhs, rhs),
+            Expr::Undefined => write!(f, "undefined"),
+            Expr::Pow(_, _) => todo!(),
+        }
+    }
 }

src/format.rs

@@ -1,5 +1,3 @@
-// src/format.rs
-
 use crate::ast::Expr;
 
 pub fn format_expr(expr: &Expr) -> String {
@@ -26,14 +24,36 @@ pub fn format_expr(expr: &Expr) -> String {
         Expr::Div(lhs, rhs) => {
             format!("({})/({})", format_expr(lhs), format_expr(rhs))
         }
+        Expr::Pow(lhs, rhs) => {
+            format!("{}^{}", format_factor(lhs), format_factor(rhs))
+        }
+        Expr::Undefined => "undefined".to_string(),
     }
 }
 
 fn format_factor(expr: &Expr) -> String {
     match expr {
-        Expr::Add(_, _) | Expr::Sub(_, _) => {
+        Expr::Number(n) => {
+            if n.fract() == 0.0 {
+                format!("{}", n.round())
+            } else {
+                format!("{}", n)
+            }
+        }
+        Expr::Variable(var) => var.clone(),
+        Expr::Mul(lhs, rhs) => {
+            let left = format_factor(lhs);
+            let right = format_factor(rhs);
+            format!("{}{}", left, right)
+        }
+        Expr::Div(lhs, rhs) => {
+            format!("({})/({})", format_expr(lhs), format_expr(rhs))
+        }
+        Expr::Pow(lhs, rhs) => {
+            format!("({})^({})", format_expr(lhs), format_expr(rhs))
+        }
+        Expr::Add(_, _) | Expr::Sub(_, _) | Expr::Undefined => {
             format!("({})", format_expr(expr))
         }
-        _ => format_expr(expr),
     }
 }

src/lib.rs

@@ -3,5 +3,9 @@ pub mod parser;
 
 pub mod format;
 pub mod simplify;
+
 pub mod token;
 pub mod tokenizer;
+
+pub mod solver;
+mod tests;

src/parser.rs

@@ -1,5 +1,3 @@
-// src/parser.rs
-
 use crate::ast::Expr;
 use crate::token::Token;
 
@@ -43,24 +41,24 @@ impl Parser {
     }
 
     fn parse_multiplication(&mut self) -> Result<Expr, String> {
-        let mut expr = self.parse_factor()?;
+        let mut expr = self.parse_exponentiation()?;
 
         loop {
             if let Some(token) = self.current_token() {
                 match token {
                     Token::Star => {
                         self.advance();
-                        let rhs = self.parse_factor()?;
+                        let rhs = self.parse_exponentiation()?;
                         expr = Expr::Mul(Box::new(expr), Box::new(rhs));
                     }
                     Token::Slash => {
                         self.advance();
-                        let rhs = self.parse_factor()?;
+                        let rhs = self.parse_exponentiation()?;
                         expr = Expr::Div(Box::new(expr), Box::new(rhs));
                     }
-                    // Handle implicit multiplication
+                    // Handle implicit multiplication (e.g., 2x, (a)(b))
                     Token::Number(_) | Token::Variable(_) | Token::LParen => {
-                        let rhs = self.parse_factor()?;
+                        let rhs = self.parse_exponentiation()?;
                         expr = Expr::Mul(Box::new(expr), Box::new(rhs));
                     }
                     _ => break,
@@ -73,6 +71,21 @@ impl Parser {
         Ok(expr)
     }
 
+    fn parse_exponentiation(&mut self) -> Result<Expr, String> {
+        let expr = self.parse_factor()?;
+        self.parse_exponentiation_rhs(expr)
+    }
+
+    fn parse_exponentiation_rhs(&mut self, left: Expr) -> Result<Expr, String> {
+        if let Some(Token::Pow) = self.current_token() {
+            self.advance();
+            let right = self.parse_exponentiation()?;
+            Ok(Expr::Pow(Box::new(left), Box::new(right)))
+        } else {
+            Ok(left)
+        }
+    }
+
     fn parse_factor(&mut self) -> Result<Expr, String> {
         if let Some(token) = self.current_token() {
             match token {