Mark/daisy
1
1
Fork 0
mirror of https://github.com/rm-dr/daisy synced 2025-08-24 04:05:29 -07:00
Code Issues Packages Projects Releases Wiki Activity

Renamed token and pretoken

Browse Source
This commit is contained in:
Mark
2023-06-16 12:58:06 -07:00
parent 081dc1b7ab
commit 1495dcd561
17 changed files with 280 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
src/evaluate/evaluate.rs
View File

@ -1,4 +1,4 @@
use crate::parser::Token;
use crate::parser::Expression;
use crate::parser::Operator;
use crate::context::Context;
@ -7,9 +7,9 @@ use super::operator::eval_operator;
use super::function::eval_function;
use super::EvalError;
pub fn evaluate(t: &Token, context: &mut Context) -> Result<Token, EvalError> {
pub fn evaluate(t: &Expression, context: &mut Context) -> Result<Expression, EvalError> {
// Keeps track of our position in the token tree.
// Keeps track of our position in the expression tree.
// For example, the coordinates [0, 2, 1] are interpreted as follows:
// Start at the root node,
// then move to that node's 0th child,
@ -40,12 +40,12 @@ pub fn evaluate(t: &Token, context: &mut Context) -> Result<Token, EvalError> {
let new = match g {
Token::Quantity(_) => None,
Expression::Quantity(_) => None,
Token::Constant(c) => { Some(evaluate(&c.value(), context).unwrap()) },
Token::Variable(s) => { context.get_variable(&s) },
Token::Operator(Operator::Function(f), v) => { Some(eval_function(&f, &v)?) },
Token::Operator(o, v) => { eval_operator(&o, &v, context)? },
Expression::Constant(c) => { Some(evaluate(&c.value(), context).unwrap()) },
Expression::Variable(s) => { context.get_variable(&s) },
Expression::Operator(Operator::Function(f), v) => { Some(eval_function(&f, &v)?) },
Expression::Operator(o, v) => { eval_operator(&o, &v, context)? },
};
if new.is_some() { *g = new.unwrap()}
@ -63,7 +63,7 @@ pub fn evaluate(t: &Token, context: &mut Context) -> Result<Token, EvalError> {
let n = root.get_at_coords(&coords[..]);
if let Some(n) = n {
if let Token::Operator(Operator::Define, _) = n {
if let Expression::Operator(Operator::Define, _) = n {
*coords.last_mut().unwrap() += 1;
}
}

58
src/evaluate/function.rs
View File

@ -1,19 +1,19 @@
use std::collections::VecDeque;
use crate::parser::Token;
use crate::parser::Expression;
use crate::parser::Function;
use super::EvalError;
pub fn eval_function(f: &Function, args: &VecDeque<Token>) -> Result<Token, EvalError> {
pub fn eval_function(f: &Function, args: &VecDeque<Expression>) -> Result<Expression, EvalError> {
if args.len() != 1 {panic!()};
let a = &args[0];
let Token::Quantity(q) = a else {panic!()};
let Expression::Quantity(q) = a else {panic!()};
match f {
Function::NoUnit => { return Ok(Token::Quantity(q.without_unit())); }
Function::ToBase => { return Ok(Token::Quantity(q.convert_to_base())); }
Function::NoUnit => { return Ok(Expression::Quantity(q.without_unit())); }
Function::ToBase => { return Ok(Expression::Quantity(q.convert_to_base())); }
_ => {}
}
@ -22,35 +22,35 @@ pub fn eval_function(f: &Function, args: &VecDeque<Token>) -> Result<Token, Eval
}
match f {
Function::Abs => { return Ok(Token::Quantity(q.abs())); },
Function::Floor => { return Ok(Token::Quantity(q.floor())); },
Function::Ceil => { return Ok(Token::Quantity(q.ceil())); },
Function::Round => { return Ok(Token::Quantity(q.round())); },
Function::Abs => { return Ok(Expression::Quantity(q.abs())); },
Function::Floor => { return Ok(Expression::Quantity(q.floor())); },
Function::Ceil => { return Ok(Expression::Quantity(q.ceil())); },
Function::Round => { return Ok(Expression::Quantity(q.round())); },
Function::NaturalLog => { return Ok(Token::Quantity(q.ln())); },
Function::TenLog => { return Ok(Token::Quantity(q.log10())); },
Function::NaturalLog => { return Ok(Expression::Quantity(q.ln())); },
Function::TenLog => { return Ok(Expression::Quantity(q.log10())); },
Function::Sin => { return Ok(Token::Quantity(q.sin())); },
Function::Cos => { return Ok(Token::Quantity(q.cos())); },
Function::Tan => { return Ok(Token::Quantity(q.tan())); },
Function::Asin => { return Ok(Token::Quantity(q.asin())); },
Function::Acos => { return Ok(Token::Quantity(q.acos())); },
Function::Atan => { return Ok(Token::Quantity(q.atan())); },
Function::Sin => { return Ok(Expression::Quantity(q.sin())); },
Function::Cos => { return Ok(Expression::Quantity(q.cos())); },
Function::Tan => { return Ok(Expression::Quantity(q.tan())); },
Function::Asin => { return Ok(Expression::Quantity(q.asin())); },
Function::Acos => { return Ok(Expression::Quantity(q.acos())); },
Function::Atan => { return Ok(Expression::Quantity(q.atan())); },
Function::Csc => { return Ok(Token::Quantity(q.csc())); },
Function::Sec => { return Ok(Token::Quantity(q.sec())); },
Function::Cot => { return Ok(Token::Quantity(q.cot())); },
Function::Csc => { return Ok(Expression::Quantity(q.csc())); },
Function::Sec => { return Ok(Expression::Quantity(q.sec())); },
Function::Cot => { return Ok(Expression::Quantity(q.cot())); },
Function::Sinh => { return Ok(Token::Quantity(q.sinh())); },
Function::Cosh => { return Ok(Token::Quantity(q.cosh())); },
Function::Tanh => { return Ok(Token::Quantity(q.tanh())); },
Function::Asinh => { return Ok(Token::Quantity(q.asinh())); },
Function::Acosh => { return Ok(Token::Quantity(q.acosh())); },
Function::Atanh => { return Ok(Token::Quantity(q.atanh())); },
Function::Sinh => { return Ok(Expression::Quantity(q.sinh())); },
Function::Cosh => { return Ok(Expression::Quantity(q.cosh())); },
Function::Tanh => { return Ok(Expression::Quantity(q.tanh())); },
Function::Asinh => { return Ok(Expression::Quantity(q.asinh())); },
Function::Acosh => { return Ok(Expression::Quantity(q.acosh())); },
Function::Atanh => { return Ok(Expression::Quantity(q.atanh())); },
Function::Csch => { return Ok(Token::Quantity(q.csch())); },
Function::Sech => { return Ok(Token::Quantity(q.sech())); },
Function::Coth => { return Ok(Token::Quantity(q.coth())); },
Function::Csch => { return Ok(Expression::Quantity(q.csch())); },
Function::Sech => { return Ok(Expression::Quantity(q.sech())); },
Function::Coth => { return Ok(Expression::Quantity(q.coth())); },
Function::ToBase
| Function::NoUnit

46
src/evaluate/operator.rs
View File

@ -2,11 +2,11 @@ use std::collections::VecDeque;
use crate::quantity::Quantity;
use crate::parser::Operator;
use crate::parser::Token;
use crate::parser::Expression;
use super::EvalError;
use crate::context::Context;
pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Context) -> Result<Option<Token>, EvalError> {
pub fn eval_operator(op: &Operator, args: &VecDeque<Expression>, context: &mut Context) -> Result<Option<Expression>, EvalError> {
match op {
// Handled seperately in evaluate.rs
@ -24,7 +24,7 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
if args.len() != 2 { panic!() };
let b = &args[1];
if let Token::Variable(s) = &args[0] {
if let Expression::Variable(s) = &args[0] {
context.push_var(s.clone(), b.clone());
return Ok(Some(b.clone()));
} else { return Err(EvalError::BadDefineName); }
@ -34,8 +34,8 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
if args.len() != 1 { panic!() };
let args = &args[0];
if let Token::Quantity(v) = args {
return Ok(Some(Token::Quantity(-v.clone())));
if let Expression::Quantity(v) = args {
return Ok(Some(Expression::Quantity(-v.clone())));
} else { return Ok(None); }
},
@ -43,9 +43,9 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
if args.len() != 1 { panic!() };
let args = &args[0];
if let Token::Quantity(v) = args {
if let Expression::Quantity(v) = args {
if v.is_zero() { return Err(EvalError::ZeroDivision); }
return Ok(Some(Token::Quantity(
return Ok(Some(Expression::Quantity(
Quantity::new_rational(1f64).unwrap()/v.clone()
)));
} else { return Ok(None); }
@ -53,14 +53,14 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
Operator::Add => {
let mut sum: Quantity;
if let Token::Quantity(s) = &args[0] {
if let Expression::Quantity(s) = &args[0] {
sum = s.clone();
} else { return Ok(None); };
let mut i: usize = 1;
while i < args.len() {
let j = &args[i];
if let Token::Quantity(v) = j {
if let Expression::Quantity(v) = j {
if !sum.unit.compatible_with(&v.unit) {
return Err(EvalError::IncompatibleUnit);
@ -70,18 +70,18 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
} else { return Ok(None); }
i += 1;
}
return Ok(Some(Token::Quantity(sum)));
return Ok(Some(Expression::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 {
if let Expression::Quantity(v) = j {
prod *= v.clone();
} else { return Ok(None); }
}
return Ok(Some(Token::Quantity(prod)));
return Ok(Some(Expression::Quantity(prod)));
},
Operator::ModuloLong
@ -90,8 +90,8 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
let a = &args[0];
let b = &args[1];
if let Token::Quantity(va) = a {
if let Token::Quantity(vb) = b {
if let Expression::Quantity(va) = a {
if let Expression::Quantity(vb) = b {
if !(va.unitless() && vb.unitless()) {
return Err(EvalError::IncompatibleUnit);
@ -101,7 +101,7 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
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(Some(Token::Quantity(va.clone() % vb.clone())));
return Ok(Some(Expression::Quantity(va.clone() % vb.clone())));
} else { return Ok(None); }
} else { return Ok(None); }
},
@ -112,13 +112,13 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
let a = &args[0];
let b = &args[1];
if let Token::Quantity(va) = a {
if let Token::Quantity(vb) = b {
if let Expression::Quantity(va) = a {
if let Expression::Quantity(vb) = b {
let n = va.clone().convert_to(vb.clone());
if n.is_none() {
return Err(EvalError::IncompatibleUnit);
}
return Ok(Some(Token::Quantity(n.unwrap())));
return Ok(Some(Expression::Quantity(n.unwrap())));
} else { return Ok(None); }
} else { return Ok(None); }
},
@ -128,8 +128,8 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
let a = &args[0];
let b = &args[1];
if let Token::Quantity(va) = a {
if let Token::Quantity(vb) = b {
if let Expression::Quantity(va) = a {
if let Expression::Quantity(vb) = b {
if !vb.unitless() {
return Err(EvalError::IncompatibleUnit);
@ -141,7 +141,7 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
let p = va.pow(vb.clone());
if p.is_nan() {return Err(EvalError::BadMath);}
return Ok(Some(Token::Quantity(p)));
return Ok(Some(Expression::Quantity(p)));
} else { return Ok(None); }
} else { return Ok(None); }
},
@ -150,7 +150,7 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
if args.len() != 1 {panic!()};
let args = &args[0];
if let Token::Quantity(v) = args {
if let Expression::Quantity(v) = args {
if !v.unitless() {
return Err(EvalError::IncompatibleUnit);
@ -166,7 +166,7 @@ pub fn eval_operator(op: &Operator, args: &VecDeque<Token>, context: &mut Contex
u = u - Quantity::new_rational(1f64).unwrap();
}
return Ok(Some(Token::Quantity(prod)));
return Ok(Some(Expression::Quantity(prod)));
} else { return Ok(None); }
}
};