symbol.rs

//! コマンド名から、表示する文字と種別への対応表

use crate::node::{Class, Style};


/// コマンド名に対応する文字と種別を返す
#[rustfmt::skip]
pub fn symbol(name: &str) -> Option<(&'static str, Class)> {
    let found = match name {
        // ギリシャ小文字は変数として斜体で組む
        "alpha" => ("α", Class::Variable), "beta" => ("β", Class::Variable),
        "gamma" => ("γ", Class::Variable), "delta" => ("δ", Class::Variable),
        "epsilon" => ("ϵ", Class::Variable), "varepsilon" => ("ε", Class::Variable),
        "zeta" => ("ζ", Class::Variable), "eta" => ("η", Class::Variable),
        "theta" => ("θ", Class::Variable), "vartheta" => ("ϑ", Class::Variable),
        "iota" => ("ι", Class::Variable), "kappa" => ("κ", Class::Variable),
        "lambda" => ("λ", Class::Variable), "mu" => ("μ", Class::Variable),
        "nu" => ("ν", Class::Variable), "xi" => ("ξ", Class::Variable),
        "omicron" => ("ο", Class::Variable), "pi" => ("π", Class::Variable),
        "varpi" => ("ϖ", Class::Variable), "rho" => ("ρ", Class::Variable),
        "varrho" => ("ϱ", Class::Variable), "sigma" => ("σ", Class::Variable),
        "varsigma" => ("ς", Class::Variable), "tau" => ("τ", Class::Variable),
        "upsilon" => ("υ", Class::Variable), "phi" => ("ϕ", Class::Variable),
        "varphi" => ("φ", Class::Variable), "chi" => ("χ", Class::Variable),
        "psi" => ("ψ", Class::Variable), "omega" => ("ω", Class::Variable),

        // ギリシャ大文字は立体
        "Gamma" => ("Γ", Class::Ordinary), "Delta" => ("Δ", Class::Ordinary),
        "Theta" => ("Θ", Class::Ordinary), "Lambda" => ("Λ", Class::Ordinary),
        "Xi" => ("Ξ", Class::Ordinary), "Pi" => ("Π", Class::Ordinary),
        "Sigma" => ("Σ", Class::Ordinary), "Upsilon" => ("Υ", Class::Ordinary),
        "Phi" => ("Φ", Class::Ordinary), "Psi" => ("Ψ", Class::Ordinary),
        "Omega" => ("Ω", Class::Ordinary),

        // 二項演算子
        "times" => ("×", Class::Binary), "div" => ("÷", Class::Binary),
        "cdot" => ("⋅", Class::Binary), "pm" => ("±", Class::Binary),
        "mp" => ("∓", Class::Binary), "ast" => ("∗", Class::Binary),
        "star" => ("⋆", Class::Binary), "circ" => ("∘", Class::Binary),
        "bullet" => ("∙", Class::Binary), "cup" => ("∪", Class::Binary),
        "cap" => ("∩", Class::Binary), "setminus" => ("∖", Class::Binary),
        "wedge" | "land" => ("∧", Class::Binary), "vee" | "lor" => ("∨", Class::Binary),
        "oplus" => ("⊕", Class::Binary), "ominus" => ("⊖", Class::Binary),
        "sqcup" => ("⊔", Class::Binary), "sqcap" => ("⊓", Class::Binary),
        "amalg" => ("⨿", Class::Binary), "uplus" => ("⊎", Class::Binary),
        "rtimes" => ("⋊", Class::Binary), "ltimes" => ("⋉", Class::Binary),
        "smallsetminus" => ("∖", Class::Binary), "diamond" => ("⋄", Class::Binary),
        "boxplus" => ("⊞", Class::Binary), "boxtimes" => ("⊠", Class::Binary),
        "otimes" => ("⊗", Class::Binary), "oslash" => ("⊘", Class::Binary),
        "odot" => ("⊙", Class::Binary), "dagger" => ("†", Class::Binary),

        // 関係記号
        "leq" | "le" => ("≤", Class::Relation), "geq" | "ge" => ("≥", Class::Relation),
        "neq" | "ne" => ("≠", Class::Relation), "approx" => ("≈", Class::Relation),
        "equiv" => ("≡", Class::Relation), "sim" => ("∼", Class::Relation),
        "simeq" => ("≃", Class::Relation), "cong" => ("≅", Class::Relation),
        "propto" => ("∝", Class::Relation), "ll" => ("≪", Class::Relation),
        "gg" => ("≫", Class::Relation), "prec" => ("≺", Class::Relation),
        "succ" => ("≻", Class::Relation), "parallel" => ("∥", Class::Relation),
        "perp" => ("⊥", Class::Relation), "mid" => ("∣", Class::Relation),
        "to" | "rightarrow" => ("→", Class::Relation),
        "leftarrow" | "gets" => ("←", Class::Relation),
        "leftrightarrow" => ("↔", Class::Relation),
        "Rightarrow" | "implies" => ("⇒", Class::Relation),
        "Leftarrow" => ("⇐", Class::Relation),
        "Leftrightarrow" | "iff" => ("⇔", Class::Relation),
        "mapsto" => ("↦", Class::Relation), "uparrow" => ("↑", Class::Relation),
        "downarrow" => ("↓", Class::Relation),
        "in" => ("∈", Class::Relation), "notin" => ("∉", Class::Relation),
        "ni" => ("∋", Class::Relation),
        "subset" => ("⊂", Class::Relation), "subseteq" => ("⊆", Class::Relation),
        "supset" => ("⊃", Class::Relation), "supseteq" => ("⊇", Class::Relation),
        "subsetneq" => ("⊊", Class::Relation), "supsetneq" => ("⊋", Class::Relation),
        "nsubseteq" => ("⊈", Class::Relation), "sqsubseteq" => ("⊑", Class::Relation),
        "sqsupseteq" => ("⊒", Class::Relation),
        "leqslant" => ("⩽", Class::Relation), "geqslant" => ("⩾", Class::Relation),
        "lesssim" => ("≲", Class::Relation), "gtrsim" => ("≳", Class::Relation),
        "asymp" => ("≍", Class::Relation), "doteq" => ("≐", Class::Relation),
        "fallingdotseq" => ("≒", Class::Relation),
        "preceq" => ("⪯", Class::Relation), "succeq" => ("⪰", Class::Relation),
        "trianglelefteq" => ("⊴", Class::Relation), "trianglerighteq" => ("⊵", Class::Relation),
        "lhd" => ("◁", Class::Relation), "rhd" => ("▷", Class::Relation),
        "vdash" => ("⊢", Class::Relation), "dashv" => ("⊣", Class::Relation),
        "models" => ("⊨", Class::Relation), "nmid" => ("∤", Class::Relation),
        "nparallel" => ("∦", Class::Relation),
        "therefore" => ("∴", Class::Relation), "because" => ("∵", Class::Relation),
        "hookrightarrow" => ("↪", Class::Relation), "hookleftarrow" => ("↩", Class::Relation),
        "twoheadrightarrow" => ("↠", Class::Relation), "twoheadleftarrow" => ("↞", Class::Relation),
        "rightarrowtail" => ("↣", Class::Relation), "leftarrowtail" => ("↢", Class::Relation),
        "longrightarrow" => ("⟶", Class::Relation), "longleftarrow" => ("⟵", Class::Relation),
        "longleftrightarrow" => ("⟷", Class::Relation), "longmapsto" => ("⟼", Class::Relation),
        "Longrightarrow" => ("⟹", Class::Relation), "Longleftarrow" => ("⟸", Class::Relation),
        "Longleftrightarrow" => ("⟺", Class::Relation),
        "nearrow" => ("↗", Class::Relation), "searrow" => ("↘", Class::Relation),
        "swarrow" => ("↙", Class::Relation), "nwarrow" => ("↖", Class::Relation),
        "rightrightarrows" => ("⇉", Class::Relation), "rightleftarrows" => ("⇄", Class::Relation),

        // 大きな演算子
        "sum" => ("∑", Class::Large), "prod" => ("∏", Class::Large),
        "coprod" => ("∐", Class::Large), "int" => ("∫", Class::Large),
        "iint" => ("∬", Class::Large), "oint" => ("∮", Class::Large),
        "bigcup" => ("⋃", Class::Large), "bigcap" => ("⋂", Class::Large),
        "bigsqcup" => ("⨆", Class::Large), "biguplus" => ("⨄", Class::Large),
        "bigwedge" => ("⋀", Class::Large), "bigvee" => ("⋁", Class::Large),
        "bigodot" => ("⨀", Class::Large), "iiint" => ("∭", Class::Large),
        "oiint" => ("∯", Class::Large),
        "bigoplus" => ("⨁", Class::Large), "bigotimes" => ("⨂", Class::Large),

        // その他の記号
        "infty" => ("∞", Class::Ordinary), "partial" => ("∂", Class::Ordinary),
        "nabla" => ("∇", Class::Ordinary), "forall" => ("∀", Class::Ordinary),
        "exists" => ("∃", Class::Ordinary), "nexists" => ("∄", Class::Ordinary),
        "neg" | "lnot" => ("¬", Class::Ordinary), "emptyset" => ("∅", Class::Ordinary),
        "aleph" => ("ℵ", Class::Ordinary), "hbar" => ("ℏ", Class::Ordinary),
        "ell" => ("ℓ", Class::Variable), "Re" => ("ℜ", Class::Ordinary),
        "Im" => ("ℑ", Class::Ordinary), "wp" => ("℘", Class::Ordinary),
        "angle" => ("∠", Class::Ordinary), "triangle" => ("△", Class::Ordinary),
        "degree" => ("°", Class::Ordinary), "prime" => ("′", Class::Ordinary),
        "surd" => ("√", Class::Ordinary), "top" => ("⊤", Class::Ordinary),
        "bot" => ("⊥", Class::Ordinary),
        "ldots" | "dots" => ("…", Class::Ordinary), "cdots" => ("⋯", Class::Ordinary),
        "vdots" => ("⋮", Class::Ordinary), "ddots" => ("⋱", Class::Ordinary),
        "varnothing" => ("∅", Class::Ordinary), "beth" => ("ℶ", Class::Ordinary),
        "square" => ("□", Class::Ordinary), "blacksquare" => ("■", Class::Ordinary),
        "imath" => ("ı", Class::Variable), "jmath" => ("ȷ", Class::Variable),
        "flat" => ("♭", Class::Ordinary), "sharp" => ("♯", Class::Ordinary),
        "natural" => ("♮", Class::Ordinary),
        "colon" => (":", Class::Punctuation),
        "lVert" => ("‖", Class::Open), "rVert" => ("‖", Class::Close),
        "lvert" => ("|", Class::Open), "rvert" => ("|", Class::Close),

        // 括弧として使う記号
        "langle" => ("⟨", Class::Open), "rangle" => ("⟩", Class::Close),
        "lceil" => ("⌈", Class::Open), "rceil" => ("⌉", Class::Close),
        "lfloor" => ("⌊", Class::Open), "rfloor" => ("⌋", Class::Close),
        "{" | "lbrace" => ("{", Class::Open), "}" | "rbrace" => ("}", Class::Close),
        "|" | "Vert" => ("‖", Class::Ordinary), "vert" => ("|", Class::Ordinary),
        "backslash" => ("\\", Class::Ordinary),

        // エスケープした文字
        "%" => ("%", Class::Ordinary), "&" => ("&", Class::Ordinary),
        "#" => ("#", Class::Ordinary), "$" => ("$", Class::Ordinary),
        "_" => ("_", Class::Ordinary),

        // 関数名は立体で組む
        "sin" => ("sin", Class::Function), "cos" => ("cos", Class::Function),
        "tan" => ("tan", Class::Function), "cot" => ("cot", Class::Function),
        "sec" => ("sec", Class::Function), "csc" => ("csc", Class::Function),
        "arcsin" => ("arcsin", Class::Function), "arccos" => ("arccos", Class::Function),
        "arctan" => ("arctan", Class::Function), "sinh" => ("sinh", Class::Function),
        "cosh" => ("cosh", Class::Function), "tanh" => ("tanh", Class::Function),
        "log" => ("log", Class::Function), "ln" => ("ln", Class::Function),
        "lg" => ("lg", Class::Function), "exp" => ("exp", Class::Function),
        "det" => ("det", Class::Function), "dim" => ("dim", Class::Function),
        "ker" => ("ker", Class::Function), "deg" => ("deg", Class::Function),
        "arg" => ("arg", Class::Function), "Pr" => ("Pr", Class::Function),
        "lim" => ("lim", Class::Function), "limsup" => ("lim sup", Class::Function),
        "liminf" => ("lim inf", Class::Function), "max" => ("max", Class::Function),
        "min" => ("min", Class::Function), "sup" => ("sup", Class::Function),
        "varprojlim" => ("lim", Class::Function), "varinjlim" => ("lim", Class::Function),
        "bmod" => ("mod", Class::Binary), "hom" => ("hom", Class::Function),
        "inf" => ("inf", Class::Function), "gcd" => ("gcd", Class::Function),

        _ => return None,
    };
    Some(found)
}


