latex2mathml 0.2.3

Convert LaTeX equations to MathML
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use std::fmt;

/// mi mathvariant attribute
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Variant {
    Normal,
    Italic,
    Bold,
    BoldItalic,
    DoubleStruck,
    BoldFraktur,
    Script,
    BoldScript,
    Fraktur,
    SansSerif,
    BoldSansSerif,
    SansSerifItalic,
    SansSerifBoldItalic,
    Monospace,
}

impl fmt::Display for Variant {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Variant::Normal              => write!(f, "normal"),
            Variant::Italic              => write!(f, "italic"),
            Variant::Bold                => write!(f, "bold"),
            Variant::BoldItalic          => write!(f, "bold-italic"),
            Variant::DoubleStruck        => write!(f, "double-struck"),
            Variant::BoldFraktur         => write!(f, "bold-fraktur"),
            Variant::Script              => write!(f, "script"),
            Variant::BoldScript          => write!(f, "bold-script"),
            Variant::Fraktur             => write!(f, "fraktur"),
            Variant::SansSerif           => write!(f, "sans-serif"),
            Variant::BoldSansSerif       => write!(f, "bold-sans-serif"),
            Variant::SansSerifItalic     => write!(f, "sans-serif-italic"),
            Variant::SansSerifBoldItalic => write!(f, "sans-serif-bold-italic"),
            Variant::Monospace           => write!(f, "monospace"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Accent {
    True,
    False,
}

impl fmt::Display for Accent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Accent::True => write!(f, "true"),
            Accent::False => write!(f, "false"),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum LineThickness {
    Thin,
    Medium,
    Thick,
    Length(u8),
}
impl fmt::Display for LineThickness {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LineThickness::Thin      => write!(f, r#" linethickness="thin""#),
            LineThickness::Medium    => write!(f, r#""#),
            LineThickness::Thick     => write!(f, r#" linethickness="medium""#),
            LineThickness::Length(l) => write!(f, r#" linethickness="{}""#, l),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ColumnAlign {
    Center,
    Left,
    Right,
}

impl fmt::Display for ColumnAlign {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ColumnAlign::Center => write!(f, r#""#),
            ColumnAlign::Left => write!(f, r#" columnalign=left"#),
            ColumnAlign::Right => write!(f, r#" columnalign=right"#),
        }
    }
}