mathlex 0.4.1

Mathematical expression parser for LaTeX and plain text notation, producing a language-agnostic AST
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Helpers for collecting variable names from an expression tree.

use crate::ast::{ExprKind, Expression};
use std::collections::HashSet;

use super::walker::for_each_child;

/// Collect all variable names (including index/bound variables) into `vars`.
pub(super) fn cv_core(expr: &Expression, vars: &mut HashSet<String>) {
    // Extract variable names from the current node
    match &expr.kind {
        ExprKind::Variable(name) => {
            vars.insert(name.clone());
        }
        ExprKind::Derivative { var, .. }
        | ExprKind::PartialDerivative { var, .. }
        | ExprKind::Integral { var, .. }
        | ExprKind::ClosedIntegral { var, .. } => {
            vars.insert(var.clone());
        }
        ExprKind::MultipleIntegral { vars: ivars, .. } => {
            for v in ivars {
                vars.insert(v.clone());
            }
        }
        ExprKind::Limit { var, .. } => {
            vars.insert(var.clone());
        }
        ExprKind::Sum { index, .. } | ExprKind::Product { index, .. } => {
            vars.insert(index.clone());
        }
        ExprKind::ForAll { variable, .. } | ExprKind::Exists { variable, .. } => {
            vars.insert(variable.clone());
        }
        ExprKind::SetBuilder { variable, .. } => {
            vars.insert(variable.clone());
        }
        ExprKind::Tensor { indices, .. }
        | ExprKind::KroneckerDelta { indices }
        | ExprKind::LeviCivita { indices } => {
            for idx in indices {
                vars.insert(idx.name.clone());
            }
        }
        ExprKind::Differential { var } => {
            vars.insert(var.clone());
        }
        _ => {}
    }
    // Recurse into child expressions
    for_each_child(expr, |child| cv_core(child, vars));
}

/// Check whether `expr` contains a variable with the given `name`.
pub(super) fn cv_contains(expr: &Expression, name: &str) -> bool {
    // Check the current node for a matching variable name
    let found = match &expr.kind {
        ExprKind::Variable(n) => n == name,
        ExprKind::Derivative { var, .. }
        | ExprKind::PartialDerivative { var, .. }
        | ExprKind::Integral { var, .. }
        | ExprKind::ClosedIntegral { var, .. }
        | ExprKind::Limit { var, .. } => var == name,
        ExprKind::MultipleIntegral { vars, .. } => vars.iter().any(|v| v == name),
        ExprKind::Sum { index, .. } | ExprKind::Product { index, .. } => index == name,
        ExprKind::ForAll { variable, .. }
        | ExprKind::Exists { variable, .. }
        | ExprKind::SetBuilder { variable, .. } => variable == name,
        ExprKind::Tensor { indices, .. }
        | ExprKind::KroneckerDelta { indices }
        | ExprKind::LeviCivita { indices } => indices.iter().any(|idx| idx.name == name),
        ExprKind::Differential { var } => var == name,
        _ => false,
    };
    if found {
        return true;
    }
    // Recurse into children
    let mut result = false;
    for_each_child(expr, |child| {
        if !result {
            result = cv_contains(child, name);
        }
    });
    result
}