Restructured packages

This commit is contained in:
2023-06-11 13:53:45 -07:00
parent 813c1e7292
commit af2eb39fd5
25 changed files with 850 additions and 833 deletions

81
src/evaluate/evaluate.rs Normal file
View 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
View 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
View 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
View 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);
}
};
}