Fraction data model + parser

iosMath/lib/MTMathList.h

@@ -205,6 +205,39 @@ typedef NS_ENUM(NSUInteger, MTTextStyle)
 
 @end
 
+/**
+ @typedef MTFractionStyle
+ @brief Explicit math style for a fraction (the AMSMath \genfrac style digit).
+
+ - kMTFractionStyleAuto: Honor the surrounding style via TeX Rule 15a
+   (one step smaller for operands; same style as parent for the bar/metrics).
+   This is the default and corresponds to plain \frac/\binom/\atop/\over.
+ - kMTFractionStyleDisplay: Force display style for this fraction
+   (\dfrac, \dbinom, \cfrac).
+ - kMTFractionStyleText: Force text style (\tfrac, \tbinom).
+ - kMTFractionStyleScript / kMTFractionStyleScriptScript: Reserved for
+   future \genfrac support. Not produced by any command in this LLD's
+   scope, but valid values for forward use.
+ */
+typedef NS_ENUM(NSUInteger, MTFractionStyle) {
+    kMTFractionStyleAuto = 0,
+    kMTFractionStyleDisplay,
+    kMTFractionStyleText,
+    kMTFractionStyleScript,
+    kMTFractionStyleScriptScript,
+};
+
+/**
+ @typedef MTFractionAlignment
+ @brief Horizontal alignment of the numerator within the fraction column.
+ Only \cfrac[l]/[c]/[r] sets a non-center value.
+ */
+typedef NS_ENUM(NSUInteger, MTFractionAlignment) {
+    kMTFractionAlignmentCenter = 0,
+    kMTFractionAlignmentLeft,
+    kMTFractionAlignmentRight,
+};
+
 /** An atom of type fraction. This atom has a numerator and denominator. */
 @interface MTFraction : MTMathAtom
 
@@ -228,6 +261,30 @@ typedef NS_ENUM(NSUInteger, MTTextStyle)
 /** An optional delimiter for a fraction on the right. */
 @property (nonatomic, nullable) NSString* rightDelimiter;
 
+/** Optional explicit style override for this fraction. Default
+ kMTFractionStyleAuto means: honor the surrounding style via TeX Rule 15a.
+ \dfrac and \dbinom set this to kMTFractionStyleDisplay; \tfrac and \tbinom
+ set this to kMTFractionStyleText; \cfrac sets this to kMTFractionStyleDisplay. */
+@property (nonatomic) MTFractionStyle styleOverride;
+
+/** True for \cfrac. The typesetter uses this flag to apply AMSMath's
+ strut equivalents to both operand displays and to wrap the rendered
+ fraction with surrounding 3mu thin space. Does not affect the style
+ decision, which is encoded in styleOverride.
+
+ Not persisted by appendLaTeXToString:/+[MTMathListBuilder mathListToString:]:
+ \cfrac serializes as \frac{\displaystyle{...}}{\displaystyle{...}}, so a
+ latex -> MTMathList -> latex round trip drops this flag. */
+@property (nonatomic) BOOL isContinuedFraction;
+
+/** Numerator alignment within max(numWidth, denWidth). Default
+ kMTFractionAlignmentCenter. Only \cfrac[l]/[r] sets a non-default value.
+
+ Not persisted by appendLaTeXToString:/+[MTMathListBuilder mathListToString:]:
+ the [l]/[r] optional argument is not emitted, so a round trip drops this
+ alignment. */
+@property (nonatomic) MTFractionAlignment numeratorAlignment;
+
 @end
 
 /** An atom of type radical (square root). */

iosMath/lib/MTMathList.m

@@ -365,6 +365,9 @@ - (id)copyWithZone:(NSZone *)zone
     frac->_hasRule = self.hasRule;
     frac.leftDelimiter = [self.leftDelimiter copyWithZone:zone];
     frac.rightDelimiter = [self.rightDelimiter copyWithZone:zone];
+    frac.styleOverride = self.styleOverride;
+    frac.isContinuedFraction = self.isContinuedFraction;
+    frac.numeratorAlignment = self.numeratorAlignment;
     return frac;
 }
 
