From 950dbddd44011beb89dbbd6210af01b8b609f625 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Thu, 25 Sep 2025 17:18:35 +0200 Subject: [PATCH 1/8] texexpr.jl: `TeXExpr`, dispatch on Val{head_symb} --- src/parser/texexpr.jl | 43 ++++++++++++++++++++++++++++--------------- 1 file changed, 28 insertions(+), 15 deletions(-) diff --git a/src/parser/texexpr.jl b/src/parser/texexpr.jl index acc29ea..e44e9ee 100644 --- a/src/parser/texexpr.jl +++ b/src/parser/texexpr.jl @@ -22,26 +22,31 @@ struct TeXExpr head::Symbol args::Vector{Any} - function TeXExpr(head, args::Vector) - # Convert math font like `\mathbb{R}` -- TeXExpr(:font, [:bb, 'R']) -- - # to unicode symbols -- e.g. TeXExpr(:symbol, 'ℝ') - if length(args) == 2 && head == :font && haskey(_math_font_mappings, args[1]) - font, content = args - to_font = _math_font_mappings[font] - return leafmap(content) do leaf - sym = only(leaf.args) - return TeXExpr(:symbol, to_font(sym)) - end - end - - return new(head, args) - end + TeXExpr(head, args::Vector)=_TeXExpr(Val(head), args) + TeXExpr(::Val{head}, args::Vector) where {head} = new(head, args) end TeXExpr(head) = TeXExpr(head, []) TeXExpr(head, args...) = TeXExpr(head, collect(args)) TeXExpr(head, arg) = TeXExpr(head, [arg]) +_TeXExpr(val_head::Val, args::Vector) = TeXExpr(val_head, args) + +function _TeXExpr(::Val{:font}, args::Vector) + # Convert math font like `\mathbb{R}` -- TeXExpr(:font, [:bb, 'R']) -- + # to unicode symbols -- e.g. TeXExpr(:symbol, 'ℝ') + if length(args) == 2 && haskey(_math_font_mappings, args[1]) + font, content = args + to_font = _math_font_mappings[font] + return leafmap(content) do leaf + sym = only(leaf.args) + return TeXExpr(:symbol, to_font(sym)) + end + end + + return TeXExpr(Val(:font), args) +end + Base.push!(texexpr::TeXExpr, arg) = push!(texexpr.args, arg) Base.pop!(texexpr::TeXExpr) = pop!(texexpr.args) Base.copy(texexpr::TeXExpr) = TeXExpr(texexpr.head, deepcopy(texexpr.args)) @@ -102,8 +107,16 @@ manual_texexpr(any) = any head(texexpr::TeXExpr) = texexpr.head head(::Char) = :char -isleaf(texexpr::TeXExpr) = texexpr.head in (:char, :delimiter, :digit, :punctuation, :symbol) isleaf(::Nothing) = true +isleaf(texexpr::TeXExpr) = _isleaf(Val(texexpr.head)) +_isleaf(::Val{head}) where head = false +_isleaf(::Union{ + Val{:char}, + Val{:delimiter}, + Val{:digit}, + Val{:punctuation}, + Val{:symbol} +}) = true function AbstractTrees.children(texexpr::TeXExpr) isleaf(texexpr) && return TeXExpr[] From 74bd6a8a7d68187d125aa8f3848b089080a33199 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Thu, 25 Sep 2025 18:19:23 +0200 Subject: [PATCH 2/8] add UnicodeMath.jl dependency and enable `\symxx` --- Project.toml | 1 + src/MathTeXEngine.jl | 1 + src/engine/fonts.jl | 10 ++--- src/engine/layout_context.jl | 3 +- src/engine/texelements.jl | 27 ++++++++++++++ src/parser/commands_registration.jl | 5 +++ src/parser/texexpr.jl | 58 +++++++++++++++-------------- 7 files changed, 71 insertions(+), 34 deletions(-) diff --git a/Project.toml b/Project.toml index be5d9d2..f2dc133 100644 --- a/Project.toml +++ b/Project.toml @@ -13,6 +13,7 @@ LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" RelocatableFolders = "05181044-ff0b-4ac5-8273-598c1e38db00" UnicodeFun = "1cfade01-22cf-5700-b092-accc4b62d6e1" +UnicodeMath = "0d34d933-8ee7-410a-b7f5-1fe550df0327" [compat] AbstractTrees = "0.3, 0.4" diff --git a/src/MathTeXEngine.jl b/src/MathTeXEngine.jl index ffb03f3..1543fc6 100644 --- a/src/MathTeXEngine.jl +++ b/src/MathTeXEngine.jl @@ -7,6 +7,7 @@ using Automa using FreeTypeAbstraction using LaTeXStrings using UnicodeFun +import UnicodeMath as UCM using DataStructures: Stack using GeometryBasics: Point2f, Rect2f diff --git a/src/engine/fonts.jl b/src/engine/fonts.jl index 677bfc2..b1a4697 100644 --- a/src/engine/fonts.jl +++ b/src/engine/fonts.jl @@ -29,12 +29,12 @@ end const _default_font_mapping = Dict( :text => :regular, - :delimiter => :regular, - :digit => :regular, - :function => :regular, - :punctuation => :regular, + :delimiter => :math, + :digit => :math, + :function => :math, + :punctuation => :math, :symbol => :math, - :char => :italic + :char => :math ) const _default_font_modifiers = Dict( diff --git a/src/engine/layout_context.jl b/src/engine/layout_context.jl index 5c9b8db..9e4d1e4 100644 --- a/src/engine/layout_context.jl +++ b/src/engine/layout_context.jl @@ -32,8 +32,9 @@ function get_font(state::LayoutState, char_type) font_id = font_family.font_mapping[char_type] for modifier in state.font_modifiers + @show modifier if haskey(font_family.font_modifiers, modifier) - mapping = font_family.font_modifiers[modifier] + @show mapping = font_family.font_modifiers[modifier] font_id = get(mapping, font_id, font_id) else throw(ArgumentError("font modifier $modifier not supported for the current font family.")) diff --git a/src/engine/texelements.jl b/src/engine/texelements.jl index 2d32932..37b04d8 100644 --- a/src/engine/texelements.jl +++ b/src/engine/texelements.jl @@ -157,6 +157,19 @@ function TeXChar(char::Char, state::LayoutState, char_type) return TeXChar(id, font, font_family, false, char) end + if state.tex_mode == :inline_math && char_type != :ucm_glyph + ## check if `char` is meant to be typeset using `:math` font + if get(state.font_family.font_mapping, char_type, :notmath) == :math + ## if `:math` font is used, apply UnicodeMath styling standard + char = UCM._sym(char) + end + end + + ## now treat any :ucm_glyph same as a :symbol + if char_type == :ucm_glyph + char_type = :symbol + end + font = get_font(state, char_type) return TeXChar( @@ -167,6 +180,20 @@ function TeXChar(char::Char, state::LayoutState, char_type) char) end +function _ucm_stylize(head, char, _ffm = nothing) + global _unicode_math_substitutions_ref + + !(_unicode_math_substitutions_ref[]) && return char + + if head in (:char, :delimiter, :digit, :punctuation, :symbol) + ffm = isnothing(_ffm) ? get_texfont_family() : _ffm + if get(ffm.font_mapping, head, :notmath) == :math + char = UCM.sym_style(char) + end + end + return char +end + function TeXChar(name::AbstractString, state::LayoutState, char_type ; represented='?') font_family = state.font_family font = get_font(state, char_type) diff --git a/src/parser/commands_registration.jl b/src/parser/commands_registration.jl index 11f474f..a4577c9 100644 --- a/src/parser/commands_registration.jl +++ b/src/parser/commands_registration.jl @@ -94,6 +94,11 @@ for name in font_names end command_definitions["\\text"] = (TeXExpr(:text, :rm), 1) +for style_symb in UCM.all_styles + com_str = "\\sym$(style_symb)" + command_definitions[com_str] = (TeXExpr(:sym, style_symb), 1) +end + ## ## Symbols ## diff --git a/src/parser/texexpr.jl b/src/parser/texexpr.jl index e44e9ee..05dd5c4 100644 --- a/src/parser/texexpr.jl +++ b/src/parser/texexpr.jl @@ -22,31 +22,38 @@ struct TeXExpr head::Symbol args::Vector{Any} - TeXExpr(head, args::Vector)=_TeXExpr(Val(head), args) - TeXExpr(::Val{head}, args::Vector) where {head} = new(head, args) + function TeXExpr(head, args::Vector) + if head == :font + # Convert math font like `\mathbb{R}` -- TeXExpr(:font, [:bb, 'R']) -- + # to unicode symbols -- e.g. TeXExpr(:symbol, 'ℝ') + if length(args) == 2 && haskey(_math_font_mappings, args[1]) + font, content = args + to_font = _math_font_mappings[font] + return leafmap(content) do leaf + sym = only(leaf.args) + return TeXExpr(:symbol, to_font(sym)) + end + end + end + if head == :sym + # Convert math font like `\symbb{R}` -- TeXExpr(:sym, [:bb, 'R']) -- + # to unicode symbols -- e.g. TeXExpr(:ucm_glyph, 'ℝ') + if length(args) == 2 && args[1] in UCM.all_styles + style_symb, content = args + return leafmap(content) do leaf + glyph = only(leaf.args) + return TeXExpr(:ucm_glyph, UCM._sym(glyph, style_symb)) + end + end + end + return new(head, args) + end end TeXExpr(head) = TeXExpr(head, []) TeXExpr(head, args...) = TeXExpr(head, collect(args)) TeXExpr(head, arg) = TeXExpr(head, [arg]) -_TeXExpr(val_head::Val, args::Vector) = TeXExpr(val_head, args) - -function _TeXExpr(::Val{:font}, args::Vector) - # Convert math font like `\mathbb{R}` -- TeXExpr(:font, [:bb, 'R']) -- - # to unicode symbols -- e.g. TeXExpr(:symbol, 'ℝ') - if length(args) == 2 && haskey(_math_font_mappings, args[1]) - font, content = args - to_font = _math_font_mappings[font] - return leafmap(content) do leaf - sym = only(leaf.args) - return TeXExpr(:symbol, to_font(sym)) - end - end - - return TeXExpr(Val(:font), args) -end - Base.push!(texexpr::TeXExpr, arg) = push!(texexpr.args, arg) Base.pop!(texexpr::TeXExpr) = pop!(texexpr.args) Base.copy(texexpr::TeXExpr) = TeXExpr(texexpr.head, deepcopy(texexpr.args)) @@ -107,16 +114,11 @@ manual_texexpr(any) = any head(texexpr::TeXExpr) = texexpr.head head(::Char) = :char +function isleaf(texexpr::TeXExpr) + return texexpr.head in ( + :char, :delimiter, :digit, :punctuation, :symbol, :ucm_glyph) +end isleaf(::Nothing) = true -isleaf(texexpr::TeXExpr) = _isleaf(Val(texexpr.head)) -_isleaf(::Val{head}) where head = false -_isleaf(::Union{ - Val{:char}, - Val{:delimiter}, - Val{:digit}, - Val{:punctuation}, - Val{:symbol} -}) = true function AbstractTrees.children(texexpr::TeXExpr) isleaf(texexpr) && return TeXExpr[] From 8ddabf608dc4f8595835fa891bc62cb5bfc48bd1 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Thu, 25 Sep 2025 18:24:46 +0200 Subject: [PATCH 3/8] remove debug @show statements --- src/engine/layout_context.jl | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/engine/layout_context.jl b/src/engine/layout_context.jl index 9e4d1e4..5c9b8db 100644 --- a/src/engine/layout_context.jl +++ b/src/engine/layout_context.jl @@ -32,9 +32,8 @@ function get_font(state::LayoutState, char_type) font_id = font_family.font_mapping[char_type] for modifier in state.font_modifiers - @show modifier if haskey(font_family.font_modifiers, modifier) - @show mapping = font_family.font_modifiers[modifier] + mapping = font_family.font_modifiers[modifier] font_id = get(mapping, font_id, font_id) else throw(ArgumentError("font modifier $modifier not supported for the current font family.")) From 99c431905cb0aa3d678e3d39c75b77648ee2a5f5 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Thu, 25 Sep 2025 18:25:40 +0200 Subject: [PATCH 4/8] remove old styling function not used anymore --- src/engine/texelements.jl | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/src/engine/texelements.jl b/src/engine/texelements.jl index 37b04d8..144fcdb 100644 --- a/src/engine/texelements.jl +++ b/src/engine/texelements.jl @@ -180,20 +180,6 @@ function TeXChar(char::Char, state::LayoutState, char_type) char) end -function _ucm_stylize(head, char, _ffm = nothing) - global _unicode_math_substitutions_ref - - !(_unicode_math_substitutions_ref[]) && return char - - if head in (:char, :delimiter, :digit, :punctuation, :symbol) - ffm = isnothing(_ffm) ? get_texfont_family() : _ffm - if get(ffm.font_mapping, head, :notmath) == :math - char = UCM.sym_style(char) - end - end - return char -end - function TeXChar(name::AbstractString, state::LayoutState, char_type ; represented='?') font_family = state.font_family font = get_font(state, char_type) From 35437cff5bbd399298a7a02a51beefe2ac1e1a15 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Tue, 21 Oct 2025 12:37:36 +0200 Subject: [PATCH 5/8] Refactor UnicodeMath integration --- Project.toml | 5 +- src/MathTeXEngine.jl | 7 +- src/UnicodeMath/LICENSE | 21 + src/UnicodeMath/README.md | 141 ++ src/UnicodeMath/src/UnicodeMath.jl | 222 +++ src/UnicodeMath/src/apply_style.jl | 594 ++++++ src/UnicodeMath/src/extra_commands.jl | 2461 +++++++++++++++++++++++++ src/UnicodeMath/src/ucmchars.jl | 413 +++++ src/UnicodeMath/test/alltests.jl | 383 ++++ src/UnicodeMath/test/runtests.jl | 5 + src/engine/fonts.jl | 95 +- src/engine/layout.jl | 26 +- src/engine/layout_context.jl | 39 +- src/engine/texelements.jl | 30 +- src/parser/commands_registration.jl | 19 +- src/parser/texexpr.jl | 34 +- test/layout.jl | 31 +- test/parser.jl | 3 +- test/runtests.jl | 8 +- 19 files changed, 4451 insertions(+), 86 deletions(-) create mode 100644 src/UnicodeMath/LICENSE create mode 100644 src/UnicodeMath/README.md create mode 100644 src/UnicodeMath/src/UnicodeMath.jl create mode 100644 src/UnicodeMath/src/apply_style.jl create mode 100644 src/UnicodeMath/src/extra_commands.jl create mode 100644 src/UnicodeMath/src/ucmchars.jl create mode 100644 src/UnicodeMath/test/alltests.jl create mode 100644 src/UnicodeMath/test/runtests.jl diff --git a/Project.toml b/Project.toml index f2dc133..7b8c698 100644 --- a/Project.toml +++ b/Project.toml @@ -12,8 +12,7 @@ GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" RelocatableFolders = "05181044-ff0b-4ac5-8273-598c1e38db00" -UnicodeFun = "1cfade01-22cf-5700-b092-accc4b62d6e1" -UnicodeMath = "0d34d933-8ee7-410a-b7f5-1fe550df0327" +UnPack = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" [compat] AbstractTrees = "0.3, 0.4" @@ -23,5 +22,5 @@ FreeTypeAbstraction = "0.10" GeometryBasics = "0.4.1, 0.5" LaTeXStrings = "1.2" RelocatableFolders = "0.1, 0.2, 0.3, 1" -UnicodeFun = "0.4" +UnPack = "1.0.2" julia = "1.6" diff --git a/src/MathTeXEngine.jl b/src/MathTeXEngine.jl index 1543fc6..13c234f 100644 --- a/src/MathTeXEngine.jl +++ b/src/MathTeXEngine.jl @@ -6,9 +6,12 @@ using AbstractTrees using Automa using FreeTypeAbstraction using LaTeXStrings -using UnicodeFun -import UnicodeMath as UCM +include("UnicodeMath/src/UnicodeMath.jl") +import .UnicodeMath as UCM +import .UnicodeMath: UCMConfig + +import UnPack: @unpack using DataStructures: Stack using GeometryBasics: Point2f, Rect2f using REPL.REPLCompletions: latex_symbols diff --git a/src/UnicodeMath/LICENSE b/src/UnicodeMath/LICENSE new file mode 100644 index 0000000..cf41da6 --- /dev/null +++ b/src/UnicodeMath/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Manuel B. Berkemeier + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/UnicodeMath/README.md b/src/UnicodeMath/README.md new file mode 100644 index 0000000..86a315e --- /dev/null +++ b/src/UnicodeMath/README.md @@ -0,0 +1,141 @@ +# UnicodeMath + +[![Build Status](https://github.com/manuelbb-upb/UnicodeMath.jl/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/manuelbb-upb/UnicodeMath.jl/actions/workflows/CI.yml?query=branch%3Amain) + +A small Julia package inspired by the great LaTeX package +[`unicode-math`](https://ctan.org/pkg/unicode-math?lang=en) that is available under +[the LaTeX Project Public License 1.3c](https://ctan.org/license/lppl1.3c). + +This project is not affiliated to `unicode-math`, the authors of `unicode-math` are +not responsible for this code, and do not offer support. + +## About +This module offers configurable Unicode glyph substitutions for Julia `Char`s or `AbstractString`s. +Specifically, the commands +``` +symup # upright shape +symit # italic/slanted shape +symbfup # bold upright +symbfit # bold italic +symsfup # sans-serif upright +symsfit # sans-serif italic +symbfsfup # bold sans-serif upright +symtt # mono spaced +symbb # blackboard +symbbit # blackboard italic +symcal # caligraphic +symbfcal # bold caligraphic +symfrak # frakture +symbffrak # bold frakture +``` +take as input a `Char` and, if applicable, return the correspondingly styled `Char`, e.g., as defined in the +[Alphanumeric Symbols Unicode block](https://en.wikipedia.org/wiki/Mathematical_operators_and_symbols_in_Unicode#Mathematical_Alphanumeric_Symbols_block). +These commands have direct equivalents in the LaTeX package `unicode-math` and are similar to commands in +[`UnicodeFun.jl`](https://github.com/SimonDanisch/UnicodeFun.jl): +``` +to_blackboardbold +to_boldface +to_italic +to_caligraphic +to_frakture +to_latex +``` + +If there is no symbol defined for the requested style, the input `Char` is returned. +Input strings are parsed one `Char` at a time. + +Internally, we define **alphabets**, e.g. +``` +:latin # lower case latin letters +:Latin # upper case latin letters +:greek # lower case greek letters +:Greek # upper case greek letters +:num # digits 0-9 +``` +Not every style is available for every character of every alphabet. +Please refer to the `unicode-math` manual for details, especially Table 7, or check the source file `apply_style.jl`. + +Besides the direct substitution commands, there are also +``` +_sym # normalization +symbf # bold +symsf # sans-serif +symbfsf # bold sans-serif +``` +These commands depend on a style configuration. +For example, `symbf` could return bold upright glyphs (`:bold_style=:upright`), +bold italic glyphs (`:bold_style=:italic`) or bold glyphs for which the shape is +chosen according to the input shape (`:bold_style=:literal`). + +The configuration is expressed by an `UCMConfig` object and is hierarchical. +The `math_style_spec` value (`:tex` (default), `:iso`, `:french`, `:upright`, `:literal`) induces +preconfigured values for `normal_style_spec`, `bold_style_spec`, `sans_style` as well as styling +information for the `:nabla` and `:partial` glyphs. +Both `normal_style_spec` and `bold_style_spec` in turn define a `normal_style` or `bold_style` +values for the latin and greek alphabets. +The defaults can be overwritten with the corresponding keyword arguments of the `UCMConfig` +constructor. +The following values are valid: +* `math_style_spec`: `:tex, :iso, :french, :upright, :literal` +* `normal_style_spec`: `:iso, :tex, :french, :upright, :literal` + or a `NamedTuple` with fields `:Greek, :greek, :Latin, :latin` and values `:upright, :italic, :literal`. +* `bold_style_spec`: `:iso, :tex, :upright, :literal` + or a `NamedTuple` with fields `:Greek, :greek, :Latin, :latin` and values `:upright, :italic, :literal`. +* `sans_style`, `partial`, `nabla`: `:upright, :italic, :literal` + +For `_sym` and the `sym` commands, a global configuration is set via `global_config!(cfg)` +or `global_config!(; kwargs...)`. +Alternatively, the lower level `apply_style` function can be called with configuration directly, as shown in the examples. + +## Examples + +### Basic Formatting +Use `apply_style` to format a `Char` or an `AbstractString` according to some configuration: +```julia-repl +julia> import UnicodeMath as UCM +julia> src = "BX 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝜵 az 𝑎𝑧 𝛤𝛯 𝛻 ∂ 𝛛 ΓΞ 𝛼𝛽 1 𝜞𝜩 𝛂𝛃" +julia> cfg_tex = UCM.UCMConfig(; math_style_spec=:tex) +julia> UCM.apply_style(src, cfg_tex) +"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷" +``` + +The same keyword arguments that define `UCMConfig` can be given to apply style directly: +```julia-repl +julia> UCM.apply_style(src; math_style_spec=:iso) +"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝜞𝜩 𝛁 𝑎𝑧 𝑎𝑧 𝛤𝛯 ∇ 𝜕 𝝏 𝛤𝛯 𝛼𝛽 1 𝜞𝜩 𝜶𝜷" +julia> UCM.apply_style(src; math_style_spec=:upright) +"BX BX ∇ 𝛁 ∂ 𝛛 𝛂𝛃 αβ 𝚪𝚵 𝛁 az az ΓΞ ∇ ∂ 𝛛 ΓΞ αβ 1 𝚪𝚵 𝛂𝛃" +julia> UCM.apply_style(src; math_style_spec=:french) +"BX BX ∇ 𝛁 ∂ 𝛛 𝛂𝛃 αβ 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ ∂ 𝛛 ΓΞ αβ 1 𝚪𝚵 𝛂𝛃" +``` + +### Target Style + +A target style can be forced. +```julia-repl +julia> UCM.apply_style(src, :bfup; math_style_spec=:iso) +"𝐁𝐗 𝐁𝐗 𝛁 𝛁 𝛛 𝛛 𝛂𝛃 𝛂𝛃 𝚪𝚵 𝛁 𝐚𝐳 𝐚𝐳 𝚪𝚵 𝛁 𝛛 𝛛 𝚪𝚵 𝛂𝛃 𝟏 𝚪𝚵 𝛂𝛃" +``` + +The styles `:bf`, `:sf` and `:bfsf` still depend on the configuration: +```julia-repl +julia> UCM.apply_style(src, :bf; math_style_spec=:iso) +"𝑩𝑿 𝑩𝑿 𝛁 𝛁 𝝏 𝝏 𝜶𝜷 𝜶𝜷 𝚪𝚵 𝜵 𝒂𝒛 𝒂𝒛 𝜞𝜩 𝛁 𝝏 𝛛 𝜞𝜩 𝜶𝜷 𝟏 𝜞𝜩 𝛂𝛃" +``` +In this example, bold glyphs have not been changed, otherwise bold italic glyphs for latin and greek letters are used. + +### Global Commands +Apply default styling (`math_style_spec=:tex`), i.e., italic regular-weight letters, except for uppercase Greek letters, which are printed upright, and upright bold-weight letters, except for lowercase greek, which are printed slanted: +```julia-repl +julia> UCM._sym(src) +"𝐵𝑋 𝐵𝑋 ∇ 𝛁 𝜕 𝝏 𝜶𝜷 𝛼𝛽 𝚪𝚵 𝛁 𝑎𝑧 𝑎𝑧 ΓΞ ∇ 𝜕 𝝏 ΓΞ 𝛼𝛽 1 𝚪𝚵 𝜶𝜷" +``` +Change the configuration: +```julia-repl +julia> UCM.global_config!(;normal_style_spec=:upright) +``` +Now regular-weight letters are all upright: +```julia-repl +julia> UCM._sym(src) +"BX BX ∇ 𝛁 𝜕 𝝏 𝜶𝜷 αβ 𝚪𝚵 𝛁 az az ΓΞ ∇ 𝜕 𝝏 ΓΞ αβ 1 𝚪𝚵 𝜶𝜷" +``` \ No newline at end of file diff --git a/src/UnicodeMath/src/UnicodeMath.jl b/src/UnicodeMath/src/UnicodeMath.jl new file mode 100644 index 0000000..9e5080a --- /dev/null +++ b/src/UnicodeMath/src/UnicodeMath.jl @@ -0,0 +1,222 @@ +""" + UnicodeMath + +A Julia package inspired by the great LaTeX package `unicode-math`. +As a user you should care mainly about [`apply_style`](@ref) and the globally +configured functions [`_sym`](@ref) and `symbf`, `symit`, etc. +The latter are configured with [`global_config!`](@ref) +""" +module UnicodeMath +#= +# Typography Terminology + +When it comes to typography, common concepts have different names in different contexts. +Here is what Wikipedia has to say about “typeface” and “font”: + +> A typeface (or font family) is a design of letters, numbers and other symbols, +> to be used in printing or for electronic display. +> Most typefaces include variations in size (e.g., 24 point), weight (e.g., light, bold), +> slope (e.g., italic), width (e.g., condensed), and so on. +> Each of these variations of the typeface is a font. + + Wikipedia contributors, "Typeface," Wikipedia, The Free Encyclopedia, + https://en.wikipedia.org/w/index.php?title=Typeface&oldid=1309901840 + (accessed September 24, 2025). + +E.g., “Times” is a typeface family, and “Times Roman” and “Times Italic” are +typefaces/font families within that typeface, and “Times Roman 10” is a font within +the typeface “Times Roman”. + +According to https://texdoc.org/serve/fntguide/0, LaTeX uses +* “family” to refer to a typeface/font family, e.g. “CMU Serif”, +* “series” for weight and spacing, +* “shape” is the form of the letters, e.g., “italic” or “upright”. +Together with “size”, a font can be selected. + +For maths, commands such as `\mathbf` are defined via +`\DeclareMathAlphabet {⟨math-alph⟩} {⟨encoding⟩} {⟨family⟩} {⟨series⟩} {⟨shape⟩}`. +Hence, a “math-alphabet” is really just a specific font +(that has glyphs for a subset of mathematical characters). +In `unicode-math`, the new wrapper command is aptly named `\setmathfontface`. +It is okay to use “alphabet” in a hand-wavy manner, because even Wikipedia and +package documentation does so. + +> Every typeface is a collection of glyphs, each of which represents an individual +> letter, number, punctuation mark, or other symbol. +> The same glyph may be used for characters from different writing systems, +> e.g. Roman uppercase A looks the same as Cyrillic uppercase А and Greek uppercase alpha (Α). +> There are typefaces tailored for special applications, such as cartography, astrology or mathematics. + + Wikipedia contributors, "Typeface," Wikipedia, The Free Encyclopedia, + https://en.wikipedia.org/w/index.php?title=Typeface&oldid=1309901840 + (accessed September 24, 2025). + +In accordance with https://en.wikipedia.org/wiki/Glyph, the concept of a letter, number, etc. +is a grapheme-like unit, or an (abstract) character. +A glyph is its graphical representation. + +In Unicode, collections of characters often form +[scripts](https://en.wikipedia.org/wiki/Script_(Unicode)), +and usually, style information is not encoded in scripts. + +Except for math charactes, **which do not constitute a script**. +Unicode has various styles for many mathematical characters. +For example, the abstract character “A” has styled variants +“𝐀” (MATHEMATICAL BOLD CAPITAL A) or “𝐴” (MATHEMATICAL ITALIC CAPITAL A). +Usually style variants (series or shape) would be provided by different fontfaces, +but math fonts contain these stylized variants themselves. + +The LaTeX package `unicode-math` has commands like `\symbf` that map between different +styles and emulate legacy commands, but do not switch fontfaces for mathematical characters +that have style variants. + +# ## Package Naming Conventions + +We mimic some of the functionality of `unicode-math` for string formatting in Julia. +To this end, we define our own “alphabets”, which are sets of abstract characters. +E.g. `:num` are numbers, `:latin` are lowercase Latin characters, and `:Greek` +are uppercase Greek characters. +There are also singleton sets to allow for granular configuration. + +Within an alphabet each abstract character has a unique “name”, i.e. "1" or "a" or "Alpha". + +Then there are styles, i.e., combinations of series and shape properties. +A math font can provide glyphs for styles defined in `base_styles` for the characters in our +alphabets. +There are styles like `:bf` (bold) or `:sf` (sans-serif) for which the mapping is +more complicated. +We might wish to have bold italic letters by default, i.e., `:bf` should alias `:bfit` +depending on a (global) configuration. + +For us, specific fonts are not relevant, so we call the Unicode characters that are mapped +“glyphs”. +It is unavoidable that sometimes the terms “character”/“glyph”/“symbol” are used +synonymously, but hopefully context disolves confusion. +It doesn't help that Julia has types `Symbol` and `Char`. +Indeed, a glyph is represented by a `Char`. +=# + +# # Simple Global Definitions +# External Dependencies: +import UnPack: @unpack + +# Simple Type Constants: +const Nothymbol = Union{Nothing, Symbol} +const SpecTup = @NamedTuple{Greek::Symbol, greek::Symbol, Latin::Symbol, latin::Symbol} + +# # Extra LaTeX Commands +# Include standalone file defining `extra_commands::Dict{Symbol,UCMCommand}`. +# The dict has custom commands defined in `unicode-math` +# which are extracted from the LaTeX source code. +include("extra_commands.jl") # `extra_commands` + +# # Styling +# Symbols for base styles (excluding derived styles like `bf`, `sf`, `bfsfup`): +const base_styles = ( + :up, :it, + :bfup, :bfit, + :sfup, :sfit, + :bfsfup, :bfsfit, + :tt, + :bb, :bbit, + :cal, :bfcal, + :frak, :bffrak +) + +# Symbols for every possible style: +const all_styles = (base_styles..., :bf, :sf, :bfsf) + +# Alphabet definitions: +include("ucmchars.jl") +const Glyph = Union{Char, UCMChar} + +# A nested dict that is needed for mapping between styles: +const ucmchars_by_alphabet_style_name = all_ucmchars() +# A dict mapping `Char`s to `UCMChar`s (which store meta data): +const chars_to_ucmchars = inverse_ucm_dict(ucmchars_by_alphabet_style_name) + +# The basic styling command, needing configuration: +include("apply_style.jl") + +# ## Global Styling Commands +# Prepare defaults for global styling commands: +const default_config_dicts = config_dicts() +const default_substitutions = default_config_dicts.substitutions +const default_aliases = default_config_dicts.aliases + +# Store internal references so that the actual config dicts can be modified: +const default_substitutions_ref = Ref(default_substitutions) +const default_aliases_ref = Ref(default_aliases) + +""" + global_config!(; kwargs...) + global_config!(cfg::UCMConfig) + +Configure how styling functions such as `symbf` act. +Take the same keyword arguments as [`UCMConfig`](@ref). +""" +function global_config!(args...; kwargs...) + global default_substitutions_ref, default_aliases_ref + s, a = config_dicts(args...; kwargs...) + default_substitutions_ref[] = s + default_aliases_ref[] = a + return nothing +end + +# Basic global styling command: +""" + _sym(glyph::Union{Char, UCMChar, AbstractString}; is_styled=false) + _sym(glyph::Union{Char, UCMChar, AbstractString}, trgt_style::Symbol; is_styled=false) + +Try to style `glyph` according to global configuration, which is set by +[`global_config!`](@ref). + +## `is_styled` keyword argument +The special keyword argument `is_styled` defines how unspecific target styles +(like `:bf` or `sf`) are handled. +In absence of a `trgt_style`, it also determines if upright or italic glyphs are “normalized”. + +### Without `trgt_style` +If there is no explicit `trgt_style`, then `trgt_style` matches the style of `glyph`. +E.g., `a` results in `trgt_style = :up` and `𝑎` in `trgt_style = :it`. +If `is_styled == false`, then `glyph` will be normalized according to configuration. +In `:iso` style, both `a` and `𝑎` should be styled to `𝑎`. +If `is_styled == true`, the styling is a no-op in this case. + +### With `trgt_style` +If `is_styled == true`, then an italic glyph will become bolditalic for `trgt_style == :bf`, +independent of the configuration. +If `is_styled == false`, then the glyph is considered “typed by the user” and the bold style +depends on the configuration. +""" +function _sym end + +function _sym(x::Union{AbstractString,Glyph}, trgt_style::Symbol...; is_styled=false) + global default_substitutions_ref, default_aliases_ref + + return apply_style( + x, + default_substitutions_ref[], + default_aliases_ref[], + trgt_style...; + is_styled + ) +end + +# Derive specific styling functions like `symbf`: +for sn in all_styles + f = Symbol("sym", sn) + @eval begin + """ + $($(Meta.quot(f)))(glyph::Union{Char, UCMChar, AbstractString}; is_styled=false) + + If applicable, return a new `Char` with style fitting `:$($(Meta.quot(sn)))`. + For information on the `is_styled` keyword argument, + see [`apply_style`](@ref) or [`_sym`](@ref).""" + function $(f)(x::Union{AbstractString, Glyph}; is_styled=false) + return _sym(x, $(Meta.quot(sn)); is_styled) + end + end +end + +end#module \ No newline at end of file diff --git a/src/UnicodeMath/src/apply_style.jl b/src/UnicodeMath/src/apply_style.jl new file mode 100644 index 0000000..99f619c --- /dev/null +++ b/src/UnicodeMath/src/apply_style.jl @@ -0,0 +1,594 @@ +const EMPTY_DICT = Base.ImmutableDict{Nothing, Nothing}() + +# There are several parameters that influence how glyphs are mapped. + +# A **normal style** defines how a user typed character in a standard style +# (`:up` or `it`) is mapped to glyphs. +# `:italic` forces italic glyphs, `:upright` forces upright glyphs, +# `:literal` does not change style. +# Similarly, a **bold style** specifies whether or not bold glyphs are upright or +# slanted. Same for **sans style**. +# Special alphabets (`partial`, `nabla`) can be configured, too. +# +# A normal style specification (:iso, :tex, ...) assigns normal styles to glyphs from +# certain alphabets, and a bold style specification assigns bold styles to glyphs from +# certain alphabets. +# +# On the top level, a math style specification sets normal and bold style specifications +# and styles for the other alphabets. + +""" + UCMConfig(; math_style_spec = :tex, kwargs...) + +Styling configuration. The keywords `normal_style_spec`, `bold_style_spec`, `sans_style`, +`partial` and `nabla` can be used to override defaults set by `math_style_spec`. +""" +Base.@kwdef struct UCMConfig + math_style_spec :: Nothymbol = :tex + ## overrides + normal_style_spec :: Union{SpecTup,Nothymbol} = nothing + bold_style_spec :: Union{SpecTup,Nothymbol} = nothing + sans_style :: Nothymbol = nothing + partial :: Nothymbol = nothing + nabla :: Nothymbol = nothing +end + +""" + apply_style(cfg::UCMConfig, glyph::Char; is_styled=false) + apply_style(cfg::UCMConfig, glyph::Char, trgt_style::Symbol; is_styled=false) + apply_style(glyph::Char; is_styled=false, kwargs...) + apply_style(glyph::Char, trgt_style::Symbol; is_styled=false, kwargs...) + +Stylize glyph according to configuration `cfg` or keyword arguments `kwargs...`. + +## `is_styled` keyword argument +The special keyword argument `is_styled` defines how unspecific target styles +(like `:bf` or `sf`) are handled. +In absence of a `trgt_style`, it also determines if upright or italic glyphs are “normalized”. + +### Without `trgt_style` +If there is no explicit `trgt_style`, then `trgt_style` matches the style of `glyph`. +E.g., `a` results in `trgt_style = :up` and `𝑎` in `trgt_style = :it`. +If `is_styled == false`, then `glyph` will be normalized according to configuration. +In `:iso` style, both `a` and `𝑎` should be styled to `𝑎`. +If `is_styled == true`, the styling is a no-op in this case. + +### With `trgt_style` +If `is_styled == true`, then an italic glyph will become bolditalic for `trgt_style == :bf`, +independent of the configuration. +If `is_styled == false`, then the glyph is considered “typed by the user” and the bold style +depends on the configuration. +""" +function apply_style end + +function apply_style(ch::Char, args...; kwargs...) + ucm_ch = get(chars_to_ucmchars, ch, nothing) + isnothing(ucm_ch) && return ch + _ucm_ch = apply_style(ucm_ch, args...; kwargs...) + return _ucm_ch.glyph +end + +function apply_style( + ucm_ch::UCMChar, cfg::UCMConfig, trgt_style::Symbol...; + is_styled=false +) + @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg + @unpack substitutions, aliases = config_dicts(; + math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla) + return apply_style(ucm_ch, substitutions, aliases, trgt_style...; is_styled) +end + +function apply_style( + ucm_ch::UCMChar, trgt_style::Symbol...; + is_styled=false, kwargs... +) + cfg = UCMConfig(; kwargs...) + return apply_style(ucm_ch, cfg, trgt_style...; is_styled) +end + +function apply_style( + ucm_ch::UCMChar, substitutions::AbstractDict, aliases::AbstractDict; + is_styled=false +) + trgt_style = ucm_ch.style + return apply_style(ucm_ch, substitutions, aliases, trgt_style; is_styled) +end + +function apply_style( + ucm_ch::UCMChar, substitutions::AbstractDict, aliases::AbstractDict, trgt_style::Symbol; + is_styled=false, +) + if !is_styled + ucm_ch = UCMChar( + ucm_ch.name, ucm_ch.alphabet, _typed_style(ucm_ch.style), ucm_ch.glyph) + end + + subs_alphabet = get(substitutions, ucm_ch.alphabet, EMPTY_DICT) + subs_current_style = get(subs_alphabet, ucm_ch.style, EMPTY_DICT) + trgt_style = get(subs_current_style, trgt_style, trgt_style) + + alisaes_alphabet = get(aliases, ucm_ch.alphabet, EMPTY_DICT) + trgt_style = get(alisaes_alphabet, trgt_style, trgt_style) + + return _choose_style(ucm_ch, trgt_style) +end + +function apply_style( + io::IO, ch::Glyph, args...; kwargs... +) + print(io, apply_style(ch, args...; kwargs...)) +end + +function apply_style(io::IO, str::AbstractString, args...; kwargs...) + cls = ch -> apply_style(ch, args...; kwargs...) + for ch in str + print(io, cls(ch)) + end +end + +function apply_style(str::AbstractString, args...; kwargs...) + sprint() do io + apply_style(io, str, args...; kwargs...) + end +end + +function _typed_style(symb) + _symb = if symb == :up + ## check normal style + :UP + elseif symb == :it + ## check normal style + :IT + elseif symb == :bfup + ## check bold style + :BFUP + elseif symb == :bfit + ## check bold style + :BFIT + elseif symb == :sfup + ## check sans style + :SFUP + elseif symb == :sfit + ## check sans style + :SFIT + elseif symb == :bfsfup + ## check sans style + :BFSFUP + elseif symb == :bfsfit + ## check sans style + :BFSFIT + else + symb + end + return _symb +end + +## helper function -- given `ucm_ch::UCMChar` and a target style like `:bf`, +## return the corresponding `UCMChar` from the styled alphabet, if it is available for `ucm_ch`. +function _choose_style(ucm_ch, style_symb) + _ucm_ch = _choose_style(ucm_ch.name, ucm_ch.alphabet, style_symb) + isnothing(_ucm_ch) && return ucm_ch + return _ucm_ch +end + +function _choose_style(name_str, alphabet_symb, style_symb) + global ucmchars_by_alphabet_style_name + ## check if the alphabet is key for outer dict: + ucmchars_by_style_name = get(ucmchars_by_alphabet_style_name, alphabet_symb, nothing) + isnothing(ucmchars_by_style_name) && return nothing + + ## check if target style is key in 2nd level: + ucmchars_by_name = get(ucmchars_by_style_name, style_symb, nothing) + isnothing(ucmchars_by_name) && return nothing + + ## inner dict has `name => UCMChar` entries for target style. + ## return value if it exists + ucm_ch = get(ucmchars_by_name, name_str, nothing) + return ucm_ch +end + +function parse_config(; + math_style_spec=:tex, + normal_style_spec=nothing, + bold_style_spec=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing +) + cfg = if math_style_spec == :iso + (; + nabla = :upright, + partial = :italic, + normal_style_spec = :iso, + bold_style_spec = :iso, + sans_style = :italic + ) + elseif math_style_spec == :tex + (; + nabla = :upright, + partial = :italic, + normal_style_spec = :tex, + bold_style_spec = :tex, + sans_style = :upright + ) + elseif math_style_spec == :french + (; + nabla = :upright, + partial = :upright, + normal_style_spec = :french, + bold_style_spec = :upright, + sans_style = :upright + ) + elseif math_style_spec == :upright + (; + nabla = :upright, + partial = :upright, + normal_style_spec = :upright, + bold_style_spec = :upright, + sans_style = :upright + ) + else + (; + nabla = :literal, + partial = :literal, + normal_style_spec = :literal, + bold_style_spec = :literal, + sans_style = :literal + ) + end + normal_style_spec = isnothing(normal_style_spec) ? cfg.normal_style_spec : normal_style_spec + bold_style_spec = isnothing(bold_style_spec) ? cfg.bold_style_spec : bold_style_spec + sans_style = isnothing(sans_style) ? cfg.sans_style : sans_style + partial = isnothing(partial) ? cfg.partial : partial + nabla = isnothing(nabla) ? cfg.nabla : nabla + return (; nabla, partial, normal_style_spec, bold_style_spec, sans_style) +end + +function config_dicts(cfg::UCMConfig) + @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg + return config_dicts(; + math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla) +end + +function config_dicts(; kwargs...) + cfg = parse_config(; kwargs...) + substitutions = alphabet_substitutions(; cfg...) + + aliases_num = Dict( + :it => :up, + :bf => :bfup, + :bfit => :bfup, + :sf => :sfup, + :sfit => :sfup, + :bfsf => :bfsfup, + :bfsfit => :bfsfup, + :bbit => :bb # this is different from LaTeX package + ) + aliases = Dict( + :num => aliases_num + ) + + return (; substitutions, aliases) +end + +# For a given alphabet, we generate a “substitutions dict (of dicts)” to map between styles. +# It is a bit verbose, but simple and we avoid recursion this way: +function alphabet_substitutions(; + normal_style_spec, + bold_style_spec, + sans_style, + partial, + nabla +) + ns = parse_normal_style_spec(normal_style_spec) + bs = parse_bold_style_spec(bold_style_spec) + subs = Dict( + :num => _subtitutions_dict(; normal_style=:upright, bold_style=:upright, sans_style=:upright), + :Greek => _subtitutions_dict(; normal_style=ns.Greek, bold_style=bs.Greek, sans_style), + :greek => _subtitutions_dict(; normal_style=ns.greek, bold_style=bs.greek, sans_style), + :Latin => _subtitutions_dict(; normal_style=ns.Latin, bold_style=bs.Latin, sans_style), + :latin => _subtitutions_dict(; normal_style=ns.latin, bold_style=bs.latin, sans_style), + :partial => _subtitutions_dict(; normal_style=partial, bold_style=partial, sans_style=partial), + :Nabla => _subtitutions_dict(; normal_style=nabla, bold_style=nabla, sans_style=nabla), + ) + subs[:dotless] = subs[:latin] + + return subs +end + +# A normal style (:iso, :tex, :french, :upright) assigns normal style specification to alphabets: +function parse_normal_style_spec(normal_style_spec::Symbol) + normal_style_ntup = if normal_style_spec == :iso + (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif normal_style_spec == :tex + (; + Greek = :upright, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif normal_style_spec == :french + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :italic + ) + elseif normal_style_spec == :upright + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + else + (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) + end + return normal_style_ntup +end +function parse_normal_style_spec(spec::SpecTup) + for symb in values(spec) + @assert symb in (:literal, :upright, :italic) + end + return spec +end +function parse_normal_style_spec(spec) + error("Normal style specification must be a symbol or of type $(SpecTup)") +end + +function parse_bold_style_spec( + bold_style_spec::Symbol +) + bold_style_ntup = if bold_style_spec == :iso + (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + elseif bold_style_spec == :tex + (; + Greek = :upright, + greek = :italic, + Latin = :upright, + latin = :upright + ) + elseif bold_style_spec == :upright + (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + else + (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) + end + return bold_style_ntup +end +function parse_bold_style_spec(spec::SpecTup) + for symb in values(spec) + @assert symb in (:literal, :upright, :italic) + end + return spec +end +function parse_bold_style_spec(spec) + error("Bold style specification must be a symbol or of type $(SpecTup)") +end + +function _subtitutions_dict(; + normal_style=:literal, + bold_style=:literal, + sans_style=:literal +) + ## `subs_up`: how glyphs with an upright style should be transformed if we request + ## a certain style, which are keys of this dict + subs_up = Dict( sn => sn for sn = base_styles ) + subs_up[:bf] = :bfup + subs_up[:sf] = :sfup + subs_up[:bfsf] = :bfsfup + + subs_UP = copy(subs_up) + subs_UP[:up] = normal_style == :italic ? :it : (normal_style == :upright ? :up : :up) + subs_UP[:bf] = if bold_style == :upright ### expanded for illustration purposes + ### bold_style forces upright bold + :bfup + elseif bold_style == :italic + ### bold_style forces italic bold + :bfit + else + ### bold_style does not care about slanting, we have an `:up` glyph, so keep it that way + :bfup + end + subs_UP[:sf] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfup) + subs_UP[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + ## `subs_it`: transformations for italic glyphs + subs_it = Dict( sn => sn for sn = base_styles ) + subs_it[:bf] = :bfit + subs_it[:sf] = :sfit + subs_it[:bfsf] = :bfsfit + subs_it[:bb] = :bbit + + subs_IT = copy(subs_it) + subs_IT[:it] = normal_style == :italic ? :it : (normal_style == :upright ? :up : :it) + subs_IT[:bf] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfit) + subs_IT[:sf] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfit) + subs_IT[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + #subs_it[:bb] = :bbit # `blackboard_style`? + + ## `sub_bfup`: transformations for bold upright glyphs + subs_bfup = Dict( + :up => :bfup, # no-op + :bfup => :bfup, # no-op + :bf => :bfup, # no-op + :it => :bfit, + :bfit => :bfit, + :sfup => :bfsfup, + :bfsf => :bfsf, + :bfsfup => :bfsfup, + :sfit => :bfsfit, + :bfsfit => :bfsfit, + :cal => :bfcal, + :frak => :bffrak, + ) + subs_BFUP = copy(subs_bfup) + subs_BFUP[:bf] = subs_BFUP[:bfup] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfup) + subs_BFUP[:bfsf] = subs_bfup[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + ## `sub_bfit`: transformations for bold italic glyphs + subs_bfit = Dict( + :bf => :bfit, # no-op + :bfit => :bfit, # no-op + :it => :bfit, # no-op + :up => :bfup, # undo italization + :bfup => :bfup, # undo italization + :sfit => :bfsfit, + :bfsf => :bfsfit, + :bfsfit => :bfsfit, + :sfup => :bfsfup, + :bfsfup => :bfsfup, + ) + subs_BFIT = copy(subs_bfit) + subs_BFIT[:bf] = subs_BFIT[:bfit] = bold_style == :upright ? :bfup : (bold_style == :italic ? :bfit : :bfit) + subs_BFIT[:bfsf] = subs_bfit[:sf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + + ## `sub_bfit`: transformations for sans-serif upright glyphs + subs_sfup = Dict( + :sf => :sfup, # no-op + :sfup => :sfup, # no-op + :up => :sfup, # no-op + :it => :sfit, + :sfit => :sfit, + :bfup => :bfsfup, + :bfsf => :bfsfup, + :bfsfup => :bfsfup, + :bfit => :bfsfit, + :bfsfit => :bfsfit, + ) + subs_SFUP = copy(subs_sfup) + subs_SFUP[:sfup] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfup) + subs_sfup[:bf] = subs_SFUP[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + ## `sub_bfit`: transformations for sans-serif italic glyphs + subs_sfit = Dict( + :sf => :sfit, # no-op + :sfit => :sfit, # no-op + :it => :sfit, # no-op + :up => :sfup, + :sfup => :sfup, + :bfit => :bfsfit, + :bfsf => :bfsfit, + :bfsfit => :bfsfit, + :bfup => :bfsfup, + :bfsfup => :bfsfup, + ) + subs_SFIT = copy(subs_sfit) + subs_SFIT[:sfit] = sans_style == :upright ? :sfup : (sans_style == :italic ? :sfit : :sfit) + subs_sfit[:bf] = subs_SFIT[:bfsf] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + + ## `sub_bfsfup`: transformations for bold sans-serif upright glyphs + subs_bfsfup = Dict( + ## no-ops: + :up => :bfsfup, + :bf => :bfsfup, + :sf => :bfsfup, + :bfup => :bfsfup, + :sfup => :bfsfup, + :bfsfup => :bfsfup, + ## other: + :it => :bfsfit, + :sfit => :bfsfit, + :bfsfit => :bfsfit + ) + subs_BFSFUP = copy(subs_bfsfup) + subs_BFSFUP[:bfsfup] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfup) + + ## `sub_bfsfit`: transformations for bold sans-serif italic glyphs + subs_bfsfit = Dict( + ## no-ops: + :it => :bfsfit, + :bf => :bfsfit, + :sf => :bfsfit, + :bfit => :bfsfit, + :sfit => :bfsfit, + :bfsfit => :bfsfit, + ## other: + :up => :bfsfup, + :sfup => :bfsfup, + :bfsfup => :bfsfup + ) + subs_BFSFIT = copy(subs_bfsfit) + subs_BFSFIT[:bfsfit] = sans_style == :upright ? :bfsfup : (sans_style == :italic ? :bfsfit : :bfsfit) + + ## other + subs_tt = Dict( + :tt => :tt, + :up => :tt, + ) + subs_bb = Dict( + :bb => :bb, + :up => :bb, + :it => :bbit + ) + subs_bbit = Dict( + :bb => :bbit, + :it => :bbit, + :up => :bb + ) + + subs_cal = Dict( + :cal => :cal, + :up => :cal, + :bf => :bfcal, + ) + subs_frak = Dict( + :frak => :frak, + :up => :frak, + :bf => :bffrak + ) + subs_bffrak = Dict( + :frak => :bffrak, + :up => :bffrak, + :bf => :bffrak + ) + + return Dict( + :up => subs_up, + :bfup => subs_bfup, + :it => subs_it, + :bfit => subs_bfit, + :sfup => subs_sfup, + :bfsfup => subs_bfsfup, + :sfit => subs_sfit, + :bfsfit => subs_bfsfit, + :tt => subs_tt, + :bb => subs_bb, + :bbit => subs_bbit, + :cal => subs_cal, + :frak => subs_frak, + :bffrak => subs_bffrak, + :UP => subs_UP, + :IT => subs_IT, + :BFUP => subs_BFUP, + :BFIT => subs_BFIT, + :SFUP => subs_SFUP, + :SFIT => subs_SFIT, + :BFSFUP => subs_BFSFUP, + :BFSFIT => subs_BFSFIT, + ) +end \ No newline at end of file diff --git a/src/UnicodeMath/src/extra_commands.jl b/src/UnicodeMath/src/extra_commands.jl new file mode 100644 index 0000000..a7458d3 --- /dev/null +++ b/src/UnicodeMath/src/extra_commands.jl @@ -0,0 +1,2461 @@ +# This file contains LaTeX commands originally +# defined in source file `unicode-math-table.tex` +# of the UNICODE-MATH package + +struct UCMCommand + latex_cmd :: String + glyph :: Char + group :: Symbol + desc :: String +end + +const extra_commands = Dict{Symbol, UCMCommand}( + :mathexclam => UCMCommand("\\mathexclam", '!', :mathclose, "exclamation mark"), + :mathoctothorpe => UCMCommand("\\mathoctothorpe", '#', :mathord, "number sign"), + :mathdollar => UCMCommand("\\mathdollar", '$', :mathord, "dollar sign"), + :mathpercent => UCMCommand("\\mathpercent", '%', :mathord, "percent sign"), + :mathampersand => UCMCommand("\\mathampersand", '&', :mathord, "ampersand"), + :lparen => UCMCommand("\\lparen", '(', :mathopen, "left parenthesis"), + :rparen => UCMCommand("\\rparen", ')', :mathclose, "right parenthesis"), + :mathplus => UCMCommand("\\mathplus", '+', :mathbin, "plus sign b:"), + :mathcomma => UCMCommand("\\mathcomma", ',', :mathpunct, "comma"), + :mathperiod => UCMCommand("\\mathperiod", '.', :mathord, "full stop, period"), + :mathslash => UCMCommand("\\mathslash", '/', :mathord, "solidus"), + :mathcolon => UCMCommand("\\mathcolon", ':', :mathpunct, "colon"), + :mathsemicolon => UCMCommand("\\mathsemicolon", ';', :mathpunct, "semicolon p:"), + :less => UCMCommand("\\less", '<', :mathrel, "less-than sign r:"), + :equal => UCMCommand("\\equal", '=', :mathrel, "equals sign r:"), + :greater => UCMCommand("\\greater", '>', :mathrel, "greater-than sign r:"), + :mathquestion => UCMCommand("\\mathquestion", '?', :mathord, "question mark"), + :mathatsign => UCMCommand("\\mathatsign", '@', :mathord, "commercial at"), + :lbrack => UCMCommand("\\lbrack", '[', :mathopen, "left square bracket"), + :backslash => UCMCommand("\\backslash", '\\', :mathord, "reverse solidus"), + :rbrack => UCMCommand("\\rbrack", ']', :mathclose, "right square bracket"), + :lbrace => UCMCommand("\\lbrace", '{', :mathopen, "left curly bracket"), + :vert => UCMCommand("\\vert", '|', :mathfence, "vertical bar"), + :rbrace => UCMCommand("\\rbrace", '}', :mathclose, "right curly bracket"), + :mathsterling => UCMCommand("\\mathsterling", '£', :mathord, "pound sign"), + :mathyen => UCMCommand("\\mathyen", '¥', :mathord, "yen sign"), + :mathsection => UCMCommand("\\mathsection", '§', :mathord, "section symbol"), + :neg => UCMCommand("\\neg", '¬', :mathord, "/neg /lnot not sign"), + :pm => UCMCommand("\\pm", '±', :mathbin, "plus-or-minus sign"), + :mathparagraph => UCMCommand("\\mathparagraph", '¶', :mathord, "paragraph symbol"), + :cdotp => UCMCommand("\\cdotp", '·', :mathbin, "/centerdot b: middle dot"), + :times => UCMCommand("\\times", '×', :mathbin, "multiply sign"), + :matheth => UCMCommand("\\matheth", 'ð', :mathalpha, "eth"), + :div => UCMCommand("\\div", '÷', :mathbin, "divide sign"), + :Zbar => UCMCommand("\\Zbar", 'Ƶ', :mathord, "impedance (latin capital letter z with stroke)"), + :grave => UCMCommand("\\grave", '̀', :mathaccent, "grave accent"), + :acute => UCMCommand("\\acute", '́', :mathaccent, "acute accent"), + :hat => UCMCommand("\\hat", '̂', :mathaccent, "circumflex accent"), + :widehat => UCMCommand("\\widehat", '̂', :mathaccentwide, "circumflex accent"), + :tilde => UCMCommand("\\tilde", '̃', :mathaccent, "tilde"), + :widetilde => UCMCommand("\\widetilde", '̃', :mathaccentwide, "tilde"), + :bar => UCMCommand("\\bar", '̄', :mathaccent, "macron"), + :overbar => UCMCommand("\\overbar", '̅', :mathaccent, "overbar embellishment"), + :wideoverbar => UCMCommand("\\wideoverbar", '̅', :mathaccentwide, "stretchy overbar embellishment"), + :breve => UCMCommand("\\breve", '̆', :mathaccent, "breve"), + :widebreve => UCMCommand("\\widebreve", '̆', :mathaccentwide, "stretchy breve"), + :dot => UCMCommand("\\dot", '̇', :mathaccent, "dot above"), + :ddot => UCMCommand("\\ddot", '̈', :mathaccent, "dieresis"), + :ovhook => UCMCommand("\\ovhook", '̉', :mathaccent, "combining hook above"), + :ocirc => UCMCommand("\\ocirc", '̊', :mathaccent, "ring"), + :check => UCMCommand("\\check", '̌', :mathaccent, "caron"), + :widecheck => UCMCommand("\\widecheck", '̌', :mathaccentwide, "stretchy caron"), + :candra => UCMCommand("\\candra", '̐', :mathaccent, "candrabindu (non-spacing)"), + :oturnedcomma => UCMCommand("\\oturnedcomma", '̒', :mathaccent, "combining turned comma above"), + :ocommatopright => UCMCommand("\\ocommatopright", '̕', :mathaccent, "combining comma above right"), + :droang => UCMCommand("\\droang", '̚', :mathaccent, "left angle above (non-spacing)"), + :wideutilde => UCMCommand("\\wideutilde", '̰', :mathbotaccentwide, "under tilde accent (multiple characters and non-spacing)"), + :mathunderbar => UCMCommand("\\mathunderbar", '̲', :mathbotaccentwide, "combining low line"), + :notaccent => UCMCommand("\\notaccent", '̸', :mathaccentoverlay, "combining long solidus overlay"), + :underleftrightarrow => UCMCommand("\\underleftrightarrow", '͍', :mathbotaccentwide, "underleftrightarrow accent"), + :mupAlpha => UCMCommand("\\mupAlpha", 'Α', :mathalpha, "capital alpha, greek"), + :mupBeta => UCMCommand("\\mupBeta", 'Β', :mathalpha, "capital beta, greek"), + :mupGamma => UCMCommand("\\mupGamma", 'Γ', :mathalpha, "capital gamma, greek"), + :mupDelta => UCMCommand("\\mupDelta", 'Δ', :mathalpha, "capital delta, greek"), + :mupEpsilon => UCMCommand("\\mupEpsilon", 'Ε', :mathalpha, "capital epsilon, greek"), + :mupZeta => UCMCommand("\\mupZeta", 'Ζ', :mathalpha, "capital zeta, greek"), + :mupEta => UCMCommand("\\mupEta", 'Η', :mathalpha, "capital eta, greek"), + :mupTheta => UCMCommand("\\mupTheta", 'Θ', :mathalpha, "capital theta, greek"), + :mupIota => UCMCommand("\\mupIota", 'Ι', :mathalpha, "capital iota, greek"), + :mupKappa => UCMCommand("\\mupKappa", 'Κ', :mathalpha, "capital kappa, greek"), + :mupLambda => UCMCommand("\\mupLambda", 'Λ', :mathalpha, "capital lambda, greek"), + :mupMu => UCMCommand("\\mupMu", 'Μ', :mathalpha, "capital mu, greek"), + :mupNu => UCMCommand("\\mupNu", 'Ν', :mathalpha, "capital nu, greek"), + :mupXi => UCMCommand("\\mupXi", 'Ξ', :mathalpha, "capital xi, greek"), + :mupOmicron => UCMCommand("\\mupOmicron", 'Ο', :mathalpha, "capital omicron, greek"), + :mupPi => UCMCommand("\\mupPi", 'Π', :mathalpha, "capital pi, greek"), + :mupRho => UCMCommand("\\mupRho", 'Ρ', :mathalpha, "capital rho, greek"), + :mupSigma => UCMCommand("\\mupSigma", 'Σ', :mathalpha, "capital sigma, greek"), + :mupTau => UCMCommand("\\mupTau", 'Τ', :mathalpha, "capital tau, greek"), + :mupUpsilon => UCMCommand("\\mupUpsilon", 'Υ', :mathalpha, "capital upsilon, greek"), + :mupPhi => UCMCommand("\\mupPhi", 'Φ', :mathalpha, "capital phi, greek"), + :mupChi => UCMCommand("\\mupChi", 'Χ', :mathalpha, "capital chi, greek"), + :mupPsi => UCMCommand("\\mupPsi", 'Ψ', :mathalpha, "capital psi, greek"), + :mupOmega => UCMCommand("\\mupOmega", 'Ω', :mathalpha, "capital omega, greek"), + :mupalpha => UCMCommand("\\mupalpha", 'α', :mathalpha, "small alpha, greek"), + :mupbeta => UCMCommand("\\mupbeta", 'β', :mathalpha, "small beta, greek"), + :mupgamma => UCMCommand("\\mupgamma", 'γ', :mathalpha, "small gamma, greek"), + :mupdelta => UCMCommand("\\mupdelta", 'δ', :mathalpha, "small delta, greek"), + :mupvarepsilon => UCMCommand("\\mupvarepsilon", 'ε', :mathalpha, "rounded small varepsilon, greek"), + :mupzeta => UCMCommand("\\mupzeta", 'ζ', :mathalpha, "small zeta, greek"), + :mupeta => UCMCommand("\\mupeta", 'η', :mathalpha, "small eta, greek"), + :muptheta => UCMCommand("\\muptheta", 'θ', :mathalpha, "straight theta, small theta, greek"), + :mupiota => UCMCommand("\\mupiota", 'ι', :mathalpha, "small iota, greek"), + :mupkappa => UCMCommand("\\mupkappa", 'κ', :mathalpha, "small kappa, greek"), + :muplambda => UCMCommand("\\muplambda", 'λ', :mathalpha, "small lambda, greek"), + :mupmu => UCMCommand("\\mupmu", 'μ', :mathalpha, "small mu, greek"), + :mupnu => UCMCommand("\\mupnu", 'ν', :mathalpha, "small nu, greek"), + :mupxi => UCMCommand("\\mupxi", 'ξ', :mathalpha, "small xi, greek"), + :mupomicron => UCMCommand("\\mupomicron", 'ο', :mathalpha, "small omicron, greek"), + :muppi => UCMCommand("\\muppi", 'π', :mathalpha, "small pi, greek"), + :muprho => UCMCommand("\\muprho", 'ρ', :mathalpha, "small rho, greek"), + :mupvarsigma => UCMCommand("\\mupvarsigma", 'ς', :mathalpha, "terminal sigma, greek"), + :mupsigma => UCMCommand("\\mupsigma", 'σ', :mathalpha, "small sigma, greek"), + :muptau => UCMCommand("\\muptau", 'τ', :mathalpha, "small tau, greek"), + :mupupsilon => UCMCommand("\\mupupsilon", 'υ', :mathalpha, "small upsilon, greek"), + :mupvarphi => UCMCommand("\\mupvarphi", 'φ', :mathalpha, "curly or open small phi, greek"), + :mupchi => UCMCommand("\\mupchi", 'χ', :mathalpha, "small chi, greek"), + :muppsi => UCMCommand("\\muppsi", 'ψ', :mathalpha, "small psi, greek"), + :mupomega => UCMCommand("\\mupomega", 'ω', :mathalpha, "small omega, greek"), + :mupvartheta => UCMCommand("\\mupvartheta", 'ϑ', :mathalpha, "/vartheta - curly or open theta"), + :mupphi => UCMCommand("\\mupphi", 'ϕ', :mathalpha, "/straightphi - small phi, greek"), + :mupvarpi => UCMCommand("\\mupvarpi", 'ϖ', :mathalpha, "rounded small pi (pomega), greek"), + :upDigamma => UCMCommand("\\upDigamma", 'Ϝ', :mathalpha, "capital digamma"), + :updigamma => UCMCommand("\\updigamma", 'ϝ', :mathalpha, "old greek small letter digamma"), + :mupvarkappa => UCMCommand("\\mupvarkappa", 'ϰ', :mathalpha, "rounded small kappa, greek"), + :mupvarrho => UCMCommand("\\mupvarrho", 'ϱ', :mathalpha, "rounded small rho, greek"), + :mupvarTheta => UCMCommand("\\mupvarTheta", 'ϴ', :mathalpha, "greek capital theta symbol"), + :mupepsilon => UCMCommand("\\mupepsilon", 'ϵ', :mathalpha, "greek lunate varepsilon symbol"), + :upbackepsilon => UCMCommand("\\upbackepsilon", '϶', :mathord, "greek reversed lunate epsilon symbol"), + :mathhyphen => UCMCommand("\\mathhyphen", '‐', :mathalpha, "hyphen"), + :horizbar => UCMCommand("\\horizbar", '―', :mathord, "horizontal bar"), + :Vert => UCMCommand("\\Vert", '‖', :mathfence, "double vertical bar"), + :twolowline => UCMCommand("\\twolowline", '‗', :mathord, "double low line (spacing)"), + :dagger => UCMCommand("\\dagger", '†', :mathbin, "dagger relation"), + :ddagger => UCMCommand("\\ddagger", '‡', :mathbin, "double dagger relation"), + :smblkcircle => UCMCommand("\\smblkcircle", '•', :mathbin, "/bullet b: round bullet, filled"), + :enleadertwodots => UCMCommand("\\enleadertwodots", '‥', :mathord, "double baseline dot (en leader)"), + :unicodeellipsis => UCMCommand("\\unicodeellipsis", '…', :mathord, "ellipsis (horizontal)"), + :prime => UCMCommand("\\prime", '′', :mathord, "prime or minute, not superscripted"), + :dprime => UCMCommand("\\dprime", '″', :mathord, "double prime or second, not superscripted"), + :trprime => UCMCommand("\\trprime", '‴', :mathord, "triple prime (not superscripted)"), + :backprime => UCMCommand("\\backprime", '‵', :mathord, "reverse prime, not superscripted"), + :backdprime => UCMCommand("\\backdprime", '‶', :mathord, "double reverse prime, not superscripted"), + :backtrprime => UCMCommand("\\backtrprime", '‷', :mathord, "triple reverse prime, not superscripted"), + :caretinsert => UCMCommand("\\caretinsert", '‸', :mathord, "caret (insertion mark)"), + :Exclam => UCMCommand("\\Exclam", '‼', :mathord, "double exclamation mark"), + :tieconcat => UCMCommand("\\tieconcat", '⁀', :mathbin, "character tie, z notation sequence concatenation"), + :hyphenbullet => UCMCommand("\\hyphenbullet", '⁃', :mathord, "rectangle, filled (hyphen bullet)"), + :fracslash => UCMCommand("\\fracslash", '⁄', :mathbin, "fraction slash"), + :Question => UCMCommand("\\Question", '⁇', :mathord, "double question mark"), + :closure => UCMCommand("\\closure", '⁐', :mathrel, "close up"), + :qprime => UCMCommand("\\qprime", '⁗', :mathord, "quadruple prime, not superscripted"), + :euro => UCMCommand("\\euro", '€', :mathord, "euro sign"), + :leftharpoonaccent => UCMCommand("\\leftharpoonaccent", '⃐', :mathaccent, "combining left harpoon above"), + :overleftharpoon => UCMCommand("\\overleftharpoon", '⃐', :mathaccentwide, "combining left harpoon above"), + :rightharpoonaccent => UCMCommand("\\rightharpoonaccent", '⃑', :mathaccent, "combining right harpoon above"), + :overrightharpoon => UCMCommand("\\overrightharpoon", '⃑', :mathaccentwide, "combining right harpoon above"), + :vertoverlay => UCMCommand("\\vertoverlay", '⃒', :mathaccent, "combining long vertical line overlay"), + :overleftarrow => UCMCommand("\\overleftarrow", '⃖', :mathaccentwide, "combining left arrow above"), + :overrightarrow => UCMCommand("\\overrightarrow", '⃗', :mathaccentwide, "combining left arrow above"), + :vec => UCMCommand("\\vec", '⃗', :mathaccent, "combining right arrow above"), + :dddot => UCMCommand("\\dddot", '⃛', :mathaccent, "combining three dots above"), + :ddddot => UCMCommand("\\ddddot", '⃜', :mathaccent, "combining four dots above"), + :enclosecircle => UCMCommand("\\enclosecircle", '⃝', :mathord, "combining enclosing circle"), + :enclosesquare => UCMCommand("\\enclosesquare", '⃞', :mathord, "combining enclosing square"), + :enclosediamond => UCMCommand("\\enclosediamond", '⃟', :mathord, "combining enclosing diamond"), + :overleftrightarrow => UCMCommand("\\overleftrightarrow", '⃡', :mathaccentwide, "combining left right arrow above"), + :enclosetriangle => UCMCommand("\\enclosetriangle", '⃤', :mathord, "combining enclosing upward pointing triangle"), + :annuity => UCMCommand("\\annuity", '⃧', :mathaccent, "combining annuity symbol"), + :threeunderdot => UCMCommand("\\threeunderdot", '⃨', :mathbotaccent, "combining triple underdot"), + :widebridgeabove => UCMCommand("\\widebridgeabove", '⃩', :mathaccent, "combining wide bridge above"), + :underrightharpoondown => UCMCommand("\\underrightharpoondown", '⃬', :mathbotaccentwide, "combining rightwards harpoon with barb downwards"), + :underleftharpoondown => UCMCommand("\\underleftharpoondown", '⃭', :mathbotaccentwide, "combining leftwards harpoon with barb downwards"), + :underleftarrow => UCMCommand("\\underleftarrow", '⃮', :mathbotaccentwide, "combining left arrow below"), + :underrightarrow => UCMCommand("\\underrightarrow", '⃯', :mathbotaccentwide, "combining right arrow below"), + :asteraccent => UCMCommand("\\asteraccent", '⃰', :mathaccent, "combining asterisk above"), + :BbbC => UCMCommand("\\BbbC", 'ℂ', :mathalpha, "/bbb c, open face c"), + :Eulerconst => UCMCommand("\\Eulerconst", 'ℇ', :mathord, "euler constant"), + :mscrg => UCMCommand("\\mscrg", 'ℊ', :mathalpha, "/scr g, script letter g"), + :mscrH => UCMCommand("\\mscrH", 'ℋ', :mathalpha, "hamiltonian (script capital h)"), + :mfrakH => UCMCommand("\\mfrakH", 'ℌ', :mathalpha, "/frak h, upper case h"), + :BbbH => UCMCommand("\\BbbH", 'ℍ', :mathalpha, "/bbb h, open face h"), + :Planckconst => UCMCommand("\\Planckconst", 'ℎ', :mathord, "planck constant"), + :hslash => UCMCommand("\\hslash", 'ℏ', :mathalpha, "/hslash - variant planck's over 2pi"), + :mscrI => UCMCommand("\\mscrI", 'ℐ', :mathalpha, "/scr i, script letter i"), + :Im => UCMCommand("\\Im", 'ℑ', :mathalpha, "imaginary part"), + :mscrL => UCMCommand("\\mscrL", 'ℒ', :mathalpha, "lagrangian (script capital l)"), + :ell => UCMCommand("\\ell", 'ℓ', :mathalpha, "cursive small l"), + :BbbN => UCMCommand("\\BbbN", 'ℕ', :mathalpha, "/bbb n, open face n"), + :wp => UCMCommand("\\wp", '℘', :mathalpha, "weierstrass p"), + :BbbP => UCMCommand("\\BbbP", 'ℙ', :mathalpha, "/bbb p, open face p"), + :BbbQ => UCMCommand("\\BbbQ", 'ℚ', :mathalpha, "/bbb q, open face q"), + :mscrR => UCMCommand("\\mscrR", 'ℛ', :mathalpha, "/scr r, script letter r"), + :Re => UCMCommand("\\Re", 'ℜ', :mathalpha, "real part"), + :BbbR => UCMCommand("\\BbbR", 'ℝ', :mathalpha, "/bbb r, open face r"), + :BbbZ => UCMCommand("\\BbbZ", 'ℤ', :mathalpha, "/bbb z, open face z"), + :mho => UCMCommand("\\mho", '℧', :mathord, "conductance"), + :mfrakZ => UCMCommand("\\mfrakZ", 'ℨ', :mathalpha, "/frak z, upper case z"), + :turnediota => UCMCommand("\\turnediota", '℩', :mathalpha, "turned iota"), + :Angstrom => UCMCommand("\\Angstrom", 'Å', :mathalpha, "angstrom capital a, ring"), + :mscrB => UCMCommand("\\mscrB", 'ℬ', :mathalpha, "bernoulli function (script capital b)"), + :mfrakC => UCMCommand("\\mfrakC", 'ℭ', :mathalpha, "black-letter capital c"), + :mscre => UCMCommand("\\mscre", 'ℯ', :mathalpha, "/scr e, script letter e"), + :mscrE => UCMCommand("\\mscrE", 'ℰ', :mathalpha, "/scr e, script letter e"), + :mscrF => UCMCommand("\\mscrF", 'ℱ', :mathalpha, "/scr f, script letter f"), + :Finv => UCMCommand("\\Finv", 'Ⅎ', :mathord, "turned capital f"), + :mscrM => UCMCommand("\\mscrM", 'ℳ', :mathalpha, "physics m-matrix (script capital m)"), + :mscro => UCMCommand("\\mscro", 'ℴ', :mathalpha, "order of (script small o)"), + :aleph => UCMCommand("\\aleph", 'ℵ', :mathalpha, "aleph, hebrew"), + :beth => UCMCommand("\\beth", 'ℶ', :mathalpha, "beth, hebrew"), + :gimel => UCMCommand("\\gimel", 'ℷ', :mathalpha, "gimel, hebrew"), + :daleth => UCMCommand("\\daleth", 'ℸ', :mathalpha, "daleth, hebrew"), + :Bbbpi => UCMCommand("\\Bbbpi", 'ℼ', :mathord, "double-struck small pi"), + :Bbbgamma => UCMCommand("\\Bbbgamma", 'ℽ', :mathalpha, "double-struck small gamma"), + :BbbGamma => UCMCommand("\\BbbGamma", 'ℾ', :mathalpha, "double-struck capital gamma"), + :BbbPi => UCMCommand("\\BbbPi", 'ℿ', :mathalpha, "double-struck capital pi"), + :Bbbsum => UCMCommand("\\Bbbsum", '⅀', :mathop, "double-struck n-ary summation"), + :Game => UCMCommand("\\Game", '⅁', :mathord, "turned sans-serif capital g"), + :sansLturned => UCMCommand("\\sansLturned", '⅂', :mathord, "turned sans-serif capital l"), + :sansLmirrored => UCMCommand("\\sansLmirrored", '⅃', :mathord, "reversed sans-serif capital l"), + :Yup => UCMCommand("\\Yup", '⅄', :mathord, "turned sans-serif capital y"), + :mitBbbD => UCMCommand("\\mitBbbD", 'ⅅ', :mathord, "double-struck italic capital d"), + :mitBbbd => UCMCommand("\\mitBbbd", 'ⅆ', :mathord, "double-struck italic small d"), + :mitBbbe => UCMCommand("\\mitBbbe", 'ⅇ', :mathord, "double-struck italic small e"), + :mitBbbi => UCMCommand("\\mitBbbi", 'ⅈ', :mathord, "double-struck italic small i"), + :mitBbbj => UCMCommand("\\mitBbbj", 'ⅉ', :mathord, "double-struck italic small j"), + :PropertyLine => UCMCommand("\\PropertyLine", '⅊', :mathord, "property line"), + :upand => UCMCommand("\\upand", '⅋', :mathbin, "turned ampersand"), + :leftarrow => UCMCommand("\\leftarrow", '←', :mathrel, "/leftarrow /gets a: leftward arrow"), + :uparrow => UCMCommand("\\uparrow", '↑', :mathrel, "upward arrow"), + :rightarrow => UCMCommand("\\rightarrow", '→', :mathrel, "/rightarrow /to a: rightward arrow"), + :downarrow => UCMCommand("\\downarrow", '↓', :mathrel, "downward arrow"), + :leftrightarrow => UCMCommand("\\leftrightarrow", '↔', :mathrel, "left and right arrow"), + :updownarrow => UCMCommand("\\updownarrow", '↕', :mathrel, "up and down arrow"), + :nwarrow => UCMCommand("\\nwarrow", '↖', :mathrel, "nw pointing arrow"), + :nearrow => UCMCommand("\\nearrow", '↗', :mathrel, "ne pointing arrow"), + :searrow => UCMCommand("\\searrow", '↘', :mathrel, "se pointing arrow"), + :swarrow => UCMCommand("\\swarrow", '↙', :mathrel, "sw pointing arrow"), + :nleftarrow => UCMCommand("\\nleftarrow", '↚', :mathrel, "not left arrow"), + :nrightarrow => UCMCommand("\\nrightarrow", '↛', :mathrel, "not right arrow"), + :leftwavearrow => UCMCommand("\\leftwavearrow", '↜', :mathrel, "left arrow-wavy"), + :rightwavearrow => UCMCommand("\\rightwavearrow", '↝', :mathrel, "right arrow-wavy"), + :twoheadleftarrow => UCMCommand("\\twoheadleftarrow", '↞', :mathrel, "left two-headed arrow"), + :twoheaduparrow => UCMCommand("\\twoheaduparrow", '↟', :mathrel, "up two-headed arrow"), + :twoheadrightarrow => UCMCommand("\\twoheadrightarrow", '↠', :mathrel, "right two-headed arrow"), + :twoheaddownarrow => UCMCommand("\\twoheaddownarrow", '↡', :mathrel, "down two-headed arrow"), + :leftarrowtail => UCMCommand("\\leftarrowtail", '↢', :mathrel, "left arrow-tailed"), + :rightarrowtail => UCMCommand("\\rightarrowtail", '↣', :mathrel, "right arrow-tailed"), + :mapsfrom => UCMCommand("\\mapsfrom", '↤', :mathrel, "maps to, leftward"), + :mapsup => UCMCommand("\\mapsup", '↥', :mathrel, "maps to, upward"), + :mapsto => UCMCommand("\\mapsto", '↦', :mathrel, "maps to, rightward"), + :mapsdown => UCMCommand("\\mapsdown", '↧', :mathrel, "maps to, downward"), + :updownarrowbar => UCMCommand("\\updownarrowbar", '↨', :mathord, "up down arrow with base (perpendicular)"), + :hookleftarrow => UCMCommand("\\hookleftarrow", '↩', :mathrel, "left arrow-hooked"), + :hookrightarrow => UCMCommand("\\hookrightarrow", '↪', :mathrel, "right arrow-hooked"), + :looparrowleft => UCMCommand("\\looparrowleft", '↫', :mathrel, "left arrow-looped"), + :looparrowright => UCMCommand("\\looparrowright", '↬', :mathrel, "right arrow-looped"), + :leftrightsquigarrow => UCMCommand("\\leftrightsquigarrow", '↭', :mathrel, "left and right arr-wavy"), + :nleftrightarrow => UCMCommand("\\nleftrightarrow", '↮', :mathrel, "not left and right arrow"), + :downzigzagarrow => UCMCommand("\\downzigzagarrow", '↯', :mathrel, "downwards zigzag arrow"), + :Lsh => UCMCommand("\\Lsh", '↰', :mathrel, "/lsh a:"), + :Rsh => UCMCommand("\\Rsh", '↱', :mathrel, "/rsh a:"), + :Ldsh => UCMCommand("\\Ldsh", '↲', :mathrel, "left down angled arrow"), + :Rdsh => UCMCommand("\\Rdsh", '↳', :mathrel, "right down angled arrow"), + :linefeed => UCMCommand("\\linefeed", '↴', :mathord, "rightwards arrow with corner downwards"), + :carriagereturn => UCMCommand("\\carriagereturn", '↵', :mathord, "downwards arrow with corner leftward = carriage return"), + :curvearrowleft => UCMCommand("\\curvearrowleft", '↶', :mathrel, "left curved arrow"), + :curvearrowright => UCMCommand("\\curvearrowright", '↷', :mathrel, "right curved arrow"), + :barovernorthwestarrow => UCMCommand("\\barovernorthwestarrow", '↸', :mathord, "north west arrow to long bar"), + :barleftarrowrightarrowbar => UCMCommand("\\barleftarrowrightarrowbar", '↹', :mathord, "leftwards arrow to bar over rightwards arrow to bar"), + :acwopencirclearrow => UCMCommand("\\acwopencirclearrow", '↺', :mathord, "anticlockwise open circle arrow"), + :cwopencirclearrow => UCMCommand("\\cwopencirclearrow", '↻', :mathord, "clockwise open circle arrow"), + :leftharpoonup => UCMCommand("\\leftharpoonup", '↼', :mathrel, "left harpoon-up"), + :leftharpoondown => UCMCommand("\\leftharpoondown", '↽', :mathrel, "left harpoon-down"), + :upharpoonright => UCMCommand("\\upharpoonright", '↾', :mathrel, "/upharpoonright /restriction a: up harpoon-right"), + :upharpoonleft => UCMCommand("\\upharpoonleft", '↿', :mathrel, "up harpoon-left"), + :rightharpoonup => UCMCommand("\\rightharpoonup", '⇀', :mathrel, "right harpoon-up"), + :rightharpoondown => UCMCommand("\\rightharpoondown", '⇁', :mathrel, "right harpoon-down"), + :downharpoonright => UCMCommand("\\downharpoonright", '⇂', :mathrel, "down harpoon-right"), + :downharpoonleft => UCMCommand("\\downharpoonleft", '⇃', :mathrel, "down harpoon-left"), + :rightleftarrows => UCMCommand("\\rightleftarrows", '⇄', :mathrel, "right arrow over left arrow"), + :updownarrows => UCMCommand("\\updownarrows", '⇅', :mathrel, "up arrow, down arrow"), + :leftrightarrows => UCMCommand("\\leftrightarrows", '⇆', :mathrel, "left arrow over right arrow"), + :leftleftarrows => UCMCommand("\\leftleftarrows", '⇇', :mathrel, "two left arrows"), + :upuparrows => UCMCommand("\\upuparrows", '⇈', :mathrel, "two up arrows"), + :rightrightarrows => UCMCommand("\\rightrightarrows", '⇉', :mathrel, "two right arrows"), + :downdownarrows => UCMCommand("\\downdownarrows", '⇊', :mathrel, "two down arrows"), + :leftrightharpoons => UCMCommand("\\leftrightharpoons", '⇋', :mathrel, "left harpoon over right"), + :rightleftharpoons => UCMCommand("\\rightleftharpoons", '⇌', :mathrel, "right harpoon over left"), + :nLeftarrow => UCMCommand("\\nLeftarrow", '⇍', :mathrel, "not implied by"), + :nLeftrightarrow => UCMCommand("\\nLeftrightarrow", '⇎', :mathrel, "not left and right double arrows"), + :nRightarrow => UCMCommand("\\nRightarrow", '⇏', :mathrel, "not implies"), + :Leftarrow => UCMCommand("\\Leftarrow", '⇐', :mathrel, "is implied by"), + :Uparrow => UCMCommand("\\Uparrow", '⇑', :mathrel, "up double arrow"), + :Rightarrow => UCMCommand("\\Rightarrow", '⇒', :mathrel, "implies"), + :Downarrow => UCMCommand("\\Downarrow", '⇓', :mathrel, "down double arrow"), + :Leftrightarrow => UCMCommand("\\Leftrightarrow", '⇔', :mathrel, "left and right double arrow"), + :Updownarrow => UCMCommand("\\Updownarrow", '⇕', :mathrel, "up and down double arrow"), + :Nwarrow => UCMCommand("\\Nwarrow", '⇖', :mathrel, "nw pointing double arrow"), + :Nearrow => UCMCommand("\\Nearrow", '⇗', :mathrel, "ne pointing double arrow"), + :Searrow => UCMCommand("\\Searrow", '⇘', :mathrel, "se pointing double arrow"), + :Swarrow => UCMCommand("\\Swarrow", '⇙', :mathrel, "sw pointing double arrow"), + :Lleftarrow => UCMCommand("\\Lleftarrow", '⇚', :mathrel, "left triple arrow"), + :Rrightarrow => UCMCommand("\\Rrightarrow", '⇛', :mathrel, "right triple arrow"), + :leftsquigarrow => UCMCommand("\\leftsquigarrow", '⇜', :mathrel, "leftwards squiggle arrow"), + :rightsquigarrow => UCMCommand("\\rightsquigarrow", '⇝', :mathrel, "rightwards squiggle arrow"), + :nHuparrow => UCMCommand("\\nHuparrow", '⇞', :mathord, "upwards arrow with double stroke"), + :nHdownarrow => UCMCommand("\\nHdownarrow", '⇟', :mathord, "downwards arrow with double stroke"), + :leftdasharrow => UCMCommand("\\leftdasharrow", '⇠', :mathord, "leftwards dashed arrow"), + :updasharrow => UCMCommand("\\updasharrow", '⇡', :mathord, "upwards dashed arrow"), + :rightdasharrow => UCMCommand("\\rightdasharrow", '⇢', :mathord, "rightwards dashed arrow"), + :downdasharrow => UCMCommand("\\downdasharrow", '⇣', :mathord, "downwards dashed arrow"), + :barleftarrow => UCMCommand("\\barleftarrow", '⇤', :mathrel, "leftwards arrow to bar"), + :rightarrowbar => UCMCommand("\\rightarrowbar", '⇥', :mathrel, "rightwards arrow to bar"), + :leftwhitearrow => UCMCommand("\\leftwhitearrow", '⇦', :mathord, "leftwards white arrow"), + :upwhitearrow => UCMCommand("\\upwhitearrow", '⇧', :mathord, "upwards white arrow"), + :rightwhitearrow => UCMCommand("\\rightwhitearrow", '⇨', :mathord, "rightwards white arrow"), + :downwhitearrow => UCMCommand("\\downwhitearrow", '⇩', :mathord, "downwards white arrow"), + :whitearrowupfrombar => UCMCommand("\\whitearrowupfrombar", '⇪', :mathord, "upwards white arrow from bar"), + :circleonrightarrow => UCMCommand("\\circleonrightarrow", '⇴', :mathrel, "right arrow with small circle"), + :downuparrows => UCMCommand("\\downuparrows", '⇵', :mathrel, "downwards arrow leftwards of upwards arrow"), + :rightthreearrows => UCMCommand("\\rightthreearrows", '⇶', :mathrel, "three rightwards arrows"), + :nvleftarrow => UCMCommand("\\nvleftarrow", '⇷', :mathrel, "leftwards arrow with vertical stroke"), + :nvrightarrow => UCMCommand("\\nvrightarrow", '⇸', :mathrel, "rightwards arrow with vertical stroke"), + :nvleftrightarrow => UCMCommand("\\nvleftrightarrow", '⇹', :mathrel, "left right arrow with vertical stroke"), + :nVleftarrow => UCMCommand("\\nVleftarrow", '⇺', :mathrel, "leftwards arrow with double vertical stroke"), + :nVrightarrow => UCMCommand("\\nVrightarrow", '⇻', :mathrel, "rightwards arrow with double vertical stroke"), + :nVleftrightarrow => UCMCommand("\\nVleftrightarrow", '⇼', :mathrel, "left right arrow with double vertical stroke"), + :leftarrowtriangle => UCMCommand("\\leftarrowtriangle", '⇽', :mathrel, "leftwards open-headed arrow"), + :rightarrowtriangle => UCMCommand("\\rightarrowtriangle", '⇾', :mathrel, "rightwards open-headed arrow"), + :leftrightarrowtriangle => UCMCommand("\\leftrightarrowtriangle", '⇿', :mathrel, "left right open-headed arrow"), + :forall => UCMCommand("\\forall", '∀', :mathord, "for all"), + :complement => UCMCommand("\\complement", '∁', :mathord, "complement sign"), + :partial => UCMCommand("\\partial", '∂', :mathalpha, "partial differential"), + :exists => UCMCommand("\\exists", '∃', :mathord, "at least one exists"), + :nexists => UCMCommand("\\nexists", '∄', :mathord, "negated exists"), + :varnothing => UCMCommand("\\varnothing", '∅', :mathord, "circle, slash"), + :increment => UCMCommand("\\increment", '∆', :mathord, "laplacian (delta; nabla\\string^2)"), + :nabla => UCMCommand("\\nabla", '∇', :mathalpha, "nabla, del, hamilton operator"), + :in => UCMCommand("\\in", '∈', :mathrel, "set membership, variant"), + :notin => UCMCommand("\\notin", '∉', :mathrel, "negated set membership"), + :smallin => UCMCommand("\\smallin", '∊', :mathrel, "set membership (small set membership)"), + :ni => UCMCommand("\\ni", '∋', :mathrel, "contains, variant"), + :nni => UCMCommand("\\nni", '∌', :mathrel, "negated contains, variant"), + :smallni => UCMCommand("\\smallni", '∍', :mathrel, "/ni /owns r: contains (small contains as member)"), + :QED => UCMCommand("\\QED", '∎', :mathord, "end of proof"), + :prod => UCMCommand("\\prod", '∏', :mathop, "product operator"), + :coprod => UCMCommand("\\coprod", '∐', :mathop, "coproduct operator"), + :sum => UCMCommand("\\sum", '∑', :mathop, "summation operator"), + :minus => UCMCommand("\\minus", '−', :mathbin, "minus sign"), + :mp => UCMCommand("\\mp", '∓', :mathbin, "minus-or-plus sign"), + :dotplus => UCMCommand("\\dotplus", '∔', :mathbin, "plus sign, dot above"), + :divslash => UCMCommand("\\divslash", '∕', :mathbin, "division slash"), + :setminus => UCMCommand("\\setminus", '∖', :mathbin, "set minus (cf. reverse solidus)"), + :ast => UCMCommand("\\ast", '∗', :mathbin, "centered asterisk"), + :vysmwhtcircle => UCMCommand("\\vysmwhtcircle", '∘', :mathbin, "composite function (small circle)"), + :vysmblkcircle => UCMCommand("\\vysmblkcircle", '∙', :mathbin, "bullet operator"), + :sqrt => UCMCommand("\\sqrt", '√', :mathopen, "radical"), + :surd => UCMCommand("\\surd", '√', :mathord, "radical"), + :cuberoot => UCMCommand("\\cuberoot", '∛', :mathopen, "cube root"), + :fourthroot => UCMCommand("\\fourthroot", '∜', :mathopen, "fourth root"), + :propto => UCMCommand("\\propto", '∝', :mathrel, "is proportional to"), + :infty => UCMCommand("\\infty", '∞', :mathord, "infinity"), + :rightangle => UCMCommand("\\rightangle", '∟', :mathord, "right (90 degree) angle"), + :angle => UCMCommand("\\angle", '∠', :mathord, "angle"), + :measuredangle => UCMCommand("\\measuredangle", '∡', :mathord, "angle-measured"), + :sphericalangle => UCMCommand("\\sphericalangle", '∢', :mathord, "angle-spherical"), + :mid => UCMCommand("\\mid", '∣', :mathrel, "/mid r:"), + :nmid => UCMCommand("\\nmid", '∤', :mathrel, "negated mid"), + :parallel => UCMCommand("\\parallel", '∥', :mathrel, "parallel"), + :nparallel => UCMCommand("\\nparallel", '∦', :mathrel, "not parallel"), + :wedge => UCMCommand("\\wedge", '∧', :mathbin, "/wedge /land b: logical and"), + :vee => UCMCommand("\\vee", '∨', :mathbin, "/vee /lor b: logical or"), + :cap => UCMCommand("\\cap", '∩', :mathbin, "intersection"), + :cup => UCMCommand("\\cup", '∪', :mathbin, "union or logical sum"), + :int => UCMCommand("\\int", '∫', :mathop, "integral operator"), + :iint => UCMCommand("\\iint", '∬', :mathop, "double integral operator"), + :iiint => UCMCommand("\\iiint", '∭', :mathop, "triple integral operator"), + :oint => UCMCommand("\\oint", '∮', :mathop, "contour integral operator"), + :oiint => UCMCommand("\\oiint", '∯', :mathop, "double contour integral operator"), + :oiiint => UCMCommand("\\oiiint", '∰', :mathop, "triple contour integral operator"), + :intclockwise => UCMCommand("\\intclockwise", '∱', :mathop, "clockwise integral"), + :varointclockwise => UCMCommand("\\varointclockwise", '∲', :mathop, "contour integral, clockwise"), + :ointctrclockwise => UCMCommand("\\ointctrclockwise", '∳', :mathop, "contour integral, anticlockwise"), + :therefore => UCMCommand("\\therefore", '∴', :mathord, "therefore"), + :because => UCMCommand("\\because", '∵', :mathord, "because"), + :mathratio => UCMCommand("\\mathratio", '∶', :mathrel, "ratio"), + :Colon => UCMCommand("\\Colon", '∷', :mathrel, "two colons"), + :dotminus => UCMCommand("\\dotminus", '∸', :mathbin, "minus sign, dot above"), + :dashcolon => UCMCommand("\\dashcolon", '∹', :mathrel, "excess (-:)"), + :dotsminusdots => UCMCommand("\\dotsminusdots", '∺', :mathrel, "minus with four dots, geometric properties"), + :kernelcontraction => UCMCommand("\\kernelcontraction", '∻', :mathrel, "homothetic"), + :sim => UCMCommand("\\sim", '∼', :mathrel, "similar"), + :backsim => UCMCommand("\\backsim", '∽', :mathrel, "reverse similar"), + :invlazys => UCMCommand("\\invlazys", '∾', :mathbin, "most positive [inverted lazy s]"), + :sinewave => UCMCommand("\\sinewave", '∿', :mathord, "sine wave"), + :wr => UCMCommand("\\wr", '≀', :mathbin, "wreath product"), + :nsim => UCMCommand("\\nsim", '≁', :mathrel, "not similar"), + :eqsim => UCMCommand("\\eqsim", '≂', :mathrel, "equals, similar"), + :simeq => UCMCommand("\\simeq", '≃', :mathrel, "similar, equals"), + :nsime => UCMCommand("\\nsime", '≄', :mathrel, "not similar, equals"), + :sime => UCMCommand("\\sime", '≃', :mathrel, "similar, equals (alias)"), + :nsimeq => UCMCommand("\\nsimeq", '≄', :mathrel, "not similar, equals (alias)"), + :cong => UCMCommand("\\cong", '≅', :mathrel, "congruent with"), + :simneqq => UCMCommand("\\simneqq", '≆', :mathrel, "similar, not equals [vert only for 9573 entity]"), + :ncong => UCMCommand("\\ncong", '≇', :mathrel, "not congruent with"), + :approx => UCMCommand("\\approx", '≈', :mathrel, "approximate"), + :napprox => UCMCommand("\\napprox", '≉', :mathrel, "not approximate"), + :approxeq => UCMCommand("\\approxeq", '≊', :mathrel, "approximate, equals"), + :approxident => UCMCommand("\\approxident", '≋', :mathrel, "approximately identical to"), + :backcong => UCMCommand("\\backcong", '≌', :mathrel, "all equal to"), + :asymp => UCMCommand("\\asymp", '≍', :mathrel, "asymptotically equal to"), + :Bumpeq => UCMCommand("\\Bumpeq", '≎', :mathrel, "bumpy equals"), + :bumpeq => UCMCommand("\\bumpeq", '≏', :mathrel, "bumpy equals, equals"), + :doteq => UCMCommand("\\doteq", '≐', :mathrel, "equals, single dot above"), + :Doteq => UCMCommand("\\Doteq", '≑', :mathrel, "/doteqdot /doteq r: equals, even dots"), + :fallingdotseq => UCMCommand("\\fallingdotseq", '≒', :mathrel, "equals, falling dots"), + :risingdotseq => UCMCommand("\\risingdotseq", '≓', :mathrel, "equals, rising dots"), + :coloneq => UCMCommand("\\coloneq", '≔', :mathrel, "colon, equals"), + :eqcolon => UCMCommand("\\eqcolon", '≕', :mathrel, "equals, colon"), + :eqcirc => UCMCommand("\\eqcirc", '≖', :mathrel, "circle on equals sign"), + :circeq => UCMCommand("\\circeq", '≗', :mathrel, "circle, equals"), + :arceq => UCMCommand("\\arceq", '≘', :mathrel, "arc, equals; corresponds to"), + :wedgeq => UCMCommand("\\wedgeq", '≙', :mathrel, "corresponds to (wedge, equals)"), + :veeeq => UCMCommand("\\veeeq", '≚', :mathrel, "logical or, equals"), + :stareq => UCMCommand("\\stareq", '≛', :mathrel, "star equals"), + :triangleq => UCMCommand("\\triangleq", '≜', :mathrel, "triangle, equals"), + :eqdef => UCMCommand("\\eqdef", '≝', :mathrel, "equals by definition"), + :measeq => UCMCommand("\\measeq", '≞', :mathrel, "measured by (m over equals)"), + :questeq => UCMCommand("\\questeq", '≟', :mathrel, "equal with questionmark"), + :ne => UCMCommand("\\ne", '≠', :mathrel, "/ne /neq r: not equal"), + :equiv => UCMCommand("\\equiv", '≡', :mathrel, "identical with"), + :nequiv => UCMCommand("\\nequiv", '≢', :mathrel, "not identical with"), + :Equiv => UCMCommand("\\Equiv", '≣', :mathrel, "strict equivalence (4 lines)"), + :leq => UCMCommand("\\leq", '≤', :mathrel, "/leq /le r: less-than-or-equal"), + :geq => UCMCommand("\\geq", '≥', :mathrel, "/geq /ge r: greater-than-or-equal"), + :leqq => UCMCommand("\\leqq", '≦', :mathrel, "less, double equals"), + :geqq => UCMCommand("\\geqq", '≧', :mathrel, "greater, double equals"), + :lneqq => UCMCommand("\\lneqq", '≨', :mathrel, "less, not double equals"), + :gneqq => UCMCommand("\\gneqq", '≩', :mathrel, "greater, not double equals"), + :ll => UCMCommand("\\ll", '≪', :mathrel, "much less than, type 2"), + :gg => UCMCommand("\\gg", '≫', :mathrel, "much greater than, type 2"), + :between => UCMCommand("\\between", '≬', :mathrel, "between"), + :nasymp => UCMCommand("\\nasymp", '≭', :mathrel, "not asymptotically equal to"), + :nless => UCMCommand("\\nless", '≮', :mathrel, "not less-than"), + :ngtr => UCMCommand("\\ngtr", '≯', :mathrel, "not greater-than"), + :nleq => UCMCommand("\\nleq", '≰', :mathrel, "not less-than-or-equal"), + :ngeq => UCMCommand("\\ngeq", '≱', :mathrel, "not greater-than-or-equal"), + :lesssim => UCMCommand("\\lesssim", '≲', :mathrel, "less, similar"), + :gtrsim => UCMCommand("\\gtrsim", '≳', :mathrel, "greater, similar"), + :nlesssim => UCMCommand("\\nlesssim", '≴', :mathrel, "not less, similar"), + :ngtrsim => UCMCommand("\\ngtrsim", '≵', :mathrel, "not greater, similar"), + :lessgtr => UCMCommand("\\lessgtr", '≶', :mathrel, "less, greater"), + :gtrless => UCMCommand("\\gtrless", '≷', :mathrel, "greater, less"), + :nlessgtr => UCMCommand("\\nlessgtr", '≸', :mathrel, "not less, greater"), + :ngtrless => UCMCommand("\\ngtrless", '≹', :mathrel, "not greater, less"), + :prec => UCMCommand("\\prec", '≺', :mathrel, "precedes"), + :succ => UCMCommand("\\succ", '≻', :mathrel, "succeeds"), + :preccurlyeq => UCMCommand("\\preccurlyeq", '≼', :mathrel, "precedes, curly equals"), + :succcurlyeq => UCMCommand("\\succcurlyeq", '≽', :mathrel, "succeeds, curly equals"), + :precsim => UCMCommand("\\precsim", '≾', :mathrel, "precedes, similar"), + :succsim => UCMCommand("\\succsim", '≿', :mathrel, "succeeds, similar"), + :nprec => UCMCommand("\\nprec", '⊀', :mathrel, "not precedes"), + :nsucc => UCMCommand("\\nsucc", '⊁', :mathrel, "not succeeds"), + :subset => UCMCommand("\\subset", '⊂', :mathrel, "subset or is implied by"), + :supset => UCMCommand("\\supset", '⊃', :mathrel, "superset or implies"), + :nsubset => UCMCommand("\\nsubset", '⊄', :mathrel, "not subset, variant [slash negation]"), + :nsupset => UCMCommand("\\nsupset", '⊅', :mathrel, "not superset, variant [slash negation]"), + :subseteq => UCMCommand("\\subseteq", '⊆', :mathrel, "subset, equals"), + :supseteq => UCMCommand("\\supseteq", '⊇', :mathrel, "superset, equals"), + :nsubseteq => UCMCommand("\\nsubseteq", '⊈', :mathrel, "not subset, equals"), + :nsupseteq => UCMCommand("\\nsupseteq", '⊉', :mathrel, "not superset, equals"), + :subsetneq => UCMCommand("\\subsetneq", '⊊', :mathrel, "subset, not equals"), + :supsetneq => UCMCommand("\\supsetneq", '⊋', :mathrel, "superset, not equals"), + :cupleftarrow => UCMCommand("\\cupleftarrow", '⊌', :mathbin, "multiset"), + :cupdot => UCMCommand("\\cupdot", '⊍', :mathbin, "union, with dot"), + :uplus => UCMCommand("\\uplus", '⊎', :mathbin, "plus sign in union"), + :sqsubset => UCMCommand("\\sqsubset", '⊏', :mathrel, "square subset"), + :sqsupset => UCMCommand("\\sqsupset", '⊐', :mathrel, "square superset"), + :sqsubseteq => UCMCommand("\\sqsubseteq", '⊑', :mathrel, "square subset, equals"), + :sqsupseteq => UCMCommand("\\sqsupseteq", '⊒', :mathrel, "square superset, equals"), + :sqcap => UCMCommand("\\sqcap", '⊓', :mathbin, "square intersection"), + :sqcup => UCMCommand("\\sqcup", '⊔', :mathbin, "square union"), + :oplus => UCMCommand("\\oplus", '⊕', :mathbin, "plus sign in circle"), + :ominus => UCMCommand("\\ominus", '⊖', :mathbin, "minus sign in circle"), + :otimes => UCMCommand("\\otimes", '⊗', :mathbin, "multiply sign in circle"), + :oslash => UCMCommand("\\oslash", '⊘', :mathbin, "solidus in circle"), + :odot => UCMCommand("\\odot", '⊙', :mathbin, "middle dot in circle"), + :circledcirc => UCMCommand("\\circledcirc", '⊚', :mathbin, "small circle in circle"), + :circledast => UCMCommand("\\circledast", '⊛', :mathbin, "asterisk in circle"), + :circledequal => UCMCommand("\\circledequal", '⊜', :mathbin, "equal in circle"), + :circleddash => UCMCommand("\\circleddash", '⊝', :mathbin, "hyphen in circle"), + :boxplus => UCMCommand("\\boxplus", '⊞', :mathbin, "plus sign in box"), + :boxminus => UCMCommand("\\boxminus", '⊟', :mathbin, "minus sign in box"), + :boxtimes => UCMCommand("\\boxtimes", '⊠', :mathbin, "multiply sign in box"), + :boxdot => UCMCommand("\\boxdot", '⊡', :mathbin, "/dotsquare /boxdot b: small dot in box"), + :vdash => UCMCommand("\\vdash", '⊢', :mathrel, "vertical, dash"), + :dashv => UCMCommand("\\dashv", '⊣', :mathrel, "dash, vertical"), + :top => UCMCommand("\\top", '⊤', :mathord, "top"), + :bot => UCMCommand("\\bot", '⊥', :mathord, "bottom"), + :assert => UCMCommand("\\assert", '⊦', :mathrel, "assertion (vertical, short dash)"), + :models => UCMCommand("\\models", '⊧', :mathrel, "models (vertical, short double dash)"), + :vDash => UCMCommand("\\vDash", '⊨', :mathrel, "vertical, double dash"), + :Vdash => UCMCommand("\\Vdash", '⊩', :mathrel, "double vertical, dash"), + :Vvdash => UCMCommand("\\Vvdash", '⊪', :mathrel, "triple vertical, dash"), + :VDash => UCMCommand("\\VDash", '⊫', :mathrel, "double vert, double dash"), + :nvdash => UCMCommand("\\nvdash", '⊬', :mathrel, "not vertical, dash"), + :nvDash => UCMCommand("\\nvDash", '⊭', :mathrel, "not vertical, double dash"), + :nVdash => UCMCommand("\\nVdash", '⊮', :mathrel, "not double vertical, dash"), + :nVDash => UCMCommand("\\nVDash", '⊯', :mathrel, "not double vert, double dash"), + :prurel => UCMCommand("\\prurel", '⊰', :mathrel, "element precedes under relation"), + :scurel => UCMCommand("\\scurel", '⊱', :mathrel, "succeeds under relation"), + :vartriangleleft => UCMCommand("\\vartriangleleft", '⊲', :mathrel, "left triangle, open, variant"), + :vartriangleright => UCMCommand("\\vartriangleright", '⊳', :mathrel, "right triangle, open, variant"), + :trianglelefteq => UCMCommand("\\trianglelefteq", '⊴', :mathrel, "left triangle, equals"), + :trianglerighteq => UCMCommand("\\trianglerighteq", '⊵', :mathrel, "right triangle, equals"), + :origof => UCMCommand("\\origof", '⊶', :mathrel, "original of"), + :imageof => UCMCommand("\\imageof", '⊷', :mathrel, "image of"), + :multimap => UCMCommand("\\multimap", '⊸', :mathrel, "/multimap a:"), + :hermitmatrix => UCMCommand("\\hermitmatrix", '⊹', :mathord, "hermitian conjugate matrix"), + :intercal => UCMCommand("\\intercal", '⊺', :mathbin, "intercal"), + :veebar => UCMCommand("\\veebar", '⊻', :mathbin, "logical or, bar below (large vee); exclusive disjunction"), + :barwedge => UCMCommand("\\barwedge", '⊼', :mathbin, "bar, wedge (large wedge)"), + :barvee => UCMCommand("\\barvee", '⊽', :mathbin, "bar, vee (large vee)"), + :measuredrightangle => UCMCommand("\\measuredrightangle", '⊾', :mathord, "right angle-measured [with arc]"), + :varlrtriangle => UCMCommand("\\varlrtriangle", '⊿', :mathord, "right triangle"), + :bigwedge => UCMCommand("\\bigwedge", '⋀', :mathop, "logical and operator"), + :bigvee => UCMCommand("\\bigvee", '⋁', :mathop, "logical or operator"), + :bigcap => UCMCommand("\\bigcap", '⋂', :mathop, "intersection operator"), + :bigcup => UCMCommand("\\bigcup", '⋃', :mathop, "union operator"), + :smwhtdiamond => UCMCommand("\\smwhtdiamond", '⋄', :mathbin, "white diamond"), + :cdot => UCMCommand("\\cdot", '⋅', :mathbin, "small middle dot"), + :star => UCMCommand("\\star", '⋆', :mathbin, "small star, filled, low"), + :divideontimes => UCMCommand("\\divideontimes", '⋇', :mathbin, "division on times"), + :bowtie => UCMCommand("\\bowtie", '⋈', :mathrel, "bowtie"), + :ltimes => UCMCommand("\\ltimes", '⋉', :mathbin, "times sign, left closed"), + :rtimes => UCMCommand("\\rtimes", '⋊', :mathbin, "times sign, right closed"), + :leftthreetimes => UCMCommand("\\leftthreetimes", '⋋', :mathbin, "left semidirect product"), + :rightthreetimes => UCMCommand("\\rightthreetimes", '⋌', :mathbin, "right semidirect product"), + :backsimeq => UCMCommand("\\backsimeq", '⋍', :mathrel, "reverse similar, equals"), + :curlyvee => UCMCommand("\\curlyvee", '⋎', :mathbin, "curly logical or"), + :curlywedge => UCMCommand("\\curlywedge", '⋏', :mathbin, "curly logical and"), + :Subset => UCMCommand("\\Subset", '⋐', :mathrel, "double subset"), + :Supset => UCMCommand("\\Supset", '⋑', :mathrel, "double superset"), + :Cap => UCMCommand("\\Cap", '⋒', :mathbin, "/cap /doublecap b: double intersection"), + :Cup => UCMCommand("\\Cup", '⋓', :mathbin, "/cup /doublecup b: double union"), + :pitchfork => UCMCommand("\\pitchfork", '⋔', :mathrel, "pitchfork"), + :equalparallel => UCMCommand("\\equalparallel", '⋕', :mathrel, "parallel, equal; equal or parallel"), + :lessdot => UCMCommand("\\lessdot", '⋖', :mathrel, "less than, with dot"), + :gtrdot => UCMCommand("\\gtrdot", '⋗', :mathrel, "greater than, with dot"), + :lll => UCMCommand("\\lll", '⋘', :mathrel, "/ll /lll /llless r: triple less-than"), + :ggg => UCMCommand("\\ggg", '⋙', :mathrel, "/ggg /gg /gggtr r: triple greater-than"), + :lesseqgtr => UCMCommand("\\lesseqgtr", '⋚', :mathrel, "less, equals, greater"), + :gtreqless => UCMCommand("\\gtreqless", '⋛', :mathrel, "greater, equals, less"), + :eqless => UCMCommand("\\eqless", '⋜', :mathrel, "equal-or-less"), + :eqgtr => UCMCommand("\\eqgtr", '⋝', :mathrel, "equal-or-greater"), + :curlyeqprec => UCMCommand("\\curlyeqprec", '⋞', :mathrel, "curly equals, precedes"), + :curlyeqsucc => UCMCommand("\\curlyeqsucc", '⋟', :mathrel, "curly equals, succeeds"), + :npreccurlyeq => UCMCommand("\\npreccurlyeq", '⋠', :mathrel, "not precedes, curly equals"), + :nsucccurlyeq => UCMCommand("\\nsucccurlyeq", '⋡', :mathrel, "not succeeds, curly equals"), + :nsqsubseteq => UCMCommand("\\nsqsubseteq", '⋢', :mathrel, "not, square subset, equals"), + :nsqsupseteq => UCMCommand("\\nsqsupseteq", '⋣', :mathrel, "not, square superset, equals"), + :sqsubsetneq => UCMCommand("\\sqsubsetneq", '⋤', :mathrel, "square subset, not equals"), + :sqsupsetneq => UCMCommand("\\sqsupsetneq", '⋥', :mathrel, "square superset, not equals"), + :lnsim => UCMCommand("\\lnsim", '⋦', :mathrel, "less, not similar"), + :gnsim => UCMCommand("\\gnsim", '⋧', :mathrel, "greater, not similar"), + :precnsim => UCMCommand("\\precnsim", '⋨', :mathrel, "precedes, not similar"), + :succnsim => UCMCommand("\\succnsim", '⋩', :mathrel, "succeeds, not similar"), + :nvartriangleleft => UCMCommand("\\nvartriangleleft", '⋪', :mathrel, "not left triangle"), + :nvartriangleright => UCMCommand("\\nvartriangleright", '⋫', :mathrel, "not right triangle"), + :ntrianglelefteq => UCMCommand("\\ntrianglelefteq", '⋬', :mathrel, "not left triangle, equals"), + :ntrianglerighteq => UCMCommand("\\ntrianglerighteq", '⋭', :mathrel, "not right triangle, equals"), + :vdots => UCMCommand("\\vdots", '⋮', :mathrel, "vertical ellipsis"), + :unicodecdots => UCMCommand("\\unicodecdots", '⋯', :mathord, "three dots, centered"), + :adots => UCMCommand("\\adots", '⋰', :mathrel, "three dots, ascending"), + :ddots => UCMCommand("\\ddots", '⋱', :mathrel, "three dots, descending"), + :disin => UCMCommand("\\disin", '⋲', :mathrel, "element of with long horizontal stroke"), + :varisins => UCMCommand("\\varisins", '⋳', :mathrel, "element of with vertical bar at end of horizontal stroke"), + :isins => UCMCommand("\\isins", '⋴', :mathrel, "small element of with vertical bar at end of horizontal stroke"), + :isindot => UCMCommand("\\isindot", '⋵', :mathrel, "element of with dot above"), + :varisinobar => UCMCommand("\\varisinobar", '⋶', :mathrel, "element of with overbar"), + :isinobar => UCMCommand("\\isinobar", '⋷', :mathrel, "small element of with overbar"), + :isinvb => UCMCommand("\\isinvb", '⋸', :mathrel, "element of with underbar"), + :isinE => UCMCommand("\\isinE", '⋹', :mathrel, "element of with two horizontal strokes"), + :nisd => UCMCommand("\\nisd", '⋺', :mathrel, "contains with long horizontal stroke"), + :varnis => UCMCommand("\\varnis", '⋻', :mathrel, "contains with vertical bar at end of horizontal stroke"), + :nis => UCMCommand("\\nis", '⋼', :mathrel, "small contains with vertical bar at end of horizontal stroke"), + :varniobar => UCMCommand("\\varniobar", '⋽', :mathrel, "contains with overbar"), + :niobar => UCMCommand("\\niobar", '⋾', :mathrel, "small contains with overbar"), + :bagmember => UCMCommand("\\bagmember", '⋿', :mathrel, "z notation bag membership"), + :diameter => UCMCommand("\\diameter", '⌀', :mathord, "diameter sign"), + :house => UCMCommand("\\house", '⌂', :mathord, "house"), + :varbarwedge => UCMCommand("\\varbarwedge", '⌅', :mathbin, "/barwedge b: logical and, bar above [projective (bar over small wedge)]"), + :vardoublebarwedge => UCMCommand("\\vardoublebarwedge", '⌆', :mathbin, "/doublebarwedge b: logical and, double bar above [perspective (double bar over small wedge)]"), + :lceil => UCMCommand("\\lceil", '⌈', :mathopen, "left ceiling"), + :rceil => UCMCommand("\\rceil", '⌉', :mathclose, "right ceiling"), + :lfloor => UCMCommand("\\lfloor", '⌊', :mathopen, "left floor"), + :rfloor => UCMCommand("\\rfloor", '⌋', :mathclose, "right floor"), + :invnot => UCMCommand("\\invnot", '⌐', :mathord, "reverse not"), + :sqlozenge => UCMCommand("\\sqlozenge", '⌑', :mathord, "square lozenge"), + :profline => UCMCommand("\\profline", '⌒', :mathord, "profile of a line"), + :profsurf => UCMCommand("\\profsurf", '⌓', :mathord, "profile of a surface"), + :viewdata => UCMCommand("\\viewdata", '⌗', :mathord, "viewdata square"), + :turnednot => UCMCommand("\\turnednot", '⌙', :mathord, "turned not sign"), + :ulcorner => UCMCommand("\\ulcorner", '⌜', :mathopen, "upper left corner"), + :urcorner => UCMCommand("\\urcorner", '⌝', :mathclose, "upper right corner"), + :llcorner => UCMCommand("\\llcorner", '⌞', :mathopen, "lower left corner"), + :lrcorner => UCMCommand("\\lrcorner", '⌟', :mathclose, "lower right corner"), + :inttop => UCMCommand("\\inttop", '⌠', :mathord, "top half integral"), + :intbottom => UCMCommand("\\intbottom", '⌡', :mathord, "bottom half integral"), + :frown => UCMCommand("\\frown", '⌢', :mathrel, "down curve"), + :smile => UCMCommand("\\smile", '⌣', :mathrel, "up curve"), + :varhexagonlrbonds => UCMCommand("\\varhexagonlrbonds", '⌬', :mathord, "six carbon ring, corner down, double bonds lower right etc"), + :conictaper => UCMCommand("\\conictaper", '⌲', :mathord, "conical taper "), + :topbot => UCMCommand("\\topbot", '⌶', :mathord, "top and bottom"), + :obar => UCMCommand("\\obar", '⌽', :mathbin, "circle with vertical bar"), + :APLnotslash => UCMCommand("\\APLnotslash", '⌿', :mathrel, "solidus, bar through (apl functional symbol slash bar)"), + :APLnotbackslash => UCMCommand("\\APLnotbackslash", '⍀', :mathord, "apl functional symbol backslash bar"), + :APLboxupcaret => UCMCommand("\\APLboxupcaret", '⍓', :mathord, "boxed up caret"), + :APLboxquestion => UCMCommand("\\APLboxquestion", '⍰', :mathord, "boxed question mark"), + :rangledownzigzagarrow => UCMCommand("\\rangledownzigzagarrow", '⍼', :mathord, "right angle with downwards zigzag arrow"), + :hexagon => UCMCommand("\\hexagon", '⎔', :mathord, "horizontal benzene ring [hexagon flat open]"), + :lparenuend => UCMCommand("\\lparenuend", '⎛', :mathord, "left parenthesis upper hook"), + :lparenextender => UCMCommand("\\lparenextender", '⎜', :mathord, "left parenthesis extension"), + :lparenlend => UCMCommand("\\lparenlend", '⎝', :mathord, "left parenthesis lower hook"), + :rparenuend => UCMCommand("\\rparenuend", '⎞', :mathord, "right parenthesis upper hook"), + :rparenextender => UCMCommand("\\rparenextender", '⎟', :mathord, "right parenthesis extension"), + :rparenlend => UCMCommand("\\rparenlend", '⎠', :mathord, "right parenthesis lower hook"), + :lbrackuend => UCMCommand("\\lbrackuend", '⎡', :mathord, "left square bracket upper corner"), + :lbrackextender => UCMCommand("\\lbrackextender", '⎢', :mathord, "left square bracket extension"), + :lbracklend => UCMCommand("\\lbracklend", '⎣', :mathord, "left square bracket lower corner"), + :rbrackuend => UCMCommand("\\rbrackuend", '⎤', :mathord, "right square bracket upper corner"), + :rbrackextender => UCMCommand("\\rbrackextender", '⎥', :mathord, "right square bracket extension"), + :rbracklend => UCMCommand("\\rbracklend", '⎦', :mathord, "right square bracket lower corner"), + :lbraceuend => UCMCommand("\\lbraceuend", '⎧', :mathord, "left curly bracket upper hook"), + :lbracemid => UCMCommand("\\lbracemid", '⎨', :mathord, "left curly bracket middle piece"), + :lbracelend => UCMCommand("\\lbracelend", '⎩', :mathord, "left curly bracket lower hook"), + :vbraceextender => UCMCommand("\\vbraceextender", '⎪', :mathord, "curly bracket extension"), + :rbraceuend => UCMCommand("\\rbraceuend", '⎫', :mathord, "right curly bracket upper hook"), + :rbracemid => UCMCommand("\\rbracemid", '⎬', :mathord, "right curly bracket middle piece"), + :rbracelend => UCMCommand("\\rbracelend", '⎭', :mathord, "right curly bracket lower hook"), + :intextender => UCMCommand("\\intextender", '⎮', :mathord, "integral extension"), + :harrowextender => UCMCommand("\\harrowextender", '⎯', :mathord, "horizontal line extension (used to extend arrows)"), + :lmoustache => UCMCommand("\\lmoustache", '⎰', :mathopen, "upper left or lower right curly bracket section"), + :rmoustache => UCMCommand("\\rmoustache", '⎱', :mathclose, "upper right or lower left curly bracket section"), + :sumtop => UCMCommand("\\sumtop", '⎲', :mathord, "summation top"), + :sumbottom => UCMCommand("\\sumbottom", '⎳', :mathord, "summation bottom"), + :overbracket => UCMCommand("\\overbracket", '⎴', :mathover, "top square bracket"), + :underbracket => UCMCommand("\\underbracket", '⎵', :mathunder, "bottom square bracket"), + :bbrktbrk => UCMCommand("\\bbrktbrk", '⎶', :mathord, "bottom square bracket over top square bracket"), + :sqrtbottom => UCMCommand("\\sqrtbottom", '⎷', :mathord, "radical symbol bottom"), + :lvboxline => UCMCommand("\\lvboxline", '⎸', :mathord, "left vertical box line"), + :rvboxline => UCMCommand("\\rvboxline", '⎹', :mathord, "right vertical box line"), + :varcarriagereturn => UCMCommand("\\varcarriagereturn", '⏎', :mathord, "return symbol"), + :overparen => UCMCommand("\\overparen", '⏜', :mathover, "top parenthesis (mathematical use)"), + :underparen => UCMCommand("\\underparen", '⏝', :mathunder, "bottom parenthesis (mathematical use)"), + :overbrace => UCMCommand("\\overbrace", '⏞', :mathover, "top curly bracket (mathematical use)"), + :underbrace => UCMCommand("\\underbrace", '⏟', :mathunder, "bottom curly bracket (mathematical use)"), + :obrbrak => UCMCommand("\\obrbrak", '⏠', :mathord, "top tortoise shell bracket (mathematical use)"), + :ubrbrak => UCMCommand("\\ubrbrak", '⏡', :mathord, "bottom tortoise shell bracket (mathematical use)"), + :trapezium => UCMCommand("\\trapezium", '⏢', :mathord, "white trapezium"), + :benzenr => UCMCommand("\\benzenr", '⏣', :mathord, "benzene ring with circle"), + :strns => UCMCommand("\\strns", '⏤', :mathord, "straightness"), + :fltns => UCMCommand("\\fltns", '⏥', :mathord, "flatness"), + :accurrent => UCMCommand("\\accurrent", '⏦', :mathord, "ac current"), + :elinters => UCMCommand("\\elinters", '⏧', :mathord, "electrical intersection"), + :blanksymbol => UCMCommand("\\blanksymbol", '␢', :mathord, "blank symbol"), + :mathvisiblespace => UCMCommand("\\mathvisiblespace", '␣', :mathord, "open box"), + :bdtriplevdash => UCMCommand("\\bdtriplevdash", '┆', :mathord, "doubly broken vert"), + :blockuphalf => UCMCommand("\\blockuphalf", '▀', :mathord, "upper half block"), + :blocklowhalf => UCMCommand("\\blocklowhalf", '▄', :mathord, "lower half block"), + :blockfull => UCMCommand("\\blockfull", '█', :mathord, "full block"), + :blocklefthalf => UCMCommand("\\blocklefthalf", '▌', :mathord, "left half block"), + :blockrighthalf => UCMCommand("\\blockrighthalf", '▐', :mathord, "right half block"), + :blockqtrshaded => UCMCommand("\\blockqtrshaded", '░', :mathord, "25\\% shaded block"), + :blockhalfshaded => UCMCommand("\\blockhalfshaded", '▒', :mathord, "50\\% shaded block"), + :blockthreeqtrshaded => UCMCommand("\\blockthreeqtrshaded", '▓', :mathord, "75\\% shaded block"), + :mdlgblksquare => UCMCommand("\\mdlgblksquare", '■', :mathord, "square, filled"), + :mdlgwhtsquare => UCMCommand("\\mdlgwhtsquare", '□', :mathord, "square, open"), + :squoval => UCMCommand("\\squoval", '▢', :mathord, "white square with rounded corners"), + :blackinwhitesquare => UCMCommand("\\blackinwhitesquare", '▣', :mathord, "white square containing black small square"), + :squarehfill => UCMCommand("\\squarehfill", '▤', :mathord, "square, horizontal rule filled"), + :squarevfill => UCMCommand("\\squarevfill", '▥', :mathord, "square, vertical rule filled"), + :squarehvfill => UCMCommand("\\squarehvfill", '▦', :mathord, "square with orthogonal crosshatch fill"), + :squarenwsefill => UCMCommand("\\squarenwsefill", '▧', :mathord, "square, nw-to-se rule filled"), + :squareneswfill => UCMCommand("\\squareneswfill", '▨', :mathord, "square, ne-to-sw rule filled"), + :squarecrossfill => UCMCommand("\\squarecrossfill", '▩', :mathord, "square with diagonal crosshatch fill"), + :smblksquare => UCMCommand("\\smblksquare", '▪', :mathord, "/blacksquare - sq bullet, filled"), + :smwhtsquare => UCMCommand("\\smwhtsquare", '▫', :mathord, "white small square"), + :hrectangleblack => UCMCommand("\\hrectangleblack", '▬', :mathord, "black rectangle"), + :hrectangle => UCMCommand("\\hrectangle", '▭', :mathord, "horizontal rectangle, open"), + :vrectangleblack => UCMCommand("\\vrectangleblack", '▮', :mathord, "black vertical rectangle"), + :vrectangle => UCMCommand("\\vrectangle", '▯', :mathord, "rectangle, white (vertical)"), + :parallelogramblack => UCMCommand("\\parallelogramblack", '▰', :mathord, "black parallelogram"), + :parallelogram => UCMCommand("\\parallelogram", '▱', :mathord, "parallelogram, open"), + :bigblacktriangleup => UCMCommand("\\bigblacktriangleup", '▲', :mathord, "black up-pointing triangle"), + :bigtriangleup => UCMCommand("\\bigtriangleup", '△', :mathbin, "big up triangle, open"), + :blacktriangle => UCMCommand("\\blacktriangle", '▴', :mathord, "up triangle, filled"), + :vartriangle => UCMCommand("\\vartriangle", '▵', :mathrel, "/triangle - up triangle, open"), + :blacktriangleright => UCMCommand("\\blacktriangleright", '▶', :mathord, "(large) right triangle, filled"), + :triangleright => UCMCommand("\\triangleright", '▷', :mathbin, "(large) right triangle, open; z notation range restriction"), + :smallblacktriangleright => UCMCommand("\\smallblacktriangleright", '▸', :mathord, "right triangle, filled"), + :smalltriangleright => UCMCommand("\\smalltriangleright", '▹', :mathord, "right triangle, open"), + :blackpointerright => UCMCommand("\\blackpointerright", '►', :mathord, "black right-pointing pointer"), + :whitepointerright => UCMCommand("\\whitepointerright", '▻', :mathord, "white right-pointing pointer"), + :bigblacktriangledown => UCMCommand("\\bigblacktriangledown", '▼', :mathord, "big down triangle, filled"), + :bigtriangledown => UCMCommand("\\bigtriangledown", '▽', :mathord, "big down triangle, open"), + :blacktriangledown => UCMCommand("\\blacktriangledown", '▾', :mathord, "down triangle, filled"), + :triangledown => UCMCommand("\\triangledown", '▿', :mathord, "down triangle, open"), + :blacktriangleleft => UCMCommand("\\blacktriangleleft", '◀', :mathord, "(large) left triangle, filled"), + :triangleleft => UCMCommand("\\triangleleft", '◁', :mathbin, "(large) left triangle, open; z notation domain restriction"), + :smallblacktriangleleft => UCMCommand("\\smallblacktriangleleft", '◂', :mathord, "left triangle, filled"), + :smalltriangleleft => UCMCommand("\\smalltriangleleft", '◃', :mathord, "left triangle, open"), + :blackpointerleft => UCMCommand("\\blackpointerleft", '◄', :mathord, "black left-pointing pointer"), + :whitepointerleft => UCMCommand("\\whitepointerleft", '◅', :mathord, "white left-pointing pointer"), + :mdlgblkdiamond => UCMCommand("\\mdlgblkdiamond", '◆', :mathord, "black diamond"), + :mdlgwhtdiamond => UCMCommand("\\mdlgwhtdiamond", '◇', :mathord, "white diamond; diamond, open"), + :blackinwhitediamond => UCMCommand("\\blackinwhitediamond", '◈', :mathord, "white diamond containing black small diamond"), + :fisheye => UCMCommand("\\fisheye", '◉', :mathord, "fisheye"), + :mdlgwhtlozenge => UCMCommand("\\mdlgwhtlozenge", '◊', :mathord, "lozenge or total mark"), + :mdlgwhtcircle => UCMCommand("\\mdlgwhtcircle", '○', :mathbin, "medium large circle"), + :dottedcircle => UCMCommand("\\dottedcircle", '◌', :mathord, "dotted circle"), + :circlevertfill => UCMCommand("\\circlevertfill", '◍', :mathord, "circle with vertical fill"), + :bullseye => UCMCommand("\\bullseye", '◎', :mathord, "bullseye"), + :mdlgblkcircle => UCMCommand("\\mdlgblkcircle", '●', :mathord, "circle, filled"), + :circlelefthalfblack => UCMCommand("\\circlelefthalfblack", '◐', :mathord, "circle, filled left half [harvey ball]"), + :circlerighthalfblack => UCMCommand("\\circlerighthalfblack", '◑', :mathord, "circle, filled right half"), + :circlebottomhalfblack => UCMCommand("\\circlebottomhalfblack", '◒', :mathord, "circle, filled bottom half"), + :circletophalfblack => UCMCommand("\\circletophalfblack", '◓', :mathord, "circle, filled top half"), + :circleurquadblack => UCMCommand("\\circleurquadblack", '◔', :mathord, "circle with upper right quadrant black"), + :blackcircleulquadwhite => UCMCommand("\\blackcircleulquadwhite", '◕', :mathord, "circle with all but upper left quadrant black"), + :blacklefthalfcircle => UCMCommand("\\blacklefthalfcircle", '◖', :mathord, "left half black circle"), + :blackrighthalfcircle => UCMCommand("\\blackrighthalfcircle", '◗', :mathord, "right half black circle"), + :inversebullet => UCMCommand("\\inversebullet", '◘', :mathord, "inverse bullet "), + :inversewhitecircle => UCMCommand("\\inversewhitecircle", '◙', :mathord, "inverse white circle"), + :invwhiteupperhalfcircle => UCMCommand("\\invwhiteupperhalfcircle", '◚', :mathord, "upper half inverse white circle"), + :invwhitelowerhalfcircle => UCMCommand("\\invwhitelowerhalfcircle", '◛', :mathord, "lower half inverse white circle"), + :ularc => UCMCommand("\\ularc", '◜', :mathord, "upper left quadrant circular arc"), + :urarc => UCMCommand("\\urarc", '◝', :mathord, "upper right quadrant circular arc"), + :lrarc => UCMCommand("\\lrarc", '◞', :mathord, "lower right quadrant circular arc"), + :llarc => UCMCommand("\\llarc", '◟', :mathord, "lower left quadrant circular arc"), + :topsemicircle => UCMCommand("\\topsemicircle", '◠', :mathord, "upper half circle"), + :botsemicircle => UCMCommand("\\botsemicircle", '◡', :mathord, "lower half circle"), + :lrblacktriangle => UCMCommand("\\lrblacktriangle", '◢', :mathord, "lower right triangle, filled"), + :llblacktriangle => UCMCommand("\\llblacktriangle", '◣', :mathord, "lower left triangle, filled"), + :ulblacktriangle => UCMCommand("\\ulblacktriangle", '◤', :mathord, "upper left triangle, filled"), + :urblacktriangle => UCMCommand("\\urblacktriangle", '◥', :mathord, "upper right triangle, filled"), + :smwhtcircle => UCMCommand("\\smwhtcircle", '◦', :mathord, "white bullet"), + :squareleftblack => UCMCommand("\\squareleftblack", '◧', :mathord, "square, filled left half"), + :squarerightblack => UCMCommand("\\squarerightblack", '◨', :mathord, "square, filled right half"), + :squareulblack => UCMCommand("\\squareulblack", '◩', :mathord, "square, filled top left corner"), + :squarelrblack => UCMCommand("\\squarelrblack", '◪', :mathord, "square, filled bottom right corner"), + :boxbar => UCMCommand("\\boxbar", '◫', :mathbin, "vertical bar in box"), + :trianglecdot => UCMCommand("\\trianglecdot", '◬', :mathord, "triangle with centered dot"), + :triangleleftblack => UCMCommand("\\triangleleftblack", '◭', :mathord, "up-pointing triangle with left half black"), + :trianglerightblack => UCMCommand("\\trianglerightblack", '◮', :mathord, "up-pointing triangle with right half black"), + :lgwhtcircle => UCMCommand("\\lgwhtcircle", '◯', :mathord, "large circle"), + :squareulquad => UCMCommand("\\squareulquad", '◰', :mathord, "white square with upper left quadrant"), + :squarellquad => UCMCommand("\\squarellquad", '◱', :mathord, "white square with lower left quadrant"), + :squarelrquad => UCMCommand("\\squarelrquad", '◲', :mathord, "white square with lower right quadrant"), + :squareurquad => UCMCommand("\\squareurquad", '◳', :mathord, "white square with upper right quadrant"), + :circleulquad => UCMCommand("\\circleulquad", '◴', :mathord, "white circle with upper left quadrant"), + :circlellquad => UCMCommand("\\circlellquad", '◵', :mathord, "white circle with lower left quadrant"), + :circlelrquad => UCMCommand("\\circlelrquad", '◶', :mathord, "white circle with lower right quadrant"), + :circleurquad => UCMCommand("\\circleurquad", '◷', :mathord, "white circle with upper right quadrant"), + :ultriangle => UCMCommand("\\ultriangle", '◸', :mathord, "upper left triangle"), + :urtriangle => UCMCommand("\\urtriangle", '◹', :mathord, "upper right triangle"), + :lltriangle => UCMCommand("\\lltriangle", '◺', :mathord, "lower left triangle"), + :mdwhtsquare => UCMCommand("\\mdwhtsquare", '◻', :mathord, "white medium square"), + :mdblksquare => UCMCommand("\\mdblksquare", '◼', :mathord, "black medium square"), + :mdsmwhtsquare => UCMCommand("\\mdsmwhtsquare", '◽', :mathord, "white medium small square"), + :mdsmblksquare => UCMCommand("\\mdsmblksquare", '◾', :mathord, "black medium small square"), + :lrtriangle => UCMCommand("\\lrtriangle", '◿', :mathord, "lower right triangle"), + :bigstar => UCMCommand("\\bigstar", '★', :mathord, "star, filled"), + :bigwhitestar => UCMCommand("\\bigwhitestar", '☆', :mathord, "star, open"), + :astrosun => UCMCommand("\\astrosun", '☉', :mathord, "sun"), + :danger => UCMCommand("\\danger", '☡', :mathord, "dangerous bend (caution sign)"), + :blacksmiley => UCMCommand("\\blacksmiley", '☻', :mathord, "black smiling face"), + :sun => UCMCommand("\\sun", '☼', :mathord, "white sun with rays"), + :rightmoon => UCMCommand("\\rightmoon", '☽', :mathord, "first quarter moon"), + :leftmoon => UCMCommand("\\leftmoon", '☾', :mathord, "last quarter moon"), + :female => UCMCommand("\\female", '♀', :mathord, "venus, female"), + :male => UCMCommand("\\male", '♂', :mathord, "mars, male"), + :spadesuit => UCMCommand("\\spadesuit", '♠', :mathord, "spades suit symbol"), + :heartsuit => UCMCommand("\\heartsuit", '♡', :mathord, "heart suit symbol"), + :diamondsuit => UCMCommand("\\diamondsuit", '♢', :mathord, "diamond suit symbol"), + :clubsuit => UCMCommand("\\clubsuit", '♣', :mathord, "club suit symbol"), + :varspadesuit => UCMCommand("\\varspadesuit", '♤', :mathord, "spade, white (card suit)"), + :varheartsuit => UCMCommand("\\varheartsuit", '♥', :mathord, "filled heart (card suit)"), + :vardiamondsuit => UCMCommand("\\vardiamondsuit", '♦', :mathord, "filled diamond (card suit)"), + :varclubsuit => UCMCommand("\\varclubsuit", '♧', :mathord, "club, white (card suit)"), + :quarternote => UCMCommand("\\quarternote", '♩', :mathord, "music note (sung text sign)"), + :eighthnote => UCMCommand("\\eighthnote", '♪', :mathord, "eighth note"), + :twonotes => UCMCommand("\\twonotes", '♫', :mathord, "beamed eighth notes"), + :flat => UCMCommand("\\flat", '♭', :mathord, "musical flat"), + :natural => UCMCommand("\\natural", '♮', :mathord, "music natural"), + :sharp => UCMCommand("\\sharp", '♯', :mathord, "musical sharp"), + :acidfree => UCMCommand("\\acidfree", '♾', :mathord, "permanent paper sign"), + :dicei => UCMCommand("\\dicei", '⚀', :mathord, "die face-1"), + :diceii => UCMCommand("\\diceii", '⚁', :mathord, "die face-2"), + :diceiii => UCMCommand("\\diceiii", '⚂', :mathord, "die face-3"), + :diceiv => UCMCommand("\\diceiv", '⚃', :mathord, "die face-4"), + :dicev => UCMCommand("\\dicev", '⚄', :mathord, "die face-5"), + :dicevi => UCMCommand("\\dicevi", '⚅', :mathord, "die face-6"), + :circledrightdot => UCMCommand("\\circledrightdot", '⚆', :mathord, "white circle with dot right"), + :circledtwodots => UCMCommand("\\circledtwodots", '⚇', :mathord, "white circle with two dots"), + :blackcircledrightdot => UCMCommand("\\blackcircledrightdot", '⚈', :mathord, "black circle with white dot right"), + :blackcircledtwodots => UCMCommand("\\blackcircledtwodots", '⚉', :mathord, "black circle with two white dots"), + :Hermaphrodite => UCMCommand("\\Hermaphrodite", '⚥', :mathord, "male and female sign"), + :mdwhtcircle => UCMCommand("\\mdwhtcircle", '⚪', :mathord, "medium white circle"), + :mdblkcircle => UCMCommand("\\mdblkcircle", '⚫', :mathord, "medium black circle"), + :mdsmwhtcircle => UCMCommand("\\mdsmwhtcircle", '⚬', :mathord, "medium small white circle"), + :neuter => UCMCommand("\\neuter", '⚲', :mathord, "neuter"), + :checkmark => UCMCommand("\\checkmark", '✓', :mathord, "tick, check mark"), + :maltese => UCMCommand("\\maltese", '✠', :mathord, "maltese cross"), + :circledstar => UCMCommand("\\circledstar", '✪', :mathord, "circled white star"), + :varstar => UCMCommand("\\varstar", '✶', :mathord, "six pointed black star"), + :dingasterisk => UCMCommand("\\dingasterisk", '✽', :mathord, "heavy teardrop-spoked asterisk"), + :lbrbrak => UCMCommand("\\lbrbrak", '❲', :mathopen, "light left tortoise shell bracket ornament"), + :rbrbrak => UCMCommand("\\rbrbrak", '❳', :mathclose, "light right tortoise shell bracket ornament"), + :draftingarrow => UCMCommand("\\draftingarrow", '➛', :mathord, "right arrow with bold head (drafting)"), + :threedangle => UCMCommand("\\threedangle", '⟀', :mathord, "three dimensional angle"), + :whiteinwhitetriangle => UCMCommand("\\whiteinwhitetriangle", '⟁', :mathord, "white triangle containing small white triangle"), + :perp => UCMCommand("\\perp", '⟂', :mathrel, "perpendicular"), + :subsetcirc => UCMCommand("\\subsetcirc", '⟃', :mathord, "open subset"), + :supsetcirc => UCMCommand("\\supsetcirc", '⟄', :mathord, "open superset"), + :lbag => UCMCommand("\\lbag", '⟅', :mathopen, "left s-shaped bag delimiter"), + :rbag => UCMCommand("\\rbag", '⟆', :mathclose, "right s-shaped bag delimiter"), + :veedot => UCMCommand("\\veedot", '⟇', :mathbin, "or with dot inside"), + :bsolhsub => UCMCommand("\\bsolhsub", '⟈', :mathrel, "reverse solidus preceding subset"), + :suphsol => UCMCommand("\\suphsol", '⟉', :mathrel, "superset preceding solidus"), + :diagup => UCMCommand("\\diagup", '⟋', :mathord, "mathematical rising diagonal"), + :longdivision => UCMCommand("\\longdivision", '⟌', :mathopen, "long division"), + :diagdown => UCMCommand("\\diagdown", '⟍', :mathord, "mathematical falling diagonal"), + :diamondcdot => UCMCommand("\\diamondcdot", '⟐', :mathord, "white diamond with centred dot"), + :wedgedot => UCMCommand("\\wedgedot", '⟑', :mathbin, "and with dot"), + :upin => UCMCommand("\\upin", '⟒', :mathrel, "element of opening upwards"), + :pullback => UCMCommand("\\pullback", '⟓', :mathrel, "lower right corner with dot"), + :pushout => UCMCommand("\\pushout", '⟔', :mathrel, "upper left corner with dot"), + :leftouterjoin => UCMCommand("\\leftouterjoin", '⟕', :mathop, "left outer join"), + :rightouterjoin => UCMCommand("\\rightouterjoin", '⟖', :mathop, "right outer join"), + :fullouterjoin => UCMCommand("\\fullouterjoin", '⟗', :mathop, "full outer join"), + :bigbot => UCMCommand("\\bigbot", '⟘', :mathop, "large up tack"), + :bigtop => UCMCommand("\\bigtop", '⟙', :mathop, "large down tack"), + :DashVDash => UCMCommand("\\DashVDash", '⟚', :mathrel, "left and right double turnstile"), + :dashVdash => UCMCommand("\\dashVdash", '⟛', :mathrel, "left and right tack"), + :multimapinv => UCMCommand("\\multimapinv", '⟜', :mathrel, "left multimap"), + :vlongdash => UCMCommand("\\vlongdash", '⟝', :mathrel, "long left tack"), + :longdashv => UCMCommand("\\longdashv", '⟞', :mathrel, "long right tack"), + :cirbot => UCMCommand("\\cirbot", '⟟', :mathrel, "up tack with circle above"), + :lozengeminus => UCMCommand("\\lozengeminus", '⟠', :mathbin, "lozenge divided by horizontal rule"), + :concavediamond => UCMCommand("\\concavediamond", '⟡', :mathbin, "white concave-sided diamond"), + :concavediamondtickleft => UCMCommand("\\concavediamondtickleft", '⟢', :mathbin, "white concave-sided diamond with leftwards tick"), + :concavediamondtickright => UCMCommand("\\concavediamondtickright", '⟣', :mathbin, "white concave-sided diamond with rightwards tick"), + :whitesquaretickleft => UCMCommand("\\whitesquaretickleft", '⟤', :mathbin, "white square with leftwards tick"), + :whitesquaretickright => UCMCommand("\\whitesquaretickright", '⟥', :mathbin, "white square with rightwards tick"), + :lBrack => UCMCommand("\\lBrack", '⟦', :mathopen, "mathematical left white square bracket"), + :rBrack => UCMCommand("\\rBrack", '⟧', :mathclose, "mathematical right white square bracket"), + :langle => UCMCommand("\\langle", '⟨', :mathopen, "mathematical left angle bracket"), + :rangle => UCMCommand("\\rangle", '⟩', :mathclose, "mathematical right angle bracket"), + :lAngle => UCMCommand("\\lAngle", '⟪', :mathopen, "mathematical left double angle bracket"), + :rAngle => UCMCommand("\\rAngle", '⟫', :mathclose, "mathematical right double angle bracket"), + :Lbrbrak => UCMCommand("\\Lbrbrak", '⟬', :mathopen, "mathematical left white tortoise shell bracket"), + :Rbrbrak => UCMCommand("\\Rbrbrak", '⟭', :mathclose, "mathematical right white tortoise shell bracket"), + :lgroup => UCMCommand("\\lgroup", '⟮', :mathopen, "mathematical left flattened parenthesis"), + :rgroup => UCMCommand("\\rgroup", '⟯', :mathclose, "mathematical right flattened parenthesis"), + :UUparrow => UCMCommand("\\UUparrow", '⟰', :mathrel, "upwards quadruple arrow"), + :DDownarrow => UCMCommand("\\DDownarrow", '⟱', :mathrel, "downwards quadruple arrow"), + :acwgapcirclearrow => UCMCommand("\\acwgapcirclearrow", '⟲', :mathrel, "anticlockwise gapped circle arrow"), + :cwgapcirclearrow => UCMCommand("\\cwgapcirclearrow", '⟳', :mathrel, "clockwise gapped circle arrow"), + :rightarrowonoplus => UCMCommand("\\rightarrowonoplus", '⟴', :mathrel, "right arrow with circled plus"), + :longleftarrow => UCMCommand("\\longleftarrow", '⟵', :mathrel, "long leftwards arrow"), + :longrightarrow => UCMCommand("\\longrightarrow", '⟶', :mathrel, "long rightwards arrow"), + :longleftrightarrow => UCMCommand("\\longleftrightarrow", '⟷', :mathrel, "long left right arrow"), + :Longleftarrow => UCMCommand("\\Longleftarrow", '⟸', :mathrel, "long leftwards double arrow"), + :Longrightarrow => UCMCommand("\\Longrightarrow", '⟹', :mathrel, "long rightwards double arrow"), + :Longleftrightarrow => UCMCommand("\\Longleftrightarrow", '⟺', :mathrel, "long left right double arrow"), + :longmapsfrom => UCMCommand("\\longmapsfrom", '⟻', :mathrel, "long leftwards arrow from bar"), + :longmapsto => UCMCommand("\\longmapsto", '⟼', :mathrel, "long rightwards arrow from bar"), + :Longmapsfrom => UCMCommand("\\Longmapsfrom", '⟽', :mathrel, "long leftwards double arrow from bar"), + :Longmapsto => UCMCommand("\\Longmapsto", '⟾', :mathrel, "long rightwards double arrow from bar"), + :longrightsquigarrow => UCMCommand("\\longrightsquigarrow", '⟿', :mathrel, "long rightwards squiggle arrow"), + :nvtwoheadrightarrow => UCMCommand("\\nvtwoheadrightarrow", '⤀', :mathrel, "rightwards two-headed arrow with vertical stroke"), + :nVtwoheadrightarrow => UCMCommand("\\nVtwoheadrightarrow", '⤁', :mathrel, "rightwards two-headed arrow with double vertical stroke"), + :nvLeftarrow => UCMCommand("\\nvLeftarrow", '⤂', :mathrel, "leftwards double arrow with vertical stroke"), + :nvRightarrow => UCMCommand("\\nvRightarrow", '⤃', :mathrel, "rightwards double arrow with vertical stroke"), + :nvLeftrightarrow => UCMCommand("\\nvLeftrightarrow", '⤄', :mathrel, "left right double arrow with vertical stroke"), + :twoheadmapsto => UCMCommand("\\twoheadmapsto", '⤅', :mathrel, "rightwards two-headed arrow from bar"), + :Mapsfrom => UCMCommand("\\Mapsfrom", '⤆', :mathrel, "leftwards double arrow from bar"), + :Mapsto => UCMCommand("\\Mapsto", '⤇', :mathrel, "rightwards double arrow from bar"), + :downarrowbarred => UCMCommand("\\downarrowbarred", '⤈', :mathrel, "downwards arrow with horizontal stroke"), + :uparrowbarred => UCMCommand("\\uparrowbarred", '⤉', :mathrel, "upwards arrow with horizontal stroke"), + :Uuparrow => UCMCommand("\\Uuparrow", '⤊', :mathrel, "upwards triple arrow"), + :Ddownarrow => UCMCommand("\\Ddownarrow", '⤋', :mathrel, "downwards triple arrow"), + :leftbkarrow => UCMCommand("\\leftbkarrow", '⤌', :mathrel, "leftwards double dash arrow"), + :rightbkarrow => UCMCommand("\\rightbkarrow", '⤍', :mathrel, "rightwards double dash arrow"), + :leftdbkarrow => UCMCommand("\\leftdbkarrow", '⤎', :mathrel, "leftwards triple dash arrow"), + :dbkarrow => UCMCommand("\\dbkarrow", '⤏', :mathrel, "rightwards triple dash arrow"), + :drbkarrow => UCMCommand("\\drbkarrow", '⤐', :mathrel, "rightwards two-headed triple dash arrow"), + :rightdotarrow => UCMCommand("\\rightdotarrow", '⤑', :mathrel, "rightwards arrow with dotted stem"), + :baruparrow => UCMCommand("\\baruparrow", '⤒', :mathrel, "upwards arrow to bar"), + :downarrowbar => UCMCommand("\\downarrowbar", '⤓', :mathrel, "downwards arrow to bar"), + :nvrightarrowtail => UCMCommand("\\nvrightarrowtail", '⤔', :mathrel, "rightwards arrow with tail with vertical stroke"), + :nVrightarrowtail => UCMCommand("\\nVrightarrowtail", '⤕', :mathrel, "rightwards arrow with tail with double vertical stroke"), + :twoheadrightarrowtail => UCMCommand("\\twoheadrightarrowtail", '⤖', :mathrel, "rightwards two-headed arrow with tail"), + :nvtwoheadrightarrowtail => UCMCommand("\\nvtwoheadrightarrowtail", '⤗', :mathrel, "rightwards two-headed arrow with tail with vertical stroke"), + :nVtwoheadrightarrowtail => UCMCommand("\\nVtwoheadrightarrowtail", '⤘', :mathrel, "rightwards two-headed arrow with tail with double vertical stroke"), + :lefttail => UCMCommand("\\lefttail", '⤙', :mathrel, "leftwards arrow-tail"), + :righttail => UCMCommand("\\righttail", '⤚', :mathrel, "rightwards arrow-tail"), + :leftdbltail => UCMCommand("\\leftdbltail", '⤛', :mathrel, "leftwards double arrow-tail"), + :rightdbltail => UCMCommand("\\rightdbltail", '⤜', :mathrel, "rightwards double arrow-tail"), + :diamondleftarrow => UCMCommand("\\diamondleftarrow", '⤝', :mathrel, "leftwards arrow to black diamond"), + :rightarrowdiamond => UCMCommand("\\rightarrowdiamond", '⤞', :mathrel, "rightwards arrow to black diamond"), + :diamondleftarrowbar => UCMCommand("\\diamondleftarrowbar", '⤟', :mathrel, "leftwards arrow from bar to black diamond"), + :barrightarrowdiamond => UCMCommand("\\barrightarrowdiamond", '⤠', :mathrel, "rightwards arrow from bar to black diamond"), + :nwsearrow => UCMCommand("\\nwsearrow", '⤡', :mathrel, "north west and south east arrow"), + :neswarrow => UCMCommand("\\neswarrow", '⤢', :mathrel, "north east and south west arrow"), + :hknwarrow => UCMCommand("\\hknwarrow", '⤣', :mathrel, "north west arrow with hook"), + :hknearrow => UCMCommand("\\hknearrow", '⤤', :mathrel, "north east arrow with hook"), + :hksearrow => UCMCommand("\\hksearrow", '⤥', :mathrel, "south east arrow with hook"), + :hkswarrow => UCMCommand("\\hkswarrow", '⤦', :mathrel, "south west arrow with hook"), + :tona => UCMCommand("\\tona", '⤧', :mathrel, "north west arrow and north east arrow"), + :toea => UCMCommand("\\toea", '⤨', :mathrel, "north east arrow and south east arrow"), + :tosa => UCMCommand("\\tosa", '⤩', :mathrel, "south east arrow and south west arrow"), + :towa => UCMCommand("\\towa", '⤪', :mathrel, "south west arrow and north west arrow"), + :rdiagovfdiag => UCMCommand("\\rdiagovfdiag", '⤫', :mathord, "rising diagonal crossing falling diagonal"), + :fdiagovrdiag => UCMCommand("\\fdiagovrdiag", '⤬', :mathord, "falling diagonal crossing rising diagonal"), + :seovnearrow => UCMCommand("\\seovnearrow", '⤭', :mathord, "south east arrow crossing north east arrow"), + :neovsearrow => UCMCommand("\\neovsearrow", '⤮', :mathord, "north east arrow crossing south east arrow"), + :fdiagovnearrow => UCMCommand("\\fdiagovnearrow", '⤯', :mathord, "falling diagonal crossing north east arrow"), + :rdiagovsearrow => UCMCommand("\\rdiagovsearrow", '⤰', :mathord, "rising diagonal crossing south east arrow"), + :neovnwarrow => UCMCommand("\\neovnwarrow", '⤱', :mathord, "north east arrow crossing north west arrow"), + :nwovnearrow => UCMCommand("\\nwovnearrow", '⤲', :mathord, "north west arrow crossing north east arrow"), + :rightcurvedarrow => UCMCommand("\\rightcurvedarrow", '⤳', :mathrel, "wave arrow pointing directly right"), + :uprightcurvearrow => UCMCommand("\\uprightcurvearrow", '⤴', :mathord, "arrow pointing rightwards then curving upwards"), + :downrightcurvedarrow => UCMCommand("\\downrightcurvedarrow", '⤵', :mathord, "arrow pointing rightwards then curving downwards"), + :leftdowncurvedarrow => UCMCommand("\\leftdowncurvedarrow", '⤶', :mathrel, "arrow pointing downwards then curving leftwards"), + :rightdowncurvedarrow => UCMCommand("\\rightdowncurvedarrow", '⤷', :mathrel, "arrow pointing downwards then curving rightwards"), + :cwrightarcarrow => UCMCommand("\\cwrightarcarrow", '⤸', :mathrel, "right-side arc clockwise arrow"), + :acwleftarcarrow => UCMCommand("\\acwleftarcarrow", '⤹', :mathrel, "left-side arc anticlockwise arrow"), + :acwoverarcarrow => UCMCommand("\\acwoverarcarrow", '⤺', :mathrel, "top arc anticlockwise arrow"), + :acwunderarcarrow => UCMCommand("\\acwunderarcarrow", '⤻', :mathrel, "bottom arc anticlockwise arrow"), + :curvearrowrightminus => UCMCommand("\\curvearrowrightminus", '⤼', :mathrel, "top arc clockwise arrow with minus"), + :curvearrowleftplus => UCMCommand("\\curvearrowleftplus", '⤽', :mathrel, "top arc anticlockwise arrow with plus"), + :cwundercurvearrow => UCMCommand("\\cwundercurvearrow", '⤾', :mathrel, "lower right semicircular clockwise arrow"), + :ccwundercurvearrow => UCMCommand("\\ccwundercurvearrow", '⤿', :mathrel, "lower left semicircular anticlockwise arrow"), + :acwcirclearrow => UCMCommand("\\acwcirclearrow", '⥀', :mathrel, "anticlockwise closed circle arrow"), + :cwcirclearrow => UCMCommand("\\cwcirclearrow", '⥁', :mathrel, "clockwise closed circle arrow"), + :rightarrowshortleftarrow => UCMCommand("\\rightarrowshortleftarrow", '⥂', :mathrel, "rightwards arrow above short leftwards arrow"), + :leftarrowshortrightarrow => UCMCommand("\\leftarrowshortrightarrow", '⥃', :mathrel, "leftwards arrow above short rightwards arrow"), + :shortrightarrowleftarrow => UCMCommand("\\shortrightarrowleftarrow", '⥄', :mathrel, "short rightwards arrow above leftwards arrow"), + :rightarrowplus => UCMCommand("\\rightarrowplus", '⥅', :mathrel, "rightwards arrow with plus below"), + :leftarrowplus => UCMCommand("\\leftarrowplus", '⥆', :mathrel, "leftwards arrow with plus below"), + :rightarrowx => UCMCommand("\\rightarrowx", '⥇', :mathrel, "rightwards arrow through x"), + :leftrightarrowcircle => UCMCommand("\\leftrightarrowcircle", '⥈', :mathrel, "left right arrow through small circle"), + :twoheaduparrowcircle => UCMCommand("\\twoheaduparrowcircle", '⥉', :mathrel, "upwards two-headed arrow from small circle"), + :leftrightharpoonupdown => UCMCommand("\\leftrightharpoonupdown", '⥊', :mathrel, "left barb up right barb down harpoon"), + :leftrightharpoondownup => UCMCommand("\\leftrightharpoondownup", '⥋', :mathrel, "left barb down right barb up harpoon"), + :updownharpoonrightleft => UCMCommand("\\updownharpoonrightleft", '⥌', :mathrel, "up barb right down barb left harpoon"), + :updownharpoonleftright => UCMCommand("\\updownharpoonleftright", '⥍', :mathrel, "up barb left down barb right harpoon"), + :leftrightharpoonupup => UCMCommand("\\leftrightharpoonupup", '⥎', :mathrel, "left barb up right barb up harpoon"), + :updownharpoonrightright => UCMCommand("\\updownharpoonrightright", '⥏', :mathrel, "up barb right down barb right harpoon"), + :leftrightharpoondowndown => UCMCommand("\\leftrightharpoondowndown", '⥐', :mathrel, "left barb down right barb down harpoon"), + :updownharpoonleftleft => UCMCommand("\\updownharpoonleftleft", '⥑', :mathrel, "up barb left down barb left harpoon"), + :barleftharpoonup => UCMCommand("\\barleftharpoonup", '⥒', :mathrel, "leftwards harpoon with barb up to bar"), + :rightharpoonupbar => UCMCommand("\\rightharpoonupbar", '⥓', :mathrel, "rightwards harpoon with barb up to bar"), + :barupharpoonright => UCMCommand("\\barupharpoonright", '⥔', :mathrel, "upwards harpoon with barb right to bar"), + :downharpoonrightbar => UCMCommand("\\downharpoonrightbar", '⥕', :mathrel, "downwards harpoon with barb right to bar"), + :barleftharpoondown => UCMCommand("\\barleftharpoondown", '⥖', :mathrel, "leftwards harpoon with barb down to bar"), + :rightharpoondownbar => UCMCommand("\\rightharpoondownbar", '⥗', :mathrel, "rightwards harpoon with barb down to bar"), + :barupharpoonleft => UCMCommand("\\barupharpoonleft", '⥘', :mathrel, "upwards harpoon with barb left to bar"), + :downharpoonleftbar => UCMCommand("\\downharpoonleftbar", '⥙', :mathrel, "downwards harpoon with barb left to bar"), + :leftharpoonupbar => UCMCommand("\\leftharpoonupbar", '⥚', :mathrel, "leftwards harpoon with barb up from bar"), + :barrightharpoonup => UCMCommand("\\barrightharpoonup", '⥛', :mathrel, "rightwards harpoon with barb up from bar"), + :upharpoonrightbar => UCMCommand("\\upharpoonrightbar", '⥜', :mathrel, "upwards harpoon with barb right from bar"), + :bardownharpoonright => UCMCommand("\\bardownharpoonright", '⥝', :mathrel, "downwards harpoon with barb right from bar"), + :leftharpoondownbar => UCMCommand("\\leftharpoondownbar", '⥞', :mathrel, "leftwards harpoon with barb down from bar"), + :barrightharpoondown => UCMCommand("\\barrightharpoondown", '⥟', :mathrel, "rightwards harpoon with barb down from bar"), + :upharpoonleftbar => UCMCommand("\\upharpoonleftbar", '⥠', :mathrel, "upwards harpoon with barb left from bar"), + :bardownharpoonleft => UCMCommand("\\bardownharpoonleft", '⥡', :mathrel, "downwards harpoon with barb left from bar"), + :leftharpoonsupdown => UCMCommand("\\leftharpoonsupdown", '⥢', :mathrel, "leftwards harpoon with barb up above leftwards harpoon with barb down"), + :upharpoonsleftright => UCMCommand("\\upharpoonsleftright", '⥣', :mathrel, "upwards harpoon with barb left beside upwards harpoon with barb right"), + :rightharpoonsupdown => UCMCommand("\\rightharpoonsupdown", '⥤', :mathrel, "rightwards harpoon with barb up above rightwards harpoon with barb down"), + :downharpoonsleftright => UCMCommand("\\downharpoonsleftright", '⥥', :mathrel, "downwards harpoon with barb left beside downwards harpoon with barb right"), + :leftrightharpoonsup => UCMCommand("\\leftrightharpoonsup", '⥦', :mathrel, "leftwards harpoon with barb up above rightwards harpoon with barb up"), + :leftrightharpoonsdown => UCMCommand("\\leftrightharpoonsdown", '⥧', :mathrel, "leftwards harpoon with barb down above rightwards harpoon with barb down"), + :rightleftharpoonsup => UCMCommand("\\rightleftharpoonsup", '⥨', :mathrel, "rightwards harpoon with barb up above leftwards harpoon with barb up"), + :rightleftharpoonsdown => UCMCommand("\\rightleftharpoonsdown", '⥩', :mathrel, "rightwards harpoon with barb down above leftwards harpoon with barb down"), + :leftharpoonupdash => UCMCommand("\\leftharpoonupdash", '⥪', :mathrel, "leftwards harpoon with barb up above long dash"), + :dashleftharpoondown => UCMCommand("\\dashleftharpoondown", '⥫', :mathrel, "leftwards harpoon with barb down below long dash"), + :rightharpoonupdash => UCMCommand("\\rightharpoonupdash", '⥬', :mathrel, "rightwards harpoon with barb up above long dash"), + :dashrightharpoondown => UCMCommand("\\dashrightharpoondown", '⥭', :mathrel, "rightwards harpoon with barb down below long dash"), + :updownharpoonsleftright => UCMCommand("\\updownharpoonsleftright", '⥮', :mathrel, "upwards harpoon with barb left beside downwards harpoon with barb right"), + :downupharpoonsleftright => UCMCommand("\\downupharpoonsleftright", '⥯', :mathrel, "downwards harpoon with barb left beside upwards harpoon with barb right"), + :rightimply => UCMCommand("\\rightimply", '⥰', :mathrel, "right double arrow with rounded head"), + :equalrightarrow => UCMCommand("\\equalrightarrow", '⥱', :mathrel, "equals sign above rightwards arrow"), + :similarrightarrow => UCMCommand("\\similarrightarrow", '⥲', :mathrel, "tilde operator above rightwards arrow"), + :leftarrowsimilar => UCMCommand("\\leftarrowsimilar", '⥳', :mathrel, "leftwards arrow above tilde operator"), + :rightarrowsimilar => UCMCommand("\\rightarrowsimilar", '⥴', :mathrel, "rightwards arrow above tilde operator"), + :rightarrowapprox => UCMCommand("\\rightarrowapprox", '⥵', :mathrel, "rightwards arrow above almost equal to"), + :ltlarr => UCMCommand("\\ltlarr", '⥶', :mathrel, "less-than above leftwards arrow"), + :leftarrowless => UCMCommand("\\leftarrowless", '⥷', :mathrel, "leftwards arrow through less-than"), + :gtrarr => UCMCommand("\\gtrarr", '⥸', :mathrel, "greater-than above rightwards arrow"), + :subrarr => UCMCommand("\\subrarr", '⥹', :mathrel, "subset above rightwards arrow"), + :leftarrowsubset => UCMCommand("\\leftarrowsubset", '⥺', :mathrel, "leftwards arrow through subset"), + :suplarr => UCMCommand("\\suplarr", '⥻', :mathrel, "superset above leftwards arrow"), + :leftfishtail => UCMCommand("\\leftfishtail", '⥼', :mathrel, "left fish tail"), + :rightfishtail => UCMCommand("\\rightfishtail", '⥽', :mathrel, "right fish tail"), + :upfishtail => UCMCommand("\\upfishtail", '⥾', :mathrel, "up fish tail"), + :downfishtail => UCMCommand("\\downfishtail", '⥿', :mathrel, "down fish tail"), + :Vvert => UCMCommand("\\Vvert", '⦀', :mathfence, "triple vertical bar delimiter"), + :mdsmblkcircle => UCMCommand("\\mdsmblkcircle", '⦁', :mathord, "z notation spot"), + :typecolon => UCMCommand("\\typecolon", '⦂', :mathrel, "z notation type colon"), + :lBrace => UCMCommand("\\lBrace", '⦃', :mathopen, "left white curly bracket"), + :rBrace => UCMCommand("\\rBrace", '⦄', :mathclose, "right white curly bracket"), + :lParen => UCMCommand("\\lParen", '⦅', :mathopen, "left white parenthesis"), + :rParen => UCMCommand("\\rParen", '⦆', :mathclose, "right white parenthesis"), + :llparenthesis => UCMCommand("\\llparenthesis", '⦇', :mathopen, "z notation left image bracket"), + :rrparenthesis => UCMCommand("\\rrparenthesis", '⦈', :mathclose, "z notation right image bracket"), + :llangle => UCMCommand("\\llangle", '⦉', :mathopen, "z notation left binding bracket"), + :rrangle => UCMCommand("\\rrangle", '⦊', :mathclose, "z notation right binding bracket"), + :lbrackubar => UCMCommand("\\lbrackubar", '⦋', :mathopen, "left square bracket with underbar"), + :rbrackubar => UCMCommand("\\rbrackubar", '⦌', :mathclose, "right square bracket with underbar"), + :lbrackultick => UCMCommand("\\lbrackultick", '⦍', :mathopen, "left square bracket with tick in top corner"), + :rbracklrtick => UCMCommand("\\rbracklrtick", '⦎', :mathclose, "right square bracket with tick in bottom corner"), + :lbracklltick => UCMCommand("\\lbracklltick", '⦏', :mathopen, "left square bracket with tick in bottom corner"), + :rbrackurtick => UCMCommand("\\rbrackurtick", '⦐', :mathclose, "right square bracket with tick in top corner"), + :langledot => UCMCommand("\\langledot", '⦑', :mathopen, "left angle bracket with dot"), + :rangledot => UCMCommand("\\rangledot", '⦒', :mathclose, "right angle bracket with dot"), + :lparenless => UCMCommand("\\lparenless", '⦓', :mathopen, "left arc less-than bracket"), + :rparengtr => UCMCommand("\\rparengtr", '⦔', :mathclose, "right arc greater-than bracket"), + :Lparengtr => UCMCommand("\\Lparengtr", '⦕', :mathopen, "double left arc greater-than bracket"), + :Rparenless => UCMCommand("\\Rparenless", '⦖', :mathclose, "double right arc less-than bracket"), + :lblkbrbrak => UCMCommand("\\lblkbrbrak", '⦗', :mathopen, "left black tortoise shell bracket"), + :rblkbrbrak => UCMCommand("\\rblkbrbrak", '⦘', :mathclose, "right black tortoise shell bracket"), + :fourvdots => UCMCommand("\\fourvdots", '⦙', :mathord, "dotted fence"), + :vzigzag => UCMCommand("\\vzigzag", '⦚', :mathord, "vertical zigzag line"), + :measuredangleleft => UCMCommand("\\measuredangleleft", '⦛', :mathord, "measured angle opening left"), + :rightanglesqr => UCMCommand("\\rightanglesqr", '⦜', :mathord, "right angle variant with square"), + :rightanglemdot => UCMCommand("\\rightanglemdot", '⦝', :mathord, "measured right angle with dot"), + :angles => UCMCommand("\\angles", '⦞', :mathord, "angle with s inside"), + :angdnr => UCMCommand("\\angdnr", '⦟', :mathord, "acute angle"), + :gtlpar => UCMCommand("\\gtlpar", '⦠', :mathord, "spherical angle opening left"), + :sphericalangleup => UCMCommand("\\sphericalangleup", '⦡', :mathord, "spherical angle opening up"), + :turnangle => UCMCommand("\\turnangle", '⦢', :mathord, "turned angle"), + :revangle => UCMCommand("\\revangle", '⦣', :mathord, "reversed angle"), + :angleubar => UCMCommand("\\angleubar", '⦤', :mathord, "angle with underbar"), + :revangleubar => UCMCommand("\\revangleubar", '⦥', :mathord, "reversed angle with underbar"), + :wideangledown => UCMCommand("\\wideangledown", '⦦', :mathord, "oblique angle opening up"), + :wideangleup => UCMCommand("\\wideangleup", '⦧', :mathord, "oblique angle opening down"), + :measanglerutone => UCMCommand("\\measanglerutone", '⦨', :mathord, "measured angle with open arm ending in arrow pointing up and right"), + :measanglelutonw => UCMCommand("\\measanglelutonw", '⦩', :mathord, "measured angle with open arm ending in arrow pointing up and left"), + :measanglerdtose => UCMCommand("\\measanglerdtose", '⦪', :mathord, "measured angle with open arm ending in arrow pointing down and right"), + :measangleldtosw => UCMCommand("\\measangleldtosw", '⦫', :mathord, "measured angle with open arm ending in arrow pointing down and left"), + :measangleurtone => UCMCommand("\\measangleurtone", '⦬', :mathord, "measured angle with open arm ending in arrow pointing right and up"), + :measangleultonw => UCMCommand("\\measangleultonw", '⦭', :mathord, "measured angle with open arm ending in arrow pointing left and up"), + :measangledrtose => UCMCommand("\\measangledrtose", '⦮', :mathord, "measured angle with open arm ending in arrow pointing right and down"), + :measangledltosw => UCMCommand("\\measangledltosw", '⦯', :mathord, "measured angle with open arm ending in arrow pointing left and down"), + :revemptyset => UCMCommand("\\revemptyset", '⦰', :mathord, "reversed empty set"), + :emptysetobar => UCMCommand("\\emptysetobar", '⦱', :mathord, "empty set with overbar"), + :emptysetocirc => UCMCommand("\\emptysetocirc", '⦲', :mathord, "empty set with small circle above"), + :emptysetoarr => UCMCommand("\\emptysetoarr", '⦳', :mathord, "empty set with right arrow above"), + :emptysetoarrl => UCMCommand("\\emptysetoarrl", '⦴', :mathord, "empty set with left arrow above"), + :circlehbar => UCMCommand("\\circlehbar", '⦵', :mathbin, "circle with horizontal bar"), + :circledvert => UCMCommand("\\circledvert", '⦶', :mathbin, "circled vertical bar"), + :circledparallel => UCMCommand("\\circledparallel", '⦷', :mathbin, "circled parallel"), + :obslash => UCMCommand("\\obslash", '⦸', :mathbin, "circled reverse solidus"), + :operp => UCMCommand("\\operp", '⦹', :mathbin, "circled perpendicular"), + :obot => UCMCommand("\\obot", '⦺', :mathord, "circle divided by horizontal bar and top half divided by vertical bar"), + :olcross => UCMCommand("\\olcross", '⦻', :mathord, "circle with superimposed x"), + :odotslashdot => UCMCommand("\\odotslashdot", '⦼', :mathord, "circled anticlockwise-rotated division sign"), + :uparrowoncircle => UCMCommand("\\uparrowoncircle", '⦽', :mathord, "up arrow through circle"), + :circledwhitebullet => UCMCommand("\\circledwhitebullet", '⦾', :mathord, "circled white bullet"), + :circledbullet => UCMCommand("\\circledbullet", '⦿', :mathord, "circled bullet"), + :olessthan => UCMCommand("\\olessthan", '⧀', :mathbin, "circled less-than"), + :ogreaterthan => UCMCommand("\\ogreaterthan", '⧁', :mathbin, "circled greater-than"), + :cirscir => UCMCommand("\\cirscir", '⧂', :mathord, "circle with small circle to the right"), + :cirE => UCMCommand("\\cirE", '⧃', :mathord, "circle with two horizontal strokes to the right"), + :boxdiag => UCMCommand("\\boxdiag", '⧄', :mathbin, "squared rising diagonal slash"), + :boxbslash => UCMCommand("\\boxbslash", '⧅', :mathbin, "squared falling diagonal slash"), + :boxast => UCMCommand("\\boxast", '⧆', :mathbin, "squared asterisk"), + :boxcircle => UCMCommand("\\boxcircle", '⧇', :mathbin, "squared small circle"), + :boxbox => UCMCommand("\\boxbox", '⧈', :mathbin, "squared square"), + :boxonbox => UCMCommand("\\boxonbox", '⧉', :mathord, "two joined squares"), + :triangleodot => UCMCommand("\\triangleodot", '⧊', :mathord, "triangle with dot above"), + :triangleubar => UCMCommand("\\triangleubar", '⧋', :mathord, "triangle with underbar"), + :triangles => UCMCommand("\\triangles", '⧌', :mathord, "s in triangle"), + :triangleserifs => UCMCommand("\\triangleserifs", '⧍', :mathbin, "triangle with serifs at bottom"), + :rtriltri => UCMCommand("\\rtriltri", '⧎', :mathrel, "right triangle above left triangle"), + :ltrivb => UCMCommand("\\ltrivb", '⧏', :mathrel, "left triangle beside vertical bar"), + :vbrtri => UCMCommand("\\vbrtri", '⧐', :mathrel, "vertical bar beside right triangle"), + :lfbowtie => UCMCommand("\\lfbowtie", '⧑', :mathrel, "left black bowtie"), + :rfbowtie => UCMCommand("\\rfbowtie", '⧒', :mathrel, "right black bowtie"), + :fbowtie => UCMCommand("\\fbowtie", '⧓', :mathrel, "black bowtie"), + :lftimes => UCMCommand("\\lftimes", '⧔', :mathrel, "left black times"), + :rftimes => UCMCommand("\\rftimes", '⧕', :mathrel, "right black times"), + :hourglass => UCMCommand("\\hourglass", '⧖', :mathbin, "white hourglass"), + :blackhourglass => UCMCommand("\\blackhourglass", '⧗', :mathbin, "black hourglass"), + :lvzigzag => UCMCommand("\\lvzigzag", '⧘', :mathopen, "left wiggly fence"), + :rvzigzag => UCMCommand("\\rvzigzag", '⧙', :mathclose, "right wiggly fence"), + :Lvzigzag => UCMCommand("\\Lvzigzag", '⧚', :mathopen, "left double wiggly fence"), + :Rvzigzag => UCMCommand("\\Rvzigzag", '⧛', :mathclose, "right double wiggly fence"), + :iinfin => UCMCommand("\\iinfin", '⧜', :mathord, "incomplete infinity"), + :tieinfty => UCMCommand("\\tieinfty", '⧝', :mathord, "tie over infinity"), + :nvinfty => UCMCommand("\\nvinfty", '⧞', :mathord, "infinity negated with vertical bar"), + :dualmap => UCMCommand("\\dualmap", '⧟', :mathrel, "double-ended multimap"), + :laplac => UCMCommand("\\laplac", '⧠', :mathord, "square with contoured outline"), + :lrtriangleeq => UCMCommand("\\lrtriangleeq", '⧡', :mathrel, "increases as"), + :shuffle => UCMCommand("\\shuffle", '⧢', :mathbin, "shuffle product"), + :eparsl => UCMCommand("\\eparsl", '⧣', :mathrel, "equals sign and slanted parallel"), + :smeparsl => UCMCommand("\\smeparsl", '⧤', :mathrel, "equals sign and slanted parallel with tilde above"), + :eqvparsl => UCMCommand("\\eqvparsl", '⧥', :mathrel, "identical to and slanted parallel"), + :gleichstark => UCMCommand("\\gleichstark", '⧦', :mathrel, "gleich stark"), + :thermod => UCMCommand("\\thermod", '⧧', :mathord, "thermodynamic"), + :downtriangleleftblack => UCMCommand("\\downtriangleleftblack", '⧨', :mathord, "down-pointing triangle with left half black"), + :downtrianglerightblack => UCMCommand("\\downtrianglerightblack", '⧩', :mathord, "down-pointing triangle with right half black"), + :blackdiamonddownarrow => UCMCommand("\\blackdiamonddownarrow", '⧪', :mathord, "black diamond with down arrow"), + :mdlgblklozenge => UCMCommand("\\mdlgblklozenge", '⧫', :mathbin, "black lozenge"), + :circledownarrow => UCMCommand("\\circledownarrow", '⧬', :mathord, "white circle with down arrow"), + :blackcircledownarrow => UCMCommand("\\blackcircledownarrow", '⧭', :mathord, "black circle with down arrow"), + :errbarsquare => UCMCommand("\\errbarsquare", '⧮', :mathord, "error-barred white square"), + :errbarblacksquare => UCMCommand("\\errbarblacksquare", '⧯', :mathord, "error-barred black square"), + :errbardiamond => UCMCommand("\\errbardiamond", '⧰', :mathord, "error-barred white diamond"), + :errbarblackdiamond => UCMCommand("\\errbarblackdiamond", '⧱', :mathord, "error-barred black diamond"), + :errbarcircle => UCMCommand("\\errbarcircle", '⧲', :mathord, "error-barred white circle"), + :errbarblackcircle => UCMCommand("\\errbarblackcircle", '⧳', :mathord, "error-barred black circle"), + :ruledelayed => UCMCommand("\\ruledelayed", '⧴', :mathrel, "rule-delayed"), + :reversesolidus => UCMCommand("\\reversesolidus", '⧵', :mathbin, "reverse solidus"), + :dsol => UCMCommand("\\dsol", '⧶', :mathbin, "solidus with overbar"), + :rsolbar => UCMCommand("\\rsolbar", '⧷', :mathbin, "reverse solidus with horizontal stroke"), + :xsol => UCMCommand("\\xsol", '⧸', :mathop, "big solidus"), + :xbsol => UCMCommand("\\xbsol", '⧹', :mathop, "big reverse solidus"), + :doubleplus => UCMCommand("\\doubleplus", '⧺', :mathbin, "double plus"), + :tripleplus => UCMCommand("\\tripleplus", '⧻', :mathbin, "triple plus"), + :lcurvyangle => UCMCommand("\\lcurvyangle", '⧼', :mathopen, "left pointing curved angle bracket"), + :rcurvyangle => UCMCommand("\\rcurvyangle", '⧽', :mathclose, "right pointing curved angle bracket"), + :tplus => UCMCommand("\\tplus", '⧾', :mathbin, "tiny"), + :tminus => UCMCommand("\\tminus", '⧿', :mathbin, "miny"), + :bigodot => UCMCommand("\\bigodot", '⨀', :mathop, "n-ary circled dot operator"), + :bigoplus => UCMCommand("\\bigoplus", '⨁', :mathop, "n-ary circled plus operator"), + :bigotimes => UCMCommand("\\bigotimes", '⨂', :mathop, "n-ary circled times operator"), + :bigcupdot => UCMCommand("\\bigcupdot", '⨃', :mathop, "n-ary union operator with dot"), + :biguplus => UCMCommand("\\biguplus", '⨄', :mathop, "n-ary union operator with plus"), + :bigsqcap => UCMCommand("\\bigsqcap", '⨅', :mathop, "n-ary square intersection operator"), + :bigsqcup => UCMCommand("\\bigsqcup", '⨆', :mathop, "n-ary square union operator"), + :conjquant => UCMCommand("\\conjquant", '⨇', :mathop, "two logical and operator"), + :disjquant => UCMCommand("\\disjquant", '⨈', :mathop, "two logical or operator"), + :bigtimes => UCMCommand("\\bigtimes", '⨉', :mathop, "n-ary times operator"), + :modtwosum => UCMCommand("\\modtwosum", '⨊', :mathop, "modulo two sum"), + :sumint => UCMCommand("\\sumint", '⨋', :mathop, "summation with integral"), + :iiiint => UCMCommand("\\iiiint", '⨌', :mathop, "quadruple integral operator"), + :intbar => UCMCommand("\\intbar", '⨍', :mathop, "finite part integral"), + :intBar => UCMCommand("\\intBar", '⨎', :mathop, "integral with double stroke"), + :fint => UCMCommand("\\fint", '⨏', :mathop, "integral average with slash"), + :cirfnint => UCMCommand("\\cirfnint", '⨐', :mathop, "circulation function"), + :awint => UCMCommand("\\awint", '⨑', :mathop, "anticlockwise integration"), + :rppolint => UCMCommand("\\rppolint", '⨒', :mathop, "line integration with rectangular path around pole"), + :scpolint => UCMCommand("\\scpolint", '⨓', :mathop, "line integration with semicircular path around pole"), + :npolint => UCMCommand("\\npolint", '⨔', :mathop, "line integration not including the pole"), + :pointint => UCMCommand("\\pointint", '⨕', :mathop, "integral around a point operator"), + :sqint => UCMCommand("\\sqint", '⨖', :mathop, "quaternion integral operator"), + :intlarhk => UCMCommand("\\intlarhk", '⨗', :mathop, "integral with leftwards arrow with hook"), + :intx => UCMCommand("\\intx", '⨘', :mathop, "integral with times sign"), + :intcap => UCMCommand("\\intcap", '⨙', :mathop, "integral with intersection"), + :intcup => UCMCommand("\\intcup", '⨚', :mathop, "integral with union"), + :upint => UCMCommand("\\upint", '⨛', :mathop, "integral with overbar"), + :lowint => UCMCommand("\\lowint", '⨜', :mathop, "integral with underbar"), + :Join => UCMCommand("\\Join", '⨝', :mathop, "join"), + :bigtriangleleft => UCMCommand("\\bigtriangleleft", '⨞', :mathop, "large left triangle operator"), + :zcmp => UCMCommand("\\zcmp", '⨟', :mathop, "z notation schema composition"), + :zpipe => UCMCommand("\\zpipe", '⨠', :mathop, "z notation schema piping"), + :zproject => UCMCommand("\\zproject", '⨡', :mathop, "z notation schema projection"), + :ringplus => UCMCommand("\\ringplus", '⨢', :mathbin, "plus sign with small circle above"), + :plushat => UCMCommand("\\plushat", '⨣', :mathbin, "plus sign with circumflex accent above"), + :simplus => UCMCommand("\\simplus", '⨤', :mathbin, "plus sign with tilde above"), + :plusdot => UCMCommand("\\plusdot", '⨥', :mathbin, "plus sign with dot below"), + :plussim => UCMCommand("\\plussim", '⨦', :mathbin, "plus sign with tilde below"), + :plussubtwo => UCMCommand("\\plussubtwo", '⨧', :mathbin, "plus sign with subscript two"), + :plustrif => UCMCommand("\\plustrif", '⨨', :mathbin, "plus sign with black triangle"), + :commaminus => UCMCommand("\\commaminus", '⨩', :mathbin, "minus sign with comma above"), + :minusdot => UCMCommand("\\minusdot", '⨪', :mathbin, "minus sign with dot below"), + :minusfdots => UCMCommand("\\minusfdots", '⨫', :mathbin, "minus sign with falling dots"), + :minusrdots => UCMCommand("\\minusrdots", '⨬', :mathbin, "minus sign with rising dots"), + :opluslhrim => UCMCommand("\\opluslhrim", '⨭', :mathbin, "plus sign in left half circle"), + :oplusrhrim => UCMCommand("\\oplusrhrim", '⨮', :mathbin, "plus sign in right half circle"), + :vectimes => UCMCommand("\\vectimes", '⨯', :mathbin, "vector or cross product"), + :dottimes => UCMCommand("\\dottimes", '⨰', :mathbin, "multiplication sign with dot above"), + :timesbar => UCMCommand("\\timesbar", '⨱', :mathbin, "multiplication sign with underbar"), + :btimes => UCMCommand("\\btimes", '⨲', :mathbin, "semidirect product with bottom closed"), + :smashtimes => UCMCommand("\\smashtimes", '⨳', :mathbin, "smash product"), + :otimeslhrim => UCMCommand("\\otimeslhrim", '⨴', :mathbin, "multiplication sign in left half circle"), + :otimesrhrim => UCMCommand("\\otimesrhrim", '⨵', :mathbin, "multiplication sign in right half circle"), + :otimeshat => UCMCommand("\\otimeshat", '⨶', :mathbin, "circled multiplication sign with circumflex accent"), + :Otimes => UCMCommand("\\Otimes", '⨷', :mathbin, "multiplication sign in double circle"), + :odiv => UCMCommand("\\odiv", '⨸', :mathbin, "circled division sign"), + :triangleplus => UCMCommand("\\triangleplus", '⨹', :mathbin, "plus sign in triangle"), + :triangleminus => UCMCommand("\\triangleminus", '⨺', :mathbin, "minus sign in triangle"), + :triangletimes => UCMCommand("\\triangletimes", '⨻', :mathbin, "multiplication sign in triangle"), + :intprod => UCMCommand("\\intprod", '⨼', :mathbin, "interior product"), + :intprodr => UCMCommand("\\intprodr", '⨽', :mathbin, "righthand interior product"), + :fcmp => UCMCommand("\\fcmp", '⨾', :mathbin, "z notation relational composition"), + :amalg => UCMCommand("\\amalg", '⨿', :mathbin, "amalgamation or coproduct"), + :capdot => UCMCommand("\\capdot", '⩀', :mathbin, "intersection with dot"), + :uminus => UCMCommand("\\uminus", '⩁', :mathbin, "union with minus sign"), + :barcup => UCMCommand("\\barcup", '⩂', :mathbin, "union with overbar"), + :barcap => UCMCommand("\\barcap", '⩃', :mathbin, "intersection with overbar"), + :capwedge => UCMCommand("\\capwedge", '⩄', :mathbin, "intersection with logical and"), + :cupvee => UCMCommand("\\cupvee", '⩅', :mathbin, "union with logical or"), + :cupovercap => UCMCommand("\\cupovercap", '⩆', :mathbin, "union above intersection"), + :capovercup => UCMCommand("\\capovercup", '⩇', :mathbin, "intersection above union"), + :cupbarcap => UCMCommand("\\cupbarcap", '⩈', :mathbin, "union above bar above intersection"), + :capbarcup => UCMCommand("\\capbarcup", '⩉', :mathbin, "intersection above bar above union"), + :twocups => UCMCommand("\\twocups", '⩊', :mathbin, "union beside and joined with union"), + :twocaps => UCMCommand("\\twocaps", '⩋', :mathbin, "intersection beside and joined with intersection"), + :closedvarcup => UCMCommand("\\closedvarcup", '⩌', :mathbin, "closed union with serifs"), + :closedvarcap => UCMCommand("\\closedvarcap", '⩍', :mathbin, "closed intersection with serifs"), + :Sqcap => UCMCommand("\\Sqcap", '⩎', :mathbin, "double square intersection"), + :Sqcup => UCMCommand("\\Sqcup", '⩏', :mathbin, "double square union"), + :closedvarcupsmashprod => UCMCommand("\\closedvarcupsmashprod", '⩐', :mathbin, "closed union with serifs and smash product"), + :wedgeodot => UCMCommand("\\wedgeodot", '⩑', :mathbin, "logical and with dot above"), + :veeodot => UCMCommand("\\veeodot", '⩒', :mathbin, "logical or with dot above"), + :Wedge => UCMCommand("\\Wedge", '⩓', :mathbin, "double logical and"), + :Vee => UCMCommand("\\Vee", '⩔', :mathbin, "double logical or"), + :wedgeonwedge => UCMCommand("\\wedgeonwedge", '⩕', :mathbin, "two intersecting logical and"), + :veeonvee => UCMCommand("\\veeonvee", '⩖', :mathbin, "two intersecting logical or"), + :bigslopedvee => UCMCommand("\\bigslopedvee", '⩗', :mathbin, "sloping large or"), + :bigslopedwedge => UCMCommand("\\bigslopedwedge", '⩘', :mathbin, "sloping large and"), + :veeonwedge => UCMCommand("\\veeonwedge", '⩙', :mathrel, "logical or overlapping logical and"), + :wedgemidvert => UCMCommand("\\wedgemidvert", '⩚', :mathbin, "logical and with middle stem"), + :veemidvert => UCMCommand("\\veemidvert", '⩛', :mathbin, "logical or with middle stem"), + :midbarwedge => UCMCommand("\\midbarwedge", '⩜', :mathbin, "ogical and with horizontal dash"), + :midbarvee => UCMCommand("\\midbarvee", '⩝', :mathbin, "logical or with horizontal dash"), + :doublebarwedge => UCMCommand("\\doublebarwedge", '⩞', :mathbin, "logical and with double overbar"), + :wedgebar => UCMCommand("\\wedgebar", '⩟', :mathbin, "logical and with underbar"), + :wedgedoublebar => UCMCommand("\\wedgedoublebar", '⩠', :mathbin, "logical and with double underbar"), + :varveebar => UCMCommand("\\varveebar", '⩡', :mathbin, "small vee with underbar"), + :doublebarvee => UCMCommand("\\doublebarvee", '⩢', :mathbin, "logical or with double overbar"), + :veedoublebar => UCMCommand("\\veedoublebar", '⩣', :mathbin, "logical or with double underbar"), + :dsub => UCMCommand("\\dsub", '⩤', :mathbin, "z notation domain antirestriction"), + :rsub => UCMCommand("\\rsub", '⩥', :mathbin, "z notation range antirestriction"), + :eqdot => UCMCommand("\\eqdot", '⩦', :mathrel, "equals sign with dot below"), + :dotequiv => UCMCommand("\\dotequiv", '⩧', :mathrel, "identical with dot above"), + :equivVert => UCMCommand("\\equivVert", '⩨', :mathrel, "triple horizontal bar with double vertical stroke"), + :equivVvert => UCMCommand("\\equivVvert", '⩩', :mathrel, "triple horizontal bar with triple vertical stroke"), + :dotsim => UCMCommand("\\dotsim", '⩪', :mathrel, "tilde operator with dot above"), + :simrdots => UCMCommand("\\simrdots", '⩫', :mathrel, "tilde operator with rising dots"), + :simminussim => UCMCommand("\\simminussim", '⩬', :mathrel, "similar minus similar"), + :congdot => UCMCommand("\\congdot", '⩭', :mathrel, "congruent with dot above"), + :asteq => UCMCommand("\\asteq", '⩮', :mathrel, "equals with asterisk"), + :hatapprox => UCMCommand("\\hatapprox", '⩯', :mathrel, "almost equal to with circumflex accent"), + :approxeqq => UCMCommand("\\approxeqq", '⩰', :mathrel, "approximately equal or equal to"), + :eqqplus => UCMCommand("\\eqqplus", '⩱', :mathbin, "equals sign above plus sign"), + :pluseqq => UCMCommand("\\pluseqq", '⩲', :mathbin, "plus sign above equals sign"), + :eqqsim => UCMCommand("\\eqqsim", '⩳', :mathrel, "equals sign above tilde operator"), + :Coloneq => UCMCommand("\\Coloneq", '⩴', :mathrel, "double colon equal"), + :eqeq => UCMCommand("\\eqeq", '⩵', :mathrel, "two consecutive equals signs"), + :eqeqeq => UCMCommand("\\eqeqeq", '⩶', :mathrel, "three consecutive equals signs"), + :ddotseq => UCMCommand("\\ddotseq", '⩷', :mathrel, "equals sign with two dots above and two dots below"), + :equivDD => UCMCommand("\\equivDD", '⩸', :mathrel, "equivalent with four dots above"), + :ltcir => UCMCommand("\\ltcir", '⩹', :mathrel, "less-than with circle inside"), + :gtcir => UCMCommand("\\gtcir", '⩺', :mathrel, "greater-than with circle inside"), + :ltquest => UCMCommand("\\ltquest", '⩻', :mathrel, "less-than with question mark above"), + :gtquest => UCMCommand("\\gtquest", '⩼', :mathrel, "greater-than with question mark above"), + :leqslant => UCMCommand("\\leqslant", '⩽', :mathrel, "less-than or slanted equal to"), + :geqslant => UCMCommand("\\geqslant", '⩾', :mathrel, "greater-than or slanted equal to"), + :lesdot => UCMCommand("\\lesdot", '⩿', :mathrel, "less-than or slanted equal to with dot inside"), + :gesdot => UCMCommand("\\gesdot", '⪀', :mathrel, "greater-than or slanted equal to with dot inside"), + :lesdoto => UCMCommand("\\lesdoto", '⪁', :mathrel, "less-than or slanted equal to with dot above"), + :gesdoto => UCMCommand("\\gesdoto", '⪂', :mathrel, "greater-than or slanted equal to with dot above"), + :lesdotor => UCMCommand("\\lesdotor", '⪃', :mathrel, "less-than or slanted equal to with dot above right"), + :gesdotol => UCMCommand("\\gesdotol", '⪄', :mathrel, "greater-than or slanted equal to with dot above left"), + :lessapprox => UCMCommand("\\lessapprox", '⪅', :mathrel, "less-than or approximate"), + :gtrapprox => UCMCommand("\\gtrapprox", '⪆', :mathrel, "greater-than or approximate"), + :lneq => UCMCommand("\\lneq", '⪇', :mathrel, "less-than and single-line not equal to"), + :gneq => UCMCommand("\\gneq", '⪈', :mathrel, "greater-than and single-line not equal to"), + :lnapprox => UCMCommand("\\lnapprox", '⪉', :mathrel, "less-than and not approximate"), + :gnapprox => UCMCommand("\\gnapprox", '⪊', :mathrel, "greater-than and not approximate"), + :lesseqqgtr => UCMCommand("\\lesseqqgtr", '⪋', :mathrel, "less-than above double-line equal above greater-than"), + :gtreqqless => UCMCommand("\\gtreqqless", '⪌', :mathrel, "greater-than above double-line equal above less-than"), + :lsime => UCMCommand("\\lsime", '⪍', :mathrel, "less-than above similar or equal"), + :gsime => UCMCommand("\\gsime", '⪎', :mathrel, "greater-than above similar or equal"), + :lsimg => UCMCommand("\\lsimg", '⪏', :mathrel, "less-than above similar above greater-than"), + :gsiml => UCMCommand("\\gsiml", '⪐', :mathrel, "greater-than above similar above less-than"), + :lgE => UCMCommand("\\lgE", '⪑', :mathrel, "less-than above greater-than above double-line equal"), + :glE => UCMCommand("\\glE", '⪒', :mathrel, "greater-than above less-than above double-line equal"), + :lesges => UCMCommand("\\lesges", '⪓', :mathrel, "less-than above slanted equal above greater-than above slanted equal"), + :gesles => UCMCommand("\\gesles", '⪔', :mathrel, "greater-than above slanted equal above less-than above slanted equal"), + :eqslantless => UCMCommand("\\eqslantless", '⪕', :mathrel, "slanted equal to or less-than"), + :eqslantgtr => UCMCommand("\\eqslantgtr", '⪖', :mathrel, "slanted equal to or greater-than"), + :elsdot => UCMCommand("\\elsdot", '⪗', :mathrel, "slanted equal to or less-than with dot inside"), + :egsdot => UCMCommand("\\egsdot", '⪘', :mathrel, "slanted equal to or greater-than with dot inside"), + :eqqless => UCMCommand("\\eqqless", '⪙', :mathrel, "double-line equal to or less-than"), + :eqqgtr => UCMCommand("\\eqqgtr", '⪚', :mathrel, "double-line equal to or greater-than"), + :eqqslantless => UCMCommand("\\eqqslantless", '⪛', :mathrel, "double-line slanted equal to or less-than"), + :eqqslantgtr => UCMCommand("\\eqqslantgtr", '⪜', :mathrel, "double-line slanted equal to or greater-than"), + :simless => UCMCommand("\\simless", '⪝', :mathrel, "similar or less-than"), + :simgtr => UCMCommand("\\simgtr", '⪞', :mathrel, "similar or greater-than"), + :simlE => UCMCommand("\\simlE", '⪟', :mathrel, "similar above less-than above equals sign"), + :simgE => UCMCommand("\\simgE", '⪠', :mathrel, "similar above greater-than above equals sign"), + :Lt => UCMCommand("\\Lt", '⪡', :mathrel, "double nested less-than"), + :Gt => UCMCommand("\\Gt", '⪢', :mathrel, "double nested greater-than"), + :partialmeetcontraction => UCMCommand("\\partialmeetcontraction", '⪣', :mathrel, "double less-than with underbar"), + :glj => UCMCommand("\\glj", '⪤', :mathrel, "greater-than overlapping less-than"), + :gla => UCMCommand("\\gla", '⪥', :mathrel, "greater-than beside less-than"), + :ltcc => UCMCommand("\\ltcc", '⪦', :mathrel, "less-than closed by curve"), + :gtcc => UCMCommand("\\gtcc", '⪧', :mathrel, "greater-than closed by curve"), + :lescc => UCMCommand("\\lescc", '⪨', :mathrel, "less-than closed by curve above slanted equal"), + :gescc => UCMCommand("\\gescc", '⪩', :mathrel, "greater-than closed by curve above slanted equal"), + :smt => UCMCommand("\\smt", '⪪', :mathrel, "smaller than"), + :lat => UCMCommand("\\lat", '⪫', :mathrel, "larger than"), + :smte => UCMCommand("\\smte", '⪬', :mathrel, "smaller than or equal to"), + :late => UCMCommand("\\late", '⪭', :mathrel, "larger than or equal to"), + :bumpeqq => UCMCommand("\\bumpeqq", '⪮', :mathrel, "equals sign with bumpy above"), + :preceq => UCMCommand("\\preceq", '⪯', :mathrel, "precedes above single-line equals sign"), + :succeq => UCMCommand("\\succeq", '⪰', :mathrel, "succeeds above single-line equals sign"), + :precneq => UCMCommand("\\precneq", '⪱', :mathrel, "precedes above single-line not equal to"), + :succneq => UCMCommand("\\succneq", '⪲', :mathrel, "succeeds above single-line not equal to"), + :preceqq => UCMCommand("\\preceqq", '⪳', :mathrel, "precedes above equals sign"), + :succeqq => UCMCommand("\\succeqq", '⪴', :mathrel, "succeeds above equals sign"), + :precneqq => UCMCommand("\\precneqq", '⪵', :mathrel, "precedes above not equal to"), + :succneqq => UCMCommand("\\succneqq", '⪶', :mathrel, "succeeds above not equal to"), + :precapprox => UCMCommand("\\precapprox", '⪷', :mathrel, "precedes above almost equal to"), + :succapprox => UCMCommand("\\succapprox", '⪸', :mathrel, "succeeds above almost equal to"), + :precnapprox => UCMCommand("\\precnapprox", '⪹', :mathrel, "precedes above not almost equal to"), + :succnapprox => UCMCommand("\\succnapprox", '⪺', :mathrel, "succeeds above not almost equal to"), + :Prec => UCMCommand("\\Prec", '⪻', :mathrel, "double precedes"), + :Succ => UCMCommand("\\Succ", '⪼', :mathrel, "double succeeds"), + :subsetdot => UCMCommand("\\subsetdot", '⪽', :mathrel, "subset with dot"), + :supsetdot => UCMCommand("\\supsetdot", '⪾', :mathrel, "superset with dot"), + :subsetplus => UCMCommand("\\subsetplus", '⪿', :mathrel, "subset with plus sign below"), + :supsetplus => UCMCommand("\\supsetplus", '⫀', :mathrel, "superset with plus sign below"), + :submult => UCMCommand("\\submult", '⫁', :mathrel, "subset with multiplication sign below"), + :supmult => UCMCommand("\\supmult", '⫂', :mathrel, "superset with multiplication sign below"), + :subedot => UCMCommand("\\subedot", '⫃', :mathrel, "subset of or equal to with dot above"), + :supedot => UCMCommand("\\supedot", '⫄', :mathrel, "superset of or equal to with dot above"), + :subseteqq => UCMCommand("\\subseteqq", '⫅', :mathrel, "subset of above equals sign"), + :supseteqq => UCMCommand("\\supseteqq", '⫆', :mathrel, "superset of above equals sign"), + :subsim => UCMCommand("\\subsim", '⫇', :mathrel, "subset of above tilde operator"), + :supsim => UCMCommand("\\supsim", '⫈', :mathrel, "superset of above tilde operator"), + :subsetapprox => UCMCommand("\\subsetapprox", '⫉', :mathrel, "subset of above almost equal to"), + :supsetapprox => UCMCommand("\\supsetapprox", '⫊', :mathrel, "superset of above almost equal to"), + :subsetneqq => UCMCommand("\\subsetneqq", '⫋', :mathrel, "subset of above not equal to"), + :supsetneqq => UCMCommand("\\supsetneqq", '⫌', :mathrel, "superset of above not equal to"), + :lsqhook => UCMCommand("\\lsqhook", '⫍', :mathrel, "square left open box operator"), + :rsqhook => UCMCommand("\\rsqhook", '⫎', :mathrel, "square right open box operator"), + :csub => UCMCommand("\\csub", '⫏', :mathrel, "closed subset"), + :csup => UCMCommand("\\csup", '⫐', :mathrel, "closed superset"), + :csube => UCMCommand("\\csube", '⫑', :mathrel, "closed subset or equal to"), + :csupe => UCMCommand("\\csupe", '⫒', :mathrel, "closed superset or equal to"), + :subsup => UCMCommand("\\subsup", '⫓', :mathrel, "subset above superset"), + :supsub => UCMCommand("\\supsub", '⫔', :mathrel, "superset above subset"), + :subsub => UCMCommand("\\subsub", '⫕', :mathrel, "subset above subset"), + :supsup => UCMCommand("\\supsup", '⫖', :mathrel, "superset above superset"), + :suphsub => UCMCommand("\\suphsub", '⫗', :mathrel, "superset beside subset"), + :supdsub => UCMCommand("\\supdsub", '⫘', :mathrel, "superset beside and joined by dash with subset"), + :forkv => UCMCommand("\\forkv", '⫙', :mathrel, "element of opening downwards"), + :topfork => UCMCommand("\\topfork", '⫚', :mathrel, "pitchfork with tee top"), + :mlcp => UCMCommand("\\mlcp", '⫛', :mathrel, "transversal intersection"), + :forks => UCMCommand("\\forks", '⫝̸', :mathrel, "forking"), + :forksnot => UCMCommand("\\forksnot", '⫝', :mathrel, "nonforking"), + :shortlefttack => UCMCommand("\\shortlefttack", '⫞', :mathrel, "short left tack"), + :shortdowntack => UCMCommand("\\shortdowntack", '⫟', :mathrel, "short down tack"), + :shortuptack => UCMCommand("\\shortuptack", '⫠', :mathrel, "short up tack"), + :perps => UCMCommand("\\perps", '⫡', :mathord, "perpendicular with s"), + :vDdash => UCMCommand("\\vDdash", '⫢', :mathrel, "vertical bar triple right turnstile"), + :dashV => UCMCommand("\\dashV", '⫣', :mathrel, "double vertical bar left turnstile"), + :Dashv => UCMCommand("\\Dashv", '⫤', :mathrel, "vertical bar double left turnstile"), + :DashV => UCMCommand("\\DashV", '⫥', :mathrel, "double vertical bar double left turnstile"), + :varVdash => UCMCommand("\\varVdash", '⫦', :mathrel, "long dash from left member of double vertical"), + :Barv => UCMCommand("\\Barv", '⫧', :mathrel, "short down tack with overbar"), + :vBar => UCMCommand("\\vBar", '⫨', :mathrel, "short up tack with underbar"), + :vBarv => UCMCommand("\\vBarv", '⫩', :mathrel, "short up tack above short down tack"), + :barV => UCMCommand("\\barV", '⫪', :mathrel, "double down tack"), + :Vbar => UCMCommand("\\Vbar", '⫫', :mathrel, "double up tack"), + :Not => UCMCommand("\\Not", '⫬', :mathrel, "double stroke not sign"), + :bNot => UCMCommand("\\bNot", '⫭', :mathrel, "reversed double stroke not sign"), + :revnmid => UCMCommand("\\revnmid", '⫮', :mathrel, "does not divide with reversed negation slash"), + :cirmid => UCMCommand("\\cirmid", '⫯', :mathrel, "vertical line with circle above"), + :midcir => UCMCommand("\\midcir", '⫰', :mathrel, "vertical line with circle below"), + :topcir => UCMCommand("\\topcir", '⫱', :mathord, "down tack with circle below"), + :nhpar => UCMCommand("\\nhpar", '⫲', :mathrel, "parallel with horizontal stroke"), + :parsim => UCMCommand("\\parsim", '⫳', :mathrel, "parallel with tilde operator"), + :interleave => UCMCommand("\\interleave", '⫴', :mathbin, "triple vertical bar binary relation"), + :nhVvert => UCMCommand("\\nhVvert", '⫵', :mathbin, "triple vertical bar with horizontal stroke"), + :threedotcolon => UCMCommand("\\threedotcolon", '⫶', :mathbin, "triple colon operator"), + :lllnest => UCMCommand("\\lllnest", '⫷', :mathrel, "stacked very much less-than"), + :gggnest => UCMCommand("\\gggnest", '⫸', :mathrel, "stacked very much greater-than"), + :leqqslant => UCMCommand("\\leqqslant", '⫹', :mathrel, "double-line slanted less-than or equal to"), + :geqqslant => UCMCommand("\\geqqslant", '⫺', :mathrel, "double-line slanted greater-than or equal to"), + :trslash => UCMCommand("\\trslash", '⫻', :mathbin, "triple solidus binary relation"), + :biginterleave => UCMCommand("\\biginterleave", '⫼', :mathop, "large triple vertical bar operator"), + :sslash => UCMCommand("\\sslash", '⫽', :mathbin, "double solidus operator"), + :talloblong => UCMCommand("\\talloblong", '⫾', :mathbin, "white vertical bar"), + :bigtalloblong => UCMCommand("\\bigtalloblong", '⫿', :mathop, "n-ary white vertical bar"), + :squaretopblack => UCMCommand("\\squaretopblack", '⬒', :mathord, "square with top half black"), + :squarebotblack => UCMCommand("\\squarebotblack", '⬓', :mathord, "square with bottom half black"), + :squareurblack => UCMCommand("\\squareurblack", '⬔', :mathord, "square with upper right diagonal half black"), + :squarellblack => UCMCommand("\\squarellblack", '⬕', :mathord, "square with lower left diagonal half black"), + :diamondleftblack => UCMCommand("\\diamondleftblack", '⬖', :mathord, "diamond with left half black"), + :diamondrightblack => UCMCommand("\\diamondrightblack", '⬗', :mathord, "diamond with right half black"), + :diamondtopblack => UCMCommand("\\diamondtopblack", '⬘', :mathord, "diamond with top half black"), + :diamondbotblack => UCMCommand("\\diamondbotblack", '⬙', :mathord, "diamond with bottom half black"), + :dottedsquare => UCMCommand("\\dottedsquare", '⬚', :mathord, "dotted square"), + :lgblksquare => UCMCommand("\\lgblksquare", '⬛', :mathord, "black large square"), + :lgwhtsquare => UCMCommand("\\lgwhtsquare", '⬜', :mathord, "white large square"), + :vysmblksquare => UCMCommand("\\vysmblksquare", '⬝', :mathord, "black very small square"), + :vysmwhtsquare => UCMCommand("\\vysmwhtsquare", '⬞', :mathord, "white very small square"), + :pentagonblack => UCMCommand("\\pentagonblack", '⬟', :mathord, "black pentagon"), + :pentagon => UCMCommand("\\pentagon", '⬠', :mathord, "white pentagon"), + :varhexagon => UCMCommand("\\varhexagon", '⬡', :mathord, "white hexagon"), + :varhexagonblack => UCMCommand("\\varhexagonblack", '⬢', :mathord, "black hexagon"), + :hexagonblack => UCMCommand("\\hexagonblack", '⬣', :mathord, "horizontal black hexagon"), + :lgblkcircle => UCMCommand("\\lgblkcircle", '⬤', :mathord, "black large circle"), + :mdblkdiamond => UCMCommand("\\mdblkdiamond", '⬥', :mathord, "black medium diamond"), + :mdwhtdiamond => UCMCommand("\\mdwhtdiamond", '⬦', :mathord, "white medium diamond"), + :mdblklozenge => UCMCommand("\\mdblklozenge", '⬧', :mathord, "black medium lozenge"), + :mdwhtlozenge => UCMCommand("\\mdwhtlozenge", '⬨', :mathord, "white medium lozenge"), + :smblkdiamond => UCMCommand("\\smblkdiamond", '⬩', :mathord, "black small diamond"), + :smblklozenge => UCMCommand("\\smblklozenge", '⬪', :mathord, "black small lozenge"), + :smwhtlozenge => UCMCommand("\\smwhtlozenge", '⬫', :mathord, "white small lozenge"), + :blkhorzoval => UCMCommand("\\blkhorzoval", '⬬', :mathord, "black horizontal ellipse"), + :whthorzoval => UCMCommand("\\whthorzoval", '⬭', :mathord, "white horizontal ellipse"), + :blkvertoval => UCMCommand("\\blkvertoval", '⬮', :mathord, "black vertical ellipse"), + :whtvertoval => UCMCommand("\\whtvertoval", '⬯', :mathord, "white vertical ellipse"), + :circleonleftarrow => UCMCommand("\\circleonleftarrow", '⬰', :mathrel, "left arrow with small circle"), + :leftthreearrows => UCMCommand("\\leftthreearrows", '⬱', :mathrel, "three leftwards arrows"), + :leftarrowonoplus => UCMCommand("\\leftarrowonoplus", '⬲', :mathrel, "left arrow with circled plus"), + :longleftsquigarrow => UCMCommand("\\longleftsquigarrow", '⬳', :mathrel, "long leftwards squiggle arrow"), + :nvtwoheadleftarrow => UCMCommand("\\nvtwoheadleftarrow", '⬴', :mathrel, "leftwards two-headed arrow with vertical stroke"), + :nVtwoheadleftarrow => UCMCommand("\\nVtwoheadleftarrow", '⬵', :mathrel, "leftwards two-headed arrow with double vertical stroke"), + :twoheadmapsfrom => UCMCommand("\\twoheadmapsfrom", '⬶', :mathrel, "leftwards two-headed arrow from bar"), + :twoheadleftdbkarrow => UCMCommand("\\twoheadleftdbkarrow", '⬷', :mathrel, "leftwards two-headed triple-dash arrow"), + :leftdotarrow => UCMCommand("\\leftdotarrow", '⬸', :mathrel, "leftwards arrow with dotted stem"), + :nvleftarrowtail => UCMCommand("\\nvleftarrowtail", '⬹', :mathrel, "leftwards arrow with tail with vertical stroke"), + :nVleftarrowtail => UCMCommand("\\nVleftarrowtail", '⬺', :mathrel, "leftwards arrow with tail with double vertical stroke"), + :twoheadleftarrowtail => UCMCommand("\\twoheadleftarrowtail", '⬻', :mathrel, "leftwards two-headed arrow with tail"), + :nvtwoheadleftarrowtail => UCMCommand("\\nvtwoheadleftarrowtail", '⬼', :mathrel, "leftwards two-headed arrow with tail with vertical stroke"), + :nVtwoheadleftarrowtail => UCMCommand("\\nVtwoheadleftarrowtail", '⬽', :mathrel, "leftwards two-headed arrow with tail with double vertical stroke"), + :leftarrowx => UCMCommand("\\leftarrowx", '⬾', :mathrel, "leftwards arrow through x"), + :leftcurvedarrow => UCMCommand("\\leftcurvedarrow", '⬿', :mathrel, "wave arrow pointing directly left"), + :equalleftarrow => UCMCommand("\\equalleftarrow", '⭀', :mathrel, "equals sign above leftwards arrow"), + :bsimilarleftarrow => UCMCommand("\\bsimilarleftarrow", '⭁', :mathrel, "reverse tilde operator above leftwards arrow"), + :leftarrowbackapprox => UCMCommand("\\leftarrowbackapprox", '⭂', :mathrel, "leftwards arrow above reverse almost equal to"), + :rightarrowgtr => UCMCommand("\\rightarrowgtr", '⭃', :mathrel, "rightwards arrow through greater-than"), + :rightarrowsupset => UCMCommand("\\rightarrowsupset", '⭄', :mathrel, "rightwards arrow through subset"), + :LLeftarrow => UCMCommand("\\LLeftarrow", '⭅', :mathrel, "leftwards quadruple arrow"), + :RRightarrow => UCMCommand("\\RRightarrow", '⭆', :mathrel, "rightwards quadruple arrow"), + :bsimilarrightarrow => UCMCommand("\\bsimilarrightarrow", '⭇', :mathrel, "reverse tilde operator above rightwards arrow"), + :rightarrowbackapprox => UCMCommand("\\rightarrowbackapprox", '⭈', :mathrel, "rightwards arrow above reverse almost equal to"), + :similarleftarrow => UCMCommand("\\similarleftarrow", '⭉', :mathrel, "tilde operator above leftwards arrow"), + :leftarrowapprox => UCMCommand("\\leftarrowapprox", '⭊', :mathrel, "leftwards arrow above almost equal to"), + :leftarrowbsimilar => UCMCommand("\\leftarrowbsimilar", '⭋', :mathrel, "leftwards arrow above reverse tilde operator"), + :rightarrowbsimilar => UCMCommand("\\rightarrowbsimilar", '⭌', :mathrel, "righttwards arrow above reverse tilde operator"), + :medwhitestar => UCMCommand("\\medwhitestar", '⭐', :mathord, "white medium star"), + :medblackstar => UCMCommand("\\medblackstar", '⭑', :mathord, "black medium star"), + :smwhitestar => UCMCommand("\\smwhitestar", '⭒', :mathord, "white small star"), + :rightpentagonblack => UCMCommand("\\rightpentagonblack", '⭓', :mathord, "black right-pointing pentagon"), + :rightpentagon => UCMCommand("\\rightpentagon", '⭔', :mathord, "white right-pointing pentagon"), + :postalmark => UCMCommand("\\postalmark", '〒', :mathord, "postal mark"), + :hzigzag => UCMCommand("\\hzigzag", '〰', :mathord, "zigzag"), + :mbfA => UCMCommand("\\mbfA", '𝐀', :mathalpha, "mathematical bold capital a"), + :mbfB => UCMCommand("\\mbfB", '𝐁', :mathalpha, "mathematical bold capital b"), + :mbfC => UCMCommand("\\mbfC", '𝐂', :mathalpha, "mathematical bold capital c"), + :mbfD => UCMCommand("\\mbfD", '𝐃', :mathalpha, "mathematical bold capital d"), + :mbfE => UCMCommand("\\mbfE", '𝐄', :mathalpha, "mathematical bold capital e"), + :mbfF => UCMCommand("\\mbfF", '𝐅', :mathalpha, "mathematical bold capital f"), + :mbfG => UCMCommand("\\mbfG", '𝐆', :mathalpha, "mathematical bold capital g"), + :mbfH => UCMCommand("\\mbfH", '𝐇', :mathalpha, "mathematical bold capital h"), + :mbfI => UCMCommand("\\mbfI", '𝐈', :mathalpha, "mathematical bold capital i"), + :mbfJ => UCMCommand("\\mbfJ", '𝐉', :mathalpha, "mathematical bold capital j"), + :mbfK => UCMCommand("\\mbfK", '𝐊', :mathalpha, "mathematical bold capital k"), + :mbfL => UCMCommand("\\mbfL", '𝐋', :mathalpha, "mathematical bold capital l"), + :mbfM => UCMCommand("\\mbfM", '𝐌', :mathalpha, "mathematical bold capital m"), + :mbfN => UCMCommand("\\mbfN", '𝐍', :mathalpha, "mathematical bold capital n"), + :mbfO => UCMCommand("\\mbfO", '𝐎', :mathalpha, "mathematical bold capital o"), + :mbfP => UCMCommand("\\mbfP", '𝐏', :mathalpha, "mathematical bold capital p"), + :mbfQ => UCMCommand("\\mbfQ", '𝐐', :mathalpha, "mathematical bold capital q"), + :mbfR => UCMCommand("\\mbfR", '𝐑', :mathalpha, "mathematical bold capital r"), + :mbfS => UCMCommand("\\mbfS", '𝐒', :mathalpha, "mathematical bold capital s"), + :mbfT => UCMCommand("\\mbfT", '𝐓', :mathalpha, "mathematical bold capital t"), + :mbfU => UCMCommand("\\mbfU", '𝐔', :mathalpha, "mathematical bold capital u"), + :mbfV => UCMCommand("\\mbfV", '𝐕', :mathalpha, "mathematical bold capital v"), + :mbfW => UCMCommand("\\mbfW", '𝐖', :mathalpha, "mathematical bold capital w"), + :mbfX => UCMCommand("\\mbfX", '𝐗', :mathalpha, "mathematical bold capital x"), + :mbfY => UCMCommand("\\mbfY", '𝐘', :mathalpha, "mathematical bold capital y"), + :mbfZ => UCMCommand("\\mbfZ", '𝐙', :mathalpha, "mathematical bold capital z"), + :mbfa => UCMCommand("\\mbfa", '𝐚', :mathalpha, "mathematical bold small a"), + :mbfb => UCMCommand("\\mbfb", '𝐛', :mathalpha, "mathematical bold small b"), + :mbfc => UCMCommand("\\mbfc", '𝐜', :mathalpha, "mathematical bold small c"), + :mbfd => UCMCommand("\\mbfd", '𝐝', :mathalpha, "mathematical bold small d"), + :mbfe => UCMCommand("\\mbfe", '𝐞', :mathalpha, "mathematical bold small e"), + :mbff => UCMCommand("\\mbff", '𝐟', :mathalpha, "mathematical bold small f"), + :mbfg => UCMCommand("\\mbfg", '𝐠', :mathalpha, "mathematical bold small g"), + :mbfh => UCMCommand("\\mbfh", '𝐡', :mathalpha, "mathematical bold small h"), + :mbfi => UCMCommand("\\mbfi", '𝐢', :mathalpha, "mathematical bold small i"), + :mbfj => UCMCommand("\\mbfj", '𝐣', :mathalpha, "mathematical bold small j"), + :mbfk => UCMCommand("\\mbfk", '𝐤', :mathalpha, "mathematical bold small k"), + :mbfl => UCMCommand("\\mbfl", '𝐥', :mathalpha, "mathematical bold small l"), + :mbfm => UCMCommand("\\mbfm", '𝐦', :mathalpha, "mathematical bold small m"), + :mbfn => UCMCommand("\\mbfn", '𝐧', :mathalpha, "mathematical bold small n"), + :mbfo => UCMCommand("\\mbfo", '𝐨', :mathalpha, "mathematical bold small o"), + :mbfp => UCMCommand("\\mbfp", '𝐩', :mathalpha, "mathematical bold small p"), + :mbfq => UCMCommand("\\mbfq", '𝐪', :mathalpha, "mathematical bold small q"), + :mbfr => UCMCommand("\\mbfr", '𝐫', :mathalpha, "mathematical bold small r"), + :mbfs => UCMCommand("\\mbfs", '𝐬', :mathalpha, "mathematical bold small s"), + :mbft => UCMCommand("\\mbft", '𝐭', :mathalpha, "mathematical bold small t"), + :mbfu => UCMCommand("\\mbfu", '𝐮', :mathalpha, "mathematical bold small u"), + :mbfv => UCMCommand("\\mbfv", '𝐯', :mathalpha, "mathematical bold small v"), + :mbfw => UCMCommand("\\mbfw", '𝐰', :mathalpha, "mathematical bold small w"), + :mbfx => UCMCommand("\\mbfx", '𝐱', :mathalpha, "mathematical bold small x"), + :mbfy => UCMCommand("\\mbfy", '𝐲', :mathalpha, "mathematical bold small y"), + :mbfz => UCMCommand("\\mbfz", '𝐳', :mathalpha, "mathematical bold small z"), + :mitA => UCMCommand("\\mitA", '𝐴', :mathalpha, "mathematical italic capital a"), + :mitB => UCMCommand("\\mitB", '𝐵', :mathalpha, "mathematical italic capital b"), + :mitC => UCMCommand("\\mitC", '𝐶', :mathalpha, "mathematical italic capital c"), + :mitD => UCMCommand("\\mitD", '𝐷', :mathalpha, "mathematical italic capital d"), + :mitE => UCMCommand("\\mitE", '𝐸', :mathalpha, "mathematical italic capital e"), + :mitF => UCMCommand("\\mitF", '𝐹', :mathalpha, "mathematical italic capital f"), + :mitG => UCMCommand("\\mitG", '𝐺', :mathalpha, "mathematical italic capital g"), + :mitH => UCMCommand("\\mitH", '𝐻', :mathalpha, "mathematical italic capital h"), + :mitI => UCMCommand("\\mitI", '𝐼', :mathalpha, "mathematical italic capital i"), + :mitJ => UCMCommand("\\mitJ", '𝐽', :mathalpha, "mathematical italic capital j"), + :mitK => UCMCommand("\\mitK", '𝐾', :mathalpha, "mathematical italic capital k"), + :mitL => UCMCommand("\\mitL", '𝐿', :mathalpha, "mathematical italic capital l"), + :mitM => UCMCommand("\\mitM", '𝑀', :mathalpha, "mathematical italic capital m"), + :mitN => UCMCommand("\\mitN", '𝑁', :mathalpha, "mathematical italic capital n"), + :mitO => UCMCommand("\\mitO", '𝑂', :mathalpha, "mathematical italic capital o"), + :mitP => UCMCommand("\\mitP", '𝑃', :mathalpha, "mathematical italic capital p"), + :mitQ => UCMCommand("\\mitQ", '𝑄', :mathalpha, "mathematical italic capital q"), + :mitR => UCMCommand("\\mitR", '𝑅', :mathalpha, "mathematical italic capital r"), + :mitS => UCMCommand("\\mitS", '𝑆', :mathalpha, "mathematical italic capital s"), + :mitT => UCMCommand("\\mitT", '𝑇', :mathalpha, "mathematical italic capital t"), + :mitU => UCMCommand("\\mitU", '𝑈', :mathalpha, "mathematical italic capital u"), + :mitV => UCMCommand("\\mitV", '𝑉', :mathalpha, "mathematical italic capital v"), + :mitW => UCMCommand("\\mitW", '𝑊', :mathalpha, "mathematical italic capital w"), + :mitX => UCMCommand("\\mitX", '𝑋', :mathalpha, "mathematical italic capital x"), + :mitY => UCMCommand("\\mitY", '𝑌', :mathalpha, "mathematical italic capital y"), + :mitZ => UCMCommand("\\mitZ", '𝑍', :mathalpha, "mathematical italic capital z"), + :mita => UCMCommand("\\mita", '𝑎', :mathalpha, "mathematical italic small a"), + :mitb => UCMCommand("\\mitb", '𝑏', :mathalpha, "mathematical italic small b"), + :mitc => UCMCommand("\\mitc", '𝑐', :mathalpha, "mathematical italic small c"), + :mitd => UCMCommand("\\mitd", '𝑑', :mathalpha, "mathematical italic small d"), + :mite => UCMCommand("\\mite", '𝑒', :mathalpha, "mathematical italic small e"), + :mitf => UCMCommand("\\mitf", '𝑓', :mathalpha, "mathematical italic small f"), + :mitg => UCMCommand("\\mitg", '𝑔', :mathalpha, "mathematical italic small g"), + :miti => UCMCommand("\\miti", '𝑖', :mathalpha, "mathematical italic small i"), + :mitj => UCMCommand("\\mitj", '𝑗', :mathalpha, "mathematical italic small j"), + :mitk => UCMCommand("\\mitk", '𝑘', :mathalpha, "mathematical italic small k"), + :mitl => UCMCommand("\\mitl", '𝑙', :mathalpha, "mathematical italic small l"), + :mitm => UCMCommand("\\mitm", '𝑚', :mathalpha, "mathematical italic small m"), + :mitn => UCMCommand("\\mitn", '𝑛', :mathalpha, "mathematical italic small n"), + :mito => UCMCommand("\\mito", '𝑜', :mathalpha, "mathematical italic small o"), + :mitp => UCMCommand("\\mitp", '𝑝', :mathalpha, "mathematical italic small p"), + :mitq => UCMCommand("\\mitq", '𝑞', :mathalpha, "mathematical italic small q"), + :mitr => UCMCommand("\\mitr", '𝑟', :mathalpha, "mathematical italic small r"), + :mits => UCMCommand("\\mits", '𝑠', :mathalpha, "mathematical italic small s"), + :mitt => UCMCommand("\\mitt", '𝑡', :mathalpha, "mathematical italic small t"), + :mitu => UCMCommand("\\mitu", '𝑢', :mathalpha, "mathematical italic small u"), + :mitv => UCMCommand("\\mitv", '𝑣', :mathalpha, "mathematical italic small v"), + :mitw => UCMCommand("\\mitw", '𝑤', :mathalpha, "mathematical italic small w"), + :mitx => UCMCommand("\\mitx", '𝑥', :mathalpha, "mathematical italic small x"), + :mity => UCMCommand("\\mity", '𝑦', :mathalpha, "mathematical italic small y"), + :mitz => UCMCommand("\\mitz", '𝑧', :mathalpha, "mathematical italic small z"), + :mbfitA => UCMCommand("\\mbfitA", '𝑨', :mathalpha, "mathematical bold italic capital a"), + :mbfitB => UCMCommand("\\mbfitB", '𝑩', :mathalpha, "mathematical bold italic capital b"), + :mbfitC => UCMCommand("\\mbfitC", '𝑪', :mathalpha, "mathematical bold italic capital c"), + :mbfitD => UCMCommand("\\mbfitD", '𝑫', :mathalpha, "mathematical bold italic capital d"), + :mbfitE => UCMCommand("\\mbfitE", '𝑬', :mathalpha, "mathematical bold italic capital e"), + :mbfitF => UCMCommand("\\mbfitF", '𝑭', :mathalpha, "mathematical bold italic capital f"), + :mbfitG => UCMCommand("\\mbfitG", '𝑮', :mathalpha, "mathematical bold italic capital g"), + :mbfitH => UCMCommand("\\mbfitH", '𝑯', :mathalpha, "mathematical bold italic capital h"), + :mbfitI => UCMCommand("\\mbfitI", '𝑰', :mathalpha, "mathematical bold italic capital i"), + :mbfitJ => UCMCommand("\\mbfitJ", '𝑱', :mathalpha, "mathematical bold italic capital j"), + :mbfitK => UCMCommand("\\mbfitK", '𝑲', :mathalpha, "mathematical bold italic capital k"), + :mbfitL => UCMCommand("\\mbfitL", '𝑳', :mathalpha, "mathematical bold italic capital l"), + :mbfitM => UCMCommand("\\mbfitM", '𝑴', :mathalpha, "mathematical bold italic capital m"), + :mbfitN => UCMCommand("\\mbfitN", '𝑵', :mathalpha, "mathematical bold italic capital n"), + :mbfitO => UCMCommand("\\mbfitO", '𝑶', :mathalpha, "mathematical bold italic capital o"), + :mbfitP => UCMCommand("\\mbfitP", '𝑷', :mathalpha, "mathematical bold italic capital p"), + :mbfitQ => UCMCommand("\\mbfitQ", '𝑸', :mathalpha, "mathematical bold italic capital q"), + :mbfitR => UCMCommand("\\mbfitR", '𝑹', :mathalpha, "mathematical bold italic capital r"), + :mbfitS => UCMCommand("\\mbfitS", '𝑺', :mathalpha, "mathematical bold italic capital s"), + :mbfitT => UCMCommand("\\mbfitT", '𝑻', :mathalpha, "mathematical bold italic capital t"), + :mbfitU => UCMCommand("\\mbfitU", '𝑼', :mathalpha, "mathematical bold italic capital u"), + :mbfitV => UCMCommand("\\mbfitV", '𝑽', :mathalpha, "mathematical bold italic capital v"), + :mbfitW => UCMCommand("\\mbfitW", '𝑾', :mathalpha, "mathematical bold italic capital w"), + :mbfitX => UCMCommand("\\mbfitX", '𝑿', :mathalpha, "mathematical bold italic capital x"), + :mbfitY => UCMCommand("\\mbfitY", '𝒀', :mathalpha, "mathematical bold italic capital y"), + :mbfitZ => UCMCommand("\\mbfitZ", '𝒁', :mathalpha, "mathematical bold italic capital z"), + :mbfita => UCMCommand("\\mbfita", '𝒂', :mathalpha, "mathematical bold italic small a"), + :mbfitb => UCMCommand("\\mbfitb", '𝒃', :mathalpha, "mathematical bold italic small b"), + :mbfitc => UCMCommand("\\mbfitc", '𝒄', :mathalpha, "mathematical bold italic small c"), + :mbfitd => UCMCommand("\\mbfitd", '𝒅', :mathalpha, "mathematical bold italic small d"), + :mbfite => UCMCommand("\\mbfite", '𝒆', :mathalpha, "mathematical bold italic small e"), + :mbfitf => UCMCommand("\\mbfitf", '𝒇', :mathalpha, "mathematical bold italic small f"), + :mbfitg => UCMCommand("\\mbfitg", '𝒈', :mathalpha, "mathematical bold italic small g"), + :mbfith => UCMCommand("\\mbfith", '𝒉', :mathalpha, "mathematical bold italic small h"), + :mbfiti => UCMCommand("\\mbfiti", '𝒊', :mathalpha, "mathematical bold italic small i"), + :mbfitj => UCMCommand("\\mbfitj", '𝒋', :mathalpha, "mathematical bold italic small j"), + :mbfitk => UCMCommand("\\mbfitk", '𝒌', :mathalpha, "mathematical bold italic small k"), + :mbfitl => UCMCommand("\\mbfitl", '𝒍', :mathalpha, "mathematical bold italic small l"), + :mbfitm => UCMCommand("\\mbfitm", '𝒎', :mathalpha, "mathematical bold italic small m"), + :mbfitn => UCMCommand("\\mbfitn", '𝒏', :mathalpha, "mathematical bold italic small n"), + :mbfito => UCMCommand("\\mbfito", '𝒐', :mathalpha, "mathematical bold italic small o"), + :mbfitp => UCMCommand("\\mbfitp", '𝒑', :mathalpha, "mathematical bold italic small p"), + :mbfitq => UCMCommand("\\mbfitq", '𝒒', :mathalpha, "mathematical bold italic small q"), + :mbfitr => UCMCommand("\\mbfitr", '𝒓', :mathalpha, "mathematical bold italic small r"), + :mbfits => UCMCommand("\\mbfits", '𝒔', :mathalpha, "mathematical bold italic small s"), + :mbfitt => UCMCommand("\\mbfitt", '𝒕', :mathalpha, "mathematical bold italic small t"), + :mbfitu => UCMCommand("\\mbfitu", '𝒖', :mathalpha, "mathematical bold italic small u"), + :mbfitv => UCMCommand("\\mbfitv", '𝒗', :mathalpha, "mathematical bold italic small v"), + :mbfitw => UCMCommand("\\mbfitw", '𝒘', :mathalpha, "mathematical bold italic small w"), + :mbfitx => UCMCommand("\\mbfitx", '𝒙', :mathalpha, "mathematical bold italic small x"), + :mbfity => UCMCommand("\\mbfity", '𝒚', :mathalpha, "mathematical bold italic small y"), + :mbfitz => UCMCommand("\\mbfitz", '𝒛', :mathalpha, "mathematical bold italic small z"), + :mscrA => UCMCommand("\\mscrA", '𝒜', :mathalpha, "mathematical script capital a"), + :mscrC => UCMCommand("\\mscrC", '𝒞', :mathalpha, "mathematical script capital c"), + :mscrD => UCMCommand("\\mscrD", '𝒟', :mathalpha, "mathematical script capital d"), + :mscrG => UCMCommand("\\mscrG", '𝒢', :mathalpha, "mathematical script capital g"), + :mscrJ => UCMCommand("\\mscrJ", '𝒥', :mathalpha, "mathematical script capital j"), + :mscrK => UCMCommand("\\mscrK", '𝒦', :mathalpha, "mathematical script capital k"), + :mscrN => UCMCommand("\\mscrN", '𝒩', :mathalpha, "mathematical script capital n"), + :mscrO => UCMCommand("\\mscrO", '𝒪', :mathalpha, "mathematical script capital o"), + :mscrP => UCMCommand("\\mscrP", '𝒫', :mathalpha, "mathematical script capital p"), + :mscrQ => UCMCommand("\\mscrQ", '𝒬', :mathalpha, "mathematical script capital q"), + :mscrS => UCMCommand("\\mscrS", '𝒮', :mathalpha, "mathematical script capital s"), + :mscrT => UCMCommand("\\mscrT", '𝒯', :mathalpha, "mathematical script capital t"), + :mscrU => UCMCommand("\\mscrU", '𝒰', :mathalpha, "mathematical script capital u"), + :mscrV => UCMCommand("\\mscrV", '𝒱', :mathalpha, "mathematical script capital v"), + :mscrW => UCMCommand("\\mscrW", '𝒲', :mathalpha, "mathematical script capital w"), + :mscrX => UCMCommand("\\mscrX", '𝒳', :mathalpha, "mathematical script capital x"), + :mscrY => UCMCommand("\\mscrY", '𝒴', :mathalpha, "mathematical script capital y"), + :mscrZ => UCMCommand("\\mscrZ", '𝒵', :mathalpha, "mathematical script capital z"), + :mscra => UCMCommand("\\mscra", '𝒶', :mathalpha, "mathematical script small a"), + :mscrb => UCMCommand("\\mscrb", '𝒷', :mathalpha, "mathematical script small b"), + :mscrc => UCMCommand("\\mscrc", '𝒸', :mathalpha, "mathematical script small c"), + :mscrd => UCMCommand("\\mscrd", '𝒹', :mathalpha, "mathematical script small d"), + :mscrf => UCMCommand("\\mscrf", '𝒻', :mathalpha, "mathematical script small f"), + :mscrh => UCMCommand("\\mscrh", '𝒽', :mathalpha, "mathematical script small h"), + :mscri => UCMCommand("\\mscri", '𝒾', :mathalpha, "mathematical script small i"), + :mscrj => UCMCommand("\\mscrj", '𝒿', :mathalpha, "mathematical script small j"), + :mscrk => UCMCommand("\\mscrk", '𝓀', :mathalpha, "mathematical script small k"), + :mscrl => UCMCommand("\\mscrl", '𝓁', :mathalpha, "mathematical script small l"), + :mscrm => UCMCommand("\\mscrm", '𝓂', :mathalpha, "mathematical script small m"), + :mscrn => UCMCommand("\\mscrn", '𝓃', :mathalpha, "mathematical script small n"), + :mscrp => UCMCommand("\\mscrp", '𝓅', :mathalpha, "mathematical script small p"), + :mscrq => UCMCommand("\\mscrq", '𝓆', :mathalpha, "mathematical script small q"), + :mscrr => UCMCommand("\\mscrr", '𝓇', :mathalpha, "mathematical script small r"), + :mscrs => UCMCommand("\\mscrs", '𝓈', :mathalpha, "mathematical script small s"), + :mscrt => UCMCommand("\\mscrt", '𝓉', :mathalpha, "mathematical script small t"), + :mscru => UCMCommand("\\mscru", '𝓊', :mathalpha, "mathematical script small u"), + :mscrv => UCMCommand("\\mscrv", '𝓋', :mathalpha, "mathematical script small v"), + :mscrw => UCMCommand("\\mscrw", '𝓌', :mathalpha, "mathematical script small w"), + :mscrx => UCMCommand("\\mscrx", '𝓍', :mathalpha, "mathematical script small x"), + :mscry => UCMCommand("\\mscry", '𝓎', :mathalpha, "mathematical script small y"), + :mscrz => UCMCommand("\\mscrz", '𝓏', :mathalpha, "mathematical script small z"), + :mbfscrA => UCMCommand("\\mbfscrA", '𝓐', :mathalpha, "mathematical bold script capital a"), + :mbfscrB => UCMCommand("\\mbfscrB", '𝓑', :mathalpha, "mathematical bold script capital b"), + :mbfscrC => UCMCommand("\\mbfscrC", '𝓒', :mathalpha, "mathematical bold script capital c"), + :mbfscrD => UCMCommand("\\mbfscrD", '𝓓', :mathalpha, "mathematical bold script capital d"), + :mbfscrE => UCMCommand("\\mbfscrE", '𝓔', :mathalpha, "mathematical bold script capital e"), + :mbfscrF => UCMCommand("\\mbfscrF", '𝓕', :mathalpha, "mathematical bold script capital f"), + :mbfscrG => UCMCommand("\\mbfscrG", '𝓖', :mathalpha, "mathematical bold script capital g"), + :mbfscrH => UCMCommand("\\mbfscrH", '𝓗', :mathalpha, "mathematical bold script capital h"), + :mbfscrI => UCMCommand("\\mbfscrI", '𝓘', :mathalpha, "mathematical bold script capital i"), + :mbfscrJ => UCMCommand("\\mbfscrJ", '𝓙', :mathalpha, "mathematical bold script capital j"), + :mbfscrK => UCMCommand("\\mbfscrK", '𝓚', :mathalpha, "mathematical bold script capital k"), + :mbfscrL => UCMCommand("\\mbfscrL", '𝓛', :mathalpha, "mathematical bold script capital l"), + :mbfscrM => UCMCommand("\\mbfscrM", '𝓜', :mathalpha, "mathematical bold script capital m"), + :mbfscrN => UCMCommand("\\mbfscrN", '𝓝', :mathalpha, "mathematical bold script capital n"), + :mbfscrO => UCMCommand("\\mbfscrO", '𝓞', :mathalpha, "mathematical bold script capital o"), + :mbfscrP => UCMCommand("\\mbfscrP", '𝓟', :mathalpha, "mathematical bold script capital p"), + :mbfscrQ => UCMCommand("\\mbfscrQ", '𝓠', :mathalpha, "mathematical bold script capital q"), + :mbfscrR => UCMCommand("\\mbfscrR", '𝓡', :mathalpha, "mathematical bold script capital r"), + :mbfscrS => UCMCommand("\\mbfscrS", '𝓢', :mathalpha, "mathematical bold script capital s"), + :mbfscrT => UCMCommand("\\mbfscrT", '𝓣', :mathalpha, "mathematical bold script capital t"), + :mbfscrU => UCMCommand("\\mbfscrU", '𝓤', :mathalpha, "mathematical bold script capital u"), + :mbfscrV => UCMCommand("\\mbfscrV", '𝓥', :mathalpha, "mathematical bold script capital v"), + :mbfscrW => UCMCommand("\\mbfscrW", '𝓦', :mathalpha, "mathematical bold script capital w"), + :mbfscrX => UCMCommand("\\mbfscrX", '𝓧', :mathalpha, "mathematical bold script capital x"), + :mbfscrY => UCMCommand("\\mbfscrY", '𝓨', :mathalpha, "mathematical bold script capital y"), + :mbfscrZ => UCMCommand("\\mbfscrZ", '𝓩', :mathalpha, "mathematical bold script capital z"), + :mbfscra => UCMCommand("\\mbfscra", '𝓪', :mathalpha, "mathematical bold script small a"), + :mbfscrb => UCMCommand("\\mbfscrb", '𝓫', :mathalpha, "mathematical bold script small b"), + :mbfscrc => UCMCommand("\\mbfscrc", '𝓬', :mathalpha, "mathematical bold script small c"), + :mbfscrd => UCMCommand("\\mbfscrd", '𝓭', :mathalpha, "mathematical bold script small d"), + :mbfscre => UCMCommand("\\mbfscre", '𝓮', :mathalpha, "mathematical bold script small e"), + :mbfscrf => UCMCommand("\\mbfscrf", '𝓯', :mathalpha, "mathematical bold script small f"), + :mbfscrg => UCMCommand("\\mbfscrg", '𝓰', :mathalpha, "mathematical bold script small g"), + :mbfscrh => UCMCommand("\\mbfscrh", '𝓱', :mathalpha, "mathematical bold script small h"), + :mbfscri => UCMCommand("\\mbfscri", '𝓲', :mathalpha, "mathematical bold script small i"), + :mbfscrj => UCMCommand("\\mbfscrj", '𝓳', :mathalpha, "mathematical bold script small j"), + :mbfscrk => UCMCommand("\\mbfscrk", '𝓴', :mathalpha, "mathematical bold script small k"), + :mbfscrl => UCMCommand("\\mbfscrl", '𝓵', :mathalpha, "mathematical bold script small l"), + :mbfscrm => UCMCommand("\\mbfscrm", '𝓶', :mathalpha, "mathematical bold script small m"), + :mbfscrn => UCMCommand("\\mbfscrn", '𝓷', :mathalpha, "mathematical bold script small n"), + :mbfscro => UCMCommand("\\mbfscro", '𝓸', :mathalpha, "mathematical bold script small o"), + :mbfscrp => UCMCommand("\\mbfscrp", '𝓹', :mathalpha, "mathematical bold script small p"), + :mbfscrq => UCMCommand("\\mbfscrq", '𝓺', :mathalpha, "mathematical bold script small q"), + :mbfscrr => UCMCommand("\\mbfscrr", '𝓻', :mathalpha, "mathematical bold script small r"), + :mbfscrs => UCMCommand("\\mbfscrs", '𝓼', :mathalpha, "mathematical bold script small s"), + :mbfscrt => UCMCommand("\\mbfscrt", '𝓽', :mathalpha, "mathematical bold script small t"), + :mbfscru => UCMCommand("\\mbfscru", '𝓾', :mathalpha, "mathematical bold script small u"), + :mbfscrv => UCMCommand("\\mbfscrv", '𝓿', :mathalpha, "mathematical bold script small v"), + :mbfscrw => UCMCommand("\\mbfscrw", '𝔀', :mathalpha, "mathematical bold script small w"), + :mbfscrx => UCMCommand("\\mbfscrx", '𝔁', :mathalpha, "mathematical bold script small x"), + :mbfscry => UCMCommand("\\mbfscry", '𝔂', :mathalpha, "mathematical bold script small y"), + :mbfscrz => UCMCommand("\\mbfscrz", '𝔃', :mathalpha, "mathematical bold script small z"), + :mfrakA => UCMCommand("\\mfrakA", '𝔄', :mathalpha, "mathematical fraktur capital a"), + :mfrakB => UCMCommand("\\mfrakB", '𝔅', :mathalpha, "mathematical fraktur capital b"), + :mfrakD => UCMCommand("\\mfrakD", '𝔇', :mathalpha, "mathematical fraktur capital d"), + :mfrakE => UCMCommand("\\mfrakE", '𝔈', :mathalpha, "mathematical fraktur capital e"), + :mfrakF => UCMCommand("\\mfrakF", '𝔉', :mathalpha, "mathematical fraktur capital f"), + :mfrakG => UCMCommand("\\mfrakG", '𝔊', :mathalpha, "mathematical fraktur capital g"), + :mfrakJ => UCMCommand("\\mfrakJ", '𝔍', :mathalpha, "mathematical fraktur capital j"), + :mfrakK => UCMCommand("\\mfrakK", '𝔎', :mathalpha, "mathematical fraktur capital k"), + :mfrakL => UCMCommand("\\mfrakL", '𝔏', :mathalpha, "mathematical fraktur capital l"), + :mfrakM => UCMCommand("\\mfrakM", '𝔐', :mathalpha, "mathematical fraktur capital m"), + :mfrakN => UCMCommand("\\mfrakN", '𝔑', :mathalpha, "mathematical fraktur capital n"), + :mfrakO => UCMCommand("\\mfrakO", '𝔒', :mathalpha, "mathematical fraktur capital o"), + :mfrakP => UCMCommand("\\mfrakP", '𝔓', :mathalpha, "mathematical fraktur capital p"), + :mfrakQ => UCMCommand("\\mfrakQ", '𝔔', :mathalpha, "mathematical fraktur capital q"), + :mfrakS => UCMCommand("\\mfrakS", '𝔖', :mathalpha, "mathematical fraktur capital s"), + :mfrakT => UCMCommand("\\mfrakT", '𝔗', :mathalpha, "mathematical fraktur capital t"), + :mfrakU => UCMCommand("\\mfrakU", '𝔘', :mathalpha, "mathematical fraktur capital u"), + :mfrakV => UCMCommand("\\mfrakV", '𝔙', :mathalpha, "mathematical fraktur capital v"), + :mfrakW => UCMCommand("\\mfrakW", '𝔚', :mathalpha, "mathematical fraktur capital w"), + :mfrakX => UCMCommand("\\mfrakX", '𝔛', :mathalpha, "mathematical fraktur capital x"), + :mfrakY => UCMCommand("\\mfrakY", '𝔜', :mathalpha, "mathematical fraktur capital y"), + :mfraka => UCMCommand("\\mfraka", '𝔞', :mathalpha, "mathematical fraktur small a"), + :mfrakb => UCMCommand("\\mfrakb", '𝔟', :mathalpha, "mathematical fraktur small b"), + :mfrakc => UCMCommand("\\mfrakc", '𝔠', :mathalpha, "mathematical fraktur small c"), + :mfrakd => UCMCommand("\\mfrakd", '𝔡', :mathalpha, "mathematical fraktur small d"), + :mfrake => UCMCommand("\\mfrake", '𝔢', :mathalpha, "mathematical fraktur small e"), + :mfrakf => UCMCommand("\\mfrakf", '𝔣', :mathalpha, "mathematical fraktur small f"), + :mfrakg => UCMCommand("\\mfrakg", '𝔤', :mathalpha, "mathematical fraktur small g"), + :mfrakh => UCMCommand("\\mfrakh", '𝔥', :mathalpha, "mathematical fraktur small h"), + :mfraki => UCMCommand("\\mfraki", '𝔦', :mathalpha, "mathematical fraktur small i"), + :mfrakj => UCMCommand("\\mfrakj", '𝔧', :mathalpha, "mathematical fraktur small j"), + :mfrakk => UCMCommand("\\mfrakk", '𝔨', :mathalpha, "mathematical fraktur small k"), + :mfrakl => UCMCommand("\\mfrakl", '𝔩', :mathalpha, "mathematical fraktur small l"), + :mfrakm => UCMCommand("\\mfrakm", '𝔪', :mathalpha, "mathematical fraktur small m"), + :mfrakn => UCMCommand("\\mfrakn", '𝔫', :mathalpha, "mathematical fraktur small n"), + :mfrako => UCMCommand("\\mfrako", '𝔬', :mathalpha, "mathematical fraktur small o"), + :mfrakp => UCMCommand("\\mfrakp", '𝔭', :mathalpha, "mathematical fraktur small p"), + :mfrakq => UCMCommand("\\mfrakq", '𝔮', :mathalpha, "mathematical fraktur small q"), + :mfrakr => UCMCommand("\\mfrakr", '𝔯', :mathalpha, "mathematical fraktur small r"), + :mfraks => UCMCommand("\\mfraks", '𝔰', :mathalpha, "mathematical fraktur small s"), + :mfrakt => UCMCommand("\\mfrakt", '𝔱', :mathalpha, "mathematical fraktur small t"), + :mfraku => UCMCommand("\\mfraku", '𝔲', :mathalpha, "mathematical fraktur small u"), + :mfrakv => UCMCommand("\\mfrakv", '𝔳', :mathalpha, "mathematical fraktur small v"), + :mfrakw => UCMCommand("\\mfrakw", '𝔴', :mathalpha, "mathematical fraktur small w"), + :mfrakx => UCMCommand("\\mfrakx", '𝔵', :mathalpha, "mathematical fraktur small x"), + :mfraky => UCMCommand("\\mfraky", '𝔶', :mathalpha, "mathematical fraktur small y"), + :mfrakz => UCMCommand("\\mfrakz", '𝔷', :mathalpha, "mathematical fraktur small z"), + :BbbA => UCMCommand("\\BbbA", '𝔸', :mathalpha, "mathematical double-struck capital a"), + :BbbB => UCMCommand("\\BbbB", '𝔹', :mathalpha, "mathematical double-struck capital b"), + :BbbD => UCMCommand("\\BbbD", '𝔻', :mathalpha, "mathematical double-struck capital d"), + :BbbE => UCMCommand("\\BbbE", '𝔼', :mathalpha, "mathematical double-struck capital e"), + :BbbF => UCMCommand("\\BbbF", '𝔽', :mathalpha, "mathematical double-struck capital f"), + :BbbG => UCMCommand("\\BbbG", '𝔾', :mathalpha, "mathematical double-struck capital g"), + :BbbI => UCMCommand("\\BbbI", '𝕀', :mathalpha, "mathematical double-struck capital i"), + :BbbJ => UCMCommand("\\BbbJ", '𝕁', :mathalpha, "mathematical double-struck capital j"), + :BbbK => UCMCommand("\\BbbK", '𝕂', :mathalpha, "mathematical double-struck capital k"), + :BbbL => UCMCommand("\\BbbL", '𝕃', :mathalpha, "mathematical double-struck capital l"), + :BbbM => UCMCommand("\\BbbM", '𝕄', :mathalpha, "mathematical double-struck capital m"), + :BbbO => UCMCommand("\\BbbO", '𝕆', :mathalpha, "mathematical double-struck capital o"), + :BbbS => UCMCommand("\\BbbS", '𝕊', :mathalpha, "mathematical double-struck capital s"), + :BbbT => UCMCommand("\\BbbT", '𝕋', :mathalpha, "mathematical double-struck capital t"), + :BbbU => UCMCommand("\\BbbU", '𝕌', :mathalpha, "mathematical double-struck capital u"), + :BbbV => UCMCommand("\\BbbV", '𝕍', :mathalpha, "mathematical double-struck capital v"), + :BbbW => UCMCommand("\\BbbW", '𝕎', :mathalpha, "mathematical double-struck capital w"), + :BbbX => UCMCommand("\\BbbX", '𝕏', :mathalpha, "mathematical double-struck capital x"), + :BbbY => UCMCommand("\\BbbY", '𝕐', :mathalpha, "mathematical double-struck capital y"), + :Bbba => UCMCommand("\\Bbba", '𝕒', :mathalpha, "mathematical double-struck small a"), + :Bbbb => UCMCommand("\\Bbbb", '𝕓', :mathalpha, "mathematical double-struck small b"), + :Bbbc => UCMCommand("\\Bbbc", '𝕔', :mathalpha, "mathematical double-struck small c"), + :Bbbd => UCMCommand("\\Bbbd", '𝕕', :mathalpha, "mathematical double-struck small d"), + :Bbbe => UCMCommand("\\Bbbe", '𝕖', :mathalpha, "mathematical double-struck small e"), + :Bbbf => UCMCommand("\\Bbbf", '𝕗', :mathalpha, "mathematical double-struck small f"), + :Bbbg => UCMCommand("\\Bbbg", '𝕘', :mathalpha, "mathematical double-struck small g"), + :Bbbh => UCMCommand("\\Bbbh", '𝕙', :mathalpha, "mathematical double-struck small h"), + :Bbbi => UCMCommand("\\Bbbi", '𝕚', :mathalpha, "mathematical double-struck small i"), + :Bbbj => UCMCommand("\\Bbbj", '𝕛', :mathalpha, "mathematical double-struck small j"), + :Bbbk => UCMCommand("\\Bbbk", '𝕜', :mathalpha, "mathematical double-struck small k"), + :Bbbl => UCMCommand("\\Bbbl", '𝕝', :mathalpha, "mathematical double-struck small l"), + :Bbbm => UCMCommand("\\Bbbm", '𝕞', :mathalpha, "mathematical double-struck small m"), + :Bbbn => UCMCommand("\\Bbbn", '𝕟', :mathalpha, "mathematical double-struck small n"), + :Bbbo => UCMCommand("\\Bbbo", '𝕠', :mathalpha, "mathematical double-struck small o"), + :Bbbp => UCMCommand("\\Bbbp", '𝕡', :mathalpha, "mathematical double-struck small p"), + :Bbbq => UCMCommand("\\Bbbq", '𝕢', :mathalpha, "mathematical double-struck small q"), + :Bbbr => UCMCommand("\\Bbbr", '𝕣', :mathalpha, "mathematical double-struck small r"), + :Bbbs => UCMCommand("\\Bbbs", '𝕤', :mathalpha, "mathematical double-struck small s"), + :Bbbt => UCMCommand("\\Bbbt", '𝕥', :mathalpha, "mathematical double-struck small t"), + :Bbbu => UCMCommand("\\Bbbu", '𝕦', :mathalpha, "mathematical double-struck small u"), + :Bbbv => UCMCommand("\\Bbbv", '𝕧', :mathalpha, "mathematical double-struck small v"), + :Bbbw => UCMCommand("\\Bbbw", '𝕨', :mathalpha, "mathematical double-struck small w"), + :Bbbx => UCMCommand("\\Bbbx", '𝕩', :mathalpha, "mathematical double-struck small x"), + :Bbby => UCMCommand("\\Bbby", '𝕪', :mathalpha, "mathematical double-struck small y"), + :Bbbz => UCMCommand("\\Bbbz", '𝕫', :mathalpha, "mathematical double-struck small z"), + :mbffrakA => UCMCommand("\\mbffrakA", '𝕬', :mathalpha, "mathematical bold fraktur capital a"), + :mbffrakB => UCMCommand("\\mbffrakB", '𝕭', :mathalpha, "mathematical bold fraktur capital b"), + :mbffrakC => UCMCommand("\\mbffrakC", '𝕮', :mathalpha, "mathematical bold fraktur capital c"), + :mbffrakD => UCMCommand("\\mbffrakD", '𝕯', :mathalpha, "mathematical bold fraktur capital d"), + :mbffrakE => UCMCommand("\\mbffrakE", '𝕰', :mathalpha, "mathematical bold fraktur capital e"), + :mbffrakF => UCMCommand("\\mbffrakF", '𝕱', :mathalpha, "mathematical bold fraktur capital f"), + :mbffrakG => UCMCommand("\\mbffrakG", '𝕲', :mathalpha, "mathematical bold fraktur capital g"), + :mbffrakH => UCMCommand("\\mbffrakH", '𝕳', :mathalpha, "mathematical bold fraktur capital h"), + :mbffrakI => UCMCommand("\\mbffrakI", '𝕴', :mathalpha, "mathematical bold fraktur capital i"), + :mbffrakJ => UCMCommand("\\mbffrakJ", '𝕵', :mathalpha, "mathematical bold fraktur capital j"), + :mbffrakK => UCMCommand("\\mbffrakK", '𝕶', :mathalpha, "mathematical bold fraktur capital k"), + :mbffrakL => UCMCommand("\\mbffrakL", '𝕷', :mathalpha, "mathematical bold fraktur capital l"), + :mbffrakM => UCMCommand("\\mbffrakM", '𝕸', :mathalpha, "mathematical bold fraktur capital m"), + :mbffrakN => UCMCommand("\\mbffrakN", '𝕹', :mathalpha, "mathematical bold fraktur capital n"), + :mbffrakO => UCMCommand("\\mbffrakO", '𝕺', :mathalpha, "mathematical bold fraktur capital o"), + :mbffrakP => UCMCommand("\\mbffrakP", '𝕻', :mathalpha, "mathematical bold fraktur capital p"), + :mbffrakQ => UCMCommand("\\mbffrakQ", '𝕼', :mathalpha, "mathematical bold fraktur capital q"), + :mbffrakR => UCMCommand("\\mbffrakR", '𝕽', :mathalpha, "mathematical bold fraktur capital r"), + :mbffrakS => UCMCommand("\\mbffrakS", '𝕾', :mathalpha, "mathematical bold fraktur capital s"), + :mbffrakT => UCMCommand("\\mbffrakT", '𝕿', :mathalpha, "mathematical bold fraktur capital t"), + :mbffrakU => UCMCommand("\\mbffrakU", '𝖀', :mathalpha, "mathematical bold fraktur capital u"), + :mbffrakV => UCMCommand("\\mbffrakV", '𝖁', :mathalpha, "mathematical bold fraktur capital v"), + :mbffrakW => UCMCommand("\\mbffrakW", '𝖂', :mathalpha, "mathematical bold fraktur capital w"), + :mbffrakX => UCMCommand("\\mbffrakX", '𝖃', :mathalpha, "mathematical bold fraktur capital x"), + :mbffrakY => UCMCommand("\\mbffrakY", '𝖄', :mathalpha, "mathematical bold fraktur capital y"), + :mbffrakZ => UCMCommand("\\mbffrakZ", '𝖅', :mathalpha, "mathematical bold fraktur capital z"), + :mbffraka => UCMCommand("\\mbffraka", '𝖆', :mathalpha, "mathematical bold fraktur small a"), + :mbffrakb => UCMCommand("\\mbffrakb", '𝖇', :mathalpha, "mathematical bold fraktur small b"), + :mbffrakc => UCMCommand("\\mbffrakc", '𝖈', :mathalpha, "mathematical bold fraktur small c"), + :mbffrakd => UCMCommand("\\mbffrakd", '𝖉', :mathalpha, "mathematical bold fraktur small d"), + :mbffrake => UCMCommand("\\mbffrake", '𝖊', :mathalpha, "mathematical bold fraktur small e"), + :mbffrakf => UCMCommand("\\mbffrakf", '𝖋', :mathalpha, "mathematical bold fraktur small f"), + :mbffrakg => UCMCommand("\\mbffrakg", '𝖌', :mathalpha, "mathematical bold fraktur small g"), + :mbffrakh => UCMCommand("\\mbffrakh", '𝖍', :mathalpha, "mathematical bold fraktur small h"), + :mbffraki => UCMCommand("\\mbffraki", '𝖎', :mathalpha, "mathematical bold fraktur small i"), + :mbffrakj => UCMCommand("\\mbffrakj", '𝖏', :mathalpha, "mathematical bold fraktur small j"), + :mbffrakk => UCMCommand("\\mbffrakk", '𝖐', :mathalpha, "mathematical bold fraktur small k"), + :mbffrakl => UCMCommand("\\mbffrakl", '𝖑', :mathalpha, "mathematical bold fraktur small l"), + :mbffrakm => UCMCommand("\\mbffrakm", '𝖒', :mathalpha, "mathematical bold fraktur small m"), + :mbffrakn => UCMCommand("\\mbffrakn", '𝖓', :mathalpha, "mathematical bold fraktur small n"), + :mbffrako => UCMCommand("\\mbffrako", '𝖔', :mathalpha, "mathematical bold fraktur small o"), + :mbffrakp => UCMCommand("\\mbffrakp", '𝖕', :mathalpha, "mathematical bold fraktur small p"), + :mbffrakq => UCMCommand("\\mbffrakq", '𝖖', :mathalpha, "mathematical bold fraktur small q"), + :mbffrakr => UCMCommand("\\mbffrakr", '𝖗', :mathalpha, "mathematical bold fraktur small r"), + :mbffraks => UCMCommand("\\mbffraks", '𝖘', :mathalpha, "mathematical bold fraktur small s"), + :mbffrakt => UCMCommand("\\mbffrakt", '𝖙', :mathalpha, "mathematical bold fraktur small t"), + :mbffraku => UCMCommand("\\mbffraku", '𝖚', :mathalpha, "mathematical bold fraktur small u"), + :mbffrakv => UCMCommand("\\mbffrakv", '𝖛', :mathalpha, "mathematical bold fraktur small v"), + :mbffrakw => UCMCommand("\\mbffrakw", '𝖜', :mathalpha, "mathematical bold fraktur small w"), + :mbffrakx => UCMCommand("\\mbffrakx", '𝖝', :mathalpha, "mathematical bold fraktur small x"), + :mbffraky => UCMCommand("\\mbffraky", '𝖞', :mathalpha, "mathematical bold fraktur small y"), + :mbffrakz => UCMCommand("\\mbffrakz", '𝖟', :mathalpha, "mathematical bold fraktur small z"), + :msansA => UCMCommand("\\msansA", '𝖠', :mathalpha, "mathematical sans-serif capital a"), + :msansB => UCMCommand("\\msansB", '𝖡', :mathalpha, "mathematical sans-serif capital b"), + :msansC => UCMCommand("\\msansC", '𝖢', :mathalpha, "mathematical sans-serif capital c"), + :msansD => UCMCommand("\\msansD", '𝖣', :mathalpha, "mathematical sans-serif capital d"), + :msansE => UCMCommand("\\msansE", '𝖤', :mathalpha, "mathematical sans-serif capital e"), + :msansF => UCMCommand("\\msansF", '𝖥', :mathalpha, "mathematical sans-serif capital f"), + :msansG => UCMCommand("\\msansG", '𝖦', :mathalpha, "mathematical sans-serif capital g"), + :msansH => UCMCommand("\\msansH", '𝖧', :mathalpha, "mathematical sans-serif capital h"), + :msansI => UCMCommand("\\msansI", '𝖨', :mathalpha, "mathematical sans-serif capital i"), + :msansJ => UCMCommand("\\msansJ", '𝖩', :mathalpha, "mathematical sans-serif capital j"), + :msansK => UCMCommand("\\msansK", '𝖪', :mathalpha, "mathematical sans-serif capital k"), + :msansL => UCMCommand("\\msansL", '𝖫', :mathalpha, "mathematical sans-serif capital l"), + :msansM => UCMCommand("\\msansM", '𝖬', :mathalpha, "mathematical sans-serif capital m"), + :msansN => UCMCommand("\\msansN", '𝖭', :mathalpha, "mathematical sans-serif capital n"), + :msansO => UCMCommand("\\msansO", '𝖮', :mathalpha, "mathematical sans-serif capital o"), + :msansP => UCMCommand("\\msansP", '𝖯', :mathalpha, "mathematical sans-serif capital p"), + :msansQ => UCMCommand("\\msansQ", '𝖰', :mathalpha, "mathematical sans-serif capital q"), + :msansR => UCMCommand("\\msansR", '𝖱', :mathalpha, "mathematical sans-serif capital r"), + :msansS => UCMCommand("\\msansS", '𝖲', :mathalpha, "mathematical sans-serif capital s"), + :msansT => UCMCommand("\\msansT", '𝖳', :mathalpha, "mathematical sans-serif capital t"), + :msansU => UCMCommand("\\msansU", '𝖴', :mathalpha, "mathematical sans-serif capital u"), + :msansV => UCMCommand("\\msansV", '𝖵', :mathalpha, "mathematical sans-serif capital v"), + :msansW => UCMCommand("\\msansW", '𝖶', :mathalpha, "mathematical sans-serif capital w"), + :msansX => UCMCommand("\\msansX", '𝖷', :mathalpha, "mathematical sans-serif capital x"), + :msansY => UCMCommand("\\msansY", '𝖸', :mathalpha, "mathematical sans-serif capital y"), + :msansZ => UCMCommand("\\msansZ", '𝖹', :mathalpha, "mathematical sans-serif capital z"), + :msansa => UCMCommand("\\msansa", '𝖺', :mathalpha, "mathematical sans-serif small a"), + :msansb => UCMCommand("\\msansb", '𝖻', :mathalpha, "mathematical sans-serif small b"), + :msansc => UCMCommand("\\msansc", '𝖼', :mathalpha, "mathematical sans-serif small c"), + :msansd => UCMCommand("\\msansd", '𝖽', :mathalpha, "mathematical sans-serif small d"), + :msanse => UCMCommand("\\msanse", '𝖾', :mathalpha, "mathematical sans-serif small e"), + :msansf => UCMCommand("\\msansf", '𝖿', :mathalpha, "mathematical sans-serif small f"), + :msansg => UCMCommand("\\msansg", '𝗀', :mathalpha, "mathematical sans-serif small g"), + :msansh => UCMCommand("\\msansh", '𝗁', :mathalpha, "mathematical sans-serif small h"), + :msansi => UCMCommand("\\msansi", '𝗂', :mathalpha, "mathematical sans-serif small i"), + :msansj => UCMCommand("\\msansj", '𝗃', :mathalpha, "mathematical sans-serif small j"), + :msansk => UCMCommand("\\msansk", '𝗄', :mathalpha, "mathematical sans-serif small k"), + :msansl => UCMCommand("\\msansl", '𝗅', :mathalpha, "mathematical sans-serif small l"), + :msansm => UCMCommand("\\msansm", '𝗆', :mathalpha, "mathematical sans-serif small m"), + :msansn => UCMCommand("\\msansn", '𝗇', :mathalpha, "mathematical sans-serif small n"), + :msanso => UCMCommand("\\msanso", '𝗈', :mathalpha, "mathematical sans-serif small o"), + :msansp => UCMCommand("\\msansp", '𝗉', :mathalpha, "mathematical sans-serif small p"), + :msansq => UCMCommand("\\msansq", '𝗊', :mathalpha, "mathematical sans-serif small q"), + :msansr => UCMCommand("\\msansr", '𝗋', :mathalpha, "mathematical sans-serif small r"), + :msanss => UCMCommand("\\msanss", '𝗌', :mathalpha, "mathematical sans-serif small s"), + :msanst => UCMCommand("\\msanst", '𝗍', :mathalpha, "mathematical sans-serif small t"), + :msansu => UCMCommand("\\msansu", '𝗎', :mathalpha, "mathematical sans-serif small u"), + :msansv => UCMCommand("\\msansv", '𝗏', :mathalpha, "mathematical sans-serif small v"), + :msansw => UCMCommand("\\msansw", '𝗐', :mathalpha, "mathematical sans-serif small w"), + :msansx => UCMCommand("\\msansx", '𝗑', :mathalpha, "mathematical sans-serif small x"), + :msansy => UCMCommand("\\msansy", '𝗒', :mathalpha, "mathematical sans-serif small y"), + :msansz => UCMCommand("\\msansz", '𝗓', :mathalpha, "mathematical sans-serif small z"), + :mbfsansA => UCMCommand("\\mbfsansA", '𝗔', :mathalpha, "mathematical sans-serif bold capital a"), + :mbfsansB => UCMCommand("\\mbfsansB", '𝗕', :mathalpha, "mathematical sans-serif bold capital b"), + :mbfsansC => UCMCommand("\\mbfsansC", '𝗖', :mathalpha, "mathematical sans-serif bold capital c"), + :mbfsansD => UCMCommand("\\mbfsansD", '𝗗', :mathalpha, "mathematical sans-serif bold capital d"), + :mbfsansE => UCMCommand("\\mbfsansE", '𝗘', :mathalpha, "mathematical sans-serif bold capital e"), + :mbfsansF => UCMCommand("\\mbfsansF", '𝗙', :mathalpha, "mathematical sans-serif bold capital f"), + :mbfsansG => UCMCommand("\\mbfsansG", '𝗚', :mathalpha, "mathematical sans-serif bold capital g"), + :mbfsansH => UCMCommand("\\mbfsansH", '𝗛', :mathalpha, "mathematical sans-serif bold capital h"), + :mbfsansI => UCMCommand("\\mbfsansI", '𝗜', :mathalpha, "mathematical sans-serif bold capital i"), + :mbfsansJ => UCMCommand("\\mbfsansJ", '𝗝', :mathalpha, "mathematical sans-serif bold capital j"), + :mbfsansK => UCMCommand("\\mbfsansK", '𝗞', :mathalpha, "mathematical sans-serif bold capital k"), + :mbfsansL => UCMCommand("\\mbfsansL", '𝗟', :mathalpha, "mathematical sans-serif bold capital l"), + :mbfsansM => UCMCommand("\\mbfsansM", '𝗠', :mathalpha, "mathematical sans-serif bold capital m"), + :mbfsansN => UCMCommand("\\mbfsansN", '𝗡', :mathalpha, "mathematical sans-serif bold capital n"), + :mbfsansO => UCMCommand("\\mbfsansO", '𝗢', :mathalpha, "mathematical sans-serif bold capital o"), + :mbfsansP => UCMCommand("\\mbfsansP", '𝗣', :mathalpha, "mathematical sans-serif bold capital p"), + :mbfsansQ => UCMCommand("\\mbfsansQ", '𝗤', :mathalpha, "mathematical sans-serif bold capital q"), + :mbfsansR => UCMCommand("\\mbfsansR", '𝗥', :mathalpha, "mathematical sans-serif bold capital r"), + :mbfsansS => UCMCommand("\\mbfsansS", '𝗦', :mathalpha, "mathematical sans-serif bold capital s"), + :mbfsansT => UCMCommand("\\mbfsansT", '𝗧', :mathalpha, "mathematical sans-serif bold capital t"), + :mbfsansU => UCMCommand("\\mbfsansU", '𝗨', :mathalpha, "mathematical sans-serif bold capital u"), + :mbfsansV => UCMCommand("\\mbfsansV", '𝗩', :mathalpha, "mathematical sans-serif bold capital v"), + :mbfsansW => UCMCommand("\\mbfsansW", '𝗪', :mathalpha, "mathematical sans-serif bold capital w"), + :mbfsansX => UCMCommand("\\mbfsansX", '𝗫', :mathalpha, "mathematical sans-serif bold capital x"), + :mbfsansY => UCMCommand("\\mbfsansY", '𝗬', :mathalpha, "mathematical sans-serif bold capital y"), + :mbfsansZ => UCMCommand("\\mbfsansZ", '𝗭', :mathalpha, "mathematical sans-serif bold capital z"), + :mbfsansa => UCMCommand("\\mbfsansa", '𝗮', :mathalpha, "mathematical sans-serif bold small a"), + :mbfsansb => UCMCommand("\\mbfsansb", '𝗯', :mathalpha, "mathematical sans-serif bold small b"), + :mbfsansc => UCMCommand("\\mbfsansc", '𝗰', :mathalpha, "mathematical sans-serif bold small c"), + :mbfsansd => UCMCommand("\\mbfsansd", '𝗱', :mathalpha, "mathematical sans-serif bold small d"), + :mbfsanse => UCMCommand("\\mbfsanse", '𝗲', :mathalpha, "mathematical sans-serif bold small e"), + :mbfsansf => UCMCommand("\\mbfsansf", '𝗳', :mathalpha, "mathematical sans-serif bold small f"), + :mbfsansg => UCMCommand("\\mbfsansg", '𝗴', :mathalpha, "mathematical sans-serif bold small g"), + :mbfsansh => UCMCommand("\\mbfsansh", '𝗵', :mathalpha, "mathematical sans-serif bold small h"), + :mbfsansi => UCMCommand("\\mbfsansi", '𝗶', :mathalpha, "mathematical sans-serif bold small i"), + :mbfsansj => UCMCommand("\\mbfsansj", '𝗷', :mathalpha, "mathematical sans-serif bold small j"), + :mbfsansk => UCMCommand("\\mbfsansk", '𝗸', :mathalpha, "mathematical sans-serif bold small k"), + :mbfsansl => UCMCommand("\\mbfsansl", '𝗹', :mathalpha, "mathematical sans-serif bold small l"), + :mbfsansm => UCMCommand("\\mbfsansm", '𝗺', :mathalpha, "mathematical sans-serif bold small m"), + :mbfsansn => UCMCommand("\\mbfsansn", '𝗻', :mathalpha, "mathematical sans-serif bold small n"), + :mbfsanso => UCMCommand("\\mbfsanso", '𝗼', :mathalpha, "mathematical sans-serif bold small o"), + :mbfsansp => UCMCommand("\\mbfsansp", '𝗽', :mathalpha, "mathematical sans-serif bold small p"), + :mbfsansq => UCMCommand("\\mbfsansq", '𝗾', :mathalpha, "mathematical sans-serif bold small q"), + :mbfsansr => UCMCommand("\\mbfsansr", '𝗿', :mathalpha, "mathematical sans-serif bold small r"), + :mbfsanss => UCMCommand("\\mbfsanss", '𝘀', :mathalpha, "mathematical sans-serif bold small s"), + :mbfsanst => UCMCommand("\\mbfsanst", '𝘁', :mathalpha, "mathematical sans-serif bold small t"), + :mbfsansu => UCMCommand("\\mbfsansu", '𝘂', :mathalpha, "mathematical sans-serif bold small u"), + :mbfsansv => UCMCommand("\\mbfsansv", '𝘃', :mathalpha, "mathematical sans-serif bold small v"), + :mbfsansw => UCMCommand("\\mbfsansw", '𝘄', :mathalpha, "mathematical sans-serif bold small w"), + :mbfsansx => UCMCommand("\\mbfsansx", '𝘅', :mathalpha, "mathematical sans-serif bold small x"), + :mbfsansy => UCMCommand("\\mbfsansy", '𝘆', :mathalpha, "mathematical sans-serif bold small y"), + :mbfsansz => UCMCommand("\\mbfsansz", '𝘇', :mathalpha, "mathematical sans-serif bold small z"), + :mitsansA => UCMCommand("\\mitsansA", '𝘈', :mathalpha, "mathematical sans-serif italic capital a"), + :mitsansB => UCMCommand("\\mitsansB", '𝘉', :mathalpha, "mathematical sans-serif italic capital b"), + :mitsansC => UCMCommand("\\mitsansC", '𝘊', :mathalpha, "mathematical sans-serif italic capital c"), + :mitsansD => UCMCommand("\\mitsansD", '𝘋', :mathalpha, "mathematical sans-serif italic capital d"), + :mitsansE => UCMCommand("\\mitsansE", '𝘌', :mathalpha, "mathematical sans-serif italic capital e"), + :mitsansF => UCMCommand("\\mitsansF", '𝘍', :mathalpha, "mathematical sans-serif italic capital f"), + :mitsansG => UCMCommand("\\mitsansG", '𝘎', :mathalpha, "mathematical sans-serif italic capital g"), + :mitsansH => UCMCommand("\\mitsansH", '𝘏', :mathalpha, "mathematical sans-serif italic capital h"), + :mitsansI => UCMCommand("\\mitsansI", '𝘐', :mathalpha, "mathematical sans-serif italic capital i"), + :mitsansJ => UCMCommand("\\mitsansJ", '𝘑', :mathalpha, "mathematical sans-serif italic capital j"), + :mitsansK => UCMCommand("\\mitsansK", '𝘒', :mathalpha, "mathematical sans-serif italic capital k"), + :mitsansL => UCMCommand("\\mitsansL", '𝘓', :mathalpha, "mathematical sans-serif italic capital l"), + :mitsansM => UCMCommand("\\mitsansM", '𝘔', :mathalpha, "mathematical sans-serif italic capital m"), + :mitsansN => UCMCommand("\\mitsansN", '𝘕', :mathalpha, "mathematical sans-serif italic capital n"), + :mitsansO => UCMCommand("\\mitsansO", '𝘖', :mathalpha, "mathematical sans-serif italic capital o"), + :mitsansP => UCMCommand("\\mitsansP", '𝘗', :mathalpha, "mathematical sans-serif italic capital p"), + :mitsansQ => UCMCommand("\\mitsansQ", '𝘘', :mathalpha, "mathematical sans-serif italic capital q"), + :mitsansR => UCMCommand("\\mitsansR", '𝘙', :mathalpha, "mathematical sans-serif italic capital r"), + :mitsansS => UCMCommand("\\mitsansS", '𝘚', :mathalpha, "mathematical sans-serif italic capital s"), + :mitsansT => UCMCommand("\\mitsansT", '𝘛', :mathalpha, "mathematical sans-serif italic capital t"), + :mitsansU => UCMCommand("\\mitsansU", '𝘜', :mathalpha, "mathematical sans-serif italic capital u"), + :mitsansV => UCMCommand("\\mitsansV", '𝘝', :mathalpha, "mathematical sans-serif italic capital v"), + :mitsansW => UCMCommand("\\mitsansW", '𝘞', :mathalpha, "mathematical sans-serif italic capital w"), + :mitsansX => UCMCommand("\\mitsansX", '𝘟', :mathalpha, "mathematical sans-serif italic capital x"), + :mitsansY => UCMCommand("\\mitsansY", '𝘠', :mathalpha, "mathematical sans-serif italic capital y"), + :mitsansZ => UCMCommand("\\mitsansZ", '𝘡', :mathalpha, "mathematical sans-serif italic capital z"), + :mitsansa => UCMCommand("\\mitsansa", '𝘢', :mathalpha, "mathematical sans-serif italic small a"), + :mitsansb => UCMCommand("\\mitsansb", '𝘣', :mathalpha, "mathematical sans-serif italic small b"), + :mitsansc => UCMCommand("\\mitsansc", '𝘤', :mathalpha, "mathematical sans-serif italic small c"), + :mitsansd => UCMCommand("\\mitsansd", '𝘥', :mathalpha, "mathematical sans-serif italic small d"), + :mitsanse => UCMCommand("\\mitsanse", '𝘦', :mathalpha, "mathematical sans-serif italic small e"), + :mitsansf => UCMCommand("\\mitsansf", '𝘧', :mathalpha, "mathematical sans-serif italic small f"), + :mitsansg => UCMCommand("\\mitsansg", '𝘨', :mathalpha, "mathematical sans-serif italic small g"), + :mitsansh => UCMCommand("\\mitsansh", '𝘩', :mathalpha, "mathematical sans-serif italic small h"), + :mitsansi => UCMCommand("\\mitsansi", '𝘪', :mathalpha, "mathematical sans-serif italic small i"), + :mitsansj => UCMCommand("\\mitsansj", '𝘫', :mathalpha, "mathematical sans-serif italic small j"), + :mitsansk => UCMCommand("\\mitsansk", '𝘬', :mathalpha, "mathematical sans-serif italic small k"), + :mitsansl => UCMCommand("\\mitsansl", '𝘭', :mathalpha, "mathematical sans-serif italic small l"), + :mitsansm => UCMCommand("\\mitsansm", '𝘮', :mathalpha, "mathematical sans-serif italic small m"), + :mitsansn => UCMCommand("\\mitsansn", '𝘯', :mathalpha, "mathematical sans-serif italic small n"), + :mitsanso => UCMCommand("\\mitsanso", '𝘰', :mathalpha, "mathematical sans-serif italic small o"), + :mitsansp => UCMCommand("\\mitsansp", '𝘱', :mathalpha, "mathematical sans-serif italic small p"), + :mitsansq => UCMCommand("\\mitsansq", '𝘲', :mathalpha, "mathematical sans-serif italic small q"), + :mitsansr => UCMCommand("\\mitsansr", '𝘳', :mathalpha, "mathematical sans-serif italic small r"), + :mitsanss => UCMCommand("\\mitsanss", '𝘴', :mathalpha, "mathematical sans-serif italic small s"), + :mitsanst => UCMCommand("\\mitsanst", '𝘵', :mathalpha, "mathematical sans-serif italic small t"), + :mitsansu => UCMCommand("\\mitsansu", '𝘶', :mathalpha, "mathematical sans-serif italic small u"), + :mitsansv => UCMCommand("\\mitsansv", '𝘷', :mathalpha, "mathematical sans-serif italic small v"), + :mitsansw => UCMCommand("\\mitsansw", '𝘸', :mathalpha, "mathematical sans-serif italic small w"), + :mitsansx => UCMCommand("\\mitsansx", '𝘹', :mathalpha, "mathematical sans-serif italic small x"), + :mitsansy => UCMCommand("\\mitsansy", '𝘺', :mathalpha, "mathematical sans-serif italic small y"), + :mitsansz => UCMCommand("\\mitsansz", '𝘻', :mathalpha, "mathematical sans-serif italic small z"), + :mbfitsansA => UCMCommand("\\mbfitsansA", '𝘼', :mathalpha, "mathematical sans-serif bold italic capital a"), + :mbfitsansB => UCMCommand("\\mbfitsansB", '𝘽', :mathalpha, "mathematical sans-serif bold italic capital b"), + :mbfitsansC => UCMCommand("\\mbfitsansC", '𝘾', :mathalpha, "mathematical sans-serif bold italic capital c"), + :mbfitsansD => UCMCommand("\\mbfitsansD", '𝘿', :mathalpha, "mathematical sans-serif bold italic capital d"), + :mbfitsansE => UCMCommand("\\mbfitsansE", '𝙀', :mathalpha, "mathematical sans-serif bold italic capital e"), + :mbfitsansF => UCMCommand("\\mbfitsansF", '𝙁', :mathalpha, "mathematical sans-serif bold italic capital f"), + :mbfitsansG => UCMCommand("\\mbfitsansG", '𝙂', :mathalpha, "mathematical sans-serif bold italic capital g"), + :mbfitsansH => UCMCommand("\\mbfitsansH", '𝙃', :mathalpha, "mathematical sans-serif bold italic capital h"), + :mbfitsansI => UCMCommand("\\mbfitsansI", '𝙄', :mathalpha, "mathematical sans-serif bold italic capital i"), + :mbfitsansJ => UCMCommand("\\mbfitsansJ", '𝙅', :mathalpha, "mathematical sans-serif bold italic capital j"), + :mbfitsansK => UCMCommand("\\mbfitsansK", '𝙆', :mathalpha, "mathematical sans-serif bold italic capital k"), + :mbfitsansL => UCMCommand("\\mbfitsansL", '𝙇', :mathalpha, "mathematical sans-serif bold italic capital l"), + :mbfitsansM => UCMCommand("\\mbfitsansM", '𝙈', :mathalpha, "mathematical sans-serif bold italic capital m"), + :mbfitsansN => UCMCommand("\\mbfitsansN", '𝙉', :mathalpha, "mathematical sans-serif bold italic capital n"), + :mbfitsansO => UCMCommand("\\mbfitsansO", '𝙊', :mathalpha, "mathematical sans-serif bold italic capital o"), + :mbfitsansP => UCMCommand("\\mbfitsansP", '𝙋', :mathalpha, "mathematical sans-serif bold italic capital p"), + :mbfitsansQ => UCMCommand("\\mbfitsansQ", '𝙌', :mathalpha, "mathematical sans-serif bold italic capital q"), + :mbfitsansR => UCMCommand("\\mbfitsansR", '𝙍', :mathalpha, "mathematical sans-serif bold italic capital r"), + :mbfitsansS => UCMCommand("\\mbfitsansS", '𝙎', :mathalpha, "mathematical sans-serif bold italic capital s"), + :mbfitsansT => UCMCommand("\\mbfitsansT", '𝙏', :mathalpha, "mathematical sans-serif bold italic capital t"), + :mbfitsansU => UCMCommand("\\mbfitsansU", '𝙐', :mathalpha, "mathematical sans-serif bold italic capital u"), + :mbfitsansV => UCMCommand("\\mbfitsansV", '𝙑', :mathalpha, "mathematical sans-serif bold italic capital v"), + :mbfitsansW => UCMCommand("\\mbfitsansW", '𝙒', :mathalpha, "mathematical sans-serif bold italic capital w"), + :mbfitsansX => UCMCommand("\\mbfitsansX", '𝙓', :mathalpha, "mathematical sans-serif bold italic capital x"), + :mbfitsansY => UCMCommand("\\mbfitsansY", '𝙔', :mathalpha, "mathematical sans-serif bold italic capital y"), + :mbfitsansZ => UCMCommand("\\mbfitsansZ", '𝙕', :mathalpha, "mathematical sans-serif bold italic capital z"), + :mbfitsansa => UCMCommand("\\mbfitsansa", '𝙖', :mathalpha, "mathematical sans-serif bold italic small a"), + :mbfitsansb => UCMCommand("\\mbfitsansb", '𝙗', :mathalpha, "mathematical sans-serif bold italic small b"), + :mbfitsansc => UCMCommand("\\mbfitsansc", '𝙘', :mathalpha, "mathematical sans-serif bold italic small c"), + :mbfitsansd => UCMCommand("\\mbfitsansd", '𝙙', :mathalpha, "mathematical sans-serif bold italic small d"), + :mbfitsanse => UCMCommand("\\mbfitsanse", '𝙚', :mathalpha, "mathematical sans-serif bold italic small e"), + :mbfitsansf => UCMCommand("\\mbfitsansf", '𝙛', :mathalpha, "mathematical sans-serif bold italic small f"), + :mbfitsansg => UCMCommand("\\mbfitsansg", '𝙜', :mathalpha, "mathematical sans-serif bold italic small g"), + :mbfitsansh => UCMCommand("\\mbfitsansh", '𝙝', :mathalpha, "mathematical sans-serif bold italic small h"), + :mbfitsansi => UCMCommand("\\mbfitsansi", '𝙞', :mathalpha, "mathematical sans-serif bold italic small i"), + :mbfitsansj => UCMCommand("\\mbfitsansj", '𝙟', :mathalpha, "mathematical sans-serif bold italic small j"), + :mbfitsansk => UCMCommand("\\mbfitsansk", '𝙠', :mathalpha, "mathematical sans-serif bold italic small k"), + :mbfitsansl => UCMCommand("\\mbfitsansl", '𝙡', :mathalpha, "mathematical sans-serif bold italic small l"), + :mbfitsansm => UCMCommand("\\mbfitsansm", '𝙢', :mathalpha, "mathematical sans-serif bold italic small m"), + :mbfitsansn => UCMCommand("\\mbfitsansn", '𝙣', :mathalpha, "mathematical sans-serif bold italic small n"), + :mbfitsanso => UCMCommand("\\mbfitsanso", '𝙤', :mathalpha, "mathematical sans-serif bold italic small o"), + :mbfitsansp => UCMCommand("\\mbfitsansp", '𝙥', :mathalpha, "mathematical sans-serif bold italic small p"), + :mbfitsansq => UCMCommand("\\mbfitsansq", '𝙦', :mathalpha, "mathematical sans-serif bold italic small q"), + :mbfitsansr => UCMCommand("\\mbfitsansr", '𝙧', :mathalpha, "mathematical sans-serif bold italic small r"), + :mbfitsanss => UCMCommand("\\mbfitsanss", '𝙨', :mathalpha, "mathematical sans-serif bold italic small s"), + :mbfitsanst => UCMCommand("\\mbfitsanst", '𝙩', :mathalpha, "mathematical sans-serif bold italic small t"), + :mbfitsansu => UCMCommand("\\mbfitsansu", '𝙪', :mathalpha, "mathematical sans-serif bold italic small u"), + :mbfitsansv => UCMCommand("\\mbfitsansv", '𝙫', :mathalpha, "mathematical sans-serif bold italic small v"), + :mbfitsansw => UCMCommand("\\mbfitsansw", '𝙬', :mathalpha, "mathematical sans-serif bold italic small w"), + :mbfitsansx => UCMCommand("\\mbfitsansx", '𝙭', :mathalpha, "mathematical sans-serif bold italic small x"), + :mbfitsansy => UCMCommand("\\mbfitsansy", '𝙮', :mathalpha, "mathematical sans-serif bold italic small y"), + :mbfitsansz => UCMCommand("\\mbfitsansz", '𝙯', :mathalpha, "mathematical sans-serif bold italic small z"), + :mttA => UCMCommand("\\mttA", '𝙰', :mathalpha, "mathematical monospace capital a"), + :mttB => UCMCommand("\\mttB", '𝙱', :mathalpha, "mathematical monospace capital b"), + :mttC => UCMCommand("\\mttC", '𝙲', :mathalpha, "mathematical monospace capital c"), + :mttD => UCMCommand("\\mttD", '𝙳', :mathalpha, "mathematical monospace capital d"), + :mttE => UCMCommand("\\mttE", '𝙴', :mathalpha, "mathematical monospace capital e"), + :mttF => UCMCommand("\\mttF", '𝙵', :mathalpha, "mathematical monospace capital f"), + :mttG => UCMCommand("\\mttG", '𝙶', :mathalpha, "mathematical monospace capital g"), + :mttH => UCMCommand("\\mttH", '𝙷', :mathalpha, "mathematical monospace capital h"), + :mttI => UCMCommand("\\mttI", '𝙸', :mathalpha, "mathematical monospace capital i"), + :mttJ => UCMCommand("\\mttJ", '𝙹', :mathalpha, "mathematical monospace capital j"), + :mttK => UCMCommand("\\mttK", '𝙺', :mathalpha, "mathematical monospace capital k"), + :mttL => UCMCommand("\\mttL", '𝙻', :mathalpha, "mathematical monospace capital l"), + :mttM => UCMCommand("\\mttM", '𝙼', :mathalpha, "mathematical monospace capital m"), + :mttN => UCMCommand("\\mttN", '𝙽', :mathalpha, "mathematical monospace capital n"), + :mttO => UCMCommand("\\mttO", '𝙾', :mathalpha, "mathematical monospace capital o"), + :mttP => UCMCommand("\\mttP", '𝙿', :mathalpha, "mathematical monospace capital p"), + :mttQ => UCMCommand("\\mttQ", '𝚀', :mathalpha, "mathematical monospace capital q"), + :mttR => UCMCommand("\\mttR", '𝚁', :mathalpha, "mathematical monospace capital r"), + :mttS => UCMCommand("\\mttS", '𝚂', :mathalpha, "mathematical monospace capital s"), + :mttT => UCMCommand("\\mttT", '𝚃', :mathalpha, "mathematical monospace capital t"), + :mttU => UCMCommand("\\mttU", '𝚄', :mathalpha, "mathematical monospace capital u"), + :mttV => UCMCommand("\\mttV", '𝚅', :mathalpha, "mathematical monospace capital v"), + :mttW => UCMCommand("\\mttW", '𝚆', :mathalpha, "mathematical monospace capital w"), + :mttX => UCMCommand("\\mttX", '𝚇', :mathalpha, "mathematical monospace capital x"), + :mttY => UCMCommand("\\mttY", '𝚈', :mathalpha, "mathematical monospace capital y"), + :mttZ => UCMCommand("\\mttZ", '𝚉', :mathalpha, "mathematical monospace capital z"), + :mtta => UCMCommand("\\mtta", '𝚊', :mathalpha, "mathematical monospace small a"), + :mttb => UCMCommand("\\mttb", '𝚋', :mathalpha, "mathematical monospace small b"), + :mttc => UCMCommand("\\mttc", '𝚌', :mathalpha, "mathematical monospace small c"), + :mttd => UCMCommand("\\mttd", '𝚍', :mathalpha, "mathematical monospace small d"), + :mtte => UCMCommand("\\mtte", '𝚎', :mathalpha, "mathematical monospace small e"), + :mttf => UCMCommand("\\mttf", '𝚏', :mathalpha, "mathematical monospace small f"), + :mttg => UCMCommand("\\mttg", '𝚐', :mathalpha, "mathematical monospace small g"), + :mtth => UCMCommand("\\mtth", '𝚑', :mathalpha, "mathematical monospace small h"), + :mtti => UCMCommand("\\mtti", '𝚒', :mathalpha, "mathematical monospace small i"), + :mttj => UCMCommand("\\mttj", '𝚓', :mathalpha, "mathematical monospace small j"), + :mttk => UCMCommand("\\mttk", '𝚔', :mathalpha, "mathematical monospace small k"), + :mttl => UCMCommand("\\mttl", '𝚕', :mathalpha, "mathematical monospace small l"), + :mttm => UCMCommand("\\mttm", '𝚖', :mathalpha, "mathematical monospace small m"), + :mttn => UCMCommand("\\mttn", '𝚗', :mathalpha, "mathematical monospace small n"), + :mtto => UCMCommand("\\mtto", '𝚘', :mathalpha, "mathematical monospace small o"), + :mttp => UCMCommand("\\mttp", '𝚙', :mathalpha, "mathematical monospace small p"), + :mttq => UCMCommand("\\mttq", '𝚚', :mathalpha, "mathematical monospace small q"), + :mttr => UCMCommand("\\mttr", '𝚛', :mathalpha, "mathematical monospace small r"), + :mtts => UCMCommand("\\mtts", '𝚜', :mathalpha, "mathematical monospace small s"), + :mttt => UCMCommand("\\mttt", '𝚝', :mathalpha, "mathematical monospace small t"), + :mttu => UCMCommand("\\mttu", '𝚞', :mathalpha, "mathematical monospace small u"), + :mttv => UCMCommand("\\mttv", '𝚟', :mathalpha, "mathematical monospace small v"), + :mttw => UCMCommand("\\mttw", '𝚠', :mathalpha, "mathematical monospace small w"), + :mttx => UCMCommand("\\mttx", '𝚡', :mathalpha, "mathematical monospace small x"), + :mtty => UCMCommand("\\mtty", '𝚢', :mathalpha, "mathematical monospace small y"), + :mttz => UCMCommand("\\mttz", '𝚣', :mathalpha, "mathematical monospace small z"), + :imath => UCMCommand("\\imath", '𝚤', :mathalpha, "mathematical italic small dotless i"), + :jmath => UCMCommand("\\jmath", '𝚥', :mathalpha, "mathematical italic small dotless j"), + :mbfAlpha => UCMCommand("\\mbfAlpha", '𝚨', :mathalpha, "mathematical bold capital alpha"), + :mbfBeta => UCMCommand("\\mbfBeta", '𝚩', :mathalpha, "mathematical bold capital beta"), + :mbfGamma => UCMCommand("\\mbfGamma", '𝚪', :mathalpha, "mathematical bold capital gamma"), + :mbfDelta => UCMCommand("\\mbfDelta", '𝚫', :mathalpha, "mathematical bold capital delta"), + :mbfEpsilon => UCMCommand("\\mbfEpsilon", '𝚬', :mathalpha, "mathematical bold capital epsilon"), + :mbfZeta => UCMCommand("\\mbfZeta", '𝚭', :mathalpha, "mathematical bold capital zeta"), + :mbfEta => UCMCommand("\\mbfEta", '𝚮', :mathalpha, "mathematical bold capital eta"), + :mbfTheta => UCMCommand("\\mbfTheta", '𝚯', :mathalpha, "mathematical bold capital theta"), + :mbfIota => UCMCommand("\\mbfIota", '𝚰', :mathalpha, "mathematical bold capital iota"), + :mbfKappa => UCMCommand("\\mbfKappa", '𝚱', :mathalpha, "mathematical bold capital kappa"), + :mbfLambda => UCMCommand("\\mbfLambda", '𝚲', :mathalpha, "mathematical bold capital lambda"), + :mbfMu => UCMCommand("\\mbfMu", '𝚳', :mathalpha, "mathematical bold capital mu"), + :mbfNu => UCMCommand("\\mbfNu", '𝚴', :mathalpha, "mathematical bold capital nu"), + :mbfXi => UCMCommand("\\mbfXi", '𝚵', :mathalpha, "mathematical bold capital xi"), + :mbfOmicron => UCMCommand("\\mbfOmicron", '𝚶', :mathalpha, "mathematical bold capital omicron"), + :mbfPi => UCMCommand("\\mbfPi", '𝚷', :mathalpha, "mathematical bold capital pi"), + :mbfRho => UCMCommand("\\mbfRho", '𝚸', :mathalpha, "mathematical bold capital rho"), + :mbfvarTheta => UCMCommand("\\mbfvarTheta", '𝚹', :mathalpha, "mathematical bold capital theta symbol"), + :mbfSigma => UCMCommand("\\mbfSigma", '𝚺', :mathalpha, "mathematical bold capital sigma"), + :mbfTau => UCMCommand("\\mbfTau", '𝚻', :mathalpha, "mathematical bold capital tau"), + :mbfUpsilon => UCMCommand("\\mbfUpsilon", '𝚼', :mathalpha, "mathematical bold capital upsilon"), + :mbfPhi => UCMCommand("\\mbfPhi", '𝚽', :mathalpha, "mathematical bold capital phi"), + :mbfChi => UCMCommand("\\mbfChi", '𝚾', :mathalpha, "mathematical bold capital chi"), + :mbfPsi => UCMCommand("\\mbfPsi", '𝚿', :mathalpha, "mathematical bold capital psi"), + :mbfOmega => UCMCommand("\\mbfOmega", '𝛀', :mathalpha, "mathematical bold capital omega"), + :mbfnabla => UCMCommand("\\mbfnabla", '𝛁', :mathalpha, "mathematical bold nabla"), + :mbfalpha => UCMCommand("\\mbfalpha", '𝛂', :mathalpha, "mathematical bold small alpha"), + :mbfbeta => UCMCommand("\\mbfbeta", '𝛃', :mathalpha, "mathematical bold small beta"), + :mbfgamma => UCMCommand("\\mbfgamma", '𝛄', :mathalpha, "mathematical bold small gamma"), + :mbfdelta => UCMCommand("\\mbfdelta", '𝛅', :mathalpha, "mathematical bold small delta"), + :mbfvarepsilon => UCMCommand("\\mbfvarepsilon", '𝛆', :mathalpha, "mathematical bold small varepsilon"), + :mbfzeta => UCMCommand("\\mbfzeta", '𝛇', :mathalpha, "mathematical bold small zeta"), + :mbfeta => UCMCommand("\\mbfeta", '𝛈', :mathalpha, "mathematical bold small eta"), + :mbftheta => UCMCommand("\\mbftheta", '𝛉', :mathalpha, "mathematical bold small theta"), + :mbfiota => UCMCommand("\\mbfiota", '𝛊', :mathalpha, "mathematical bold small iota"), + :mbfkappa => UCMCommand("\\mbfkappa", '𝛋', :mathalpha, "mathematical bold small kappa"), + :mbflambda => UCMCommand("\\mbflambda", '𝛌', :mathalpha, "mathematical bold small lambda"), + :mbfmu => UCMCommand("\\mbfmu", '𝛍', :mathalpha, "mathematical bold small mu"), + :mbfnu => UCMCommand("\\mbfnu", '𝛎', :mathalpha, "mathematical bold small nu"), + :mbfxi => UCMCommand("\\mbfxi", '𝛏', :mathalpha, "mathematical bold small xi"), + :mbfomicron => UCMCommand("\\mbfomicron", '𝛐', :mathalpha, "mathematical bold small omicron"), + :mbfpi => UCMCommand("\\mbfpi", '𝛑', :mathalpha, "mathematical bold small pi"), + :mbfrho => UCMCommand("\\mbfrho", '𝛒', :mathalpha, "mathematical bold small rho"), + :mbfvarsigma => UCMCommand("\\mbfvarsigma", '𝛓', :mathalpha, "mathematical bold small final sigma"), + :mbfsigma => UCMCommand("\\mbfsigma", '𝛔', :mathalpha, "mathematical bold small sigma"), + :mbftau => UCMCommand("\\mbftau", '𝛕', :mathalpha, "mathematical bold small tau"), + :mbfupsilon => UCMCommand("\\mbfupsilon", '𝛖', :mathalpha, "mathematical bold small upsilon"), + :mbfvarphi => UCMCommand("\\mbfvarphi", '𝛗', :mathalpha, "mathematical bold small phi"), + :mbfchi => UCMCommand("\\mbfchi", '𝛘', :mathalpha, "mathematical bold small chi"), + :mbfpsi => UCMCommand("\\mbfpsi", '𝛙', :mathalpha, "mathematical bold small psi"), + :mbfomega => UCMCommand("\\mbfomega", '𝛚', :mathalpha, "mathematical bold small omega"), + :mbfpartial => UCMCommand("\\mbfpartial", '𝛛', :mathalpha, "mathematical bold partial differential"), + :mbfepsilon => UCMCommand("\\mbfepsilon", '𝛜', :mathalpha, "mathematical bold varepsilon symbol"), + :mbfvartheta => UCMCommand("\\mbfvartheta", '𝛝', :mathalpha, "mathematical bold theta symbol"), + :mbfvarkappa => UCMCommand("\\mbfvarkappa", '𝛞', :mathalpha, "mathematical bold kappa symbol"), + :mbfphi => UCMCommand("\\mbfphi", '𝛟', :mathalpha, "mathematical bold phi symbol"), + :mbfvarrho => UCMCommand("\\mbfvarrho", '𝛠', :mathalpha, "mathematical bold rho symbol"), + :mbfvarpi => UCMCommand("\\mbfvarpi", '𝛡', :mathalpha, "mathematical bold pi symbol"), + :mitAlpha => UCMCommand("\\mitAlpha", '𝛢', :mathalpha, "mathematical italic capital alpha"), + :mitBeta => UCMCommand("\\mitBeta", '𝛣', :mathalpha, "mathematical italic capital beta"), + :mitGamma => UCMCommand("\\mitGamma", '𝛤', :mathalpha, "mathematical italic capital gamma"), + :mitDelta => UCMCommand("\\mitDelta", '𝛥', :mathalpha, "mathematical italic capital delta"), + :mitEpsilon => UCMCommand("\\mitEpsilon", '𝛦', :mathalpha, "mathematical italic capital epsilon"), + :mitZeta => UCMCommand("\\mitZeta", '𝛧', :mathalpha, "mathematical italic capital zeta"), + :mitEta => UCMCommand("\\mitEta", '𝛨', :mathalpha, "mathematical italic capital eta"), + :mitTheta => UCMCommand("\\mitTheta", '𝛩', :mathalpha, "mathematical italic capital theta"), + :mitIota => UCMCommand("\\mitIota", '𝛪', :mathalpha, "mathematical italic capital iota"), + :mitKappa => UCMCommand("\\mitKappa", '𝛫', :mathalpha, "mathematical italic capital kappa"), + :mitLambda => UCMCommand("\\mitLambda", '𝛬', :mathalpha, "mathematical italic capital lambda"), + :mitMu => UCMCommand("\\mitMu", '𝛭', :mathalpha, "mathematical italic capital mu"), + :mitNu => UCMCommand("\\mitNu", '𝛮', :mathalpha, "mathematical italic capital nu"), + :mitXi => UCMCommand("\\mitXi", '𝛯', :mathalpha, "mathematical italic capital xi"), + :mitOmicron => UCMCommand("\\mitOmicron", '𝛰', :mathalpha, "mathematical italic capital omicron"), + :mitPi => UCMCommand("\\mitPi", '𝛱', :mathalpha, "mathematical italic capital pi"), + :mitRho => UCMCommand("\\mitRho", '𝛲', :mathalpha, "mathematical italic capital rho"), + :mitvarTheta => UCMCommand("\\mitvarTheta", '𝛳', :mathalpha, "mathematical italic capital theta symbol"), + :mitSigma => UCMCommand("\\mitSigma", '𝛴', :mathalpha, "mathematical italic capital sigma"), + :mitTau => UCMCommand("\\mitTau", '𝛵', :mathalpha, "mathematical italic capital tau"), + :mitUpsilon => UCMCommand("\\mitUpsilon", '𝛶', :mathalpha, "mathematical italic capital upsilon"), + :mitPhi => UCMCommand("\\mitPhi", '𝛷', :mathalpha, "mathematical italic capital phi"), + :mitChi => UCMCommand("\\mitChi", '𝛸', :mathalpha, "mathematical italic capital chi"), + :mitPsi => UCMCommand("\\mitPsi", '𝛹', :mathalpha, "mathematical italic capital psi"), + :mitOmega => UCMCommand("\\mitOmega", '𝛺', :mathalpha, "mathematical italic capital omega"), + :mitnabla => UCMCommand("\\mitnabla", '𝛻', :mathalpha, "mathematical italic nabla"), + :mitalpha => UCMCommand("\\mitalpha", '𝛼', :mathalpha, "mathematical italic small alpha"), + :mitbeta => UCMCommand("\\mitbeta", '𝛽', :mathalpha, "mathematical italic small beta"), + :mitgamma => UCMCommand("\\mitgamma", '𝛾', :mathalpha, "mathematical italic small gamma"), + :mitdelta => UCMCommand("\\mitdelta", '𝛿', :mathalpha, "mathematical italic small delta"), + :mitvarepsilon => UCMCommand("\\mitvarepsilon", '𝜀', :mathalpha, "mathematical italic small varepsilon"), + :mitzeta => UCMCommand("\\mitzeta", '𝜁', :mathalpha, "mathematical italic small zeta"), + :miteta => UCMCommand("\\miteta", '𝜂', :mathalpha, "mathematical italic small eta"), + :mittheta => UCMCommand("\\mittheta", '𝜃', :mathalpha, "mathematical italic small theta"), + :mitiota => UCMCommand("\\mitiota", '𝜄', :mathalpha, "mathematical italic small iota"), + :mitkappa => UCMCommand("\\mitkappa", '𝜅', :mathalpha, "mathematical italic small kappa"), + :mitlambda => UCMCommand("\\mitlambda", '𝜆', :mathalpha, "mathematical italic small lambda"), + :mitmu => UCMCommand("\\mitmu", '𝜇', :mathalpha, "mathematical italic small mu"), + :mitnu => UCMCommand("\\mitnu", '𝜈', :mathalpha, "mathematical italic small nu"), + :mitxi => UCMCommand("\\mitxi", '𝜉', :mathalpha, "mathematical italic small xi"), + :mitomicron => UCMCommand("\\mitomicron", '𝜊', :mathalpha, "mathematical italic small omicron"), + :mitpi => UCMCommand("\\mitpi", '𝜋', :mathalpha, "mathematical italic small pi"), + :mitrho => UCMCommand("\\mitrho", '𝜌', :mathalpha, "mathematical italic small rho"), + :mitvarsigma => UCMCommand("\\mitvarsigma", '𝜍', :mathalpha, "mathematical italic small final sigma"), + :mitsigma => UCMCommand("\\mitsigma", '𝜎', :mathalpha, "mathematical italic small sigma"), + :mittau => UCMCommand("\\mittau", '𝜏', :mathalpha, "mathematical italic small tau"), + :mitupsilon => UCMCommand("\\mitupsilon", '𝜐', :mathalpha, "mathematical italic small upsilon"), + :mitvarphi => UCMCommand("\\mitvarphi", '𝜑', :mathalpha, "mathematical italic small phi"), + :mitchi => UCMCommand("\\mitchi", '𝜒', :mathalpha, "mathematical italic small chi"), + :mitpsi => UCMCommand("\\mitpsi", '𝜓', :mathalpha, "mathematical italic small psi"), + :mitomega => UCMCommand("\\mitomega", '𝜔', :mathalpha, "mathematical italic small omega"), + :mitpartial => UCMCommand("\\mitpartial", '𝜕', :mathalpha, "mathematical italic partial differential"), + :mitepsilon => UCMCommand("\\mitepsilon", '𝜖', :mathalpha, "mathematical italic varepsilon symbol"), + :mitvartheta => UCMCommand("\\mitvartheta", '𝜗', :mathalpha, "mathematical italic theta symbol"), + :mitvarkappa => UCMCommand("\\mitvarkappa", '𝜘', :mathalpha, "mathematical italic kappa symbol"), + :mitphi => UCMCommand("\\mitphi", '𝜙', :mathalpha, "mathematical italic phi symbol"), + :mitvarrho => UCMCommand("\\mitvarrho", '𝜚', :mathalpha, "mathematical italic rho symbol"), + :mitvarpi => UCMCommand("\\mitvarpi", '𝜛', :mathalpha, "mathematical italic pi symbol"), + :mbfitAlpha => UCMCommand("\\mbfitAlpha", '𝜜', :mathalpha, "mathematical bold italic capital alpha"), + :mbfitBeta => UCMCommand("\\mbfitBeta", '𝜝', :mathalpha, "mathematical bold italic capital beta"), + :mbfitGamma => UCMCommand("\\mbfitGamma", '𝜞', :mathalpha, "mathematical bold italic capital gamma"), + :mbfitDelta => UCMCommand("\\mbfitDelta", '𝜟', :mathalpha, "mathematical bold italic capital delta"), + :mbfitEpsilon => UCMCommand("\\mbfitEpsilon", '𝜠', :mathalpha, "mathematical bold italic capital epsilon"), + :mbfitZeta => UCMCommand("\\mbfitZeta", '𝜡', :mathalpha, "mathematical bold italic capital zeta"), + :mbfitEta => UCMCommand("\\mbfitEta", '𝜢', :mathalpha, "mathematical bold italic capital eta"), + :mbfitTheta => UCMCommand("\\mbfitTheta", '𝜣', :mathalpha, "mathematical bold italic capital theta"), + :mbfitIota => UCMCommand("\\mbfitIota", '𝜤', :mathalpha, "mathematical bold italic capital iota"), + :mbfitKappa => UCMCommand("\\mbfitKappa", '𝜥', :mathalpha, "mathematical bold italic capital kappa"), + :mbfitLambda => UCMCommand("\\mbfitLambda", '𝜦', :mathalpha, "mathematical bold italic capital lambda"), + :mbfitMu => UCMCommand("\\mbfitMu", '𝜧', :mathalpha, "mathematical bold italic capital mu"), + :mbfitNu => UCMCommand("\\mbfitNu", '𝜨', :mathalpha, "mathematical bold italic capital nu"), + :mbfitXi => UCMCommand("\\mbfitXi", '𝜩', :mathalpha, "mathematical bold italic capital xi"), + :mbfitOmicron => UCMCommand("\\mbfitOmicron", '𝜪', :mathalpha, "mathematical bold italic capital omicron"), + :mbfitPi => UCMCommand("\\mbfitPi", '𝜫', :mathalpha, "mathematical bold italic capital pi"), + :mbfitRho => UCMCommand("\\mbfitRho", '𝜬', :mathalpha, "mathematical bold italic capital rho"), + :mbfitvarTheta => UCMCommand("\\mbfitvarTheta", '𝜭', :mathalpha, "mathematical bold italic capital theta symbol"), + :mbfitSigma => UCMCommand("\\mbfitSigma", '𝜮', :mathalpha, "mathematical bold italic capital sigma"), + :mbfitTau => UCMCommand("\\mbfitTau", '𝜯', :mathalpha, "mathematical bold italic capital tau"), + :mbfitUpsilon => UCMCommand("\\mbfitUpsilon", '𝜰', :mathalpha, "mathematical bold italic capital upsilon"), + :mbfitPhi => UCMCommand("\\mbfitPhi", '𝜱', :mathalpha, "mathematical bold italic capital phi"), + :mbfitChi => UCMCommand("\\mbfitChi", '𝜲', :mathalpha, "mathematical bold italic capital chi"), + :mbfitPsi => UCMCommand("\\mbfitPsi", '𝜳', :mathalpha, "mathematical bold italic capital psi"), + :mbfitOmega => UCMCommand("\\mbfitOmega", '𝜴', :mathalpha, "mathematical bold italic capital omega"), + :mbfitnabla => UCMCommand("\\mbfitnabla", '𝜵', :mathalpha, "mathematical bold italic nabla"), + :mbfitalpha => UCMCommand("\\mbfitalpha", '𝜶', :mathalpha, "mathematical bold italic small alpha"), + :mbfitbeta => UCMCommand("\\mbfitbeta", '𝜷', :mathalpha, "mathematical bold italic small beta"), + :mbfitgamma => UCMCommand("\\mbfitgamma", '𝜸', :mathalpha, "mathematical bold italic small gamma"), + :mbfitdelta => UCMCommand("\\mbfitdelta", '𝜹', :mathalpha, "mathematical bold italic small delta"), + :mbfitvarepsilon => UCMCommand("\\mbfitvarepsilon", '𝜺', :mathalpha, "mathematical bold italic small varepsilon"), + :mbfitzeta => UCMCommand("\\mbfitzeta", '𝜻', :mathalpha, "mathematical bold italic small zeta"), + :mbfiteta => UCMCommand("\\mbfiteta", '𝜼', :mathalpha, "mathematical bold italic small eta"), + :mbfittheta => UCMCommand("\\mbfittheta", '𝜽', :mathalpha, "mathematical bold italic small theta"), + :mbfitiota => UCMCommand("\\mbfitiota", '𝜾', :mathalpha, "mathematical bold italic small iota"), + :mbfitkappa => UCMCommand("\\mbfitkappa", '𝜿', :mathalpha, "mathematical bold italic small kappa"), + :mbfitlambda => UCMCommand("\\mbfitlambda", '𝝀', :mathalpha, "mathematical bold italic small lambda"), + :mbfitmu => UCMCommand("\\mbfitmu", '𝝁', :mathalpha, "mathematical bold italic small mu"), + :mbfitnu => UCMCommand("\\mbfitnu", '𝝂', :mathalpha, "mathematical bold italic small nu"), + :mbfitxi => UCMCommand("\\mbfitxi", '𝝃', :mathalpha, "mathematical bold italic small xi"), + :mbfitomicron => UCMCommand("\\mbfitomicron", '𝝄', :mathalpha, "mathematical bold italic small omicron"), + :mbfitpi => UCMCommand("\\mbfitpi", '𝝅', :mathalpha, "mathematical bold italic small pi"), + :mbfitrho => UCMCommand("\\mbfitrho", '𝝆', :mathalpha, "mathematical bold italic small rho"), + :mbfitvarsigma => UCMCommand("\\mbfitvarsigma", '𝝇', :mathalpha, "mathematical bold italic small final sigma"), + :mbfitsigma => UCMCommand("\\mbfitsigma", '𝝈', :mathalpha, "mathematical bold italic small sigma"), + :mbfittau => UCMCommand("\\mbfittau", '𝝉', :mathalpha, "mathematical bold italic small tau"), + :mbfitupsilon => UCMCommand("\\mbfitupsilon", '𝝊', :mathalpha, "mathematical bold italic small upsilon"), + :mbfitvarphi => UCMCommand("\\mbfitvarphi", '𝝋', :mathalpha, "mathematical bold italic small phi"), + :mbfitchi => UCMCommand("\\mbfitchi", '𝝌', :mathalpha, "mathematical bold italic small chi"), + :mbfitpsi => UCMCommand("\\mbfitpsi", '𝝍', :mathalpha, "mathematical bold italic small psi"), + :mbfitomega => UCMCommand("\\mbfitomega", '𝝎', :mathalpha, "mathematical bold italic small omega"), + :mbfitpartial => UCMCommand("\\mbfitpartial", '𝝏', :mathalpha, "mathematical bold italic partial differential"), + :mbfitepsilon => UCMCommand("\\mbfitepsilon", '𝝐', :mathalpha, "mathematical bold italic varepsilon symbol"), + :mbfitvartheta => UCMCommand("\\mbfitvartheta", '𝝑', :mathalpha, "mathematical bold italic theta symbol"), + :mbfitvarkappa => UCMCommand("\\mbfitvarkappa", '𝝒', :mathalpha, "mathematical bold italic kappa symbol"), + :mbfitphi => UCMCommand("\\mbfitphi", '𝝓', :mathalpha, "mathematical bold italic phi symbol"), + :mbfitvarrho => UCMCommand("\\mbfitvarrho", '𝝔', :mathalpha, "mathematical bold italic rho symbol"), + :mbfitvarpi => UCMCommand("\\mbfitvarpi", '𝝕', :mathalpha, "mathematical bold italic pi symbol"), + :mbfsansAlpha => UCMCommand("\\mbfsansAlpha", '𝝖', :mathalpha, "mathematical sans-serif bold capital alpha"), + :mbfsansBeta => UCMCommand("\\mbfsansBeta", '𝝗', :mathalpha, "mathematical sans-serif bold capital beta"), + :mbfsansGamma => UCMCommand("\\mbfsansGamma", '𝝘', :mathalpha, "mathematical sans-serif bold capital gamma"), + :mbfsansDelta => UCMCommand("\\mbfsansDelta", '𝝙', :mathalpha, "mathematical sans-serif bold capital delta"), + :mbfsansEpsilon => UCMCommand("\\mbfsansEpsilon", '𝝚', :mathalpha, "mathematical sans-serif bold capital epsilon"), + :mbfsansZeta => UCMCommand("\\mbfsansZeta", '𝝛', :mathalpha, "mathematical sans-serif bold capital zeta"), + :mbfsansEta => UCMCommand("\\mbfsansEta", '𝝜', :mathalpha, "mathematical sans-serif bold capital eta"), + :mbfsansTheta => UCMCommand("\\mbfsansTheta", '𝝝', :mathalpha, "mathematical sans-serif bold capital theta"), + :mbfsansIota => UCMCommand("\\mbfsansIota", '𝝞', :mathalpha, "mathematical sans-serif bold capital iota"), + :mbfsansKappa => UCMCommand("\\mbfsansKappa", '𝝟', :mathalpha, "mathematical sans-serif bold capital kappa"), + :mbfsansLambda => UCMCommand("\\mbfsansLambda", '𝝠', :mathalpha, "mathematical sans-serif bold capital lambda"), + :mbfsansMu => UCMCommand("\\mbfsansMu", '𝝡', :mathalpha, "mathematical sans-serif bold capital mu"), + :mbfsansNu => UCMCommand("\\mbfsansNu", '𝝢', :mathalpha, "mathematical sans-serif bold capital nu"), + :mbfsansXi => UCMCommand("\\mbfsansXi", '𝝣', :mathalpha, "mathematical sans-serif bold capital xi"), + :mbfsansOmicron => UCMCommand("\\mbfsansOmicron", '𝝤', :mathalpha, "mathematical sans-serif bold capital omicron"), + :mbfsansPi => UCMCommand("\\mbfsansPi", '𝝥', :mathalpha, "mathematical sans-serif bold capital pi"), + :mbfsansRho => UCMCommand("\\mbfsansRho", '𝝦', :mathalpha, "mathematical sans-serif bold capital rho"), + :mbfsansvarTheta => UCMCommand("\\mbfsansvarTheta", '𝝧', :mathalpha, "mathematical sans-serif bold capital theta symbol"), + :mbfsansSigma => UCMCommand("\\mbfsansSigma", '𝝨', :mathalpha, "mathematical sans-serif bold capital sigma"), + :mbfsansTau => UCMCommand("\\mbfsansTau", '𝝩', :mathalpha, "mathematical sans-serif bold capital tau"), + :mbfsansUpsilon => UCMCommand("\\mbfsansUpsilon", '𝝪', :mathalpha, "mathematical sans-serif bold capital upsilon"), + :mbfsansPhi => UCMCommand("\\mbfsansPhi", '𝝫', :mathalpha, "mathematical sans-serif bold capital phi"), + :mbfsansChi => UCMCommand("\\mbfsansChi", '𝝬', :mathalpha, "mathematical sans-serif bold capital chi"), + :mbfsansPsi => UCMCommand("\\mbfsansPsi", '𝝭', :mathalpha, "mathematical sans-serif bold capital psi"), + :mbfsansOmega => UCMCommand("\\mbfsansOmega", '𝝮', :mathalpha, "mathematical sans-serif bold capital omega"), + :mbfsansnabla => UCMCommand("\\mbfsansnabla", '𝝯', :mathalpha, "mathematical sans-serif bold nabla"), + :mbfsansalpha => UCMCommand("\\mbfsansalpha", '𝝰', :mathalpha, "mathematical sans-serif bold small alpha"), + :mbfsansbeta => UCMCommand("\\mbfsansbeta", '𝝱', :mathalpha, "mathematical sans-serif bold small beta"), + :mbfsansgamma => UCMCommand("\\mbfsansgamma", '𝝲', :mathalpha, "mathematical sans-serif bold small gamma"), + :mbfsansdelta => UCMCommand("\\mbfsansdelta", '𝝳', :mathalpha, "mathematical sans-serif bold small delta"), + :mbfsansvarepsilon => UCMCommand("\\mbfsansvarepsilon", '𝝴', :mathalpha, "mathematical sans-serif bold small varepsilon"), + :mbfsanszeta => UCMCommand("\\mbfsanszeta", '𝝵', :mathalpha, "mathematical sans-serif bold small zeta"), + :mbfsanseta => UCMCommand("\\mbfsanseta", '𝝶', :mathalpha, "mathematical sans-serif bold small eta"), + :mbfsanstheta => UCMCommand("\\mbfsanstheta", '𝝷', :mathalpha, "mathematical sans-serif bold small theta"), + :mbfsansiota => UCMCommand("\\mbfsansiota", '𝝸', :mathalpha, "mathematical sans-serif bold small iota"), + :mbfsanskappa => UCMCommand("\\mbfsanskappa", '𝝹', :mathalpha, "mathematical sans-serif bold small kappa"), + :mbfsanslambda => UCMCommand("\\mbfsanslambda", '𝝺', :mathalpha, "mathematical sans-serif bold small lambda"), + :mbfsansmu => UCMCommand("\\mbfsansmu", '𝝻', :mathalpha, "mathematical sans-serif bold small mu"), + :mbfsansnu => UCMCommand("\\mbfsansnu", '𝝼', :mathalpha, "mathematical sans-serif bold small nu"), + :mbfsansxi => UCMCommand("\\mbfsansxi", '𝝽', :mathalpha, "mathematical sans-serif bold small xi"), + :mbfsansomicron => UCMCommand("\\mbfsansomicron", '𝝾', :mathalpha, "mathematical sans-serif bold small omicron"), + :mbfsanspi => UCMCommand("\\mbfsanspi", '𝝿', :mathalpha, "mathematical sans-serif bold small pi"), + :mbfsansrho => UCMCommand("\\mbfsansrho", '𝞀', :mathalpha, "mathematical sans-serif bold small rho"), + :mbfsansvarsigma => UCMCommand("\\mbfsansvarsigma", '𝞁', :mathalpha, "mathematical sans-serif bold small final sigma"), + :mbfsanssigma => UCMCommand("\\mbfsanssigma", '𝞂', :mathalpha, "mathematical sans-serif bold small sigma"), + :mbfsanstau => UCMCommand("\\mbfsanstau", '𝞃', :mathalpha, "mathematical sans-serif bold small tau"), + :mbfsansupsilon => UCMCommand("\\mbfsansupsilon", '𝞄', :mathalpha, "mathematical sans-serif bold small upsilon"), + :mbfsansvarphi => UCMCommand("\\mbfsansvarphi", '𝞅', :mathalpha, "mathematical sans-serif bold small phi"), + :mbfsanschi => UCMCommand("\\mbfsanschi", '𝞆', :mathalpha, "mathematical sans-serif bold small chi"), + :mbfsanspsi => UCMCommand("\\mbfsanspsi", '𝞇', :mathalpha, "mathematical sans-serif bold small psi"), + :mbfsansomega => UCMCommand("\\mbfsansomega", '𝞈', :mathalpha, "mathematical sans-serif bold small omega"), + :mbfsanspartial => UCMCommand("\\mbfsanspartial", '𝞉', :mathalpha, "mathematical sans-serif bold partial differential"), + :mbfsansepsilon => UCMCommand("\\mbfsansepsilon", '𝞊', :mathalpha, "mathematical sans-serif bold varepsilon symbol"), + :mbfsansvartheta => UCMCommand("\\mbfsansvartheta", '𝞋', :mathalpha, "mathematical sans-serif bold theta symbol"), + :mbfsansvarkappa => UCMCommand("\\mbfsansvarkappa", '𝞌', :mathalpha, "mathematical sans-serif bold kappa symbol"), + :mbfsansphi => UCMCommand("\\mbfsansphi", '𝞍', :mathalpha, "mathematical sans-serif bold phi symbol"), + :mbfsansvarrho => UCMCommand("\\mbfsansvarrho", '𝞎', :mathalpha, "mathematical sans-serif bold rho symbol"), + :mbfsansvarpi => UCMCommand("\\mbfsansvarpi", '𝞏', :mathalpha, "mathematical sans-serif bold pi symbol"), + :mbfitsansAlpha => UCMCommand("\\mbfitsansAlpha", '𝞐', :mathalpha, "mathematical sans-serif bold italic capital alpha"), + :mbfitsansBeta => UCMCommand("\\mbfitsansBeta", '𝞑', :mathalpha, "mathematical sans-serif bold italic capital beta"), + :mbfitsansGamma => UCMCommand("\\mbfitsansGamma", '𝞒', :mathalpha, "mathematical sans-serif bold italic capital gamma"), + :mbfitsansDelta => UCMCommand("\\mbfitsansDelta", '𝞓', :mathalpha, "mathematical sans-serif bold italic capital delta"), + :mbfitsansEpsilon => UCMCommand("\\mbfitsansEpsilon", '𝞔', :mathalpha, "mathematical sans-serif bold italic capital epsilon"), + :mbfitsansZeta => UCMCommand("\\mbfitsansZeta", '𝞕', :mathalpha, "mathematical sans-serif bold italic capital zeta"), + :mbfitsansEta => UCMCommand("\\mbfitsansEta", '𝞖', :mathalpha, "mathematical sans-serif bold italic capital eta"), + :mbfitsansTheta => UCMCommand("\\mbfitsansTheta", '𝞗', :mathalpha, "mathematical sans-serif bold italic capital theta"), + :mbfitsansIota => UCMCommand("\\mbfitsansIota", '𝞘', :mathalpha, "mathematical sans-serif bold italic capital iota"), + :mbfitsansKappa => UCMCommand("\\mbfitsansKappa", '𝞙', :mathalpha, "mathematical sans-serif bold italic capital kappa"), + :mbfitsansLambda => UCMCommand("\\mbfitsansLambda", '𝞚', :mathalpha, "mathematical sans-serif bold italic capital lambda"), + :mbfitsansMu => UCMCommand("\\mbfitsansMu", '𝞛', :mathalpha, "mathematical sans-serif bold italic capital mu"), + :mbfitsansNu => UCMCommand("\\mbfitsansNu", '𝞜', :mathalpha, "mathematical sans-serif bold italic capital nu"), + :mbfitsansXi => UCMCommand("\\mbfitsansXi", '𝞝', :mathalpha, "mathematical sans-serif bold italic capital xi"), + :mbfitsansOmicron => UCMCommand("\\mbfitsansOmicron", '𝞞', :mathalpha, "mathematical sans-serif bold italic capital omicron"), + :mbfitsansPi => UCMCommand("\\mbfitsansPi", '𝞟', :mathalpha, "mathematical sans-serif bold italic capital pi"), + :mbfitsansRho => UCMCommand("\\mbfitsansRho", '𝞠', :mathalpha, "mathematical sans-serif bold italic capital rho"), + :mbfitsansvarTheta => UCMCommand("\\mbfitsansvarTheta", '𝞡', :mathalpha, "mathematical sans-serif bold italic capital theta symbol"), + :mbfitsansSigma => UCMCommand("\\mbfitsansSigma", '𝞢', :mathalpha, "mathematical sans-serif bold italic capital sigma"), + :mbfitsansTau => UCMCommand("\\mbfitsansTau", '𝞣', :mathalpha, "mathematical sans-serif bold italic capital tau"), + :mbfitsansUpsilon => UCMCommand("\\mbfitsansUpsilon", '𝞤', :mathalpha, "mathematical sans-serif bold italic capital upsilon"), + :mbfitsansPhi => UCMCommand("\\mbfitsansPhi", '𝞥', :mathalpha, "mathematical sans-serif bold italic capital phi"), + :mbfitsansChi => UCMCommand("\\mbfitsansChi", '𝞦', :mathalpha, "mathematical sans-serif bold italic capital chi"), + :mbfitsansPsi => UCMCommand("\\mbfitsansPsi", '𝞧', :mathalpha, "mathematical sans-serif bold italic capital psi"), + :mbfitsansOmega => UCMCommand("\\mbfitsansOmega", '𝞨', :mathalpha, "mathematical sans-serif bold italic capital omega"), + :mbfitsansnabla => UCMCommand("\\mbfitsansnabla", '𝞩', :mathalpha, "mathematical sans-serif bold italic nabla"), + :mbfitsansalpha => UCMCommand("\\mbfitsansalpha", '𝞪', :mathalpha, "mathematical sans-serif bold italic small alpha"), + :mbfitsansbeta => UCMCommand("\\mbfitsansbeta", '𝞫', :mathalpha, "mathematical sans-serif bold italic small beta"), + :mbfitsansgamma => UCMCommand("\\mbfitsansgamma", '𝞬', :mathalpha, "mathematical sans-serif bold italic small gamma"), + :mbfitsansdelta => UCMCommand("\\mbfitsansdelta", '𝞭', :mathalpha, "mathematical sans-serif bold italic small delta"), + :mbfitsansvarepsilon => UCMCommand("\\mbfitsansvarepsilon", '𝞮', :mathalpha, "mathematical sans-serif bold italic small varepsilon"), + :mbfitsanszeta => UCMCommand("\\mbfitsanszeta", '𝞯', :mathalpha, "mathematical sans-serif bold italic small zeta"), + :mbfitsanseta => UCMCommand("\\mbfitsanseta", '𝞰', :mathalpha, "mathematical sans-serif bold italic small eta"), + :mbfitsanstheta => UCMCommand("\\mbfitsanstheta", '𝞱', :mathalpha, "mathematical sans-serif bold italic small theta"), + :mbfitsansiota => UCMCommand("\\mbfitsansiota", '𝞲', :mathalpha, "mathematical sans-serif bold italic small iota"), + :mbfitsanskappa => UCMCommand("\\mbfitsanskappa", '𝞳', :mathalpha, "mathematical sans-serif bold italic small kappa"), + :mbfitsanslambda => UCMCommand("\\mbfitsanslambda", '𝞴', :mathalpha, "mathematical sans-serif bold italic small lambda"), + :mbfitsansmu => UCMCommand("\\mbfitsansmu", '𝞵', :mathalpha, "mathematical sans-serif bold italic small mu"), + :mbfitsansnu => UCMCommand("\\mbfitsansnu", '𝞶', :mathalpha, "mathematical sans-serif bold italic small nu"), + :mbfitsansxi => UCMCommand("\\mbfitsansxi", '𝞷', :mathalpha, "mathematical sans-serif bold italic small xi"), + :mbfitsansomicron => UCMCommand("\\mbfitsansomicron", '𝞸', :mathalpha, "mathematical sans-serif bold italic small omicron"), + :mbfitsanspi => UCMCommand("\\mbfitsanspi", '𝞹', :mathalpha, "mathematical sans-serif bold italic small pi"), + :mbfitsansrho => UCMCommand("\\mbfitsansrho", '𝞺', :mathalpha, "mathematical sans-serif bold italic small rho"), + :mbfitsansvarsigma => UCMCommand("\\mbfitsansvarsigma", '𝞻', :mathalpha, "mathematical sans-serif bold italic small final sigma"), + :mbfitsanssigma => UCMCommand("\\mbfitsanssigma", '𝞼', :mathalpha, "mathematical sans-serif bold italic small sigma"), + :mbfitsanstau => UCMCommand("\\mbfitsanstau", '𝞽', :mathalpha, "mathematical sans-serif bold italic small tau"), + :mbfitsansupsilon => UCMCommand("\\mbfitsansupsilon", '𝞾', :mathalpha, "mathematical sans-serif bold italic small upsilon"), + :mbfitsansvarphi => UCMCommand("\\mbfitsansvarphi", '𝞿', :mathalpha, "mathematical sans-serif bold italic small phi"), + :mbfitsanschi => UCMCommand("\\mbfitsanschi", '𝟀', :mathalpha, "mathematical sans-serif bold italic small chi"), + :mbfitsanspsi => UCMCommand("\\mbfitsanspsi", '𝟁', :mathalpha, "mathematical sans-serif bold italic small psi"), + :mbfitsansomega => UCMCommand("\\mbfitsansomega", '𝟂', :mathalpha, "mathematical sans-serif bold italic small omega"), + :mbfitsanspartial => UCMCommand("\\mbfitsanspartial", '𝟃', :mathalpha, "mathematical sans-serif bold italic partial differential"), + :mbfitsansepsilon => UCMCommand("\\mbfitsansepsilon", '𝟄', :mathalpha, "mathematical sans-serif bold italic varepsilon symbol"), + :mbfitsansvartheta => UCMCommand("\\mbfitsansvartheta", '𝟅', :mathalpha, "mathematical sans-serif bold italic theta symbol"), + :mbfitsansvarkappa => UCMCommand("\\mbfitsansvarkappa", '𝟆', :mathalpha, "mathematical sans-serif bold italic kappa symbol"), + :mbfitsansphi => UCMCommand("\\mbfitsansphi", '𝟇', :mathalpha, "mathematical sans-serif bold italic phi symbol"), + :mbfitsansvarrho => UCMCommand("\\mbfitsansvarrho", '𝟈', :mathalpha, "mathematical sans-serif bold italic rho symbol"), + :mbfitsansvarpi => UCMCommand("\\mbfitsansvarpi", '𝟉', :mathalpha, "mathematical sans-serif bold italic pi symbol"), + :mbfDigamma => UCMCommand("\\mbfDigamma", '𝟊', :mathalpha, "mathematical bold capital digamma"), + :mbfdigamma => UCMCommand("\\mbfdigamma", '𝟋', :mathalpha, "mathematical bold small digamma"), + :mbfzero => UCMCommand("\\mbfzero", '𝟎', :mathord, "mathematical bold digit 0"), + :mbfone => UCMCommand("\\mbfone", '𝟏', :mathord, "mathematical bold digit 1"), + :mbftwo => UCMCommand("\\mbftwo", '𝟐', :mathord, "mathematical bold digit 2"), + :mbfthree => UCMCommand("\\mbfthree", '𝟑', :mathord, "mathematical bold digit 3"), + :mbffour => UCMCommand("\\mbffour", '𝟒', :mathord, "mathematical bold digit 4"), + :mbffive => UCMCommand("\\mbffive", '𝟓', :mathord, "mathematical bold digit 5"), + :mbfsix => UCMCommand("\\mbfsix", '𝟔', :mathord, "mathematical bold digit 6"), + :mbfseven => UCMCommand("\\mbfseven", '𝟕', :mathord, "mathematical bold digit 7"), + :mbfeight => UCMCommand("\\mbfeight", '𝟖', :mathord, "mathematical bold digit 8"), + :mbfnine => UCMCommand("\\mbfnine", '𝟗', :mathord, "mathematical bold digit 9"), + :Bbbzero => UCMCommand("\\Bbbzero", '𝟘', :mathord, "mathematical double-struck digit 0"), + :Bbbone => UCMCommand("\\Bbbone", '𝟙', :mathord, "mathematical double-struck digit 1"), + :Bbbtwo => UCMCommand("\\Bbbtwo", '𝟚', :mathord, "mathematical double-struck digit 2"), + :Bbbthree => UCMCommand("\\Bbbthree", '𝟛', :mathord, "mathematical double-struck digit 3"), + :Bbbfour => UCMCommand("\\Bbbfour", '𝟜', :mathord, "mathematical double-struck digit 4"), + :Bbbfive => UCMCommand("\\Bbbfive", '𝟝', :mathord, "mathematical double-struck digit 5"), + :Bbbsix => UCMCommand("\\Bbbsix", '𝟞', :mathord, "mathematical double-struck digit 6"), + :Bbbseven => UCMCommand("\\Bbbseven", '𝟟', :mathord, "mathematical double-struck digit 7"), + :Bbbeight => UCMCommand("\\Bbbeight", '𝟠', :mathord, "mathematical double-struck digit 8"), + :Bbbnine => UCMCommand("\\Bbbnine", '𝟡', :mathord, "mathematical double-struck digit 9"), + :msanszero => UCMCommand("\\msanszero", '𝟢', :mathord, "mathematical sans-serif digit 0"), + :msansone => UCMCommand("\\msansone", '𝟣', :mathord, "mathematical sans-serif digit 1"), + :msanstwo => UCMCommand("\\msanstwo", '𝟤', :mathord, "mathematical sans-serif digit 2"), + :msansthree => UCMCommand("\\msansthree", '𝟥', :mathord, "mathematical sans-serif digit 3"), + :msansfour => UCMCommand("\\msansfour", '𝟦', :mathord, "mathematical sans-serif digit 4"), + :msansfive => UCMCommand("\\msansfive", '𝟧', :mathord, "mathematical sans-serif digit 5"), + :msanssix => UCMCommand("\\msanssix", '𝟨', :mathord, "mathematical sans-serif digit 6"), + :msansseven => UCMCommand("\\msansseven", '𝟩', :mathord, "mathematical sans-serif digit 7"), + :msanseight => UCMCommand("\\msanseight", '𝟪', :mathord, "mathematical sans-serif digit 8"), + :msansnine => UCMCommand("\\msansnine", '𝟫', :mathord, "mathematical sans-serif digit 9"), + :mbfsanszero => UCMCommand("\\mbfsanszero", '𝟬', :mathord, "mathematical sans-serif bold digit 0"), + :mbfsansone => UCMCommand("\\mbfsansone", '𝟭', :mathord, "mathematical sans-serif bold digit 1"), + :mbfsanstwo => UCMCommand("\\mbfsanstwo", '𝟮', :mathord, "mathematical sans-serif bold digit 2"), + :mbfsansthree => UCMCommand("\\mbfsansthree", '𝟯', :mathord, "mathematical sans-serif bold digit 3"), + :mbfsansfour => UCMCommand("\\mbfsansfour", '𝟰', :mathord, "mathematical sans-serif bold digit 4"), + :mbfsansfive => UCMCommand("\\mbfsansfive", '𝟱', :mathord, "mathematical sans-serif bold digit 5"), + :mbfsanssix => UCMCommand("\\mbfsanssix", '𝟲', :mathord, "mathematical sans-serif bold digit 6"), + :mbfsansseven => UCMCommand("\\mbfsansseven", '𝟳', :mathord, "mathematical sans-serif bold digit 7"), + :mbfsanseight => UCMCommand("\\mbfsanseight", '𝟴', :mathord, "mathematical sans-serif bold digit 8"), + :mbfsansnine => UCMCommand("\\mbfsansnine", '𝟵', :mathord, "mathematical sans-serif bold digit 9"), + :mttzero => UCMCommand("\\mttzero", '𝟶', :mathord, "mathematical monospace digit 0"), + :mttone => UCMCommand("\\mttone", '𝟷', :mathord, "mathematical monospace digit 1"), + :mtttwo => UCMCommand("\\mtttwo", '𝟸', :mathord, "mathematical monospace digit 2"), + :mttthree => UCMCommand("\\mttthree", '𝟹', :mathord, "mathematical monospace digit 3"), + :mttfour => UCMCommand("\\mttfour", '𝟺', :mathord, "mathematical monospace digit 4"), + :mttfive => UCMCommand("\\mttfive", '𝟻', :mathord, "mathematical monospace digit 5"), + :mttsix => UCMCommand("\\mttsix", '𝟼', :mathord, "mathematical monospace digit 6"), + :mttseven => UCMCommand("\\mttseven", '𝟽', :mathord, "mathematical monospace digit 7"), + :mtteight => UCMCommand("\\mtteight", '𝟾', :mathord, "mathematical monospace digit 8"), + :mttnine => UCMCommand("\\mttnine", '𝟿', :mathord, "mathematical monospace digit 9"), + :arabicmaj => UCMCommand("\\arabicmaj", '𞻰', :mathop, "arabic mathematical operator meem with hah with tatweel"), + :arabichad => UCMCommand("\\arabichad", '𞻱', :mathop, "arabic mathematical operator hah with dal"), +) \ No newline at end of file diff --git a/src/UnicodeMath/src/ucmchars.jl b/src/UnicodeMath/src/ucmchars.jl new file mode 100644 index 0000000..ba15fab --- /dev/null +++ b/src/UnicodeMath/src/ucmchars.jl @@ -0,0 +1,413 @@ +# This file takes inspiration from source file `um-code-usv.dtx` +# of the UNICODE-MATH package + +# We generate two mappings in here: +# +# `const ucmchars_by_alphabet_style_name = all_chars()` +# +# `ucmchars_by_alphabet_style_name` is a dict-of-dict-of-dict (?) +# * alphabet (:Greek, :greek, :Latin, …) +# => style (:up, :bfup, …) +# => name ("a", "Gamma", "1", … ) +# => ucm_ch::UCMChar +# +# `const chars_to_ucmchars = inverse_ucm_dict(ucmchars_by_alphabet_style_name)` +# +# `chars_to_ucmchars` is an inverse look-up dict, mapping +# glyphs of type `Char` to UCMChars (if they are defined in `ucmchars_by_alphabet_style_name`) + +""" + UCMChar(; name, alphabet, style, glyph) + +Internal type decorating a `glyph::Char` with meta data.""" +Base.@kwdef struct UCMChar + name :: String + alphabet :: Symbol + style :: Symbol + glyph :: Char +end + +function Base.show(io::IO, ucmchar::UCMChar) + print(io, "UCMChar('$(ucmchar.glyph)')") +end + +## helper: "theta" ↦ "Theta", "vartheta" ↦ "varTheta" … +_cap(n) = startswith(n, "var") ? "var" * uppercasefirst(n[4:end]) : uppercasefirst(n) +## helper: "Theta" ↦ "theta", "varTheta" ↦ "vartheta" … +_decap(n) = startswith(n, "var") ? "var" * lowercasefirst(n[4:end]) : lowercasefirst(n) + +# ## Greek Alphabet +const names_Greek = ( + "Alpha", "Beta", "Gamma", "Delta", "Epsilon", + "Zeta", "Eta", "Theta", "Iota", "Kappa", + "Lambda", "Mu", "Nu", "Xi", "Omicron", + "Pi", "Rho", "varTheta", "Sigma", "Tau", + "Upsilon", "Phi", "Chi", "Psi", "Omega", +) + +## starting indices for glyph ranges in unicode +const usv_Greek = Dict( + :up => 0x391, + :it => 0x1D6E2, + :bfup => 0x1D6A8, + :bfit => 0x1D71C, + :bfsfup => 0x1D756, + :bfsfit => 0x1D790 +) + +## additional glyphs +const extras_Greek = Dict( + :up => Dict( + "varTheta" => 0x3F4, + "Digamma" => 0x3DC, + ), + :bfup => Dict( + "varTheta" => 0x1D6B9, + "Digamma" => 0x1D7CA, + ), + :it => Dict( + "varTheta" => 0x1D6F3, + ), + :bfit => Dict( + "varTheta" => 0x1D72D, + ), + :bfsfit => Dict( + "varTheta" => 0x1D7A1, + ), + :bb => Dict( + "Gamma" => 0x213E, + "Pi" => 0x0213F, + ) +) + +# ## greek Alphabet + +## generate lowercase names +const names_greek = begin + ng = _decap.(names_Greek) |> collect + + # rename according to LaTeX conventions: + for i in eachindex(ng) + if ng[i] == "phi" || ng[i] == "epsilon" + ng[i] = "var" * ng[i] + end + end + tuple(ng...) +end + +const usv_greek = Dict( + :up => 0x3B1, + :it => 0x1D6FC, + :bfup => 0x1D6C2, + :bfit => 0x1D736, + :bfsfup => 0x1D770, + :bfsfit => 0x1D7AA, +) + +const extras_greek = Dict( + :up => Dict( + "epsilon" => 0x3F5, + "vartheta" => 0x3D1, + "varkappa" => 0x3F0, + "phi" => 0x3D5, + "varrho" => 0x3F1, + "varpi" => 0x3D6, + "digamma" => 0x3DD, + ), + :it => Dict( + "epsilon" => 0x1D716, + "vartheta" => 0x1D717, + "varkappa" => 0x1D718, + "phi" => 0x1D719, + "varrho" => 0x1D71A, + "varpi" => 0x1D71B, + ), + :bfit => Dict( + "epsilon" => 0x1D750, + "vartheta" => 0x1D751, + "varkappa" => 0x1D752, + "phi" => 0x1D753, + "varrho" => 0x1D754, + "varpi" => 0x1D755, + ), + :bfup => Dict( + "epsilon" => 0x1D6DC, + "vartheta" => 0x1D6DD, + "varkappa" => 0x1D6DE, + "phi" => 0x1D6DF, + "varrho" => 0x1D6E0, + "varpi" => 0x1D6E1, + "digamma" => 0x1D7CB, + ), + :bfsfup => Dict( + "epsilon" => 0x1D78A, + "vartheta" => 0x1D78B, + "varkappa" => 0x1D78C, + "phi" => 0x1D78D, + "varrho" => 0x1D78E, + "varpi" => 0x1D78F, + ), + :bfsfit => Dict( + "epsilon" => 0x1D7C4, + "vartheta" => 0x1D7C5, + "varkappa" => 0x1D7C6, + "phi" => 0x1D7C7, + "varrho" => 0x1D7C8, + "varpi" => 0x1D7C9, + ), + :bb => Dict( + "gamma" => 0x0213D, + "pi" => 0x0213C, + ) +) + +# ## Latin +const names_Latin = ( + "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", + "S", "T", "U", "V", "W", "X", "Y", "Z" +) + +const usv_Latin = Dict( + :up => 65, + :it => 0x1D434, + :bb => 0x1D538, + :cal => 0x1D49C, + :frak => 0x1D504, + :sfup => 0x1D5A0, + :sfit => 0x1D608, + :tt => 0x1D670, + :bfup => 0x1D400, + :bfit => 0x1D468, + :bffrak => 0x1D56C, + :bfcal => 0x1D4D0, + :bfsfup => 0x1D5D4, + :bfsfit => 0x1D63C, +) + +extras_Latin = Dict( + :cal => Dict( + "B" => 0x212C, + "E" => 0x2130, + "F" => 0x2131, + "H" => 0x210B, + "I" => 0x2110, + "L" => 0x2112, + "M" => 0x2133, + "R" => 0x211B, + ), + :bb => Dict( + "C" => 0x2102, + "H" => 0x210D, + "N" => 0x2115, + "P" => 0x2119, + "Q" => 0x211A, + "R" => 0x211D, + "Z" => 0x2124, + ), + :frak => Dict( + "C" => 0x212D, + "H" => 0x210C, + "I" => 0x2111, + "R" => 0x211C, + "Z" => 0x2128, + ), + :bbit => Dict( + "D" => 0x2145 + ) +) + +# ## latin Alphabet +const names_latin = _decap.(names_Latin) + +const extras_latin = Dict( + :cal => Dict( + "e" => 0x212F, + "g" => 0x210A, + "o" => 0x2134 + ), + :it => Dict( + "h" => 0x0210E, + ), + :bbit => Dict( + "d" => 0x2146, + "e" => 0x2147, + "i" => 0x2148, + "j" => 0x2149, + ) +) +const usv_latin = Dict( + :up => 97, + :it => 0x1D44E, + :bb => 0x1D552, + :cal => 0x1D4B6, + :frak => 0x1D51E, + :sfup => 0x1D5BA, + :sfit => 0x1D622, + :tt => 0x1D68A, + :bfup => 0x1D41A, + :bfit => 0x1D482, + :bffrak => 0x1D586, + :bfcal => 0x1D4EA, + :bfsfup => 0x1D5EE, + :bfsfit => 0x1D656 +) + +# ## Numbers +const names_num = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9") +const usv_num = Dict( + :up => 48, + :bb => 0x1D7D8, + :sfup => 0x1D7E2, + :tt => 0x1D7F6, + :bfup => 0x1D7CE, + :bfsfup => 0x1D7EC +) + +# ## Singletons +# ### partial +const names_partial = ("partial",) +const usv_partial = Dict( + :up => 0x02202, + :it => 0x1D715, + :bfup => 0x1D6DB, + :bfit => 0x1D74F, + :bfsfup => 0x1D789, + :bfsfit => 0x1D7C3, +) +# ### Nabla +const names_Nabla = ("Nabla",) +const usv_Nabla = Dict( + :up => 0x02207, + :it => 0x1D6FB, + :bfup => 0x1D6C1, + :bfit => 0x1D735, + :bfsfup => 0x1D76F, + :bfsfit => 0x1D7A9, +) + +# ### dotless +const names_dotless = ("dotlessi", "dotlessj") +const usv_dotless = Dict( + :up => 0x00131, + :it => 0x1D6A4 +) +const extras_dotless = Dict( + :up => Dict( + "dotlessj" => 0x00237, + ), + :it => Dict( + "dotlessi" => 0x1D6A4, + ) +) + +const ucmchars_dotless = Dict( + :up => Dict( + "dotlessi" => UCMChar(; name="dotlessi", glyph=Char(0x00131), alphabet=:dotless, style=:up), + "dotlessj" => UCMChar(; name="dotlessi", glyph=Char(0x00237), alphabet=:dotless, style=:up) + ), + :it => Dict( + "dotlessi" => UCMChar(; name="dotlessi", glyph=Char(0x1D6A4), alphabet=:dotless, style=:it), + "dotlessj" => UCMChar(; name="dotlessi", glyph=Char(0x1D6A5), alphabet=:dotless, style=:it), + ) +) + +""" + all_ucmchars() + +Internal helper function to generate/collect all nested dict of available `UCMChars`.""" +function all_ucmchars() + global ucmchars_dotless + ucmchars_Greek = collect_ucmchars(names_Greek, usv_Greek, extras_Greek; alphabet=:Greek) + ucmchars_greek = collect_ucmchars(names_greek, usv_greek, extras_greek; alphabet=:greek) + + ucmchars_Latin = collect_ucmchars(names_Latin, usv_Latin, extras_Latin; alphabet=:Latin) + ucmchars_latin = collect_ucmchars(names_latin, usv_latin, extras_latin; alphabet=:latin) + ucmchars_num = collect_ucmchars(names_num, usv_num; alphabet=:num) + + ucmchars_Nabla = collect_ucmchars(names_Nabla, usv_Nabla; alphabet=:Nabla) + ucmchars_partial = collect_ucmchars(names_partial, usv_partial; alphabet=:partial) + + return Dict( + :Greek => ucmchars_Greek, + :greek => ucmchars_greek, + :Latin => ucmchars_Latin, + :latin => ucmchars_latin, + :num => ucmchars_num, + :Nabla => ucmchars_Nabla, + :partial => ucmchars_partial, + :dotless => ucmchars_dotless + ) +end + +""" + collect_ucmchars( + char_names, usv_dict, extras_dict=Dict(); + alphabet, fixes=Dict()) + +Given a vector of character names `char_names::AbstractVector{String}`, +and a dictionary mapping style symbols (`:up`, `:it`) to unicode points, +collect all the glyphs as `UCMChar` objects. +The returned dict has structure `Dict(style_symb => Dict(name => ucm_char))`. + +* `fixes` is a global `Char`-to-`Char` dict, overwriting characters independent of style. +* `extras_dict` can be used to overwrite characters or define additional symbols. +""" +function collect_ucmchars( + char_names, + usv_dict, + extras_dict=Dict(); + alphabet=:UnknownAlphabet, + fixes=Dict{Char,Char}() +) + ucm_dict = Dict{Symbol, Dict{String, UCMChar}}() + + for (sn, cp) in pairs(usv_dict) + dict_sn = Dict( + n => let ch = Char(cp + i - 1); + UCMChar(; + name=n, glyph=get(fixes, ch, ch), style=sn, alphabet) + end for (i, n) = enumerate(char_names) + ) + ucm_dict[sn] = dict_sn + end + + for (sn, extras) in pairs(extras_dict) + if !haskey(ucm_dict, sn) + dict_sn = Dict{String, UCMChar}() + ucm_dict[sn] = dict_sn + else + dict_sn = ucm_dict[sn] + end + for (n, cp) in pairs(extras) + if haskey(dict_sn, n) + @unpack name, style = dict_sn[n] + dict_sn[n] = UCMChar(; + glyph=Char(cp), alphabet=dict_sn[n].alphabet, name, style) + else + dict_sn[n] = UCMChar(; + name=n, glyph=Char(cp), style=sn, alphabet) + end + end + end + return ucm_dict +end + +function inverse_ucm_dict(ucm_dict) + d = Dict{Char, UCMChar}() + for (rn, chd) = pairs(ucm_dict) + for (sn, ucms) = pairs(chd) + for (n, uch) = pairs(ucms) + ch = uch.glyph + if haskey(d, ch) + @warn """ + '$(ch)' already assigned: + is : alphabet=$(d[ch].alphabet), style=$(d[ch].style), + new: alphabet=$(uch.alphabet), style=$(uch.style)""" + else + d[ch] = uch + end + end + end + end + return d +end \ No newline at end of file diff --git a/src/UnicodeMath/test/alltests.jl b/src/UnicodeMath/test/alltests.jl new file mode 100644 index 0000000..bbbb3b7 --- /dev/null +++ b/src/UnicodeMath/test/alltests.jl @@ -0,0 +1,383 @@ +function test_parse_cfg(cfg::UCM.UCMConfig) + @unpack math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla = cfg + return UCM.parse_config(; + math_style_spec, normal_style_spec, bold_style_spec, sans_style, partial, nabla + ) +end + +@testset "`UnicodeMath` Defaults" begin + @test UCM.UCMConfig() == UCM.UCMConfig(; + math_style_spec=:tex, + normal_style_spec=nothing, + bold_style_spec=nothing, + sans_style=nothing, + partial=nothing, + nabla=nothing, + ) + + for normal_style_spec in (nothing, :tex, :iso, :french, :upright, :literal) + for bold_style_spec in (nothing, :tex, :iso, :upright, :literal) + for sans_style in (nothing, :upright, :italic, :literal) + for partial in (nothing, :upright, :italic, :literal) + for nabla in (nothing, :upright, :italic, :literal) + overrides = (;normal_style_spec, bold_style_spec, sans_style, partial, nabla) + cfg_tex = UCM.UCMConfig(; math_style_spec=:tex, overrides...) + cfg_iso = UCM.UCMConfig(; math_style_spec=:iso, overrides...) + cfg_french = UCM.UCMConfig(; math_style_spec=:french, overrides...) + cfg_upright = UCM.UCMConfig(; math_style_spec=:upright, overrides...) + cfg_literal = UCM.UCMConfig(; math_style_spec=:literal, overrides...) + + ntup_tex = test_parse_cfg(cfg_tex) + ntup_iso = test_parse_cfg(cfg_iso) + ntup_french = test_parse_cfg(cfg_french) + ntup_upright = test_parse_cfg(cfg_upright) + ntup_literal = test_parse_cfg(cfg_literal) + + ns = if isnothing(normal_style_spec) + identity + else + symb -> normal_style_spec + end + bs = if isnothing(bold_style_spec) + identity + else + symb -> bold_style_spec + end + ss = if isnothing(sans_style) + identity + else + symb -> sans_style + end + p = if isnothing(partial) + identity + else + symb -> partial + end + n = if isnothing(nabla) + identity + else + symb -> nabla + end + @test ntup_tex == (; + nabla = n(:upright), + partial = p(:italic), + normal_style_spec = ns(:tex), + bold_style_spec = bs(:tex), + sans_style = ss(:upright) + ) + + @test ntup_iso == (; + nabla = n(:upright), + partial = p(:italic), + normal_style_spec = ns(:iso), + bold_style_spec = bs(:iso), + sans_style = ss(:italic) + ) + + @test ntup_french == (; + nabla = n(:upright), + partial = p(:upright), + normal_style_spec = ns(:french), + bold_style_spec = bs(:upright), + sans_style = ss(:upright) + ) + + @test ntup_upright == (; + nabla = n(:upright), + partial = p(:upright), + normal_style_spec = ns(:upright), + bold_style_spec = bs(:upright), + sans_style = ss(:upright) + ) + + @test ntup_literal == (; + nabla = n(:literal), + partial = p(:literal), + normal_style_spec = ns(:literal), + bold_style_spec = bs(:literal), + sans_style = ss(:literal) + ) + end + end + end + end + end + + @test UCM.parse_normal_style_spec(:iso) == (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + @test UCM.parse_normal_style_spec(:tex) == (; + Greek = :upright, + greek = :italic, + Latin = :italic, + latin = :italic + ) + @test UCM.parse_normal_style_spec(:french) == (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :italic + ) + @test UCM.parse_normal_style_spec(:upright) == (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + @test UCM.parse_normal_style_spec(:literal) == (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) + + @test UCM.parse_bold_style_spec(:iso) == (; + Greek = :italic, + greek = :italic, + Latin = :italic, + latin = :italic + ) + @test UCM.parse_bold_style_spec(:tex) == (; + Greek = :upright, + greek = :italic, + Latin = :upright, + latin = :upright + ) + @test UCM.parse_bold_style_spec(:upright) == (; + Greek = :upright, + greek = :upright, + Latin = :upright, + latin = :upright, + ) + @test UCM.parse_bold_style_spec(:literal) == (; + Greek = :literal, + greek = :literal, + Latin = :literal, + latin = :literal, + ) +end + +const test_strings = Dict( + :num_up => "1", + :latin_up => "az", + :Latin_up => "BX", + :latin_it => "𝑎𝑧", + :Latin_it => "𝐵𝑋", + :Latin_bfit => "𝑨𝒁", + :latin_bfit => "𝒂𝒛", + :Latin_bfup => "𝐀𝐙", + :latin_bfup => "𝐚𝐳", + :greek_up => "αβ", + :Greek_up => "ΓΞ", + :greek_it => "𝛼𝛽", + :Greek_it => "𝛤𝛯", + :greek_bfit => "𝜶𝜷", + :Greek_bfit => "𝜞𝜩", + :greek_bfup => "𝛂𝛃", + :Greek_bfup => "𝚪𝚵", + :Nabla_up => "∇", + :Nabla_it => "𝛻", + :Nabla_bfup => "𝛁", + :Nabla_bfit => "𝜵", + :partial_up => "∂", + :partial_it => "𝜕", + :partial_bfup => "𝛛", + :partial_bfit => "𝝏", +) + +@testset "`UnicodeMath` string styling with `math_style_spec`" begin + + results_tex = Dict( + :num_up => :num_up, + :latin_up => :latin_it, + :Latin_up => :Latin_it, + :latin_it => :latin_it, + :Latin_it => :Latin_it, + :Latin_bfit => :Latin_bfup, + :Latin_bfup => :Latin_bfup, + :latin_bfit => :latin_bfup, + :latin_bfup => :latin_bfup, + :greek_up => :greek_it, + :Greek_up => :Greek_up, + :greek_it => :greek_it, + :Greek_it => :Greek_up, + :greek_bfit => :greek_bfit, + :Greek_bfit => :Greek_bfup, + :greek_bfup => :greek_bfit, + :Greek_bfup => :Greek_bfup, + :Nabla_up => :Nabla_up, + :Nabla_it => :Nabla_up, + :Nabla_bfup => :Nabla_bfup, + :Nabla_bfit => :Nabla_bfup, + :partial_up => :partial_it, + :partial_it => :partial_it, + :partial_bfup => :partial_bfit, + :partial_bfit => :partial_bfit, + ) + + results_iso = Dict( + :num_up => :num_up, + :latin_up => :latin_it, + :Latin_up => :Latin_it, + :latin_it => :latin_it, + :Latin_it => :Latin_it, + :Latin_bfit => :Latin_bfit, + :Latin_bfup => :Latin_bfit, + :latin_bfit => :latin_bfit, + :latin_bfup => :latin_bfit, + :greek_up => :greek_it, + :Greek_up => :Greek_it, + :greek_it => :greek_it, + :Greek_it => :Greek_it, + :greek_bfit => :greek_bfit, + :Greek_bfit => :Greek_bfit, + :greek_bfup => :greek_bfit, + :Greek_bfup => :Greek_bfit, + :Nabla_up => :Nabla_up, + :Nabla_it => :Nabla_up, + :Nabla_bfup => :Nabla_bfup, + :Nabla_bfit => :Nabla_bfup, + :partial_up => :partial_it, + :partial_it => :partial_it, + :partial_bfup => :partial_bfit, + :partial_bfit => :partial_bfit, + ) + + results_upright = Dict( + :num_up => :num_up, + :latin_up => :latin_up, + :Latin_up => :Latin_up, + :latin_it => :latin_up, + :Latin_it => :Latin_up, + :Latin_bfit => :Latin_bfup, + :Latin_bfup => :Latin_bfup, + :latin_bfit => :latin_bfup, + :latin_bfup => :latin_bfup, + :greek_up => :greek_up, + :Greek_up => :Greek_up, + :greek_it => :greek_up, + :Greek_it => :Greek_up, + :greek_bfit => :greek_bfup, + :Greek_bfit => :Greek_bfup, + :greek_bfup => :greek_bfup, + :Greek_bfup => :Greek_bfup, + :Nabla_up => :Nabla_up, + :Nabla_it => :Nabla_up, + :Nabla_bfup => :Nabla_bfup, + :Nabla_bfit => :Nabla_bfup, + :partial_up => :partial_up, + :partial_it => :partial_up, + :partial_bfup => :partial_bfup, + :partial_bfit => :partial_bfup, + ) + + results_french = Dict( + :num_up => :num_up, + :latin_up => :latin_it, + :Latin_up => :Latin_up, + :latin_it => :latin_it, + :Latin_it => :Latin_up, + :Latin_bfit => :Latin_bfup, + :Latin_bfup => :Latin_bfup, + :latin_bfit => :latin_bfup, + :latin_bfup => :latin_bfup, + :greek_up => :greek_up, + :Greek_up => :Greek_up, + :greek_it => :greek_up, + :Greek_it => :Greek_up, + :greek_bfit => :greek_bfup, + :Greek_bfit => :Greek_bfup, + :greek_bfup => :greek_bfup, + :Greek_bfup => :Greek_bfup, + :Nabla_up => :Nabla_up, + :Nabla_it => :Nabla_up, + :Nabla_bfup => :Nabla_bfup, + :Nabla_bfit => :Nabla_bfup, + :partial_up => :partial_up, + :partial_it => :partial_up, + :partial_bfup => :partial_bfup, + :partial_bfit => :partial_bfup, + ) + + results_literal = Dict(k => k for k = keys(test_strings)) + + cfg_tex = UCM.UCMConfig(; math_style_spec=:tex) + cfg_iso = UCM.UCMConfig(; math_style_spec=:iso) + cfg_upright = UCM.UCMConfig(; math_style_spec=:upright) + cfg_french = UCM.UCMConfig(; math_style_spec=:french) + cfg_literal = UCM.UCMConfig(; math_style_spec=:literal) + for (cfg, res) = ( + (cfg_iso, results_iso), + (cfg_tex, results_tex), + (cfg_upright, results_upright), + (cfg_french, results_french), + (cfg_literal, results_literal), + ) + for (k, _str) = pairs(test_strings) + _styled = test_strings[res[k]] + @test UCM.apply_style(_str, cfg) == _styled + end + end + +end + +@testset "`UnicodeMath` granular overrides" begin + normal_style_spec = (; + Greek = :literal, + greek = :upright, + Latin = :upright, + latin = :italic + ) + str_in = test_strings[:Greek_it] * + test_strings[:Greek_up] * + test_strings[:greek_it] * + test_strings[:greek_up] * + test_strings[:Latin_it] * + test_strings[:Latin_up] * + test_strings[:latin_it] * + test_strings[:latin_up] + + str_out = test_strings[:Greek_it] * + test_strings[:Greek_up] * + test_strings[:greek_up] * + test_strings[:greek_up] * + test_strings[:Latin_up] * + test_strings[:Latin_up] * + test_strings[:latin_it] * + test_strings[:latin_it] + + cfg = UCM.UCMConfig(; normal_style_spec) + + @test UCM.apply_style(str_in, cfg) == str_out + + bold_style_spec = (; + Greek = :literal, + greek = :upright, + Latin = :upright, + latin = :italic + ) + str_in = test_strings[:Greek_bfit] * + test_strings[:Greek_bfup] * + test_strings[:greek_bfit] * + test_strings[:greek_bfup] * + test_strings[:Latin_bfit] * + test_strings[:Latin_bfup] * + test_strings[:latin_bfit] * + test_strings[:latin_bfup] + + str_out = test_strings[:Greek_bfit] * + test_strings[:Greek_bfup] * + test_strings[:greek_bfup] * + test_strings[:greek_bfup] * + test_strings[:Latin_bfup] * + test_strings[:Latin_bfup] * + test_strings[:latin_bfit] * + test_strings[:latin_bfit] + + cfg = UCM.UCMConfig(; bold_style_spec) + + @test UCM.apply_style(str_in, cfg) == str_out +end \ No newline at end of file diff --git a/src/UnicodeMath/test/runtests.jl b/src/UnicodeMath/test/runtests.jl new file mode 100644 index 0000000..652cfca --- /dev/null +++ b/src/UnicodeMath/test/runtests.jl @@ -0,0 +1,5 @@ +import UnicodeMath as UCM +import UnPack: @unpack +using Test + +include("alltests.jl") \ No newline at end of file diff --git a/src/engine/fonts.jl b/src/engine/fonts.jl index b1a4697..56e15e1 100644 --- a/src/engine/fonts.jl +++ b/src/engine/fonts.jl @@ -51,29 +51,65 @@ const _default_fonts = Dict( :math => joinpath("NewComputerModern", "NewCMMath-Regular.otf") ) +const _default_mathfont_command_mapping = Dict( + ## by default, `\mathbf` now acts like `\symbf`, i.e., its a glyph-substitution switch + ## rather than a font switch. + ## To have it act like `\textbf`, add an entry `:bf` => (:text, :bf), +) + """ - FontFamily(fonts ; font_mapping, font_modifiers, special_chars, slant_angle, thickness) + FontFamily( + fonts; + font_mapping, font_modifiers, special_chars, slant_angle, thickness, + unicode_math_substitutions, unicode_math_aliases, unicode_math_config, + mathfont_command_mapping + ) A set of font for LaTeX rendering. # Required fields - `fonts` A with the path to 5 fonts (:regular, :italic, :bold, :bolditalic, and :math). The same font can be used for multiple entries, and unrelated - fonts can be mixed. - Missing fields are completed with the default fonts from NewComputerModern. + fonts can be mixed.\n + Missing fields are completed with the default fonts from NewComputerModern.\n + It is suggested to use a proper `:math` font for best rendering results of + mathematical expressions. # Optional fields - `font_mapping` a dict mapping the different character types (`:digit`, - `:function`, `:punctuation`, `:symbol`, `:variable`) to a font identifier. - Default to `MathTeXEngine._default_font_mapping` + `:function`, `:punctuation`, `:symbol`, `:variable`) to a font identifier.\n + This mapping is relevant mainly for characters typed in “math mode”, i.e., + characters enclosed by \\\$-signs, because otherwise the default text font is used.\n + Defaults to `MathTeXEngine._default_font_mapping`. - `font_modifiers` a dict of dict, one entry per font command supported in the font set. Each entry is a dict that maps a font identifier to another. - Default to `MathTeXEngine._default_font_modifiers`. - - `specail_chars` mapping for special characters that should not be + This dict determines the font selection of (nested) `\\textXX` commands.\n + Defaults to `MathTeXEngine._default_font_modifiers`. + - `special_chars` mapping for special characters that should not be represented by their default unicode glyph - (for example necessary to access the big integral glyph). + (for example necessary to access the big integral glyph).\n + Defaults to an empty `Dict`. - `slant_angle` the angle by which the italic fonts are slanted, in degree. - `thickness` the thickness of the lines associated to the font. + - `unicode_math_substitutions` is nested dict to determine glyph styling and + substitutions in math mode. See the README of the `UnicodeMath` sub-module for details. + It is recommended to use `unicode_math_config` instead of setting this manually.\n + Defaults to `MathTeXEngine.UCM.default_substitutions`. + - `unicode_math_aliases` is a nested dict for style aliases by alphabet. + It is recommended to use `unicode_math_config` instead of setting this manually.\n + Defaults to `MathTeXEngine.UCM.default_aliases`. + - `unicode_math_config` can be used to set `unicode_math_substitutions` and + `unicode_math_aliases` in tandem by giving a valid `UCMConfig` object.\n + For example, `UCMConfig(; math_style_spec=:iso)` will result in common glyphs adhering + to ISO recommendations within mathematical expressions.\n + Defaults to `nothing`. + - `mathfont_command_mapping` is a `Dict{Symbol, Tuple{Symbol, Symbol}` and + configures the behavior of `\\mathXX` commands. + By default `\\mathit` is synonymous for `\\symit` and rather than switching fonts, + for every glyph in the argument a fitting Unicode substitution is chosen. + This corresponds to an entry `:it => (:sym, :it)`. + To enable legacy behavior, add an entry `:it => (:text, it)`.\n + Defaults to `MathTeXEngine._default_mathfont_command_mapping`. """ struct FontFamily fonts::Dict{Symbol, String} @@ -82,16 +118,28 @@ struct FontFamily special_chars::Dict{Char, Tuple{String, Int}} slant_angle::Float64 thickness::Float64 + unicode_math_substitutions::Dict{Symbol, Dict{Symbol, Dict{Symbol, Symbol}}} + unicode_math_aliases::Dict{Symbol, Dict{Symbol, Symbol}} + mathfont_command_mapping::Dict{Symbol, Tuple{Symbol, Symbol}} end -function FontFamily(fonts ; +function FontFamily(fonts; font_mapping = _default_font_mapping, font_modifiers = _default_font_modifiers, special_chars = Dict{Char, Tuple{String, Int}}(), slant_angle = 13, - thickness = 0.0375) + thickness = 0.0375, + unicode_math_substitutions = UCM.default_substitutions, + unicode_math_aliases = UCM.default_aliases, + unicode_math_config = nothing, + mathfont_command_mapping = _default_mathfont_command_mapping + ) fonts = merge(_default_fonts, Dict(fonts)) + + if isa(unicode_math_config, UCM.UCMConfig) + unicode_math_substitutions, unicode_math_aliases = UCM.config_dicts(unicode_math_config) + end return FontFamily( fonts, @@ -99,7 +147,10 @@ function FontFamily(fonts ; font_modifiers, special_chars, slant_angle, - thickness + thickness, + unicode_math_substitutions, + unicode_math_aliases, + mathfont_command_mapping ) end @@ -255,9 +306,25 @@ object. get_fontpath(font_family::FontFamily, fontstyle::Symbol) = full_fontpath(font_family.fonts[fontstyle]) get_fontpath(fontstyle::Symbol) = get_fontpath(FontFamily(), fontstyle) -function is_slanted(font_family, char_type) - font_id = font_family.font_mapping[char_type] - return font_id == :italic +function is_slanted(font_family, char_type, char...) + font_id = get(font_family.font_mapping, char_type, :math) + return is_slanted(font_id, char...) +end +function is_slanted(font_id) + return font_id == :italic || font_id == :bolditalic +end +function is_slanted(font_id, char) + is_slanted(font_id) && return true + + if font_id == :math + if haskey(UCM.chars_to_ucmchars, char) + ucm_char = UCM.chars_to_ucmchars[char] + if ucm_char.style in (:it, :bfit, :sfit, :bfsfit, :bbit) # TODO `:bfcal` ? + return true + end + end + end + return false end slant_angle(font_family) = font_family.slant_angle * π / 180 diff --git a/src/engine/layout.jl b/src/engine/layout.jl index d30c340..90dec8d 100644 --- a/src/engine/layout.jl +++ b/src/engine/layout.jl @@ -28,6 +28,28 @@ function tex_layout(expr, state) shrink = 0.6 try + ## intercept `\mathXX` commands before layouting because their behavior depends + ## on `font_family.mathfont_command_mapping`: + if head == :mathfont + modifier, content = args + if haskey(font_family.mathfont_command_mapping, modifier) + _head, _modifier = font_family.mathfont_command_mapping[modifier] + if _head == :text || _head == :sym + head = _head + if _head == :sym + if _modifier == :rm + _modifier = :up + elseif _modifier == :src + _modifier = :cal + end + end + args = [_modifier, content] + end + else + head = :sym + end + end + if isleaf(expr) # :char, :delimiter, :digit, :punctuation, :symbol char = args[1] if char == ' ' && state.tex_mode == :inline_math @@ -105,9 +127,9 @@ function tex_layout(expr, state) ], scales ) - elseif head == :font + elseif head == :sym modifier, content = args - return tex_layout(content, add_font_modifier(state, modifier)) + return tex_layout(content, add_ucm_modifier(state, modifier)) elseif head == :fontfamily return Space(0) elseif head == :frac diff --git a/src/engine/layout_context.jl b/src/engine/layout_context.jl index 5c9b8db..75253b7 100644 --- a/src/engine/layout_context.jl +++ b/src/engine/layout_context.jl @@ -1,10 +1,11 @@ struct LayoutState font_family::FontFamily font_modifiers::Vector{Symbol} + ucm_modifiers::Vector{Symbol} tex_mode::Symbol end -LayoutState(font_family::FontFamily, modifiers::Vector) = LayoutState(font_family, modifiers, :text) +LayoutState(font_family::FontFamily, modifiers::Vector) = LayoutState(font_family, modifiers, Symbol[], :text) LayoutState(font_family::FontFamily) = LayoutState(font_family, Symbol[]) LayoutState() = LayoutState(FontFamily()) @@ -15,30 +16,42 @@ end Base.broadcastable(state::LayoutState) = Ref(state) function change_mode(state::LayoutState, mode) - LayoutState(state.font_family, state.font_modifiers, mode) + LayoutState(state.font_family, state.font_modifiers, state.ucm_modifiers, mode) end function add_font_modifier(state::LayoutState, modifier) modifiers = vcat(state.font_modifiers, modifier) - return LayoutState(state.font_family, modifiers, state.tex_mode) + return LayoutState(state.font_family, modifiers, state.ucm_modifiers, state.tex_mode) +end + +function add_ucm_modifier(state::LayoutState, modifier) + modifiers = vcat(state.ucm_modifiers, modifier) + return LayoutState(state.font_family, state.font_modifiers, modifiers, state.tex_mode) end function get_font(state::LayoutState, char_type) + font_family = state.font_family + font_id = get_font_id(state, char_type) + return get_font(font_family, font_id) +end + +function get_font_id(state::LayoutState, char_type) if state.tex_mode == :text char_type = :text end font_family = state.font_family - font_id = font_family.font_mapping[char_type] - - for modifier in state.font_modifiers - if haskey(font_family.font_modifiers, modifier) - mapping = font_family.font_modifiers[modifier] - font_id = get(mapping, font_id, font_id) - else - throw(ArgumentError("font modifier $modifier not supported for the current font family.")) + font_id = get(font_family.font_mapping, char_type, :math) + + if font_id != :math + for modifier in state.font_modifiers # TODO should we use `reverse` here? + if haskey(font_family.font_modifiers, modifier) + mapping = font_family.font_modifiers[modifier] + font_id = get(mapping, font_id, font_id) + else + throw(ArgumentError("font modifier $modifier not supported for the current font family.")) + end end end - - return get_font(font_family, font_id) + return font_id end \ No newline at end of file diff --git a/src/engine/texelements.jl b/src/engine/texelements.jl index 144fcdb..ab1e565 100644 --- a/src/engine/texelements.jl +++ b/src/engine/texelements.jl @@ -154,29 +154,31 @@ function TeXChar(char::Char, state::LayoutState, char_type) if haskey(font_family.special_chars, char) fontpath, id = font_family.special_chars[char] font = load_font(fontpath) - return TeXChar(id, font, font_family, false, char) + return TeXChar(id, font, font_family, false, char) ## TODO is_slanted end - if state.tex_mode == :inline_math && char_type != :ucm_glyph - ## check if `char` is meant to be typeset using `:math` font - if get(state.font_family.font_mapping, char_type, :notmath) == :math - ## if `:math` font is used, apply UnicodeMath styling standard - char = UCM._sym(char) + font_id = get_font_id(state, char_type) + font = get_font(font_family, font_id) + + if font_id == :math + @unpack unicode_math_substitutions, unicode_math_aliases = font_family + char = UCM.apply_style(char, unicode_math_substitutions, unicode_math_aliases) + @unpack ucm_modifiers = state + if !isempty(ucm_modifiers) + for trgt_style in reverse(ucm_modifiers) + char = UCM.apply_style( + char, unicode_math_substitutions, unicode_math_aliases, trgt_style; + is_styled=true + ) + end end end - ## now treat any :ucm_glyph same as a :symbol - if char_type == :ucm_glyph - char_type = :symbol - end - - font = get_font(state, char_type) - return TeXChar( glyph_index(font, char), font, font_family, - is_slanted(state.font_family, char_type), + is_slanted(font_id, char), char) end diff --git a/src/parser/commands_registration.jl b/src/parser/commands_registration.jl index a4577c9..3166134 100644 --- a/src/parser/commands_registration.jl +++ b/src/parser/commands_registration.jl @@ -88,7 +88,7 @@ end for name in font_names com_str = "\\math$name" - command_definitions[com_str] = (TeXExpr(:font, Symbol(name)), 1) + command_definitions[com_str] = (TeXExpr(:mathfont, Symbol(name)), 1) com_str = "\\text$name" command_definitions[com_str] = (TeXExpr(:text, Symbol(name)), 1) end @@ -98,6 +98,8 @@ for style_symb in UCM.all_styles com_str = "\\sym$(style_symb)" command_definitions[com_str] = (TeXExpr(:sym, style_symb), 1) end +command_definitions["\\symrm"] = (TeXExpr(:sym, :up), 1) +command_definitions["\\symscr"] = (TeXExpr(:sym, :cal), 1) ## ## Symbols @@ -173,3 +175,18 @@ for (com_str, symbol) in latex_symbols command_definitions[com_str] = (symbol_expr, 0) end end + +# Register extra commands provided by `unicode-math` LaTeX package: +for ucm_cmd in values(UCM.extra_commands) + com_str = ucm_cmd.latex_cmd + symbol = ucm_cmd.glyph + symbol_expr = TeXExpr(:symbol, symbol) + + if !haskey(symbol_to_canonical, symbol) + symbol_to_canonical[symbol] = symbol_expr + end + + if !haskey(command_definitions, com_str) + command_definitions[com_str] = (symbol_expr, 0) + end +end \ No newline at end of file diff --git a/src/parser/texexpr.jl b/src/parser/texexpr.jl index 05dd5c4..311394d 100644 --- a/src/parser/texexpr.jl +++ b/src/parser/texexpr.jl @@ -1,10 +1,3 @@ -const _math_font_mappings = Dict( - :bb => to_blackboardbold, - :cal => to_caligraphic, - :frak => to_frakture, - :scr => to_caligraphic -) - """ TeXExpr(head::Symbol, args::Vector) @@ -22,32 +15,7 @@ struct TeXExpr head::Symbol args::Vector{Any} - function TeXExpr(head, args::Vector) - if head == :font - # Convert math font like `\mathbb{R}` -- TeXExpr(:font, [:bb, 'R']) -- - # to unicode symbols -- e.g. TeXExpr(:symbol, 'ℝ') - if length(args) == 2 && haskey(_math_font_mappings, args[1]) - font, content = args - to_font = _math_font_mappings[font] - return leafmap(content) do leaf - sym = only(leaf.args) - return TeXExpr(:symbol, to_font(sym)) - end - end - end - if head == :sym - # Convert math font like `\symbb{R}` -- TeXExpr(:sym, [:bb, 'R']) -- - # to unicode symbols -- e.g. TeXExpr(:ucm_glyph, 'ℝ') - if length(args) == 2 && args[1] in UCM.all_styles - style_symb, content = args - return leafmap(content) do leaf - glyph = only(leaf.args) - return TeXExpr(:ucm_glyph, UCM._sym(glyph, style_symb)) - end - end - end - return new(head, args) - end + TeXExpr(head, args::Vector) = new(head, args) end TeXExpr(head) = TeXExpr(head, []) diff --git a/test/layout.jl b/test/layout.jl index 881a8a0..0cec195 100644 --- a/test/layout.jl +++ b/test/layout.jl @@ -47,9 +47,38 @@ end texchar = tex_layout(expr, FontFamily()) @test isa(texchar, TeXChar) - expr = manual_texexpr((:font, :rm, 'u')) + expr = manual_texexpr((:mathfont, :rm, 'u')) texchar = tex_layout(expr, FontFamily()) @test isa(texchar, TeXChar) + + ## UnicodeMath + expr = manual_texexpr((:char, 'a')) + texchar = tex_layout(expr, FontFamily()) + @test texchar.represented_char == 'a' + + expr = manual_texexpr((:inline_math, (:char, 'a'))) + texgroup = tex_layout(expr, FontFamily()) + texchar = only(texgroup.elements) + @test texchar.represented_char == '𝑎' + + expr = manual_texexpr((:inline_math, (:text, :rm, (:char, 'a')))) + texgroup = tex_layout(expr, FontFamily()) + texchar = only(texgroup.elements) + @test texchar.represented_char == 'a' + @test texchar.font == get_font(FontFamily(), :regular) + + expr = manual_texexpr((:inline_math, (:mathfont, :rm, (:char, 'a')))) + texgroup = tex_layout(expr, FontFamily()) + texchar = only(texgroup.elements) + @test texchar.represented_char == '𝑎' + @test texchar.font == get_font(FontFamily(), :math) + + ffam = deepcopy(FontFamily()) + ffam.mathfont_command_mapping[:rm] = (:text, :rm) + expr = manual_texexpr((:inline_math, (:mathfont, :rm, (:char, 'a')))) + texgroup = tex_layout(expr, ffam) + texchar = only(texgroup.elements) + @test texchar.font == get_font(ffam, :regular) end @testset "Group" begin diff --git a/test/parser.jl b/test/parser.jl index 6370ec3..0aaf863 100644 --- a/test/parser.jl +++ b/test/parser.jl @@ -70,7 +70,8 @@ end (:char, 'v') ))) - @test texparse(raw"ℝ") == texparse(raw"\mathbb{R}") + @test texparse(raw"ℝ") == manual_texexpr((:line, (:symbol, 'ℝ'))) + @test texparse(raw"\mathbb{R}") == manual_texexpr((:line, (:mathfont, :bb, 'R'))) end @testset "Fraction" begin diff --git a/test/runtests.jl b/test/runtests.jl index 17e3032..ec6b636 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -7,10 +7,14 @@ import MathTeXEngine: TeXParseError import MathTeXEngine: tex_layout, generate_tex_elements import MathTeXEngine: Space, TeXElement -import MathTeXEngine: load_font +import MathTeXEngine: load_font, get_font import MathTeXEngine: inkheight, inkwidth include("texexpr.jl") include("parser.jl") include("fonts.jl") -include("layout.jl") \ No newline at end of file +include("layout.jl") + +import MathTeXEngine: UCM +import UnPack: @unpack +include("../src/UnicodeMath/test/alltests.jl") \ No newline at end of file From 11c55d6a7b13f9bc4d611cbdf6dde6e171da1349 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Tue, 21 Oct 2025 12:57:19 +0200 Subject: [PATCH 6/8] add new commands to README --- README.md | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a879ff5..ab09050 100644 --- a/README.md +++ b/README.md @@ -10,8 +10,13 @@ This is a package aimed at providing a pure Julia engine for LaTeX math mode. It # Fonts -The characters in a math expression come from a variety of fonts depending on their role (most notably italic for variable, regular for functions, math for the symbols). -A set of such font forms a `FontFamily`, and several are predefined here (NewComputerModer, TeXGyreHeros, TeXGyrePagella, and LucioleMath) +When a string is parsed, a character can occur as a text character or within +a math expression, and a font has to be chosen accordingly. +The characters in a text expression come from a variety of fonts, +depending of whether they should be rendered upright or italic or with some other style. +For characters in mathematical expressions usually a single [mathematical font](https://en.wikipedia.org/wiki/OpenType#Math) is used, +and stylized glyphs are chosen from the [Unicode maths blocks](https://en.wikipedia.org/wiki/Mathematical_operators_and_symbols_in_Unicode). +The set of all fonts forms a `FontFamily`, and several are predefined here (NewComputerModer, TeXGyreHeros, TeXGyrePagella, and LucioleMath) and can be access by `FontFamily(name)`. A font family is defined by a dictionary of the paths of the font files: @@ -173,7 +178,9 @@ The table below contains the list of all supported LaTeX construction and their | Group | `{ }` | `:group` | `elements...` | | Inline math | `$ $` | `:inline_math` | `content` | | Integral | `\int_a^b` | `:integral` | `symbol, low_bound, high_bound` | -| Math fonts | `\mathrm{}` | `:font` | `font_modifier, expr` | +| Math glyph substitution | `\symit{}` | `:sym` | `font_modifier, expr` | +| Text fonts | `\textit{}` | `:text` | `font_modifier, expr` | +| Math fonts[^1] | `\mathrm{}` | `:mathfont` | `font_modifier, expr` | | Punctuation | `!` | `:punctuation` | | Simple delimiter | `(` | `:delimiter` | | Square root | `\sqrt{2}` | `:sqrt` | `content` | @@ -182,6 +189,10 @@ The table below contains the list of all supported LaTeX construction and their | Subscript and superscript | `x_0^2` | `:decorated` | `core, subscript, superscript` | | Symbol with script under and/or over it | `\sum_i^k` | `:underover` | `symbol, under, over` | +[^1]: The behavior of the `:mathfont` command can be controlled with the `mathfont_command_mapping` field of a `FontFamily`. + By default, these commands are **not** font switches, but alias the corresponding `:sym` commands, so that glyphs are substituted and the `:math` font is used. + To have `\mathbf` them act like `\textbf`, add an entry `:bf => (:text, :bf)` to the `mathfont_command_mapping` dict of the current font family. + ## Parser examples ### Basic examples From 202334923964b02d1d9c10c1908c1534be34cef2 Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Tue, 21 Oct 2025 12:59:06 +0200 Subject: [PATCH 7/8] typos in README --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index ab09050..401a74e 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ This is a package aimed at providing a pure Julia engine for LaTeX math mode. It When a string is parsed, a character can occur as a text character or within a math expression, and a font has to be chosen accordingly. The characters in a text expression come from a variety of fonts, -depending of whether they should be rendered upright or italic or with some other style. +depending on whether they should be rendered upright or italic or with some other style. For characters in mathematical expressions usually a single [mathematical font](https://en.wikipedia.org/wiki/OpenType#Math) is used, and stylized glyphs are chosen from the [Unicode maths blocks](https://en.wikipedia.org/wiki/Mathematical_operators_and_symbols_in_Unicode). The set of all fonts forms a `FontFamily`, and several are predefined here (NewComputerModer, TeXGyreHeros, TeXGyrePagella, and LucioleMath) @@ -191,7 +191,7 @@ The table below contains the list of all supported LaTeX construction and their [^1]: The behavior of the `:mathfont` command can be controlled with the `mathfont_command_mapping` field of a `FontFamily`. By default, these commands are **not** font switches, but alias the corresponding `:sym` commands, so that glyphs are substituted and the `:math` font is used. - To have `\mathbf` them act like `\textbf`, add an entry `:bf => (:text, :bf)` to the `mathfont_command_mapping` dict of the current font family. + To have `\mathbf` act like `\textbf`, add an entry `:bf => (:text, :bf)` to the `mathfont_command_mapping` dict of the current font family. ## Parser examples From b3220ef0c7ec6c36c4f9a7709f44a9fbb2e2a68d Mon Sep 17 00:00:00 2001 From: manuelbb-upb Date: Tue, 21 Oct 2025 13:09:29 +0200 Subject: [PATCH 8/8] README: add sym footnote --- README.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 401a74e..2fe6d6a 100644 --- a/README.md +++ b/README.md @@ -178,9 +178,9 @@ The table below contains the list of all supported LaTeX construction and their | Group | `{ }` | `:group` | `elements...` | | Inline math | `$ $` | `:inline_math` | `content` | | Integral | `\int_a^b` | `:integral` | `symbol, low_bound, high_bound` | -| Math glyph substitution | `\symit{}` | `:sym` | `font_modifier, expr` | +| Math glyph substitution[^1] | `\symit{}` | `:sym` | `font_modifier, expr` | | Text fonts | `\textit{}` | `:text` | `font_modifier, expr` | -| Math fonts[^1] | `\mathrm{}` | `:mathfont` | `font_modifier, expr` | +| Math fonts[^2] | `\mathrm{}` | `:mathfont` | `font_modifier, expr` | | Punctuation | `!` | `:punctuation` | | Simple delimiter | `(` | `:delimiter` | | Square root | `\sqrt{2}` | `:sqrt` | `content` | @@ -189,7 +189,11 @@ The table below contains the list of all supported LaTeX construction and their | Subscript and superscript | `x_0^2` | `:decorated` | `core, subscript, superscript` | | Symbol with script under and/or over it | `\sum_i^k` | `:underover` | `symbol, under, over` | -[^1]: The behavior of the `:mathfont` command can be controlled with the `mathfont_command_mapping` field of a `FontFamily`. +[^1]: By default, glyph substitutions loosely imitate the `math-style=TeX` setting of the LaTeX package [`unicode-math`](https://ctan.org/pkg/unicode-math?lang=en). + The `\symXX` commands are controlled by the fields `unicode_math_substitutions` and `unicode_math_aliases` of a `FontFamily`. + The `FontFamily` constructor accepts the `unicode_math_config` keyword argument to switch to other predefined styling conventions, e.g. `FontFamily(fonts; unicode_math_config=MathTeXEngine.UCMConfig(; math_style_spec=:iso))`. + +[^2]: The behavior of the `:mathfont` command can be controlled with the `mathfont_command_mapping` field of a `FontFamily`. By default, these commands are **not** font switches, but alias the corresponding `:sym` commands, so that glyphs are substituted and the `:math` font is used. To have `\mathbf` act like `\textbf`, add an entry `:bf => (:text, :bf)` to the `mathfont_command_mapping` dict of the current font family.