mirror of
https://github.com/rm-dr/daisy
synced 2025-07-05 10:09:33 -07:00
Restructured packages
This commit is contained in:
81
src/evaluate/evaluate.rs
Normal file
81
src/evaluate/evaluate.rs
Normal file
@ -0,0 +1,81 @@
|
||||
use crate::parser::Token;
|
||||
use crate::parser::Constant;
|
||||
use crate::quantity::Quantity;
|
||||
|
||||
use super::operator::op_apply;
|
||||
use super::EvalError;
|
||||
|
||||
pub fn evaluate(t: &Token) -> Result<Token, EvalError> {
|
||||
let mut g = t.clone();
|
||||
let mut coords: Vec<usize> = Vec::with_capacity(16);
|
||||
coords.push(0);
|
||||
|
||||
'outer: loop {
|
||||
|
||||
let mut h = &mut g;
|
||||
for t in coords.iter() {
|
||||
let inner = h.get_args_mut();
|
||||
|
||||
if inner.is_none() || *t >= inner.as_ref().unwrap().len() {
|
||||
coords.pop();
|
||||
|
||||
|
||||
let p = Token::get_at_coords(&mut g, &coords);
|
||||
|
||||
let e: Token = match p {
|
||||
Token::Quantity(_) => { p.clone() },
|
||||
Token::Constant(c) => {
|
||||
match c {
|
||||
// Mathematical constants
|
||||
// 100 digits of each.
|
||||
Constant::Pi => { Token::Quantity(Quantity::new_float_from_string(
|
||||
"3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067"
|
||||
).unwrap())},
|
||||
|
||||
Constant::E => { Token::Quantity(Quantity::new_float_from_string(
|
||||
"2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427"
|
||||
).unwrap()) },
|
||||
|
||||
Constant::Phi => { Token::Quantity(Quantity::new_float_from_string(
|
||||
"1.618033988749894848204586834365638117720309179805762862135448622705260462818902449707207204189391137"
|
||||
).unwrap()) },
|
||||
}
|
||||
},
|
||||
Token::Operator(o,v) => { op_apply(o, &v)? }
|
||||
};
|
||||
|
||||
//let e = p.eval()?;
|
||||
*p = e;
|
||||
|
||||
if coords.len() == 0 { break 'outer; }
|
||||
let l = coords.pop().unwrap();
|
||||
coords.push(l + 1);
|
||||
continue 'outer;
|
||||
}
|
||||
|
||||
h = &mut inner.unwrap()[*t];
|
||||
}
|
||||
|
||||
|
||||
|
||||
match h {
|
||||
Token::Operator(_,_) => {
|
||||
coords.push(0);
|
||||
continue 'outer;
|
||||
},
|
||||
|
||||
Token::Constant(_) => {
|
||||
coords.push(0);
|
||||
continue 'outer;
|
||||
},
|
||||
|
||||
Token::Quantity(_) => {
|
||||
let l = coords.pop().unwrap();
|
||||
coords.push(l + 1);
|
||||
continue 'outer;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return Ok(g);
|
||||
}
|
102
src/evaluate/function.rs
Normal file
102
src/evaluate/function.rs
Normal file
@ -0,0 +1,102 @@
|
||||
use std::collections::VecDeque;
|
||||
|
||||
use crate::parser::Token;
|
||||
use crate::parser::Function;
|
||||
use crate::parser::Operator;
|
||||
use super::EvalError;
|
||||
use super::operator::op_apply;
|
||||
use crate::quantity::Quantity;
|
||||
|
||||
fn eval(t: Token) -> Result<Token, EvalError> {
|
||||
Ok(match t {
|
||||
Token::Quantity(_) => { t },
|
||||
Token::Constant(_) => { Token::Quantity( Quantity::new_rational_from_string("1").unwrap() ) },
|
||||
Token::Operator(mut o, v) => { op_apply(&mut o, &v)? }
|
||||
})
|
||||
}
|
||||
|
||||
pub fn func_apply(f: &Function, args: &VecDeque<Token>) -> Result<Token, EvalError> {
|
||||
if args.len() != 1 {panic!()};
|
||||
let a = &args[0];
|
||||
let Token::Quantity(q) = a else {panic!()};
|
||||
|
||||
if !q.unitless() {
|
||||
return Err(EvalError::IncompatibleUnit);
|
||||
}
|
||||
|
||||
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::NaturalLog => { return Ok(Token::Quantity(q.ln())); },
|
||||
Function::TenLog => { return Ok(Token::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::Csc => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.sin())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
Function::Sec => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.cos())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
Function::Cot => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.tan())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
|
||||
|
||||
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::Csch => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.sinh())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
Function::Sech => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.cosh())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
Function::Coth => {
|
||||
return Ok(
|
||||
eval(Token::Operator(
|
||||
Operator::Flip,
|
||||
VecDeque::from(vec!(Token::Quantity(q.tanh())))
|
||||
))?
|
||||
);
|
||||
},
|
||||
|
||||
}
|
||||
}
|
11
src/evaluate/mod.rs
Normal file
11
src/evaluate/mod.rs
Normal file
@ -0,0 +1,11 @@
|
||||
mod operator;
|
||||
mod function;
|
||||
mod evaluate;
|
||||
pub use self::evaluate::evaluate;
|
||||
|
||||
pub enum EvalError {
|
||||
BadMath,
|
||||
TooBig,
|
||||
ZeroDivision,
|
||||
IncompatibleUnit
|
||||
}
|
165
src/evaluate/operator.rs
Normal file
165
src/evaluate/operator.rs
Normal file
@ -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);
|
||||
}
|
||||
};
|
||||
}
|
Reference in New Issue
Block a user