@@ -378,12 +381,31 @@ - (instancetype)finalized
 
 - (void)appendLaTeXToString:(NSMutableString *)str
 {
+    NSString* numLatex = [MTMathListBuilder mathListToString:self.numerator];
+    NSString* denLatex = [MTMathListBuilder mathListToString:self.denominator];
+    NSString* (^wrap)(NSString*) = ^NSString*(NSString* inner) {
+        switch (self.styleOverride) {
+            case kMTFractionStyleDisplay:
+                return [NSString stringWithFormat:@"\\displaystyle{%@}", inner];
+            case kMTFractionStyleText:
+                return [NSString stringWithFormat:@"\\textstyle{%@}", inner];
+            case kMTFractionStyleScript:
+                return [NSString stringWithFormat:@"\\scriptstyle{%@}", inner];
+            case kMTFractionStyleScriptScript:
+                return [NSString stringWithFormat:@"\\scriptscriptstyle{%@}", inner];
+            case kMTFractionStyleAuto:
+            default:
+                return inner;
+        }
+    };
+    NSString* numWrapped = wrap(numLatex);
+    NSString* denWrapped = wrap(denLatex);
     if (self.hasRule) {
-        [str appendFormat:@"\\frac{%@}{%@}", [MTMathListBuilder mathListToString:self.numerator], [MTMathListBuilder mathListToString:self.denominator]];
+        [str appendFormat:@"\\frac{%@}{%@}", numWrapped, denWrapped];
         return;
     }
     NSString* command = fractionCommandForDelimiterPair(self.leftDelimiter, self.rightDelimiter);
-    [str appendFormat:@"{%@ \\%@ %@}", [MTMathListBuilder mathListToString:self.numerator], command, [MTMathListBuilder mathListToString:self.denominator]];
+    [str appendFormat:@"{%@ \\%@ %@}", numWrapped, command, denWrapped];
 }
 
 @end

iosMath/lib/MTMathListBuilder.m

@@ -84,6 +84,60 @@ - (void) unlookCharacter
     _currentChar--;
 }
 
+// Reads an optional [l|c|r] argument for \cfrac. If the next character is '[',
+// consumes one letter (l|c|r), then ']', writes the corresponding
+// MTFractionAlignment to *outAlignment, returns YES. If the bracket body is
+// anything else, calls -setError: and still returns YES (consumption happened);
+// the caller should bail on _error. If the next character is not '[', restores
+// the position and returns NO.
+- (BOOL) readOptionalAlignment:(MTFractionAlignment*)outAlignment
+{
+    if (![self hasCharacters]) {
+        return NO;
+    }
+    unichar ch = [self getNextCharacter];
+    if (ch != '[') {
+        [self unlookCharacter];
+        return NO;
+    }
+    // Read one alignment letter
+    if (![self hasCharacters]) {
+        [self setError:MTParseErrorInvalidCommand
+               message:@"Unterminated optional alignment for \\cfrac"];
+        return YES;
+    }
+    unichar letter = [self getNextCharacter];
+    MTFractionAlignment alignment;
+    switch (letter) {
+        case 'l': alignment = kMTFractionAlignmentLeft;   break;
+        case 'c': alignment = kMTFractionAlignmentCenter; break;
+        case 'r': alignment = kMTFractionAlignmentRight;  break;
+        default: {
+            NSString* errorMessage = [NSString stringWithFormat:
+                @"Invalid alignment for \\cfrac: '%C' (expected l, c, or r)", letter];
+            [self setError:MTParseErrorInvalidCommand message:errorMessage];
+            return YES;
+        }
+    }
+    // Require closing ']'
+    if (![self hasCharacters]) {
+        [self setError:MTParseErrorInvalidCommand
+               message:@"Unterminated optional alignment for \\cfrac"];
+        return YES;
+    }
+    unichar close = [self getNextCharacter];
+    if (close != ']') {
+        NSString* errorMessage = [NSString stringWithFormat:
+            @"Expected ']' to close \\cfrac alignment, got '%C'", close];
+        [self setError:MTParseErrorInvalidCommand message:errorMessage];
+        return YES;
+    }
+    if (outAlignment) {
+        *outAlignment = alignment;
+    }
+    return YES;
+}
+
 - (MTMathList *)build
 {
     MTMathList* list = [self buildInternal:false];
@@ -653,25 +707,42 @@ - (MTMathAtom*) atomForCommand:(NSString*) command
                                                         mathClass:mathClass
                                                              size:size];
     }
