calc_lib 2.1.0

A library for calculating things with correct order of operations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::fmt::{Display, Formatter};
use crate::Error;

#[derive(Debug, Clone, Eq, PartialEq)]
pub(crate) enum Operator {
    LeftParen,  // (
    RightParen, // )
    Add,        // +
    Sub,        // -
    Mul,        // *
    Div,        // / or รท
    Mod,        // %
    Assign,     // =
    Pow,        // ^
}

impl Operator {
    /// returns a number from 0 to 2 depending on its precedence, with 3 being the highest
    /// if the operator does not have a precedence, returns None
    pub fn precedence(&self) -> Option<u8> {
        match self {
            Operator::Add | Operator::Sub => Some(0),
            Operator::Mul | Operator::Div | Operator::Mod => Some(1),
            Operator::Pow => Some(2),
            _ => None,
        }
    }

    pub(crate) fn can_apply(&self) -> bool {
        match self {
            Operator::LeftParen | Operator::RightParen | Operator::Assign => false,
            _ => true,
        }
    }

    pub(crate) fn apply(&self, left: f64, right: f64) -> Result<f64, Error> {
        Ok(match self {
            Operator::Add => left + right,
            Operator::Sub => left - right,
            Operator::Mul => left * right,
            Operator::Div => {
                if right == 0.0 {
                    return Err(Error::DivByZero);
                }
                left / right
            },
            Operator::Mod => left % right,
            Operator::Pow => {
                if right < 0.0 {
                    return Err(Error::NegativeExponent);
                }
                left.powf(right)
            }
            _ => panic!("Operator::apply() called on non-operator"),
        })
    }
}

impl Display for Operator {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Operator::LeftParen => write!(f, "("),
            Operator::RightParen => write!(f, ")"),
            Operator::Add => write!(f, "+"),
            Operator::Sub => write!(f, "-"),
            Operator::Mul => write!(f, "*"),
            Operator::Div => write!(f, "/"),
            Operator::Mod => write!(f, "%"),
            Operator::Assign => write!(f, "="),
            Operator::Pow => write!(f, "^"),
        }
    }
}