/// 幅だけを持つコマンド。返す値は em
pub fn space(name: &str) -> Option<f64> {
    let width = match name {
        "!" => -3.0 / 18.0,
        "," | "thinspace" => 3.0 / 18.0,
        ":" | "medspace" => 4.0 / 18.0,
        ";" | "thickspace" => 5.0 / 18.0,
        " " => 4.0 / 18.0,
        "enspace" => 0.5,
        "quad" => 1.0,
        "qquad" => 2.0,
        _ => return None,
    };
    Some(width)
}


/// display のとき、上下に添字を置く演算子かどうか
pub fn takes_limits(name: &str) -> bool {
    matches!(
        name,
        "sum" | "prod" | "coprod" | "bigcup" | "bigcap" | "bigoplus" | "bigotimes"
            | "bigsqcup" | "biguplus" | "bigwedge" | "bigvee" | "bigodot"
            | "lim" | "limsup" | "liminf" | "max" | "min" | "sup" | "inf" | "gcd"
            | "varprojlim" | "varinjlim"
    )
}


/// 上に付ける印を返す
pub fn accent(name: &str) -> Option<&'static str> {
    let mark = match name {
        // 数式フォントは組み合わせ用の位置に印の字形を持っている。
        // 単独で置ける字とは形も位置も違うので、こちらを使う
        "hat" | "widehat" => "\u{302}",
        "tilde" | "widetilde" => "\u{303}",
        "dot" => "\u{307}",
        "ddot" => "\u{308}",
        "check" => "\u{30c}",
        "breve" => "\u{306}",
        "acute" => "\u{301}",
        "grave" => "\u{300}",
        "vec" => "\u{20d7}",
        _ => return None,
    };
    Some(mark)
}


