exercises

operator.rs (5733B)

---

 use std::{collections::HashMap, f32::consts::FRAC_PI_2};
 
 use crate::{Expression, OperatorToken, token::Function};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Operator {
     Add,
     Subtract,
     Multiply,
     Divide,
     Power,
     Root,
     Factorial,
 }
 
 #[derive(Clone)]
 pub struct StandardOperator(pub Operator);
 
 impl OperatorToken for StandardOperator {
     fn precedence(&self) -> u8 {
         match self.0 {
             Operator::Add | Operator::Subtract => 1,
             Operator::Multiply | Operator::Divide => 2,
             Operator::Power => 3,
             Operator::Root | Operator::Factorial => 4,
         }
     }
 
     fn evaluate(&self, args: &[f64]) -> Result<f64, String> {
         match self.0 {
             Operator::Add => Ok(args[0] + args[1]),
             Operator::Subtract => Ok(args[0] - args[1]),
             Operator::Multiply => Ok(args[0] * args[1]),
             Operator::Divide => {
                 if args[1] == 0.0 {
                     Err("Division by zero".to_string())
                 } else {
                     Ok(args[0] / args[1])
                 }
             }
             // ... other operators
             _ => Err("Operation not supported in standard mode".to_string()),
         }
     }
 }
 
 #[derive(Clone)]
 pub enum ScientificOperator {
     Basic(Operator),
     Function(Function),
 }
 
 impl OperatorToken for ScientificOperator {
     fn precedence(&self) -> u8 {
         todo!()
     }
 
     fn evaluate(&self, args: &[f64]) -> Result<f64, String> {
         todo!()
     }
 }
 
 /// Composite Pattern: this is a composite node, it holds two child expressions
 /// and an operator. The children are `Box<dyn Expression>` trait objects, which
 /// means each child can be any expression type: a number, a variable, another
 /// binary operation, or even a decorated expression.
 ///
 /// We use `Box<dyn Expression>` rather than generic type parameters because
 /// generic would make each `BinaryOperation` monomorphic (specialized to one
 /// concrete type) over its children's types.
 pub struct BinaryOperation {
     pub left: Box<dyn Expression>,
     pub right: Box<dyn Expression>,
     pub operator: Operator,
 }
 
 impl BinaryOperation {
     pub fn new(left: Box<dyn Expression>, right: Box<dyn Expression>, operator: Operator) -> Self {
         Self {
             left,
             right,
             operator,
         }
     }
 
     fn operator_symbol(&self) -> &'static str {
         match self.operator {
             Operator::Add => "+",
             Operator::Subtract => "-",
             Operator::Multiply => "*",
             Operator::Divide => "/",
             Operator::Power => "^",
             Operator::Root => todo!(),
             Operator::Factorial => todo!(),
         }
     }
 }
 
 impl Expression for BinaryOperation {
     fn evaluate(&self, variables: &std::collections::HashMap<String, f64>) -> Result<f64, String> {
         // Evaluates both children recursively
         let l = self.left.evaluate(variables)?;
         let r = self.right.evaluate(variables)?;
 
         match self.operator {
             Operator::Add => Ok(l + r),
             Operator::Subtract => Ok(l - r),
             Operator::Multiply => Ok(l * r),
             Operator::Divide if r == 0.0 => Err("Division by zero".to_string()),
             Operator::Divide => Ok(l / r),
             Operator::Power => Ok(l.powf(r)),
             _ => Ok(l + r),
         }
     }
 
     fn to_string(&self) -> String {
         let left_str = if self.left.precedence() < self.precedence() {
             format!("({})", self.left.to_string())
         } else {
             self.left.to_string()
         };
 
         let right_str = if self.right.precedence() < self.precedence() {
             format!("({})", self.right.to_string())
         } else {
             self.right.to_string()
         };
 
         format!("{} {} {}", left_str, self.operator_symbol(), right_str)
     }
 
     fn precedence(&self) -> u8 {
         match self.operator {
             Operator::Add | Operator::Subtract => 1,
             Operator::Multiply | Operator::Divide => 2,
             Operator::Power => 3,
             Operator::Root => todo!(),
             Operator::Factorial => todo!(),
         }
     }
 }
 
 /// Like BinaryOperation, FunctionCall demonstrates the recursive nature of
 /// the Composite pattern: the argument can itself be an arbitrarily complex
 /// expression tree, and the uniform Expression interface handles any depth
 /// of nesting.
 pub struct FunctionCall {
     pub function: Function,
     pub argument: Box<dyn Expression>,
 }
 
 impl Expression for FunctionCall {
     fn evaluate(&self, variables: &HashMap<String, f64>) -> Result<f64, String> {
         let val = self.argument.evaluate(variables)?;
 
         match self.function {
             Function::Sin => Ok(val.sin()),
             Function::Cos => Ok(val.cos()),
             Function::Tan => {
                 let hp = std::f64::consts::FRAC_PI_2;
                 if (val - hp).abs() % std::f64::consts::PI < 1e-10 {
                     Err("Targent undefined at this value".into())
                 } else {
                     Ok(val.tan())
                 }
             }
             Function::Sqrt if val < 0.0 => Err("Cannot take square root of negative number".into()),
             Function::Sqrt => Ok(val.sqrt()),
         }
     }
 
     /// This method reconstructs the function call syntax for display purpose
     fn to_string(&self) -> String {
         let func_name = match self.function {
             Function::Sqrt => "sqrt",
             Function::Sin => "sin",
             Function::Cos => "cos",
             Function::Tan => "tan",
         };
         format!("{}({})", func_name, self.argument.to_string())
     }
 
     fn precedence(&self) -> u8 {
         4
     }
 }