iosMath Documentation

The iosMath rendering process follows a pipeline that transforms a LaTeX string into a visual display. While TeX uses a two-pass algorithm, iosMath collapses this into a single left-to-right pass because critical preprocessing (Rules 5, 6, and 14) is performed during the MTMathList.finalized stage before layout begins.

The Pipeline Stages:

1. LaTeX string $\rightarrow$ MTMathListBuilder $\rightarrow$ MTMathList (a list of MTMathAtoms).
2. MTMathList.finalized: Pre-bakes important rules (Rules 5, 6, 14).
3. MTTypesetter.preprocessMathList: Merges Rule 14 and reclassifies Number, Variable, and Unary atoms to Ord (Ordinary).
4. MTTypesetter.createDisplayAtoms: Executes the core typesetting rules (Rules 1–4, 7–13, 15–18, 20, 22) in a single pass.
5. MTMathListDisplay: Produces a tree of MTDisplay objects.
6. MTDisplay.draw: Final rendering using CoreText or CGContext.

LaTeX string ──► MTMathListBuilder ──► MTMathList (of MTMathAtoms)
                                            │
                                            ▼
                                   MTMathList.finalized  (Rules 5, 6, 14 pre-bake)
                                            │
                                            ▼
                     MTTypesetter.preprocessMathList  (Rule 14 merge + Number→Ord, Variable→Ord, Unary→Ord)
                                            │
                                            ▼
            MTTypesetter.createDisplayAtoms  (Rules 1–4, 7–13, 15–18, 20, 22; two-pass merged into one)
                                            │
                                MTMathListDisplay (tree of MTDisplays)
                                            │
                                     MTDisplay.draw:  (CoreText / CGContext)

iosMath implements a math typesetting pipeline inspired by TeX Appendix G, mapping TeX rules to an OpenType MATH-based model. The process involves two main phases:

1. First Pass (MTTypesetter.createDisplayAtoms:): The engine traverses the math list, creating MTMathAtom objects. During this pass, it handles style changes, calculates spacing (mu to pt conversion), and processes complex structures like radicals, fractions, and accents.
2. Finalize Phase (MTMathList.finalized): The engine performs a second pass to refine the list. This includes reclassifying atom types (e.g., converting BinaryOperator to UnaryOperator or Ordinary based on context) to ensure correct inter-element spacing.

Key Implementation Notes:

• Spacing: Uses an OpenType-era equivalent of TeX's $\sigma_6$ (calculated as fontSize / 18) for space units.
• Atom Reclassification: To handle TeX's Rule 5 and 6, iosMath uses a two-step path: Bin $\rightarrow$ UnaryOperator $\rightarrow$ Ordinary. This ensures spacing is handled correctly before the final layout.
• Limitations: Unlike TeX, iosMath does not implement \mathchoice, \vcenter, or line-breaking penalties (\binoppenalty), as math lists are laid out monolithically.

iosMath manages large operators and their limits (e.g., \sum_{i=1}^n) through MTTypesetter.makeLargeOp: and addLimitsToDisplay:forOperator:delta::

• Limits Decision: The limits property on MTLargeOperator is determined at parse time. Symbols like \sum and \prod default to limits:YES, while \int and \log default to NO.
• Vertical Centering: The operator is centered on the axis using the formula: shiftDown = 0.5 * (ascent - descent) - axisHeight.
• Limit Placement: When limits are attached, an MTLargeOpLimitsDisplay is created.
  • Upper limits use style C^up (cramped).
  • Lower limits use style C^down (always cramped).
  • Vertical gaps are determined by UpperLimitGapMin and LowerLimitGapMin from the MATH table.
• Italic Correction: If a subscript exists and limits are not used, an italic correction (delta) is applied to allow the subscript to nestle under the italic overhang.

TeX Gyre Termes Math is an OpenType (OTF) math companion font designed for the TeX Gyre Termes family. It is specifically built for mathematical typesetting and includes a MATH table as described in Microsoft's OpenType Math specifications.

Key features include:

• Comprehensive Scripts: Contains basic serif (regular, bold, italic, bold italic), calligraphic (regular, bold), double-struck, fraktur (regular, bold), sans-serif (regular, bold, oblique, bold oblique), and monospaced scripts.
• Mathematical Symbols: Includes specialized symbols for Greek, Hebrew, and various mathematical notations.
• Compatibility: Designed to support Unicode mathematical character sets (referencing Unicode Technical Report #25).

Note that scripts like fraktur, sans-serif, and monospaced are treated as symbols rather than standard text letters and are intended to be used in mathematical contexts (e.g., with subscripts, superscripts, or primes).

Fractions and stacks (like \frac, \atop, \binom) are handled by MTTypesetter.makeFraction: and addDelimitersToFractionDisplay:forFraction::

• Bar Thickness: For \frac and \over, the bar thickness is set to FractionRuleThickness. For stack-based commands like \binom or \atop, the thickness is 0.
• Styles:
  • The numerator is typeset in a style one level higher than the current style (e.g., Display $\rightarrow$ TeX), with cramped:NO.
  • The denominator is typeset in the same style as the numerator, but with cramped:YES.
• Delimiters: If delimiters (like \left( and \right)) are provided, the fraction is wrapped in an MTMathListDisplay using glyphs of height fractionDelimiterDisplayStyleSize (Display) or fractionDelimiterSize (TeX).
• Alignment: Both numerator and denominator are reboxed to a common width by centering them at (width - their.width) / 2.