use crate::node::Node;
pub type Scaled = i64;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Class {
Ord = 0,
Op = 1,
Bin = 2,
Rel = 3,
Open = 4,
Close = 5,
Punct = 6,
Inner = 7,
}
impl Class {
pub fn from_code(c: i64) -> Class {
match c {
1 => Class::Op,
2 => Class::Bin,
3 => Class::Rel,
4 => Class::Open,
5 => Class::Close,
6 => Class::Punct,
7 => Class::Inner,
_ => Class::Ord,
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub enum Limits {
#[default]
Normal,
Above,
Beside,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct MathChar {
pub fam: usize,
pub character: u8,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
pub struct Delimiter {
pub small_fam: usize,
pub small_char: u8,
pub large_fam: usize,
pub large_char: u8,
}
impl Delimiter {
pub fn null() -> Delimiter {
Delimiter::default()
}
pub fn is_null(&self) -> bool {
self.small_fam == 0 && self.small_char == 0 && self.large_fam == 0 && self.large_char == 0
}
pub fn from_code(code: i64) -> Delimiter {
Delimiter {
small_fam: ((code >> 20) & 0xF) as usize,
small_char: ((code >> 12) & 0xFF) as u8,
large_fam: ((code >> 8) & 0xF) as usize,
large_char: (code & 0xFF) as u8,
}
}
}
#[derive(Clone, Debug, Default)]
pub enum Field {
#[default]
Empty,
Char(MathChar),
Box(Box<crate::node::BoxNode>),
List(Vec<Noad>),
Literal(char),
}
impl Field {
pub fn is_empty(&self) -> bool {
matches!(self, Field::Empty)
}
}
pub type Style = i64;
pub const DISPLAY_STYLE: Style = 0;
pub const TEXT_STYLE: Style = 2;
pub const SCRIPT_STYLE: Style = 4;
pub const SCRIPT_SCRIPT_STYLE: Style = 6;
pub const CRAMPED: Style = 1;
pub fn cramped_style(s: Style) -> Style {
2 * (s / 2) + CRAMPED
}
pub fn sub_style(s: Style) -> Style {
2 * (s / 4) + SCRIPT_STYLE + CRAMPED
}
pub fn sup_style(s: Style) -> Style {
2 * (s / 4) + SCRIPT_STYLE + (s % 2)
}
pub fn num_style(s: Style) -> Style {
s + 2 - 2 * (s / 6)
}
pub fn denom_style(s: Style) -> Style {
2 * (s / 2) + CRAMPED + 2 - 2 * (s / 6)
}
pub fn size_of(style: Style) -> usize {
match style < SCRIPT_STYLE {
true => crate::math::font::TEXT_SIZE,
false => ((style - TEXT_STYLE) / 2) as usize,
}
}
#[derive(Clone, Debug)]
pub enum Noad {
Atom(Atom),
Fraction(Fraction),
Radical(Radical),
Over(Atom),
Under(Atom),
Accent(Accent),
VCenter(Atom),
Choice(Box<Choice>),
Left(Delimiter),
Right(Delimiter),
Style(Style),
Glue(Scaled),
Kern(Scaled),
MuGlue(MuGlue),
MuKern(Scaled),
Node(Node),
}
#[derive(Clone, Debug, Default)]
pub struct Atom {
pub class: ClassOrOrd,
pub nucleus: Field,
pub supscr: Field,
pub subscr: Field,
pub limits: Limits,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct ClassOrOrd(pub Class);
impl Default for ClassOrOrd {
fn default() -> ClassOrOrd {
ClassOrOrd(Class::Ord)
}
}
impl Atom {
pub fn new(class: Class, nucleus: Field) -> Atom {
Atom {
class: ClassOrOrd(class),
nucleus,
..Atom::default()
}
}
pub fn class(&self) -> Class {
self.class.0
}
}
#[derive(Clone, Debug)]
pub struct Fraction {
pub thickness: Option<Scaled>,
pub numerator: Vec<Noad>,
pub denominator: Vec<Noad>,
pub left_delimiter: Delimiter,
pub right_delimiter: Delimiter,
}
#[derive(Clone, Debug)]
pub struct Radical {
pub left_delimiter: Delimiter,
pub nucleus: Atom,
pub index: Option<Vec<Noad>>,
}
#[derive(Clone, Debug)]
pub struct Accent {
pub accent: MathChar,
pub atom: Atom,
}
#[derive(Clone, Debug, Default)]
pub struct Choice {
pub display: Vec<Noad>,
pub text: Vec<Noad>,
pub script: Vec<Noad>,
pub script_script: Vec<Noad>,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct MuGlue {
pub natural: Scaled,
pub stretch: Scaled,
pub shrink: Scaled,
pub stretch_order: i64,
pub shrink_order: i64,
}
impl MuGlue {
pub fn fixed(natural: Scaled) -> MuGlue {
MuGlue {
natural,
..MuGlue::default()
}
}
pub fn of(spec: (i64, i64, i64)) -> MuGlue {
MuGlue {
natural: spec.0,
stretch: spec.1,
shrink: spec.2,
..MuGlue::default()
}
}
pub fn negated(self) -> MuGlue {
MuGlue {
natural: -self.natural,
stretch: -self.stretch,
shrink: -self.shrink,
..self
}
}
}
pub const MATH_SPACING: &[u8; 64] =
b"0234000122*4000133**3**344*0400400*000000234000111*1111112341011";
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Space {
None,
ConditionalThin,
Thin,
ConditionalMedium,
ConditionalThick,
Impossible,
}
pub fn spacing(left: Class, right: Class) -> Space {
match MATH_SPACING[left as usize * 8 + right as usize] {
b'0' => Space::None,
b'1' => Space::ConditionalThin,
b'2' => Space::Thin,
b'3' => Space::ConditionalMedium,
b'4' => Space::ConditionalThick,
_ => Space::Impossible,
}
}
pub const THIN_MU_SKIP: (i64, i64, i64) = (3 * 65536, 0, 0);
pub const MED_MU_SKIP: (i64, i64, i64) = (4 * 65536, 2 * 65536, 4 * 65536);
pub const THICK_MU_SKIP: (i64, i64, i64) = (5 * 65536, 5 * 65536, 0);
pub const SCRIPT_SPACE: Scaled = 32768;
pub const DELIMITER_FACTOR: i64 = 901;
pub const DELIMITER_SHORTFALL: Scaled = 5 * 65536;
pub const NULL_DELIMITER_SPACE: Scaled = 78643;
pub const SKEW_CHAR: [Option<u8>; 4] = [None, Some(0o177), Some(0o60), None];
pub const BIN_OP_PENALTY: i64 = 700;
pub const REL_PENALTY: i64 = 500;
pub const INF_PENALTY: i64 = 10000;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct MathParams {
pub thin_mu_skip: MuGlue,
pub med_mu_skip: MuGlue,
pub thick_mu_skip: MuGlue,
pub script_space: Scaled,
pub delimiter_factor: i64,
pub delimiter_shortfall: Scaled,
pub null_delimiter_space: Scaled,
pub bin_op_penalty: i64,
pub rel_penalty: i64,
}
impl MathParams {
pub fn plain() -> MathParams {
MathParams {
thin_mu_skip: MuGlue::of(THIN_MU_SKIP),
med_mu_skip: MuGlue::of(MED_MU_SKIP),
thick_mu_skip: MuGlue::of(THICK_MU_SKIP),
script_space: SCRIPT_SPACE,
delimiter_factor: DELIMITER_FACTOR,
delimiter_shortfall: DELIMITER_SHORTFALL,
null_delimiter_space: NULL_DELIMITER_SPACE,
bin_op_penalty: BIN_OP_PENALTY,
rel_penalty: REL_PENALTY,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_spacing_table_is_the_one_in_section_764() {
assert_eq!(MATH_SPACING.len(), 64);
assert_eq!(spacing(Class::Ord, Class::Ord), Space::None);
assert_eq!(spacing(Class::Ord, Class::Op), Space::Thin);
assert_eq!(spacing(Class::Ord, Class::Bin), Space::ConditionalMedium);
assert_eq!(spacing(Class::Ord, Class::Rel), Space::ConditionalThick);
assert_eq!(spacing(Class::Ord, Class::Inner), Space::ConditionalThin);
assert_eq!(spacing(Class::Bin, Class::Rel), Space::Impossible);
assert_eq!(spacing(Class::Bin, Class::Close), Space::Impossible);
assert_eq!(spacing(Class::Open, Class::Ord), Space::None);
assert_eq!(spacing(Class::Punct, Class::Ord), Space::ConditionalThin);
}
#[test]
fn the_style_transitions_are_section_702s() {
assert_eq!(sup_style(DISPLAY_STYLE), SCRIPT_STYLE);
assert_eq!(sup_style(TEXT_STYLE), SCRIPT_STYLE);
assert_eq!(sup_style(SCRIPT_STYLE), SCRIPT_SCRIPT_STYLE);
assert_eq!(sup_style(SCRIPT_SCRIPT_STYLE), SCRIPT_SCRIPT_STYLE);
assert_eq!(sub_style(DISPLAY_STYLE), SCRIPT_STYLE + CRAMPED);
assert_eq!(sub_style(SCRIPT_STYLE), SCRIPT_SCRIPT_STYLE + CRAMPED);
assert_eq!(num_style(DISPLAY_STYLE), TEXT_STYLE);
assert_eq!(num_style(SCRIPT_SCRIPT_STYLE), SCRIPT_SCRIPT_STYLE);
assert_eq!(denom_style(DISPLAY_STYLE), TEXT_STYLE + CRAMPED);
assert_eq!(cramped_style(DISPLAY_STYLE), DISPLAY_STYLE + CRAMPED);
assert_eq!(cramped_style(TEXT_STYLE + CRAMPED), TEXT_STYLE + CRAMPED);
}
#[test]
fn the_size_of_a_style_is_section_703s() {
assert_eq!(size_of(DISPLAY_STYLE), 0);
assert_eq!(size_of(TEXT_STYLE + CRAMPED), 0);
assert_eq!(size_of(SCRIPT_STYLE), 1);
assert_eq!(size_of(SCRIPT_STYLE + CRAMPED), 1);
assert_eq!(size_of(SCRIPT_SCRIPT_STYLE), 2);
assert_eq!(size_of(SCRIPT_SCRIPT_STYLE + CRAMPED), 2);
}
}