/// 装いを変えるコマンド
pub fn style(name: &str) -> Option<Style> {
    let found = match name {
        "mathrm" => Style::Roman,
        "mathit" => Style::Italic,
        "mathbf" => Style::Bold,
        "bm" | "boldsymbol" => Style::BoldItalic,
        "mathbb" => Style::Blackboard,
        "mathcal" | "mathscr" => Style::Script,
        "mathfrak" => Style::Fraktur,
        "mathsf" => Style::SansSerif,
        "mathtt" => Style::Monospace,
        _ => return None,
    };
    Some(found)
}


/// \left と \right の後に置ける括弧。コマンドはバックスラッシュ付きの名前で引く
pub fn delimiter(text: &str) -> Option<&'static str> {
    let shown = match text {
        "." => "",
        "(" => "(",
        ")" => ")",
        "[" | "\\lbrack" => "[",
        "]" | "\\rbrack" => "]",
        "|" | "\\vert" | "\\lvert" | "\\rvert" | "\\mid" => "|",
        "\\|" | "\\Vert" | "\\lVert" | "\\rVert" => "‖",
        "\\{" | "\\lbrace" => "{",
        "\\}" | "\\rbrace" => "}",
        "\\langle" => "⟨",
        "\\rangle" => "⟩",
        "\\lceil" => "⌈",
        "\\rceil" => "⌉",
        "\\lfloor" => "⌊",
        "\\rfloor" => "⌋",
        "/" => "/",
        "\\backslash" => "\\",
        "\\uparrow" => "↑",
        "\\downarrow" => "↓",
        _ => return None,
    };
    Some(shown)
}


