d803bfe2b1
git-subtree-dir: vendor/ruvector git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900
49 KiB
49 KiB
LaTeX Generation and Mathematical Expression Pipeline
Project: ruvector-scipix Component: LaTeX/Math Processing Specialist Version: 1.0.0 Last Updated: 2025-11-28
Table of Contents
- Mathematical Symbol Recognition
- LaTeX Token Generation
- Expression Tree Representation
- Output Format Specifications
- Chemistry Notation (SMILES)
- Rust Implementation Patterns
- Performance Considerations
- Testing Strategy
1. Mathematical Symbol Recognition
1.1 Symbol Categories
The LaTeX pipeline must recognize and classify mathematical symbols into distinct categories for proper rendering.
Greek Letters
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum GreekLetter {
// Lowercase
Alpha, Beta, Gamma, Delta, Epsilon, Zeta, Eta, Theta,
Iota, Kappa, Lambda, Mu, Nu, Xi, Omicron, Pi,
Rho, Sigma, Tau, Upsilon, Phi, Chi, Psi, Omega,
// Uppercase
CapitalGamma, CapitalDelta, CapitalTheta, CapitalLambda,
CapitalXi, CapitalPi, CapitalSigma, CapitalUpsilon,
CapitalPhi, CapitalPsi, CapitalOmega,
// Variants
VarEpsilon, VarTheta, VarPi, VarRho, VarSigma, VarPhi,
}
impl GreekLetter {
pub fn to_latex(&self) -> &'static str {
match self {
Self::Alpha => r"\alpha",
Self::Beta => r"\beta",
Self::Gamma => r"\gamma",
Self::Delta => r"\delta",
Self::Epsilon => r"\epsilon",
Self::VarEpsilon => r"\varepsilon",
Self::CapitalGamma => r"\Gamma",
// ... complete mapping
_ => "",
}
}
}
Mathematical Operators
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MathOperator {
// Binary operators
Plus, Minus, Times, Divide, Dot, Cross, Wedge, Vee,
Cap, Cup, Oplus, Ominus, Otimes, Oslash,
// Relational operators
Equals, NotEquals, Less, Greater, LessEq, GreaterEq,
Approx, Equiv, Sim, Cong, Propto,
// Large operators
Sum, Product, Integral, DoubleIntegral, TripleIntegral,
ContourIntegral, Limit, Supremum, Infimum,
// Set operators
In, NotIn, Subset, Superset, SubsetEq, SupersetEq,
Union, Intersection, EmptySet,
// Logic operators
And, Or, Not, Implies, Iff, Forall, Exists,
}
impl MathOperator {
pub fn to_latex(&self) -> &'static str {
match self {
Self::Plus => "+",
Self::Minus => "-",
Self::Times => r"\times",
Self::Divide => r"\div",
Self::Sum => r"\sum",
Self::Integral => r"\int",
Self::Subset => r"\subset",
Self::Forall => r"\forall",
// ... complete mapping
_ => "",
}
}
pub fn is_large_operator(&self) -> bool {
matches!(self,
Self::Sum | Self::Product | Self::Integral |
Self::DoubleIntegral | Self::TripleIntegral |
Self::Limit | Self::Supremum | Self::Infimum
)
}
pub fn requires_limits(&self) -> bool {
self.is_large_operator()
}
}
Fractions and Roots
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum FractionType {
/// Standard fraction: \frac{num}{den}
Standard,
/// Display style fraction: \dfrac{num}{den}
Display,
/// Text style fraction: \tfrac{num}{den}
Text,
/// Continued fraction: \cfrac{num}{den}
Continued,
/// Binomial coefficient: \binom{n}{k}
Binomial,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum RootType {
/// Square root: \sqrt{expr}
Square,
/// Nth root: \sqrt[n]{expr}
Nth(Box<MathExpr>),
}
Subscripts and Superscripts
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Script {
pub base: Box<MathExpr>,
pub subscript: Option<Box<MathExpr>>,
pub superscript: Option<Box<MathExpr>>,
}
impl Script {
pub fn to_latex(&self) -> String {
let mut result = self.base.to_latex();
if let Some(sub) = &self.subscript {
result.push('_');
if self.needs_braces(&sub) {
result.push('{');
result.push_str(&sub.to_latex());
result.push('}');
} else {
result.push_str(&sub.to_latex());
}
}
if let Some(sup) = &self.superscript {
result.push('^');
if self.needs_braces(&sup) {
result.push('{');
result.push_str(&sup.to_latex());
result.push('}');
} else {
result.push_str(&sup.to_latex());
}
}
result
}
fn needs_braces(&self, expr: &MathExpr) -> bool {
!matches!(expr, MathExpr::Symbol(_) | MathExpr::Number(_))
}
}
Matrices, Vectors, and Tensors
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MatrixType {
/// Standard matrix: \begin{matrix}...\end{matrix}
Plain,
/// Parentheses: \begin{pmatrix}...\end{pmatrix}
Paren,
/// Brackets: \begin{bmatrix}...\end{bmatrix}
Bracket,
/// Braces: \begin{Bmatrix}...\end{Bmatrix}
Brace,
/// Vertical bars: \begin{vmatrix}...\end{vmatrix}
Vbar,
/// Double vertical bars: \begin{Vmatrix}...\end{Vmatrix}
DoubleVbar,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Matrix {
pub matrix_type: MatrixType,
pub rows: Vec<Vec<MathExpr>>,
}
impl Matrix {
pub fn to_latex(&self) -> String {
let env_name = match self.matrix_type {
MatrixType::Plain => "matrix",
MatrixType::Paren => "pmatrix",
MatrixType::Bracket => "bmatrix",
MatrixType::Brace => "Bmatrix",
MatrixType::Vbar => "vmatrix",
MatrixType::DoubleVbar => "Vmatrix",
};
let mut result = format!(r"\begin{{{}}}", env_name);
for (i, row) in self.rows.iter().enumerate() {
if i > 0 {
result.push_str(r" \\ ");
}
for (j, cell) in row.iter().enumerate() {
if j > 0 {
result.push_str(" & ");
}
result.push_str(&cell.to_latex());
}
}
result.push_str(&format!(r" \end{{{}}}", env_name));
result
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Vector {
pub components: Vec<MathExpr>,
pub style: VectorStyle,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum VectorStyle {
/// Column vector
Column,
/// Row vector
Row,
/// Arrow notation: \vec{v}
Arrow,
/// Bold notation: \mathbf{v}
Bold,
}
Limits and Integrals
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Limit {
pub operator: MathOperator,
pub lower: Option<Box<MathExpr>>,
pub upper: Option<Box<MathExpr>>,
}
impl Limit {
pub fn to_latex(&self, display_mode: bool) -> String {
let op = self.operator.to_latex();
let mut result = String::from(op);
if let Some(lower) = &self.lower {
result.push_str("_{");
result.push_str(&lower.to_latex());
result.push('}');
}
if let Some(upper) = &self.upper {
result.push_str("^{");
result.push_str(&upper.to_latex());
result.push('}');
}
if display_mode && self.operator.requires_limits() {
format!(r"\limits {}", result)
} else {
result
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Integral {
pub integral_type: IntegralType,
pub lower_limit: Option<Box<MathExpr>>,
pub upper_limit: Option<Box<MathExpr>>,
pub integrand: Box<MathExpr>,
pub variable: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum IntegralType {
Single,
Double,
Triple,
Contour,
Surface,
Volume,
}
2. LaTeX Token Generation
2.1 Symbol-to-LaTeX Mapping Table
use std::collections::HashMap;
use once_cell::sync::Lazy;
/// Global symbol mapping table for efficient lookup
pub static SYMBOL_MAP: Lazy<HashMap<&'static str, &'static str>> = Lazy::new(|| {
let mut m = HashMap::new();
// Greek letters
m.insert("α", r"\alpha");
m.insert("β", r"\beta");
m.insert("γ", r"\gamma");
m.insert("δ", r"\delta");
m.insert("ε", r"\epsilon");
m.insert("θ", r"\theta");
m.insert("λ", r"\lambda");
m.insert("μ", r"\mu");
m.insert("π", r"\pi");
m.insert("σ", r"\sigma");
m.insert("φ", r"\phi");
m.insert("ω", r"\omega");
// Operators
m.insert("≤", r"\leq");
m.insert("≥", r"\geq");
m.insert("≠", r"\neq");
m.insert("≈", r"\approx");
m.insert("≡", r"\equiv");
m.insert("∈", r"\in");
m.insert("∉", r"\notin");
m.insert("⊂", r"\subset");
m.insert("⊆", r"\subseteq");
m.insert("∪", r"\cup");
m.insert("∩", r"\cap");
m.insert("∅", r"\emptyset");
m.insert("∞", r"\infty");
m.insert("∇", r"\nabla");
m.insert("∂", r"\partial");
m.insert("∫", r"\int");
m.insert("∑", r"\sum");
m.insert("∏", r"\prod");
m.insert("√", r"\sqrt");
m.insert("±", r"\pm");
m.insert("×", r"\times");
m.insert("÷", r"\div");
m.insert("⋅", r"\cdot");
// Logic
m.insert("∧", r"\land");
m.insert("∨", r"\lor");
m.insert("¬", r"\neg");
m.insert("⇒", r"\Rightarrow");
m.insert("⇔", r"\Leftrightarrow");
m.insert("∀", r"\forall");
m.insert("∃", r"\exists");
// Arrows
m.insert("→", r"\to");
m.insert("←", r"\leftarrow");
m.insert("↔", r"\leftrightarrow");
m.insert("⇒", r"\Rightarrow");
m.insert("⇐", r"\Leftarrow");
m.insert("⇔", r"\Leftrightarrow");
m
});
pub fn unicode_to_latex(symbol: &str) -> Option<&'static str> {
SYMBOL_MAP.get(symbol).copied()
}
2.2 Structural Tokens
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum StructuralToken {
/// Fraction: \frac{numerator}{denominator}
Frac {
numerator: Box<MathExpr>,
denominator: Box<MathExpr>,
frac_type: FractionType,
},
/// Square root: \sqrt{expr} or \sqrt[n]{expr}
Sqrt {
root_type: RootType,
expr: Box<MathExpr>,
},
/// Summation: \sum_{lower}^{upper}
Sum {
lower: Option<Box<MathExpr>>,
upper: Option<Box<MathExpr>>,
},
/// Product: \prod_{lower}^{upper}
Prod {
lower: Option<Box<MathExpr>>,
upper: Option<Box<MathExpr>>,
},
/// Integral: \int_{lower}^{upper}
Int {
integral_type: IntegralType,
lower: Option<Box<MathExpr>>,
upper: Option<Box<MathExpr>>,
},
/// Limit: \lim_{var \to value}
Lim {
variable: String,
approach: Box<MathExpr>,
},
/// Matrix environment
Matrix(Matrix),
/// Cases environment: \begin{cases}...\end{cases}
Cases {
cases: Vec<(MathExpr, MathExpr)>, // (expression, condition)
},
}
impl StructuralToken {
pub fn to_latex(&self) -> String {
match self {
Self::Frac { numerator, denominator, frac_type } => {
let cmd = match frac_type {
FractionType::Standard => r"\frac",
FractionType::Display => r"\dfrac",
FractionType::Text => r"\tfrac",
FractionType::Continued => r"\cfrac",
FractionType::Binomial => r"\binom",
};
format!("{}{{{}}}{{{}}}",
cmd,
numerator.to_latex(),
denominator.to_latex()
)
}
Self::Sqrt { root_type, expr } => {
match root_type {
RootType::Square => format!(r"\sqrt{{{}}}", expr.to_latex()),
RootType::Nth(n) => format!(
r"\sqrt[{{{}}}]{{{}}}",
n.to_latex(),
expr.to_latex()
),
}
}
Self::Cases { cases } => {
let mut result = String::from(r"\begin{cases}");
for (i, (expr, cond)) in cases.iter().enumerate() {
if i > 0 {
result.push_str(r" \\ ");
}
result.push_str(&format!(
"{} & \\text{{if }} {}",
expr.to_latex(),
cond.to_latex()
));
}
result.push_str(r" \end{cases}");
result
}
_ => String::new(),
}
}
}
2.3 Delimiter Handling
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Delimiter {
Paren, // ( )
Bracket, // [ ]
Brace, // { }
Angle, // ⟨ ⟩
Pipe, // | |
DoublePipe, // ‖ ‖
Floor, // ⌊ ⌋
Ceiling, // ⌈ ⌉
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DelimitedExpr {
pub delimiter: Delimiter,
pub content: Box<MathExpr>,
pub auto_size: bool,
}
impl DelimitedExpr {
pub fn to_latex(&self) -> String {
let (left, right) = match self.delimiter {
Delimiter::Paren => ("(", ")"),
Delimiter::Bracket => ("[", "]"),
Delimiter::Brace => (r"\{", r"\}"),
Delimiter::Angle => (r"\langle", r"\rangle"),
Delimiter::Pipe => ("|", "|"),
Delimiter::DoublePipe => (r"\|", r"\|"),
Delimiter::Floor => (r"\lfloor", r"\rfloor"),
Delimiter::Ceiling => (r"\lceil", r"\rceil"),
};
if self.auto_size {
format!(r"\left{} {} \right{}", left, self.content.to_latex(), right)
} else {
format!("{} {} {}", left, self.content.to_latex(), right)
}
}
}
3. Expression Tree Representation
3.1 Node Types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MathExpr {
/// Single symbol (variable, constant)
Symbol(String),
/// Numeric literal
Number(Number),
/// Greek letter
Greek(GreekLetter),
/// Operator
Operator(MathOperator),
/// Binary operation
Binary {
op: MathOperator,
left: Box<MathExpr>,
right: Box<MathExpr>,
},
/// Unary operation
Unary {
op: MathOperator,
operand: Box<MathExpr>,
},
/// Function application: f(x)
Function {
name: String,
args: Vec<MathExpr>,
},
/// Subscript/superscript
Script(Script),
/// Structural token (fraction, root, etc.)
Structural(StructuralToken),
/// Delimited expression
Delimited(DelimitedExpr),
/// Text within math mode
Text(String),
/// Sequence of expressions
Sequence(Vec<MathExpr>),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Number {
Integer(i64),
Float(f64),
Decimal(String), // For exact decimal representation
Scientific { mantissa: f64, exponent: i32 },
}
impl Number {
pub fn to_latex(&self) -> String {
match self {
Self::Integer(n) => n.to_string(),
Self::Float(f) => {
if f.is_infinite() {
r"\infty".to_string()
} else if f.is_nan() {
r"\text{NaN}".to_string()
} else {
f.to_string()
}
}
Self::Decimal(s) => s.clone(),
Self::Scientific { mantissa, exponent } => {
format!("{} \\times 10^{{{}}}", mantissa, exponent)
}
}
}
}
3.2 Tree Traversal
impl MathExpr {
/// Convert expression tree to LaTeX string
pub fn to_latex(&self) -> String {
match self {
Self::Symbol(s) => s.clone(),
Self::Number(n) => n.to_latex(),
Self::Greek(g) => g.to_latex().to_string(),
Self::Operator(op) => op.to_latex().to_string(),
Self::Binary { op, left, right } => {
let left_str = self.maybe_parenthesize(left);
let right_str = self.maybe_parenthesize(right);
let op_str = op.to_latex();
format!("{} {} {}", left_str, op_str, right_str)
}
Self::Unary { op, operand } => {
format!("{} {}", op.to_latex(), operand.to_latex())
}
Self::Function { name, args } => {
let args_str = args
.iter()
.map(|arg| arg.to_latex())
.collect::<Vec<_>>()
.join(", ");
if self.is_standard_function(name) {
format!(r"\{} \left( {} \right)", name, args_str)
} else {
format!("{} \\left( {} \\right)", name, args_str)
}
}
Self::Script(s) => s.to_latex(),
Self::Structural(st) => st.to_latex(),
Self::Delimited(d) => d.to_latex(),
Self::Text(t) => format!(r"\text{{{}}}", t),
Self::Sequence(exprs) => {
exprs.iter()
.map(|e| e.to_latex())
.collect::<Vec<_>>()
.join(" ")
}
}
}
/// Add parentheses if needed based on precedence
fn maybe_parenthesize(&self, expr: &MathExpr) -> String {
if self.needs_parentheses(expr) {
format!(r"\left( {} \right)", expr.to_latex())
} else {
expr.to_latex()
}
}
/// Determine if parentheses are needed
fn needs_parentheses(&self, expr: &MathExpr) -> bool {
match (self, expr) {
(Self::Binary { op: parent_op, .. }, Self::Binary { op: child_op, .. }) => {
self.precedence(child_op) < self.precedence(parent_op)
}
_ => false,
}
}
/// Operator precedence
fn precedence(&self, op: &MathOperator) -> u8 {
match op {
MathOperator::Plus | MathOperator::Minus => 1,
MathOperator::Times | MathOperator::Divide | MathOperator::Dot => 2,
MathOperator::Cross | MathOperator::Wedge => 3,
_ => 0,
}
}
/// Check if function name is a standard LaTeX function
fn is_standard_function(&self, name: &str) -> bool {
matches!(name,
"sin" | "cos" | "tan" | "sec" | "csc" | "cot" |
"sinh" | "cosh" | "tanh" | "sech" | "csch" | "coth" |
"arcsin" | "arccos" | "arctan" |
"log" | "ln" | "exp" |
"det" | "dim" | "deg" | "gcd" | "lcm" |
"max" | "min" | "sup" | "inf" | "lim"
)
}
/// Depth-first traversal
pub fn traverse<F>(&self, visitor: &mut F)
where
F: FnMut(&MathExpr),
{
visitor(self);
match self {
Self::Binary { left, right, .. } => {
left.traverse(visitor);
right.traverse(visitor);
}
Self::Unary { operand, .. } => {
operand.traverse(visitor);
}
Self::Function { args, .. } => {
for arg in args {
arg.traverse(visitor);
}
}
Self::Script(Script { base, subscript, superscript }) => {
base.traverse(visitor);
if let Some(sub) = subscript {
sub.traverse(visitor);
}
if let Some(sup) = superscript {
sup.traverse(visitor);
}
}
Self::Sequence(exprs) => {
for expr in exprs {
expr.traverse(visitor);
}
}
_ => {}
}
}
}
3.3 Precedence and Grouping Rules
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Precedence {
Assignment = 0, // = := ≔
LogicalOr = 1, // ∨ ∥
LogicalAnd = 2, // ∧ &
Relational = 3, // = ≠ < > ≤ ≥
Additive = 4, // + -
Multiplicative = 5, // × ÷ · /
Unary = 6, // - ¬
Exponential = 7, // ^
Application = 8, // function application
}
pub struct PrecedenceRules;
impl PrecedenceRules {
pub fn get_precedence(op: &MathOperator) -> Precedence {
match op {
MathOperator::Equals | MathOperator::NotEquals |
MathOperator::Less | MathOperator::Greater |
MathOperator::LessEq | MathOperator::GreaterEq |
MathOperator::Approx | MathOperator::Equiv => Precedence::Relational,
MathOperator::Plus | MathOperator::Minus => Precedence::Additive,
MathOperator::Times | MathOperator::Divide |
MathOperator::Dot | MathOperator::Cross => Precedence::Multiplicative,
MathOperator::And => Precedence::LogicalAnd,
MathOperator::Or => Precedence::LogicalOr,
MathOperator::Not => Precedence::Unary,
_ => Precedence::Application,
}
}
pub fn needs_grouping(parent: &MathOperator, child: &MathOperator) -> bool {
Self::get_precedence(child) < Self::get_precedence(parent)
}
}
4. Output Format Specifications
4.1 Scipix Markdown (MMD) Format
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScipixMarkdown {
pub content: String,
pub metadata: MmdMetadata,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MmdMetadata {
pub version: String,
pub math_mode: MathMode,
pub delimiter_config: DelimiterConfig,
pub extensions: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum MathMode {
Inline,
Display,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DelimiterConfig {
pub inline_start: String,
pub inline_end: String,
pub display_start: String,
pub display_end: String,
}
impl Default for DelimiterConfig {
fn default() -> Self {
Self {
inline_start: "$".to_string(),
inline_end: "$".to_string(),
display_start: "$$".to_string(),
display_end: "$$".to_string(),
}
}
}
impl ScipixMarkdown {
pub fn new(expr: &MathExpr, mode: MathMode) -> Self {
let latex = expr.to_latex();
let config = DelimiterConfig::default();
let content = match mode {
MathMode::Inline => format!("{}{}{}",
config.inline_start, latex, config.inline_end),
MathMode::Display => format!("{}\n{}\n{}",
config.display_start, latex, config.display_end),
};
Self {
content,
metadata: MmdMetadata {
version: "1.0".to_string(),
math_mode: mode,
delimiter_config: config,
extensions: vec!["amsmath".to_string(), "amssymb".to_string()],
},
}
}
pub fn to_string(&self) -> String {
self.content.clone()
}
}
4.2 Inline vs Display Math Modes
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MathRenderer {
pub mode: MathMode,
pub style: RenderStyle,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum RenderStyle {
/// Compact rendering for inline math
Compact,
/// Expanded rendering for display math
Expanded,
/// Auto-detect based on expression complexity
Auto,
}
impl MathRenderer {
pub fn render(&self, expr: &MathExpr) -> String {
let latex = expr.to_latex();
let style_prefix = match (&self.mode, &self.style) {
(MathMode::Display, RenderStyle::Expanded) |
(MathMode::Display, RenderStyle::Auto) => r"\displaystyle ",
(MathMode::Inline, RenderStyle::Compact) => r"\textstyle ",
_ => "",
};
format!("{}{}", style_prefix, latex)
}
pub fn should_use_display_mode(&self, expr: &MathExpr) -> bool {
match &self.style {
RenderStyle::Auto => self.is_complex(expr),
_ => matches!(self.mode, MathMode::Display),
}
}
fn is_complex(&self, expr: &MathExpr) -> bool {
match expr {
MathExpr::Structural(StructuralToken::Frac { .. }) |
MathExpr::Structural(StructuralToken::Sum { .. }) |
MathExpr::Structural(StructuralToken::Prod { .. }) |
MathExpr::Structural(StructuralToken::Int { .. }) |
MathExpr::Structural(StructuralToken::Matrix(_)) => true,
_ => false,
}
}
}
4.3 Custom Delimiter Support
pub struct CustomDelimiters {
delimiters: HashMap<String, (String, String)>,
}
impl CustomDelimiters {
pub fn new() -> Self {
let mut delimiters = HashMap::new();
// Add default delimiter pairs
delimiters.insert("inline".to_string(), ("$".to_string(), "$".to_string()));
delimiters.insert("display".to_string(), ("$$".to_string(), "$$".to_string()));
delimiters.insert("bracket".to_string(), (r"\[".to_string(), r"\]".to_string()));
delimiters.insert("paren".to_string(), (r"\(".to_string(), r"\)".to_string()));
Self { delimiters }
}
pub fn add_delimiter(&mut self, name: String, start: String, end: String) {
self.delimiters.insert(name, (start, end));
}
pub fn wrap(&self, latex: &str, delimiter_type: &str) -> String {
if let Some((start, end)) = self.delimiters.get(delimiter_type) {
format!("{}{}{}", start, latex, end)
} else {
latex.to_string()
}
}
}
4.4 MathML Conversion
pub struct MathMLConverter;
impl MathMLConverter {
pub fn convert(expr: &MathExpr) -> String {
match expr {
MathExpr::Symbol(s) => {
format!("<mi>{}</mi>", Self::escape_xml(s))
}
MathExpr::Number(n) => {
format!("<mn>{}</mn>", n.to_latex())
}
MathExpr::Operator(op) => {
format!("<mo>{}</mo>", op.to_latex())
}
MathExpr::Binary { op, left, right } => {
format!(
"<mrow>{}<mo>{}</mo>{}</mrow>",
Self::convert(left),
op.to_latex(),
Self::convert(right)
)
}
MathExpr::Script(Script { base, subscript, superscript }) => {
match (subscript, superscript) {
(Some(sub), Some(sup)) => {
format!(
"<msubsup>{}{}{}</msubsup>",
Self::convert(base),
Self::convert(sub),
Self::convert(sup)
)
}
(Some(sub), None) => {
format!(
"<msub>{}{}</msub>",
Self::convert(base),
Self::convert(sub)
)
}
(None, Some(sup)) => {
format!(
"<msup>{}{}</msup>",
Self::convert(base),
Self::convert(sup)
)
}
(None, None) => Self::convert(base),
}
}
MathExpr::Structural(StructuralToken::Frac { numerator, denominator, .. }) => {
format!(
"<mfrac>{}{}</mfrac>",
Self::convert(numerator),
Self::convert(denominator)
)
}
MathExpr::Structural(StructuralToken::Sqrt { expr, root_type }) => {
match root_type {
RootType::Square => {
format!("<msqrt>{}</msqrt>", Self::convert(expr))
}
RootType::Nth(n) => {
format!(
"<mroot>{}{}</mroot>",
Self::convert(expr),
Self::convert(n)
)
}
}
}
_ => String::from("<mrow></mrow>"),
}
}
fn escape_xml(s: &str) -> String {
s.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}
pub fn wrap_mathml(content: &str, display: bool) -> String {
let display_attr = if display { " display=\"block\"" } else { "" };
format!(
"<math xmlns=\"http://www.w3.org/1998/Math/MathML\"{}>{}</math>",
display_attr, content
)
}
}
5. Chemistry Notation (SMILES)
5.1 Molecular Structure Detection
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MolecularStructure {
pub atoms: Vec<Atom>,
pub bonds: Vec<Bond>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Atom {
pub element: ChemicalElement,
pub charge: i8,
pub isotope: Option<u16>,
pub aromatic: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ChemicalElement {
H, C, N, O, F, P, S, Cl, Br, I,
// Extend as needed
Other(String),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Bond {
pub from: usize,
pub to: usize,
pub bond_type: BondType,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum BondType {
Single,
Double,
Triple,
Aromatic,
}
pub struct MolecularDetector;
impl MolecularDetector {
/// Detect if an expression represents a chemical structure
pub fn is_chemical(expr: &MathExpr) -> bool {
// Look for patterns like CH3, H2O, etc.
match expr {
MathExpr::Script(Script { base, subscript, .. }) => {
if let MathExpr::Symbol(s) = &**base {
Self::is_element_symbol(s)
} else {
false
}
}
MathExpr::Sequence(exprs) => {
exprs.iter().any(|e| Self::is_chemical(e))
}
_ => false,
}
}
fn is_element_symbol(s: &str) -> bool {
matches!(s,
"H" | "He" | "Li" | "Be" | "B" | "C" | "N" | "O" | "F" | "Ne" |
"Na" | "Mg" | "Al" | "Si" | "P" | "S" | "Cl" | "Ar" |
"K" | "Ca" | "Fe" | "Cu" | "Zn" | "Br" | "Ag" | "I" | "Au"
)
}
}
5.2 SMILES String Generation
pub struct SmilesGenerator;
impl SmilesGenerator {
/// Convert molecular structure to SMILES string
pub fn generate(structure: &MolecularStructure) -> Result<String, SmilesError> {
let mut smiles = String::new();
let mut visited = vec![false; structure.atoms.len()];
// Start DFS from first atom
if !structure.atoms.is_empty() {
Self::dfs(structure, 0, &mut visited, &mut smiles, None)?;
}
Ok(smiles)
}
fn dfs(
structure: &MolecularStructure,
atom_idx: usize,
visited: &mut [bool],
smiles: &mut String,
from_bond: Option<BondType>,
) -> Result<(), SmilesError> {
if visited[atom_idx] {
return Ok(());
}
visited[atom_idx] = true;
let atom = &structure.atoms[atom_idx];
// Add bond symbol if needed
if let Some(bond_type) = from_bond {
smiles.push_str(&Self::bond_symbol(&bond_type));
}
// Add atom symbol
smiles.push_str(&Self::atom_symbol(atom));
// Find connected atoms
let mut neighbors = Vec::new();
for bond in &structure.bonds {
if bond.from == atom_idx && !visited[bond.to] {
neighbors.push((bond.to, bond.bond_type.clone()));
} else if bond.to == atom_idx && !visited[bond.from] {
neighbors.push((bond.from, bond.bond_type.clone()));
}
}
// Process first neighbor inline
if let Some((next_idx, bond_type)) = neighbors.first() {
Self::dfs(structure, *next_idx, visited, smiles, Some(bond_type.clone()))?;
}
// Process remaining neighbors in branches
for (next_idx, bond_type) in neighbors.iter().skip(1) {
smiles.push('(');
Self::dfs(structure, *next_idx, visited, smiles, Some(bond_type.clone()))?;
smiles.push(')');
}
Ok(())
}
fn atom_symbol(atom: &Atom) -> String {
let element = match &atom.element {
ChemicalElement::H => "H",
ChemicalElement::C if !atom.aromatic => "C",
ChemicalElement::C => "c",
ChemicalElement::N if !atom.aromatic => "N",
ChemicalElement::N => "n",
ChemicalElement::O if !atom.aromatic => "O",
ChemicalElement::O => "o",
ChemicalElement::F => "F",
ChemicalElement::P => "P",
ChemicalElement::S if !atom.aromatic => "S",
ChemicalElement::S => "s",
ChemicalElement::Cl => "Cl",
ChemicalElement::Br => "Br",
ChemicalElement::I => "I",
ChemicalElement::Other(s) => s,
};
let mut result = element.to_string();
// Add charge if present
if atom.charge != 0 {
result = format!("[{}{}]", element, Self::charge_string(atom.charge));
}
// Add isotope if present
if let Some(isotope) = atom.isotope {
result = format!("[{}{}]", isotope, element);
}
result
}
fn bond_symbol(bond_type: &BondType) -> String {
match bond_type {
BondType::Single => String::new(), // Implicit
BondType::Double => "=".to_string(),
BondType::Triple => "#".to_string(),
BondType::Aromatic => ":".to_string(),
}
}
fn charge_string(charge: i8) -> String {
match charge {
1 => "+".to_string(),
-1 => "-".to_string(),
n if n > 0 => format!("+{}", n),
n => format!("{}", n),
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum SmilesError {
#[error("Invalid molecular structure")]
InvalidStructure,
#[error("Unsupported element: {0}")]
UnsupportedElement(String),
}
6. Rust Implementation Patterns
6.1 Token Enum Definitions
use serde::{Deserialize, Serialize};
/// Main token type for LaTeX generation
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum LatexToken {
/// Mathematical expression
Math(MathExpr),
/// Text content
Text(String),
/// Environment begin
BeginEnv { name: String, options: Option<String> },
/// Environment end
EndEnv { name: String },
/// Command with optional arguments
Command {
name: String,
args: Vec<String>,
optional: Option<String>,
},
/// Whitespace
Space,
/// Newline
Newline,
}
impl LatexToken {
pub fn to_latex(&self) -> String {
match self {
Self::Math(expr) => expr.to_latex(),
Self::Text(s) => s.clone(),
Self::BeginEnv { name, options } => {
if let Some(opts) = options {
format!(r"\begin{{{}}}[{}]", name, opts)
} else {
format!(r"\begin{{{}}}", name)
}
}
Self::EndEnv { name } => format!(r"\end{{{}}}", name),
Self::Command { name, args, optional } => {
let mut result = format!(r"\{}", name);
if let Some(opt) = optional {
result.push_str(&format!("[{}]", opt));
}
for arg in args {
result.push_str(&format!("{{{}}}", arg));
}
result
}
Self::Space => " ".to_string(),
Self::Newline => "\n".to_string(),
}
}
}
6.2 Parser Combinators
use nom::{
IResult,
branch::alt,
bytes::complete::{tag, take_while1},
character::complete::{char, digit1, multispace0},
combinator::{map, opt, recognize},
multi::{many0, separated_list0},
sequence::{delimited, pair, preceded, tuple},
};
pub struct LatexParser;
impl LatexParser {
/// Parse a number
fn parse_number(input: &str) -> IResult<&str, Number> {
alt((
Self::parse_float,
Self::parse_integer,
))(input)
}
fn parse_integer(input: &str) -> IResult<&str, Number> {
map(
recognize(pair(opt(char('-')), digit1)),
|s: &str| Number::Integer(s.parse().unwrap())
)(input)
}
fn parse_float(input: &str) -> IResult<&str, Number> {
map(
recognize(tuple((
opt(char('-')),
digit1,
char('.'),
digit1,
))),
|s: &str| Number::Float(s.parse().unwrap())
)(input)
}
/// Parse a symbol (variable name)
fn parse_symbol(input: &str) -> IResult<&str, MathExpr> {
map(
take_while1(|c: char| c.is_alphabetic() || c == '_'),
|s: &str| MathExpr::Symbol(s.to_string())
)(input)
}
/// Parse a fraction: \frac{num}{den}
fn parse_frac(input: &str) -> IResult<&str, MathExpr> {
map(
preceded(
tag(r"\frac"),
pair(
delimited(char('{'), Self::parse_expr, char('}')),
delimited(char('{'), Self::parse_expr, char('}')),
)
),
|(num, den)| MathExpr::Structural(StructuralToken::Frac {
numerator: Box::new(num),
denominator: Box::new(den),
frac_type: FractionType::Standard,
})
)(input)
}
/// Parse square root: \sqrt{expr} or \sqrt[n]{expr}
fn parse_sqrt(input: &str) -> IResult<&str, MathExpr> {
map(
preceded(
tag(r"\sqrt"),
pair(
opt(delimited(char('['), Self::parse_expr, char(']'))),
delimited(char('{'), Self::parse_expr, char('}')),
)
),
|(root, expr)| {
let root_type = if let Some(n) = root {
RootType::Nth(Box::new(n))
} else {
RootType::Square
};
MathExpr::Structural(StructuralToken::Sqrt {
root_type,
expr: Box::new(expr),
})
}
)(input)
}
/// Parse subscript/superscript
fn parse_script(input: &str) -> IResult<&str, MathExpr> {
map(
tuple((
Self::parse_primary,
opt(preceded(char('_'), Self::parse_primary)),
opt(preceded(char('^'), Self::parse_primary)),
)),
|(base, sub, sup)| {
if sub.is_some() || sup.is_some() {
MathExpr::Script(Script {
base: Box::new(base),
subscript: sub.map(Box::new),
superscript: sup.map(Box::new),
})
} else {
base
}
}
)(input)
}
/// Parse primary expression (atom)
fn parse_primary(input: &str) -> IResult<&str, MathExpr> {
preceded(
multispace0,
alt((
Self::parse_frac,
Self::parse_sqrt,
delimited(char('('), Self::parse_expr, char(')')),
map(Self::parse_number, MathExpr::Number),
Self::parse_symbol,
))
)(input)
}
/// Parse full expression
fn parse_expr(input: &str) -> IResult<&str, MathExpr> {
Self::parse_script(input)
}
/// Main entry point
pub fn parse(input: &str) -> Result<MathExpr, String> {
match Self::parse_expr(input) {
Ok((_, expr)) => Ok(expr),
Err(e) => Err(format!("Parse error: {:?}", e)),
}
}
}
6.3 Serde Serialization
use serde::{Deserialize, Serialize};
use serde_json;
/// Serializable representation of the expression tree
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SerializableMathExpr {
#[serde(rename = "type")]
pub expr_type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<serde_json::Value>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub children: Vec<SerializableMathExpr>,
}
impl From<&MathExpr> for SerializableMathExpr {
fn from(expr: &MathExpr) -> Self {
match expr {
MathExpr::Symbol(s) => Self {
expr_type: "symbol".to_string(),
value: Some(serde_json::json!(s)),
children: vec![],
},
MathExpr::Number(n) => Self {
expr_type: "number".to_string(),
value: Some(serde_json::json!(n.to_latex())),
children: vec![],
},
MathExpr::Binary { op, left, right } => Self {
expr_type: "binary".to_string(),
value: Some(serde_json::json!(op.to_latex())),
children: vec![
SerializableMathExpr::from(&**left),
SerializableMathExpr::from(&**right),
],
},
MathExpr::Script(Script { base, subscript, superscript }) => {
let mut children = vec![SerializableMathExpr::from(&**base)];
if let Some(sub) = subscript {
children.push(SerializableMathExpr::from(&**sub));
}
if let Some(sup) = superscript {
children.push(SerializableMathExpr::from(&**sup));
}
Self {
expr_type: "script".to_string(),
value: None,
children,
}
}
_ => Self {
expr_type: "unknown".to_string(),
value: None,
children: vec![],
},
}
}
}
/// Serialization helpers
pub mod serialization {
use super::*;
pub fn to_json(expr: &MathExpr) -> Result<String, serde_json::Error> {
let serializable = SerializableMathExpr::from(expr);
serde_json::to_string_pretty(&serializable)
}
pub fn to_json_compact(expr: &MathExpr) -> Result<String, serde_json::Error> {
let serializable = SerializableMathExpr::from(expr);
serde_json::to_string(&serializable)
}
}
7. Performance Considerations
7.1 String Building Optimization
use std::fmt::Write;
/// Efficient LaTeX string builder
pub struct LatexBuilder {
buffer: String,
capacity_hint: usize,
}
impl LatexBuilder {
pub fn new() -> Self {
Self {
buffer: String::with_capacity(1024),
capacity_hint: 1024,
}
}
pub fn with_capacity(capacity: usize) -> Self {
Self {
buffer: String::with_capacity(capacity),
capacity_hint: capacity,
}
}
pub fn push_expr(&mut self, expr: &MathExpr) {
self.write_expr(expr);
}
fn write_expr(&mut self, expr: &MathExpr) {
match expr {
MathExpr::Symbol(s) => {
self.buffer.push_str(s);
}
MathExpr::Binary { op, left, right } => {
self.write_expr(left);
self.buffer.push(' ');
self.buffer.push_str(op.to_latex());
self.buffer.push(' ');
self.write_expr(right);
}
_ => {
self.buffer.push_str(&expr.to_latex());
}
}
}
pub fn build(self) -> String {
self.buffer
}
}
7.2 Caching Strategies
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
/// Cache for frequently used LaTeX conversions
pub struct LatexCache {
cache: Arc<RwLock<HashMap<String, String>>>,
max_size: usize,
}
impl LatexCache {
pub fn new(max_size: usize) -> Self {
Self {
cache: Arc::new(RwLock::new(HashMap::new())),
max_size,
}
}
pub fn get_or_compute<F>(&self, key: &str, compute: F) -> String
where
F: FnOnce() -> String,
{
// Try to read from cache
{
let cache = self.cache.read().unwrap();
if let Some(value) = cache.get(key) {
return value.clone();
}
}
// Compute the value
let value = compute();
// Store in cache
{
let mut cache = self.cache.write().unwrap();
if cache.len() >= self.max_size {
// Simple eviction: clear half the cache
cache.clear();
}
cache.insert(key.to_string(), value.clone());
}
value
}
}
8. Testing Strategy
8.1 Unit Tests
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_greek_letter_conversion() {
assert_eq!(GreekLetter::Alpha.to_latex(), r"\alpha");
assert_eq!(GreekLetter::Beta.to_latex(), r"\beta");
assert_eq!(GreekLetter::CapitalGamma.to_latex(), r"\Gamma");
}
#[test]
fn test_fraction_rendering() {
let frac = MathExpr::Structural(StructuralToken::Frac {
numerator: Box::new(MathExpr::Number(Number::Integer(1))),
denominator: Box::new(MathExpr::Number(Number::Integer(2))),
frac_type: FractionType::Standard,
});
assert_eq!(frac.to_latex(), r"\frac{1}{2}");
}
#[test]
fn test_script_rendering() {
let script = MathExpr::Script(Script {
base: Box::new(MathExpr::Symbol("x".to_string())),
subscript: Some(Box::new(MathExpr::Number(Number::Integer(1)))),
superscript: Some(Box::new(MathExpr::Number(Number::Integer(2)))),
});
assert_eq!(script.to_latex(), "x_{1}^{2}");
}
#[test]
fn test_matrix_rendering() {
let matrix = Matrix {
matrix_type: MatrixType::Bracket,
rows: vec![
vec![
MathExpr::Number(Number::Integer(1)),
MathExpr::Number(Number::Integer(2)),
],
vec![
MathExpr::Number(Number::Integer(3)),
MathExpr::Number(Number::Integer(4)),
],
],
};
let expected = r"\begin{bmatrix}1 & 2 \\ 3 & 4 \end{bmatrix}";
assert_eq!(
MathExpr::Structural(StructuralToken::Matrix(matrix)).to_latex(),
expected
);
}
}
8.2 Integration Tests
#[cfg(test)]
mod integration_tests {
use super::*;
#[test]
fn test_quadratic_formula() {
// x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}
let b_squared = MathExpr::Script(Script {
base: Box::new(MathExpr::Symbol("b".to_string())),
subscript: None,
superscript: Some(Box::new(MathExpr::Number(Number::Integer(2)))),
});
// Continue building the expression...
// This tests complex expression assembly
}
}
Conclusion
This LaTeX generation pipeline provides a comprehensive framework for converting mathematical expressions from various input formats into properly formatted LaTeX output. The Rust implementation emphasizes type safety, performance, and extensibility while supporting advanced features like MathML conversion and chemical notation.
Key Features
- Type-safe expression representation with comprehensive enum types
- Extensible architecture supporting new mathematical constructs
- Performant with caching and efficient string building
- Standards-compliant with Scipix Markdown and MathML support
- Chemistry-aware with SMILES notation support
- Well-tested with comprehensive unit and integration tests
Next Steps
- Implement OCR integration for symbol recognition
- Add support for additional LaTeX packages (tikz, pgfplots)
- Develop interactive editing capabilities
- Create rendering preview system
- Optimize for real-time conversion pipelines