mathml-rs 0.1.2

MathML parser written in Rust.
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

use std::str::FromStr;

#[derive(Debug, Clone)]
pub enum NumType {
    Real,
    Integer,
    Rational,
    ComplexCartesian,
    ComplexPolar,
    Constant,
    ENotation,
}

impl FromStr for NumType {
    type Err = ();

    fn from_str(s: &str) -> Result<NumType, ()> {
        match s {
            "integer" => Ok(NumType::Integer),
            "real" | "double" => Ok(NumType::Real),
            "e-notation" => Ok(NumType::ENotation),
            "rational" => Ok(NumType::Rational),
            "complex-cartesian" => Ok(NumType::ComplexCartesian),
            "complex-polar" => Ok(NumType::ComplexPolar),
            "constant" => Ok(NumType::Constant),
            _ => Err(()),
        }
    }
}

#[derive(Debug, Clone)]
pub enum Number {
    Real(f64),
    Integer(i32),
    Rational(i64, i64),
    ComplexCartesian(f64, f64),
    ComplexPolar(f64, f64),
    Constant(String),
    ENotation(f64, i64),
}

impl Eq for Number {}
impl PartialEq for Number {
    fn eq(&self, other: &Self) -> bool {
        use Number::*;
        match (self, other) {
            (Real(r), Real(r2)) => approx::abs_diff_eq!(r, r2),
            (Integer(r1), Integer(r2)) => r1 == r2,
            (Rational(a, b), Rational(c, d)) => (a == c) && (b == d),
            (ComplexPolar(a, b), ComplexPolar(c, d))
            | (ComplexCartesian(a, b), ComplexCartesian(c, d)) => {
                approx::abs_diff_eq!(a, c) && approx::abs_diff_eq!(b, d)
            }
            (Constant(a), Constant(b)) => a == b,
            (ENotation(a, b), ENotation(c, d)) => a == c && b == d,
            _ => false,
        }
    }
}