Spaces:
Sleeping
Sleeping
File size: 6,590 Bytes
fe0c99f de8ccff fe0c99f | 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 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | r"""Extract the inner expression and parameters from full LaTeX notation."""
import re
from typing import Any, Dict, Optional
class ExpressionExtractor:
r"""Pull inner expressions out of \frac{d}{dx}, \int, \lim, and similar forms."""
def extract(
self,
latex: str,
explicit_type: Optional[str] = None,
params: Optional[Dict[str, Any]] = None,
):
"""Strip calculus notation and return the inner expression with its parameters.
Handles derivatives (``\\frac{d}{dx}``, ``d/dx``, prime notation),
definite and indefinite integrals, limits, and sums. Extracts bounds,
variable, and order into ``params`` where applicable.
Args:
latex: Full LaTeX expression including operation wrapper, e.g.
``r"\\int_0^1 x^2 \\, dx"`` or ``r"\\frac{d}{dx} \\sin(x)"``.
explicit_type: Reserved for future use; currently unused.
params: Seed parameter dict that extracted values are merged into.
Returns:
A tuple ``(inner_latex, merged_params)`` where ``inner_latex`` is
the expression with the operation wrapper removed and
``merged_params`` is a dict that may contain keys such as
``"variable"``, ``"order"``, ``"lower"``, ``"upper"``, and
``"point"``.
"""
_ = explicit_type # reserved for future explicit-type extraction overrides
params = dict(params or {})
# derivative
m = re.search(
r"\\frac\{d(?:\^(\d+))?\}\{d([a-z])(?:\^(\d+))?\}\s*(.*)",
latex, re.DOTALL,
)
if m:
order = int(m.group(1) or m.group(3) or 1)
params.setdefault("variable", m.group(2))
params["order"] = order
return m.group(4).strip() or latex, params
# plain derivative d^n/dx^n ...
m = re.search(
r"\bd(?:\^(\d+))?\s*/\s*d([a-z])(?:\^(\d+))?\s*(.*)",
latex, re.DOTALL,
)
if m:
order = int(m.group(1) or m.group(3) or 1)
params.setdefault("variable", m.group(2))
params["order"] = order
return m.group(4).strip() or latex, params
# partial derivative
m = re.search(
r"\\frac\{\\partial(?:\^(\d+))?\}\{\\partial\s*([a-z])(?:\^(\d+))?\}\s*(.*)",
latex, re.DOTALL,
)
if m:
order = int(m.group(1) or m.group(3) or 1)
params.setdefault("variable", m.group(2))
params["order"] = order
return m.group(4).strip() or latex, params
# prime notation f'(x), y''
m = re.match(r"([a-zA-Z]+)('+)\s*(?:\(([a-z])\))?", latex)
if m:
params["order"] = len(m.group(2))
params.setdefault("variable", m.group(3) or "x")
# can't extract expression from f' alone
return latex, params
# definite integral \int_{a}^{b} ... dx
m = re.search(
r"\\int_\{([^{}]+)\}\^\{([^{}]+)\}\s*(.*?)\s*d([a-z])",
latex, re.DOTALL,
)
if not m:
m = re.search(
r"\\int_([^\s^_{}]+)\^([^\s{}]+)\s*(.*?)\s*d([a-z])",
latex, re.DOTALL,
)
if m:
params["lower"] = self._parse_bound(m.group(1))
params["upper"] = self._parse_bound(m.group(2))
params.setdefault("variable", m.group(4))
return m.group(3).strip(), params
# plain definite integral int_a^b ... dx / ∫_a^b ... dx
m = re.search(
r"(?:∫|int)_\{?([^\s^{}]+)\}?\^\{?([^\s{}]+)\}?\s*(.*?)\s*d\s*([a-z])",
latex, re.DOTALL,
)
if m:
params["lower"] = self._parse_bound(m.group(1))
params["upper"] = self._parse_bound(m.group(2))
params.setdefault("variable", m.group(4))
return m.group(3).strip(), params
# indefinite integral \int ... dx
m = re.search(r"\\int\s*(.*?)\s*d([a-z])", latex, re.DOTALL)
if m:
params.setdefault("variable", m.group(2))
return m.group(1).strip(), params
# plain indefinite integral int ... dx / ∫ ... dx
m = re.search(r"(?:∫|int)\s*(.*?)\s*d\s*([a-z])", latex, re.DOTALL)
if m:
params.setdefault("variable", m.group(2))
return m.group(1).strip(), params
# limit \lim_{x \to a} ...
m = re.search(
r"\\lim_\{?\s*([a-z])\s*(?:\\to|\\rightarrow|->)\s*([^{}]+?)\s*\}?\s*(.*)",
latex, re.DOTALL,
)
if m:
params.setdefault("variable", m.group(1))
params["point"] = m.group(2).strip()
return m.group(3).strip(), params
# plain limit lim_(x -> a) ... / lim_{x -> a} ... / lim x->a ...
m = re.search(
r"\blim_\s*[\(\{\[]\s*([a-z])\s*(?:->|→|to)\s*([^\)\}\]\s]+)\s*[\)\}\]]\s*(.*)",
latex, re.DOTALL,
)
if m:
params.setdefault("variable", m.group(1))
params["point"] = m.group(2).strip()
return m.group(3).strip(), params
m = re.search(
r"\blim_?\{?\s*([a-z])\s*(?:->|→|to)\s*([^{} ]+)\s*\}?\s*(.*)",
latex, re.DOTALL,
)
if m:
params.setdefault("variable", m.group(1))
params["point"] = m.group(2).strip()
return m.group(3).strip(), params
m = re.search(
r"\blim\s+([a-z])\s*(?:->|→|to)\s*([^\s]+)\s*(.*)",
latex, re.DOTALL,
)
if m:
params.setdefault("variable", m.group(1))
params["point"] = m.group(2).strip()
return m.group(3).strip(), params
# sum \sum_{n=a}^{b} ...
m = re.search(
r"\\sum_\{?\s*([a-z])=([^{}]*?)\}?\^\{?([^{}]*?)\}?\s*(.*)",
latex, re.DOTALL,
)
if m:
params.setdefault("variable", m.group(1))
params["lower"] = self._parse_bound(m.group(2))
params["upper"] = self._parse_bound(m.group(3))
return m.group(4).strip(), params
return latex, params
@staticmethod
def _parse_bound(s: str):
s = s.strip().replace(" ", "")
if s in ("\\infty", "+\\infty", "oo", "+oo", "∞", "+∞"):
return "oo"
if s in ("-\\infty", "-oo", "-∞"):
return "-oo"
try:
return float(s) if "." in s else int(s)
except ValueError:
return s
|