Added color and font styles.
This commit is contained in:
Michael Griebling
702
Sources/SwiftMathRender/MathRender/MTMathList.swift
Normal file
702
Sources/SwiftMathRender/MathRender/MTMathList.swift
Normal file
@@ -0,0 +1,702 @@
|
||||
//
|
||||
// MTMathList.swift
|
||||
// MathRenderSwift
|
||||
//
|
||||
// Created by Mike Griebling on 2022-12-31.
|
||||
//
|
||||
|
||||
import Foundation
|
||||
|
||||
// type defines spacing and how it is rendered
|
||||
public enum MTMathAtomType: String, CustomStringConvertible {
|
||||
case ordinary // number or text
|
||||
case number // number
|
||||
case variable // text in italic
|
||||
case largeOperator // sin/cos, integral
|
||||
case binaryOperator // \bin
|
||||
case unaryOperator //
|
||||
case relation // = < >
|
||||
case open // open bracket
|
||||
case close // close bracket
|
||||
case fraction // \frac
|
||||
case radical // \sqrt
|
||||
case punctuation // ,
|
||||
case placeholder // inner atom
|
||||
case inner // embedded list
|
||||
case underline // underlined atom
|
||||
case overline // overlined atom
|
||||
case accent // accented atom
|
||||
|
||||
// these atoms do not support subscripts/superscripts:
|
||||
case boundary
|
||||
case space
|
||||
|
||||
// Denotes style changes during randering
|
||||
case style
|
||||
case color
|
||||
case colorBox
|
||||
|
||||
case table
|
||||
|
||||
func isNotBinaryOperator() -> Bool {
|
||||
switch self {
|
||||
case .binaryOperator, .relation, .open, .punctuation, .largeOperator: return true
|
||||
default: return false
|
||||
}
|
||||
}
|
||||
|
||||
func isScriptAllowed() -> Bool {
|
||||
return self != .boundary && self != .space && self != .style && self != .table
|
||||
}
|
||||
|
||||
// we want string representations to be capitalized
|
||||
public var description: String {
|
||||
self.rawValue.capitalized
|
||||
}
|
||||
}
|
||||
|
||||
public enum MTFontStyle:Int {
|
||||
/// The default latex rendering style. i.e. variables are italic and numbers are roman.
|
||||
case defaultStyle = 0,
|
||||
/// Roman font style i.e. \mathrm
|
||||
roman,
|
||||
/// Bold font style i.e. \mathbf
|
||||
bold,
|
||||
/// Caligraphic font style i.e. \mathcal
|
||||
caligraphic,
|
||||
/// Typewriter (monospace) style i.e. \mathtt
|
||||
typewriter,
|
||||
/// Italic style i.e. \mathit
|
||||
italic,
|
||||
/// San-serif font i.e. \mathss
|
||||
sansSerif,
|
||||
/// Fractur font i.e \mathfrak
|
||||
fraktur,
|
||||
/// Blackboard font i.e. \mathbb
|
||||
blackboard,
|
||||
/// Bold italic
|
||||
boldItalic
|
||||
}
|
||||
|
||||
public class MTMathAtom: Any, CustomStringConvertible {
|
||||
public var type: MTMathAtomType
|
||||
public var subScript: MTMathList?
|
||||
public var superScript: MTMathList?
|
||||
var fontStyle: MTFontStyle = .defaultStyle
|
||||
var fusedAtoms: MTMathList?
|
||||
|
||||
public static func atom(withType type:MTMathAtomType, value:String) -> MTMathAtom {
|
||||
switch type {
|
||||
case .largeOperator:
|
||||
return MTLargeOperator(value: value, limits: true)
|
||||
case .fraction:
|
||||
return MTFraction()
|
||||
case .radical:
|
||||
return MTRadical()
|
||||
case .placeholder:
|
||||
return MTMathAtom(type: type, value: UnicodeSymbol.whiteSquare)
|
||||
case .inner:
|
||||
return MTInner()
|
||||
case .underline:
|
||||
return MTUnderLine()
|
||||
case .overline:
|
||||
return MTOverLine()
|
||||
case .accent:
|
||||
return MTAccent(value: value)
|
||||
case .space:
|
||||
return MTMathSpace(space: 0)
|
||||
case .color:
|
||||
return MTMathColor()
|
||||
case .colorBox:
|
||||
return MTMathColorbox()
|
||||
default:
|
||||
return MTMathAtom(type: type, value: value)
|
||||
}
|
||||
}
|
||||
|
||||
public func setSuperScript(_ list: MTMathList?) {
|
||||
if self.isScriptAllowed() {
|
||||
self.superScript = list
|
||||
} else {
|
||||
print("superscripts not allowed for atom \(self.type.rawValue)")
|
||||
self.superScript = nil
|
||||
}
|
||||
}
|
||||
|
||||
public func setSubScript(_ list: MTMathList?) {
|
||||
if self.isScriptAllowed() {
|
||||
self.subScript = list
|
||||
} else {
|
||||
print("subscripts not allowed for atom \(self.type.rawValue)")
|
||||
self.subScript = nil
|
||||
}
|
||||
}
|
||||
|
||||
public var description: String {
|
||||
var string = ""
|
||||
|
||||
string += self.nucleus
|
||||
if self.superScript != nil {
|
||||
string += "^{\(self.superScript!.description)}"
|
||||
}
|
||||
if self.subScript != nil {
|
||||
string += "_{\(self.subScript!.description)}"
|
||||
}
|
||||
|
||||
return string
|
||||
}
|
||||
|
||||
public var nucleus: String = ""
|
||||
public var finalized: MTMathAtom {
|
||||
let finalized = self
|
||||
if finalized.superScript != nil {
|
||||
finalized.superScript = finalized.superScript!.finalized
|
||||
}
|
||||
if finalized.subScript != nil {
|
||||
finalized.subScript = finalized.subScript!.finalized
|
||||
}
|
||||
return finalized
|
||||
}
|
||||
|
||||
// atoms that fused to create this one
|
||||
public var childAtoms = [MTMathAtom]()
|
||||
|
||||
// indexRange in list that this atom tracks:
|
||||
public var indexRange = NSRange(location: 0, length: 0)
|
||||
|
||||
public var string:String {
|
||||
var str = self.nucleus
|
||||
if let superScript = self.superScript {
|
||||
str.append("^{\(superScript.string)}")
|
||||
}
|
||||
if let subScript = self.subScript {
|
||||
str.append("_{\(subScript.string)}")
|
||||
}
|
||||
return str
|
||||
}
|
||||
|
||||
func fuse(with atom: MTMathAtom) {
|
||||
assert(self.subScript == nil, "Cannot fuse into an atom which has a subscript: \(self)");
|
||||
assert(self.superScript == nil, "Cannot fuse into an atom which has a superscript: \(self)");
|
||||
assert(atom.type == self.type, "Only atoms of the same type can be fused. \(self), \(atom)");
|
||||
guard self.subScript == nil,
|
||||
self.superScript == nil,
|
||||
self.type == atom.type
|
||||
else {
|
||||
print("Can't fuse these 2 atom")
|
||||
return
|
||||
}
|
||||
|
||||
self.childAtoms.append(self)
|
||||
if atom.childAtoms.count > 0 {
|
||||
self.childAtoms += atom.childAtoms
|
||||
} else {
|
||||
self.childAtoms.append(atom)
|
||||
}
|
||||
|
||||
// Update nucleus:
|
||||
self.nucleus += atom.nucleus
|
||||
|
||||
// Update range:
|
||||
self.indexRange.length += atom.indexRange.length
|
||||
|
||||
// Update super/subscript:
|
||||
self.superScript = atom.superScript
|
||||
self.subScript = atom.subScript
|
||||
}
|
||||
|
||||
func isScriptAllowed() -> Bool { self.type.isScriptAllowed() }
|
||||
|
||||
public init(type: MTMathAtomType, value: String) {
|
||||
self.type = type
|
||||
self.nucleus = value
|
||||
}
|
||||
|
||||
func isNotBinaryOperator() -> Bool { self.type.isNotBinaryOperator() }
|
||||
|
||||
}
|
||||
|
||||
func isNotBinaryOperator(_ prevNode:MTMathAtom?) -> Bool {
|
||||
if prevNode == nil { return true }
|
||||
return prevNode!.type.isNotBinaryOperator()
|
||||
}
|
||||
|
||||
public class MTFraction: MTMathAtom {
|
||||
public var hasRule: Bool = true
|
||||
public var leftDelimiter: String?
|
||||
public var rightDelimiter: String?
|
||||
public var numerator: MTMathList? = MTMathList()
|
||||
public var denominator: MTMathList? = MTMathList()
|
||||
|
||||
override public var description: String {
|
||||
var string = ""
|
||||
if self.hasRule {
|
||||
string += "\\atop"
|
||||
} else {
|
||||
string += "\\frac"
|
||||
}
|
||||
if self.leftDelimiter != nil {
|
||||
string += "[\(self.leftDelimiter!)]"
|
||||
}
|
||||
if self.rightDelimiter != nil {
|
||||
string += "[\(self.rightDelimiter!)]"
|
||||
}
|
||||
|
||||
string += "{\(self.numerator?.description ?? "placeholder")}{\(self.denominator?.description ?? "placeholder")}"
|
||||
|
||||
if self.superScript != nil {
|
||||
string += "^{\(self.superScript!.description)}"
|
||||
}
|
||||
if self.subScript != nil {
|
||||
string += "_{\(self.subScript!.description)}"
|
||||
}
|
||||
|
||||
return string
|
||||
}
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTFraction = super.finalized as! MTFraction
|
||||
|
||||
finalized.numerator = finalized.numerator?.finalized
|
||||
finalized.denominator = finalized.denominator?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
|
||||
convenience init(hasRule: Bool = true) {
|
||||
self.init(type: .fraction, value: "")
|
||||
self.hasRule = hasRule
|
||||
}
|
||||
}
|
||||
|
||||
public class MTRadical: MTMathAtom {
|
||||
// Under the roof
|
||||
var radicand: MTMathList? = MTMathList()
|
||||
|
||||
// Value on radical sign
|
||||
var degree: MTMathList?
|
||||
|
||||
convenience init() {
|
||||
self.init(type: .radical, value: "")
|
||||
}
|
||||
|
||||
override public var description: String {
|
||||
var string = "\\sqrt"
|
||||
|
||||
if self.degree != nil {
|
||||
string += "[\(self.degree!.description)]"
|
||||
}
|
||||
|
||||
if self.radicand != nil {
|
||||
string += "{\(self.radicand?.description ?? "placeholder")}"
|
||||
}
|
||||
|
||||
if self.superScript != nil {
|
||||
string += "^{\(self.superScript!.description)}"
|
||||
}
|
||||
if self.subScript != nil {
|
||||
string += "_{\(self.subScript!.description)}"
|
||||
}
|
||||
|
||||
return string
|
||||
}
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTRadical = super.finalized as! MTRadical
|
||||
|
||||
finalized.radicand = finalized.radicand?.finalized
|
||||
finalized.degree = finalized.degree?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
}
|
||||
|
||||
public class MTLargeOperator: MTMathAtom {
|
||||
var limits: Bool = false
|
||||
|
||||
convenience init(value: String, limits: Bool = false) {
|
||||
self.init(type: .largeOperator, value: value)
|
||||
self.limits = limits
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - MTInner
|
||||
|
||||
public class MTInner: MTMathAtom {
|
||||
var innerList: MTMathList?
|
||||
var leftBoundary: MTMathAtom? {
|
||||
didSet {
|
||||
if leftBoundary != nil && leftBoundary!.type != .boundary {
|
||||
assertionFailure("Left boundary must be of type .boundary")
|
||||
}
|
||||
}
|
||||
}
|
||||
var rightBoundary: MTMathAtom? {
|
||||
didSet {
|
||||
if rightBoundary != nil && rightBoundary!.type != .boundary {
|
||||
assertionFailure("Right boundary must be of type .boundary")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
init() {
|
||||
super.init(type: .inner, value: "")
|
||||
}
|
||||
|
||||
public override convenience init(type: MTMathAtomType, value: String) {
|
||||
if type == .inner {
|
||||
self.init(); return
|
||||
}
|
||||
assertionFailure("MTInner(type:value:) cannot be called. Use MTInner() instead.")
|
||||
self.init()
|
||||
}
|
||||
|
||||
override public var description: String {
|
||||
var string = "\\inner"
|
||||
|
||||
if self.leftBoundary != nil {
|
||||
string += "[\(self.leftBoundary!.nucleus)]"
|
||||
}
|
||||
string += "{\(self.innerList!.description)}"
|
||||
|
||||
if self.rightBoundary != nil {
|
||||
string += "[\(self.rightBoundary!.nucleus)]"
|
||||
}
|
||||
|
||||
if self.superScript != nil {
|
||||
string += "^{\(self.superScript!.description)}"
|
||||
}
|
||||
if self.subScript != nil {
|
||||
string += "_{\(self.subScript!.description)}"
|
||||
}
|
||||
|
||||
return string
|
||||
}
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTInner = super.finalized as! MTInner
|
||||
|
||||
finalized.innerList = finalized.innerList?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
}
|
||||
|
||||
public class MTOverLine: MTMathAtom {
|
||||
var innerList: MTMathList?
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTOverLine = super.finalized as! MTOverLine
|
||||
|
||||
finalized.innerList = finalized.innerList?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
|
||||
convenience init() {
|
||||
self.init(type: .overline, value: "")
|
||||
}
|
||||
}
|
||||
|
||||
public class MTUnderLine: MTMathAtom {
|
||||
var innerList: MTMathList?
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTUnderLine = super.finalized as! MTUnderLine
|
||||
|
||||
finalized.innerList = finalized.innerList?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
|
||||
convenience init() {
|
||||
self.init(type: .underline, value: "")
|
||||
}
|
||||
}
|
||||
|
||||
public class MTAccent: MTMathAtom {
|
||||
var innerList: MTMathList?
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTAccent = super.finalized as! MTAccent
|
||||
|
||||
finalized.innerList = finalized.innerList?.finalized
|
||||
|
||||
return finalized
|
||||
}
|
||||
|
||||
convenience init(value: String) {
|
||||
self.init(type: .accent, value: value)
|
||||
}
|
||||
}
|
||||
|
||||
public class MTMathSpace: MTMathAtom {
|
||||
var space: CGFloat = 0
|
||||
|
||||
convenience init(space: CGFloat) {
|
||||
self.init(type: .space, value: "")
|
||||
self.space = space
|
||||
}
|
||||
}
|
||||
|
||||
public enum MTLineStyle {
|
||||
case display
|
||||
case text
|
||||
case script
|
||||
case scriptOfScript
|
||||
|
||||
public func inc() -> MTLineStyle {
|
||||
switch self {
|
||||
case .display: return .text
|
||||
case .text: return .script
|
||||
case .script: return .scriptOfScript
|
||||
case .scriptOfScript: return .display
|
||||
}
|
||||
}
|
||||
|
||||
public var isNotScript:Bool {
|
||||
self == .display || self == .text
|
||||
}
|
||||
}
|
||||
|
||||
public class MTMathStyle: MTMathAtom {
|
||||
var style: MTLineStyle = .display
|
||||
|
||||
convenience init(style: MTLineStyle = .display) {
|
||||
self.init(type: .space, value: "")
|
||||
self.style = style
|
||||
}
|
||||
}
|
||||
|
||||
public class MTMathColor: MTMathAtom {
|
||||
public var colorString:String=""
|
||||
public var innerList:MTMathList?
|
||||
|
||||
init() {
|
||||
super.init(type: .color, value: "")
|
||||
}
|
||||
|
||||
public override convenience init(type: MTMathAtomType, value: String) {
|
||||
if type == .color {
|
||||
self.init(); return
|
||||
}
|
||||
NSException(name: NSExceptionName("InvalidMethod"), reason: "MTMathColor(type:value) cannot be called. Use MTMathColor() instead.").raise()
|
||||
self.init()
|
||||
}
|
||||
|
||||
public override var string: String {
|
||||
"\\color{\(self.colorString)}{\(self.innerList!.string)}"
|
||||
}
|
||||
}
|
||||
|
||||
public class MTMathColorbox: MTMathAtom {
|
||||
public var colorString:String=""
|
||||
public var innerList:MTMathList?
|
||||
|
||||
init() {
|
||||
super.init(type: .color, value: "")
|
||||
}
|
||||
|
||||
public override convenience init(type: MTMathAtomType, value: String) {
|
||||
if type == .color {
|
||||
self.init(); return
|
||||
}
|
||||
NSException(name: NSExceptionName("InvalidMethod"), reason: "MTMathColorbox(type:value) cannot be called. Use MTMathColorbox() instead.").raise()
|
||||
self.init()
|
||||
}
|
||||
|
||||
public override var string: String {
|
||||
"\\colorbox{\(self.colorString)}{\(self.innerList!.string)}"
|
||||
}
|
||||
}
|
||||
|
||||
public enum MTColumnAlignment {
|
||||
case left
|
||||
case center
|
||||
case right
|
||||
}
|
||||
|
||||
public class MTMathTable: MTMathAtom {
|
||||
var alignments = [MTColumnAlignment]()
|
||||
var cells = [[MTMathList]]()
|
||||
|
||||
var environment: String?
|
||||
var interColumnSpacing: CGFloat = 0
|
||||
var interRowAdditionalSpacing: CGFloat = 0
|
||||
var numColumns = 0
|
||||
var numRows = 0
|
||||
|
||||
override public var finalized: MTMathAtom {
|
||||
let finalized: MTMathTable = super.finalized as! MTMathTable
|
||||
|
||||
for var row in finalized.cells {
|
||||
for i in 0..<row.count {
|
||||
row[i] = row[i].finalized
|
||||
}
|
||||
}
|
||||
|
||||
return finalized
|
||||
}
|
||||
|
||||
convenience init(environment: String? = nil) {
|
||||
self.init(type: .table, value: "")
|
||||
self.environment = environment
|
||||
}
|
||||
|
||||
func set(cell list: MTMathList, forRow row:Int, column:Int) {
|
||||
if self.cells.count <= row {
|
||||
for _ in self.cells.count...row {
|
||||
self.cells.append([])
|
||||
}
|
||||
}
|
||||
var rowArray = self.cells[row]
|
||||
if rowArray.count <= column {
|
||||
for _ in rowArray.count...column {
|
||||
rowArray.append(MTMathList())
|
||||
}
|
||||
}
|
||||
rowArray[column] = list
|
||||
}
|
||||
|
||||
func set(alignment: MTColumnAlignment, forCol col: Int) {
|
||||
if self.alignments.count <= col {
|
||||
for _ in self.alignments.count...col {
|
||||
self.alignments.append(MTColumnAlignment.center)
|
||||
}
|
||||
}
|
||||
|
||||
self.alignments[col] = alignment
|
||||
}
|
||||
|
||||
func getAlignmentOf(col: Int) -> MTColumnAlignment {
|
||||
if self.alignments.count <= col {
|
||||
return MTColumnAlignment.center
|
||||
} else {
|
||||
return self.alignments[col]
|
||||
}
|
||||
}
|
||||
|
||||
func numberOfCols() -> Int {
|
||||
var numberOfCols = 0
|
||||
|
||||
for row in self.cells {
|
||||
numberOfCols = max(numberOfCols, row.count)
|
||||
}
|
||||
|
||||
return numberOfCols
|
||||
}
|
||||
|
||||
func numberOfRows() -> Int {
|
||||
return self.cells.count
|
||||
}
|
||||
}
|
||||
|
||||
// represent list of math objects
|
||||
extension MTMathList: CustomStringConvertible {
|
||||
public var description: String { self.atoms.description }
|
||||
public var string: String { self.description }
|
||||
}
|
||||
|
||||
public class MTMathList {
|
||||
public var atoms = [MTMathAtom]()
|
||||
|
||||
public var finalized: MTMathList {
|
||||
let finalizedList = MTMathList()
|
||||
let zeroRange = NSMakeRange(0, 0)
|
||||
|
||||
var prevNode: MTMathAtom? = nil
|
||||
for atom in self.atoms {
|
||||
let newNode = atom.finalized
|
||||
|
||||
if NSEqualRanges(zeroRange, atom.indexRange) {
|
||||
let index = prevNode == nil ? 0 : prevNode!.indexRange.location + prevNode!.indexRange.length
|
||||
newNode.indexRange = NSMakeRange(index, 1)
|
||||
}
|
||||
|
||||
switch newNode.type {
|
||||
case .binaryOperator:
|
||||
if prevNode == nil || prevNode!.isNotBinaryOperator() {
|
||||
newNode.type = .unaryOperator
|
||||
}
|
||||
break
|
||||
case .relation, .punctuation, .close:
|
||||
if prevNode != nil &&
|
||||
prevNode!.type == .binaryOperator {
|
||||
prevNode!.type = .unaryOperator
|
||||
}
|
||||
break
|
||||
case .number:
|
||||
if prevNode != nil &&
|
||||
prevNode!.type == .number &&
|
||||
prevNode!.subScript == nil &&
|
||||
prevNode!.superScript == nil {
|
||||
prevNode!.fuse(with: newNode)
|
||||
continue
|
||||
}
|
||||
break
|
||||
default: break
|
||||
}
|
||||
|
||||
finalizedList.add(newNode)
|
||||
prevNode = newNode
|
||||
}
|
||||
|
||||
if prevNode != nil && prevNode!.type == .binaryOperator {
|
||||
prevNode!.type = .unaryOperator
|
||||
finalizedList.removeLastAtom()
|
||||
finalizedList.add(prevNode!)
|
||||
}
|
||||
|
||||
return finalizedList
|
||||
}
|
||||
|
||||
public init(atoms: [MTMathAtom]) {
|
||||
self.atoms.append(contentsOf: atoms)
|
||||
}
|
||||
|
||||
public init(atom: MTMathAtom) {
|
||||
self.atoms.append(atom)
|
||||
}
|
||||
|
||||
public init() {
|
||||
self.atoms = []
|
||||
}
|
||||
|
||||
func add(_ atom: MTMathAtom) {
|
||||
if self.isAtomAllowed(atom) {
|
||||
self.atoms.append(atom)
|
||||
} else {
|
||||
print("error, cannot add atom of type \(atom.type.rawValue) into atomlist")
|
||||
}
|
||||
}
|
||||
|
||||
func insert(_ atom: MTMathAtom, at index: Int) {
|
||||
if self.isAtomAllowed(atom) {
|
||||
self.atoms.insert(atom, at: index)
|
||||
} else {
|
||||
print("error, cannot add atom of type \(atom.type.rawValue) into atomlist")
|
||||
}
|
||||
}
|
||||
|
||||
func append(_ list: MTMathList) {
|
||||
self.atoms += list.atoms
|
||||
}
|
||||
|
||||
func removeLastAtom() {
|
||||
if self.atoms.count > 0 {
|
||||
self.atoms.removeLast()
|
||||
}
|
||||
}
|
||||
|
||||
func removeAtom(at index: Int) {
|
||||
self.atoms.remove(at: index)
|
||||
}
|
||||
|
||||
func removeAtoms(in range: ClosedRange<Int>) {
|
||||
self.atoms.removeSubrange(range)
|
||||
}
|
||||
|
||||
func isAtomAllowed(_ atom: MTMathAtom) -> Bool {
|
||||
return atom.type != .boundary
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user