/// 装いに当たる数式用の文字。数式フォントはこれらを別の字形として持っている。
/// 字を傾けて作るのではなく、その装いのために引かれた字形を使うためのものである
pub fn styled(character: char, style: Style) -> Option<char> {
    match style {
        Style::Auto | Style::Roman => None,
        Style::Italic => italic(character),
        Style::Bold => bold(character),
        Style::BoldItalic => bold_italic(character),
        Style::Blackboard => blackboard(character),
        Style::Script => script(character),
        Style::Fraktur => fraktur(character),
        Style::SansSerif => sans_serif(character),
        Style::Monospace => monospace(character),
    }
}


/// 太字の斜体
#[rustfmt::skip]
pub fn bold_italic(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'A'..='Z' => 0x1d468 + (code - 0x41),
        'a'..='z' => 0x1d482 + (code - 0x61),
        'Α'..='Ω' => 0x1d71c + (code - 0x391),
        'α'..='ω' => 0x1d736 + (code - 0x3b1),
        _ => return bold(character),
    };

    char::from_u32(found)
}


/// スクリプト体。いくつかの字は別の位置に置かれている
#[rustfmt::skip]
pub fn script(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'B' => 0x212c, 'E' => 0x2130, 'F' => 0x2131, 'H' => 0x210b,
        'I' => 0x2110, 'L' => 0x2112, 'M' => 0x2133, 'R' => 0x211b,
        'A'..='Z' => 0x1d49c + (code - 0x41),
        'e' => 0x212f, 'g' => 0x210a, 'o' => 0x2134,
        'a'..='z' => 0x1d4b6 + (code - 0x61),
        _ => return None,
    };

    char::from_u32(found)
}


