mathlex 0.1.1

Mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic AST
Documentation

mathlex

License GitHub Release CI Crates.io Rust Version docs.rs Swift Package Index Swift Platform

A mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic Abstract Syntax Tree (AST).

Features

  • LaTeX Parsing - Parse mathematical LaTeX notation (\frac{1}{2}, \int_0^1, \sum_{i=1}^n)
  • Plain Text Parsing - Parse standard math notation (2*x + 3, sin(x))
  • Rich AST - Comprehensive AST supporting algebra, calculus, and linear algebra
  • No Evaluation - Pure parsing library, interpretation is client responsibility
  • Cross-Platform - Native support for Rust and Swift (iOS/macOS)

Installation

Rust

Add to your Cargo.toml:

[dependencies]
mathlex = "0.1.0"

Swift

Add to your Package.swift:

dependencies: [
    .package(url: "https://github.com/ChrisGVE/mathlex.git", from: "0.1.0")
]

Or in Xcode: File → Add Package Dependencies → Enter https://github.com/ChrisGVE/mathlex.git

Quick Start

Rust

Parse Plain Text

use mathlex::{parse, Expression};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let expr = parse("2*x + sin(y)")?;

    // Find all variables
    let vars = expr.find_variables();
    println!("Variables: {:?}", vars); // {"x", "y"}

    // Convert back to string
    println!("{}", expr); // "2 * x + sin(y)"

    Ok(())
}

Parse LaTeX

use mathlex::{parse_latex, Expression};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let expr = parse_latex(r"\frac{1}{2} + \sqrt{x}")?;

    // Convert to LaTeX string
    println!("{}", expr.to_latex()); // "\frac{1}{2} + \sqrt{x}"

    Ok(())
}

Swift

import MathLex

do {
    // Parse plain text
    let expr = try MathExpression.parse("2*x + sin(y)")
    print(expr.variables) // ["x", "y"]
    print(expr.description) // "2 * x + sin(y)"

    // Parse LaTeX
    let latex = try MathExpression.parseLatex(#"\frac{1}{2}"#)
    print(latex.latex) // "\frac{1}{2}"
} catch {
    print("Parse error: \(error)")
}

Supported Notation

Literals

  • Integers: 42, -17
  • Floats: 3.14, 2.5e-3
  • Rationals: LaTeX \frac{1}{2}
  • Complex: via construction

Symbols

  • Variables: x, y, theta
  • Greek letters: \alpha, \beta, \Gamma
  • Constants: \pi, \infty, e, i

Operations

  • Binary: +, -, *, /, ^, %
  • Unary: -x, x!
  • Functions: sin, cos, tan, log, ln, exp, sqrt, abs

Calculus (Representation Only)

  • Derivatives: \frac{d}{dx}, \frac{\partial}{\partial x}
  • Integrals: \int, \int_a^b
  • Limits: \lim_{x \to a}
  • Sums: \sum_{i=1}^{n}
  • Products: \prod_{i=1}^{n}

Structures

  • Vectors: \begin{pmatrix} a \\ b \end{pmatrix}
  • Matrices: \begin{bmatrix} a & b \\ c & d \end{bmatrix}
  • Equations: x = y
  • Inequalities: x < y, \leq, \geq, \neq

Design Philosophy

mathlex is a pure parsing library. It converts text to AST and back - nothing more.

  • No evaluation - mathlex does not compute values
  • No simplification - mathlex does not transform expressions
  • No dependencies on consumers - can be used by any library

This design allows different libraries to interpret the AST according to their capabilities:

  • A CAS library can perform symbolic differentiation on Derivative nodes
  • A numerical library can evaluate Function nodes numerically
  • An educational tool can render step-by-step explanations

Optional Features

Rust

[dependencies]
mathlex = { version = "0.1.0", features = ["serde"] }
  • serde - Enable serialization/deserialization of AST types
  • ffi - Enable Swift FFI bindings (for building XCFramework)

Documentation

License

MIT License - see LICENSE for details.

Links