Restructured packages

src/evaluate/operator.rs

@@ -0,0 +1,165 @@
+use std::collections::VecDeque;
+
+use crate::quantity::Quantity;
+use crate::parser::Operator;
+use crate::parser::Token;
+use super::EvalError;
+use super::function::func_apply;
+
+
+pub fn op_apply(op: &mut Operator, args: &VecDeque<Token>) -> Result<Token, EvalError> {
+	match op {
+		Operator::ImplicitMultiply |
+		Operator::Sqrt |
+		Operator::Divide |
+		Operator::Subtract => { panic!() }
+
+		Operator::Negative => {
+			if args.len() != 1 {panic!()};
+			let args = &args[0];
+
+			if let Token::Quantity(v) = args {
+				return Ok(Token::Quantity(-v.clone()));
+			} else { panic!(); }
+		},
+
+		Operator::Flip => {
+			if args.len() != 1 {panic!()};
+			let args = &args[0];
+
+			if let Token::Quantity(v) = args {
+				if v.is_zero() { return Err(EvalError::ZeroDivision); }
+				return Ok(Token::Quantity(
+					Quantity::new_rational(1f64).unwrap()/v.clone()
+				));
+			} else { panic!(); }
+		},
+
+		Operator::Add => {
+			let mut sum: Quantity;
+			if let Token::Quantity(s) = &args[0] {
+				sum = s.clone();
+			} else {panic!()};
+
+			let mut i: usize = 1;
+			while i < args.len() {
+				let j = &args[i];
+				if let Token::Quantity(v) = j {
+
+					if !sum.unit.compatible_with(&v.unit) {
+						return Err(EvalError::IncompatibleUnit);
+					}
+
+					sum += v.clone();
+				} else {
+					panic!();
+				}
+				i += 1;
+			}
+			return Ok(Token::Quantity(sum));
+		},
+
+		Operator::Multiply => {
+			let mut prod = Quantity::new_rational(1f64).unwrap();
+			for i in args.iter() {
+				let j = i;
+				if let Token::Quantity(v) = j {
+					prod *= v.clone();
+				} else {
+					panic!();
+				}
+			}
+			return Ok(Token::Quantity(prod));
+		},
+
+		Operator::ModuloLong
+		| Operator::Modulo => {
+			if args.len() != 2 {panic!()};
+			let a = &args[0];
+			let b = &args[1];
+
+			if let Token::Quantity(va) = a {
+				if let Token::Quantity(vb) = b {
+
+					if !(va.unitless() && vb.unitless()) {
+						return Err(EvalError::IncompatibleUnit);
+					}
+
+					if vb <= &Quantity::new_rational(1f64).unwrap() { return Err(EvalError::BadMath); }
+					if va.fract() != Quantity::new_rational(0f64).unwrap() { return Err(EvalError::BadMath); }
+					if vb.fract() != Quantity::new_rational(0f64).unwrap() { return Err(EvalError::BadMath); }
+
+					return Ok(Token::Quantity(va.clone() % vb.clone()));
+				} else { panic!(); }
+			} else { panic!(); }
+		},
+
+		Operator::UnitConvert
+		=> {
+			if args.len() != 2 {panic!()};
+			let a = &args[0];
+			let b = &args[1];
+
+			if let Token::Quantity(va) = a {
+				if let Token::Quantity(vb) = b {
+					let n = va.clone().convert_to(vb.clone());
+					if n.is_none() {
+						return Err(EvalError::IncompatibleUnit);
+					}
+					return Ok(Token::Quantity(n.unwrap()));
+				} else { panic!(); }
+			} else { panic!(); }
+		},
+
+		Operator::Power => {
+			if args.len() != 2 {panic!()};
+			let a = &args[0];
+			let b = &args[1];
+
+			if let Token::Quantity(va) = a {
+				if let Token::Quantity(vb) = b {
+
+					if !vb.unitless() {
+						return Err(EvalError::IncompatibleUnit);
+					}
+
+					if va.is_zero() && vb.is_negative() {
+						return Err(EvalError::ZeroDivision);
+					}
+
+					let p = va.pow(vb.clone());
+					if p.is_nan() {return Err(EvalError::BadMath);}
+					return Ok(Token::Quantity(p));
+				} else { panic!(); }
+			} else { panic!(); }
+		},
+
+		Operator::Factorial => {
+			if args.len() != 1 {panic!()};
+			let args = &args[0];
+
+			if let Token::Quantity(v) = args {
+
+				if !v.unitless() {
+					return Err(EvalError::IncompatibleUnit);
+				}
+
+				if !v.fract().is_zero() { return Err(EvalError::BadMath); }
+				if v > &Quantity::new_rational(50_000f64).unwrap() { return Err(EvalError::TooBig); }
+
+				let mut prod = Quantity::new_rational(1f64).unwrap();
+				let mut u = v.clone();
+				while u > Quantity::new_rational(0f64).unwrap() {
+					prod *= u.clone();
+					u = u - Quantity::new_rational(1f64).unwrap();
+				}
+
+				return Ok(Token::Quantity(prod));
+			} else { panic!(); }
+		},
+
+		Operator::Function(f) => {
+			return func_apply(f, args);
+		}
+	};
+}