/// フラクトゥール
#[rustfmt::skip]
pub fn fraktur(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'C' => 0x212d, 'H' => 0x210c, 'I' => 0x2111, 'R' => 0x211c, 'Z' => 0x2128,
        'A'..='Z' => 0x1d504 + (code - 0x41),
        'a'..='z' => 0x1d51e + (code - 0x61),
        _ => return None,
    };

    char::from_u32(found)
}


/// サンセリフ
#[rustfmt::skip]
pub fn sans_serif(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'A'..='Z' => 0x1d5a0 + (code - 0x41),
        'a'..='z' => 0x1d5ba + (code - 0x61),
        '0'..='9' => 0x1d7e2 + (code - 0x30),
        _ => return None,
    };

    char::from_u32(found)
}


/// 等幅
#[rustfmt::skip]
pub fn monospace(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'A'..='Z' => 0x1d670 + (code - 0x41),
        'a'..='z' => 0x1d68a + (code - 0x61),
        '0'..='9' => 0x1d7f6 + (code - 0x30),
        _ => return None,
    };

    char::from_u32(found)
}


/// 斜体の数式文字
#[rustfmt::skip]
pub fn italic(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        // h だけは数式用の斜体がなく、プランク定数の字形を使う
        'h' => 0x210e,
        'A'..='Z' => 0x1d434 + (code - 0x41),
        'a'..='z' => 0x1d44e + (code - 0x61),
        'Α'..='Ω' => 0x1d6e2 + (code - 0x391),
        'α'..='ω' => 0x1d6fc + (code - 0x3b1),
        'ϵ' => 0x1d716, 'ϑ' => 0x1d717, 'ϰ' => 0x1d718,
        'ϕ' => 0x1d719, 'ϱ' => 0x1d71a, 'ϖ' => 0x1d71b,
        '∂' => 0x1d715, '∇' => 0x1d6fb,
        _ => return None,
    };

    char::from_u32(found)
}


