Rosetta Code

Arithmetic evaluation: Difference between revisions

Page Discussion

Arithmetic evaluation (view source)

Revision as of 10:55, 30 June 2019

127 bytes removed ,  4 years ago
Formatting had broken something
(Rust implementation)
(Formatting had broken something)
Line 5,062:
=={{header|Rust}}==
<lang rust>//! Simple calculator parser and evaluator
 
 
/// Binary operator
Line 5,069 ⟶ 5,070:
Substract,
Multiply,
Divide,
}
 
Line 5,077 ⟶ 5,078:
Value(f64),
SubNode(Box<Node>),
Binary(Operator, Box<Node>, Box<Node>),
}
 
/// parse a string into a node
pub fn parse(txt: :&str) -> Option<Node> {
let chars = txt.chars().filter(|c| *c != ' ').collect();
parse_expression(&chars, 0).map(|(_, n)| n)
}
 
/// parse an expression into a node, keeping track of the position in the character vector
fn parse_expression(chars: &Vec<char>, pos: usize) -> Option<(usize, Node)> {
match parse_start(chars, pos) {
Some((new_pos, first)) => match parse_operator(chars, new_pos) {
Somematch parse_operator((new_pos2chars, opnew_pos)) => {
if let Some((new_pos3new_pos2, secondop)) = parse_expression(chars, new_pos2)> {
if let Some((new_pos3, combinesecond)) = parse_expression(opchars, first, second))new_pos2) {
} else { Some((new_pos3, combine(op, first, second)))
None} else {
} None
}▼
} else { },▼
None => Some((new_pos,first)),
}
None => Some((new_pos, first))},
None => None,
}
Line 5,105 ⟶ 5,109:
fn combine(op: Operator, first: Node, second: Node) -> Node {
match second {
Node::Binary(op2, v21, v22) => if precedence(&op)>=precedence(&op2) {
Node::Binary(op2, Box::new(combine(op, first, *v21)), v22)▼
if precedence(&op) >= precedence(&op2) {
} else {▼
▲ Node::Binary(op2, Box::new(combine(op, first, *v21)), v22)
Node::Binary(op, Box::new(first), Box::new(Node::Binary(op2, v21, v22)))▼
▲ } else {
},▼
▲ Node::Binary(op, Box::new(first), Box::new(Node::Binary(op2, v21, v22)))
_ => Node::Binary(op, Box::new(first), Box::new(second)),▼
▲ }
▲ }
▲ _ => Node::Binary(op, Box::new(first), Box::new(second)),
}
}
Line 5,118 ⟶ 5,120:
/// a precedence rank for operators
fn precedence(op: &Operator) -> usize {
match op {
Operator::Multiply | Operator::Divide => 2,
_ => 1,
}
}
 
/// try to parse from the start of an expression (either a parenthesis or a value)
fn parse_start(chars: &Vec<char>, pos: usize) -> Option<(usize, Node)> {
match start_parenthesis(chars, pos) {
Some (new_pos) => {
let r = parse_expression(chars, new_pos);
end_parenthesis(chars, r)
},
None => parse_value(chars, pos),
}
Line 5,136 ⟶ 5,138:
 
/// match a starting parentheseis
fn start_parenthesis(chars: &Vec<char>, pos: usize) -> Option<usize> {
if pos < chars.len() && chars[pos] == '(' {
Some(pos + 1)
} else {
None
Line 5,145 ⟶ 5,147:
 
/// match an end parenthesis, if successful will create a sub node contained the wrapped expression
fn end_parenthesis(chars: &Vec<char>, wrapped: :Option<(usize, Node)>) -> Option<(usize, Node)> {
match wrapped {
Some((pos, node)) => if pos<chars.len() && chars[pos] == ')' {
if pos < chars.len() && chars[Some((pos] == '+1,Node::SubNode(Box::new(node))))' {
Some((pos + 1, Node::SubNode(Box::new(node))))
} else {
None
},
▲ }
None => None,
}
Line 5,159:
 
/// parse a value: an decimal with an optional minus sign
fn parse_value(chars: &Vec<char>, pos: usize) -> Option<(usize, Node)> {
let mut new_pos = pos;
if new_pos < chars.len() && chars[new_pos] == '-' {
new_pos = new_pos + 1;
}
while new_pos < chars.len() && (chars[new_pos]=='.' || (chars[new_pos] >= '0' && chars[new_pos] <= '9')) {
&& (chars[new_pos] == '.' || (chars[new_pos] >= '0' && chars[new_pos] <= '9'))+1;
{▼
new_pos = new_pos + 1;
}
if new_pos > pos {
if let Ok(v) = dbg!(chars[pos..new_pos].iter().collect::<String>()).parse() {
Some((new_pos, Node::Value(v)))
} else {
None
Line 5,182 ⟶ 5,180:
 
/// parse an operator
fn parse_operator(chars: &Vec<char>, pos: usize) -> Option<(usize, Operator)> {
if pos < chars.len() {
let ops_with_char = vec![(('+',Operator::Add),('-',Operator::Substract),('*',Operator::Multiply),('/',Operator::Divide));
for (ch,op) in ops_with_char ('+', Operator::Add),{
('-', Operator::Substract),
('*', Operator::Multiply),
('/', Operator::Divide),
];▼
for (ch, op) in ops_with_char {
if chars[pos] == ch {
return Some((pos + 1, op));
}
}
}
None
}
 
/// eval a string
pub fn eval(txt: :&str) -> f64 {
match parse(txt) {
Some(t) => eval_term(&t),
None => panic!("Cannot parse {}", txt),
}
▲ {
 
}
 
Line 5,213 ⟶ 5,206:
Node::Value(v) => *v,
Node::SubNode(t) => eval_term(t),
Node::Binary(Operator::Add, t1, t2) => eval_term(t1) + eval_term(t2),
Node::Binary(Operator::Substract, t1, t2) => eval_term(t1) - eval_term(t2),
Node::Binary(Operator::Multiply, t1, t2) => eval_term(t1) * eval_term(t2),
Node::Binary(Operator::Divide, t1, t2) => eval_term(t1) / eval_term(t2),
}
}
Line 5,225 ⟶ 5,218:
 
#[test]
fn test_eval() {
assert_eq!(2.0, eval("2"));
assert_eq!(4.0, eval("2+2"));
assert_eq!(11.0 / 4.0, eval("2+3/4"));
assert_eq!(2.0, eval("2*3-4"));
assert_eq!(3.0, eval("1+2*3-4"));
assert_eq!(89.0 / 6.0, eval("2*(3+4)+5/6"));
assert_eq!(14.0, eval("2 * (3 -1) + 2 * 5"));
assert_eq!(7000.0, eval("2 * (3 + (4 * 5 + (6 * 7) * 8) - 9) * 10"));
assert_eq!(-9.0 / 4.0, eval("2*-3--4+-.25"));
assert_eq!(1.5, eval("1 - 5 * 2 / 20 + 1"));
assert_eq!(3.5, eval("2 * (3 + ((5) / (7 - 11)))"));
▲ ];
 
}
}
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/50728"