+    NSDictionary<NSString*, NSDictionary*>* fracTable = [MTMathListBuilder fractionMacroCommands];
+    NSDictionary* fracSpec = fracTable[command];
+    if (fracSpec) {
+        BOOL hasRule = [fracSpec[@"hasRule"] boolValue];
+        MTFractionStyle style = (MTFractionStyle)[fracSpec[@"style"] unsignedIntegerValue];
+        MTFraction* frac = hasRule ? [MTFraction new] : [[MTFraction alloc] initWithRule:NO];
+        frac.styleOverride = style;
+        if ([fracSpec[@"acceptsAlign"] boolValue]) {
+            MTFractionAlignment alignment = kMTFractionAlignmentCenter;
+            if ([self readOptionalAlignment:&alignment]) {
+                if (_error) {
+                    return nil;
+                }
+                frac.numeratorAlignment = alignment;
+            }
+        }
+        if ([fracSpec[@"continued"] boolValue]) {
+            frac.isContinuedFraction = YES;
+        }
+        frac.numerator = [self buildInternal:true];
+        frac.denominator = [self buildInternal:true];
+        NSString* leftDelim = fracSpec[@"leftDelim"];
+        NSString* rightDelim = fracSpec[@"rightDelim"];
+        if (leftDelim) {
+            frac.leftDelimiter = leftDelim;
+        }
+        if (rightDelim) {
+            frac.rightDelimiter = rightDelim;
+        }
+        return frac;
+    }
     MTAccent* accent = [MTMathAtomFactory accentWithName:command];
     if (accent) {
         // The command is an accent
         accent.innerList = [self buildInternal:true];
         return accent;
-    } else if ([command isEqualToString:@"frac"]) {
-        // A fraction command has 2 arguments
-        MTFraction* frac = [MTFraction new];
-        frac.numerator = [self buildInternal:true];
-        frac.denominator = [self buildInternal:true];
-        return frac;
-    } else if ([command isEqualToString:@"binom"]) {
-        // A binom command has 2 arguments
-        MTFraction* frac = [[MTFraction alloc] initWithRule:NO];
-        frac.numerator = [self buildInternal:true];
-        frac.denominator = [self buildInternal:true];
-        frac.leftDelimiter = @"(";
-        frac.rightDelimiter = @")";
-        return frac;
     } else if ([command isEqualToString:@"sqrt"]) {
         // A sqrt command with one argument
         MTRadical* rad = [MTRadical new];
@@ -959,6 +1030,39 @@ + (NSDictionary*) spaceToCommands
     return largeDelimiterCommands;
 }
 
++ (NSDictionary<NSString*, NSDictionary*>*) fractionMacroCommands
+{
+    static NSDictionary<NSString*, NSDictionary*>* fractionMacroCommands = nil;
+    static dispatch_once_t fractionOnceToken;
+    dispatch_once(&fractionOnceToken, ^{
+        fractionMacroCommands = @{
+            @"frac"   : @{ @"hasRule": @YES,
+                           @"style":   @(kMTFractionStyleAuto) },
+            @"binom"  : @{ @"hasRule":    @NO,
+                           @"leftDelim":  @"(",
+                           @"rightDelim": @")",
+                           @"style":      @(kMTFractionStyleAuto) },
+            @"dfrac"  : @{ @"hasRule": @YES,
+                           @"style":   @(kMTFractionStyleDisplay) },
+            @"tfrac"  : @{ @"hasRule": @YES,
+                           @"style":   @(kMTFractionStyleText) },
+            @"dbinom" : @{ @"hasRule":    @NO,
+                           @"leftDelim":  @"(",
+                           @"rightDelim": @")",
+                           @"style":      @(kMTFractionStyleDisplay) },
+            @"tbinom" : @{ @"hasRule":    @NO,
+                           @"leftDelim":  @"(",
+                           @"rightDelim": @")",
+                           @"style":      @(kMTFractionStyleText) },
+            @"cfrac"  : @{ @"hasRule":      @YES,
+                           @"style":       @(kMTFractionStyleDisplay),
+                           @"continued":   @YES,
+                           @"acceptsAlign":@YES },
+        };
+    });
+    return fractionMacroCommands;
+}
+
 + (NSDictionary*) styleToCommands
 {
     static NSDictionary* styleToCommands = nil;