/// 太字の数式文字
#[rustfmt::skip]
pub fn bold(character: char) -> Option<char> {
    let code = character as u32;
    let found = match character {
        'A'..='Z' => 0x1d400 + (code - 0x41),
        'a'..='z' => 0x1d41a + (code - 0x61),
        '0'..='9' => 0x1d7ce + (code - 0x30),
        'Α'..='Ω' => 0x1d6a8 + (code - 0x391),
        'α'..='ω' => 0x1d6c2 + (code - 0x3b1),
        'ϵ' => 0x1d6dc, 'ϑ' => 0x1d6dd, 'ϰ' => 0x1d6de,
        'ϕ' => 0x1d6df, 'ϱ' => 0x1d6e0, 'ϖ' => 0x1d6e1,
        '∂' => 0x1d6db, '∇' => 0x1d6c1,
        _ => return None,
    };

    char::from_u32(found)
}


/// 黒板太字にした文字
#[rustfmt::skip]
pub fn blackboard(character: char) -> Option<char> {
    let found = match character {
        'C' => 'ℂ', 'H' => 'ℍ', 'N' => 'ℕ', 'P' => 'ℙ', 'Q' => 'ℚ', 'R' => 'ℝ', 'Z' => 'ℤ',
        'A'..='Z' => char::from_u32(0x1d538 + (character as u32 - 'A' as u32))?,
        'a'..='z' => char::from_u32(0x1d552 + (character as u32 - 'a' as u32))?,
        '0'..='9' => char::from_u32(0x1d7d8 + (character as u32 - '0' as u32))?,
        _ => return None,
    };
    Some(found)
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn looks_up_symbols() {
        assert_eq!(symbol("alpha"), Some(("α", Class::Variable)));
        assert_eq!(symbol("leq"), Some(("≤", Class::Relation)));
        assert_eq!(symbol("sum"), Some(("∑", Class::Large)));
        assert_eq!(symbol("nowhere"), None);
    }

    #[test]
    fn spaces_have_widths() {
        assert_eq!(space("quad"), Some(1.0));
        assert!(space("!").unwrap() < 0.0);
        assert_eq!(space("alpha"), None);
    }

    #[test]
    fn math_letters_have_their_own_shapes() {
        assert_eq!(styled('x', Style::Italic), Some('\u{1d465}'));
        assert_eq!(styled('h', Style::Italic), Some('\u{210e}'));
        assert_eq!(styled('α', Style::Italic), Some('\u{1d6fc}'));
        assert_eq!(styled('ϕ', Style::Italic), Some('\u{1d719}'));
        assert_eq!(styled('φ', Style::Italic), Some('\u{1d711}'));
        assert_eq!(styled('A', Style::Bold), Some('\u{1d400}'));
        assert_eq!(styled('2', Style::Bold), Some('\u{1d7d0}'));
        assert_eq!(styled('x', Style::Roman), None);
        assert_eq!(styled('+', Style::Italic), None);
    }

    #[test]
    fn the_other_alphabets() {
        assert_eq!(styled('C', Style::Script), Some('\u{1d49e}'));
        assert_eq!(styled('L', Style::Script), Some('\u{2112}'));
        assert_eq!(styled('g', Style::Fraktur), Some('\u{1d524}'));
        assert_eq!(styled('R', Style::Fraktur), Some('\u{211c}'));
        assert_eq!(styled('S', Style::SansSerif), Some('\u{1d5b2}'));
        assert_eq!(styled('T', Style::Monospace), Some('\u{1d683}'));
        assert_eq!(styled('a', Style::BoldItalic), Some('\u{1d482}'));
        assert_eq!(styled('α', Style::BoldItalic), Some('\u{1d736}'));
    }

    #[test]
    fn blackboard_letters() {
        assert_eq!(blackboard('R'), Some('ℝ'));
        assert_eq!(blackboard('A'), Some('𝔸'));
        assert_eq!(blackboard('+'), None);
    }

    #[test]
    fn delimiters_tell_commands_from_characters() {
        assert_eq!(delimiter("|"), Some("|"));
        assert_eq!(delimiter("\\|"), Some("‖"));
        assert_eq!(delimiter("."), Some(""));
        assert_eq!(delimiter("x"), None);
    }
}