[feat] Implement PolynomialTraits for Polynomial

spindalis_core/src/polynomials/advanced.rs

@@ -581,6 +581,51 @@ impl From<&'static str> for Expr {
     }
 }
 
+#[allow(dead_code)]
+fn eval_advanced_polynomial<V, S, F>(poly: &Polynomial, variables: V) -> Polynomial
+where
+    V: IntoIterator<Item = (S, F)> + std::fmt::Debug + Clone,
+    S: AsRef<str>,
+    F: Into<f64>,
+{
+    let expr = variables
+        .into_iter()
+        .fold(poly.expr.clone(), |acc, (name, value)| {
+            replace_variable_occurence(&acc, name.as_ref(), value.into())
+        });
+    Polynomial::new(expr)
+}
+
+#[allow(dead_code)]
+fn replace_variable_occurence(expr: &Expr, var_name: &str, var_val: f64) -> Expr {
+    match expr {
+        // replaces value of variable with variable's assigned value.
+        Expr::Variable(v) if v == var_name => var_val.into(),
+
+        // recursively walks down the polynomial for operators
+        Expr::BinaryOp {
+            op,
+            lhs,
+            rhs,
+            paren,
+        } => Expr::BinaryOp {
+            op: *op,
+            lhs: Box::new(replace_variable_occurence(lhs, var_name, var_val)),
+            rhs: Box::new(replace_variable_occurence(rhs, var_name, var_val)),
+            paren: *paren,
+        },
+        Expr::UnaryOpPrefix { op, value } => Expr::UnaryOpPrefix {
+            op: *op,
+            value: Box::new(replace_variable_occurence(value, var_name, var_val)),
+        },
+        Expr::UnaryOpPostfix { op, value } => Expr::UnaryOpPostfix {
+            op: *op,
+            value: Box::new(replace_variable_occurence(value, var_name, var_val)),
+        },
+        expr => expr.clone(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1498,6 +1543,16 @@ mod tests {
             let expected = Polynomial::new(Expr::Number(0.));
             assert_eq!(result, expected);
         }
+        #[test]
+        fn test_eval_expression() {
+            let expr = "x^3-3xy+5";
+            let tok_str = lexer(expr).unwrap();
+            let parsed_result = parser(tok_str).unwrap();
+            let evaluated_result =
+                eval_advanced_polynomial(&parsed_result, vec![("x", 5), ("y", 6)]);
+            println!("{}", parsed_result);
+            println!("{}", evaluated_result);
+        }
     }
     // ---------------------------
     // Test Display

spindalis_core/src/polynomials/structs/advanced.rs

@@ -6,38 +6,15 @@ pub type TokenStream = Peekable<IntoIter<Token>>;
 
 #[derive(Debug, PartialEq)]
 pub struct Polynomial {
-    expr: Expr,
+    pub expr: Expr,
 }
 impl Polynomial {
     pub fn new(expr: Expr) -> Self {
         Self { expr }
     }
 }
-
 impl std::fmt::Display for Polynomial {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.expr)
     }
 }
-
-// impl PolynomialTraits for Polynomial {
-//     fn parse(input: &str) -> Result<Self, PolynomialError>{
-//         let tokens = lexer(input)?;
-//         let polynomial = parser(tokens)?;
-//         // TODO add a pass to combine 0*_ as 0 and 1*_ as _
-//         Some(polynomial)
-//     }
-//     fn eval_univariate<F>(&self, point: F) -> Result<f64, PolynomialError>{
-//     }
-//     fn eval_multivariate<V, S, F>(&self, vars: &V) -> Result<f64, PolynomialError> {
-//     }
-//     fn derivate_univariate(&self) -> Result<Self, PolynomialError>{
-//     }
-//     fn derivate_multivariate<S>(&self, var: S) -> Self{
-//     }
-//     fn indefinite_integral_univariate(&self) -> Result<Self, PolynomialError>{
-//     }
-//     fn indefinite_integral_multivariate<S>(&self, var: S) -> Self{
-//     }
-//
-// }