algo2code 0.2.1__py3-none-any.whl

algo2code/library/pcg.py

@@ -0,0 +1,127 @@
+r"""Canonical Preconditioned Conjugate Gradient (PCG) algorithm in algpseudocode.
+
+This module is the **algo2code interface hook** consumed by
+``mechdsl-core``'s ``Algo2CodePCGSolver`` adapter (Plan recovery task P6-1).
+It exposes:
+
+* :data:`PCG_ALGORITHM_LATEX` — the verbatim LaTeX source of the canonical
+  PCG algorithm, mirrored from
+  ``dev/tasks/recovery_plan_latex_contract/json/P6-1.json`` field
+  ``pcg_algorithm_latex.latex``.
+* :func:`get_pcg_algorithm_latex` — accessor returning that text.
+
+Runtime invariant
+-----------------
+
+This module imports **only stdlib**.  ``algo2code`` is the runtime-free
+sibling package of ``mechdsl-core`` (see ``.claude/CLAUDE.md`` /
+``dev/design_docs/11-ALGO2CODE.md``); nothing here imports — directly or
+transitively — ``mechdsl``.  Consumers that want a runnable implementation
+own the translation step.
+
+Transpilation status (issue #307, updated)
+------------------------------------------
+
+This LaTeX **now transpiles** via :func:`algo2code.transpile`. The original
+deferral — multi-letter scratch identifiers such as ``pq`` tokenising as
+``p * q`` — was resolved by the tokenizer's multi-character identifier rule
+(``expr_parser.TOKEN_PATTERNS``), and the compound updates lower correctly via
+the SSA vector-lowering pass (issue #307 F1/F2). The generated ``pcg`` driver is
+runnable Taichi.
+
+``mechdsl-core``'s ``Algo2CodePCGSolver`` is the hand-written, line-by-line
+translation. A numeric comparison (hand-written vs ``transpile`` output, run under
+Taichi) now shows them **bit-identical on every path** — both the converged path
+and the max-iteration-exhausted path — after the for-loop range lowering was
+fixed to emit the inclusive ``range(start, end + 1)`` (issue #307; the generated
+``\For{$k = 1, ..., \text{maxiter}$}`` previously did one fewer iteration). The
+parity is guarded by
+``...recovery_plan_latex_contract/test_pcg_transpiler_parity.py``.
+
+The hand-translation is **retained** despite the parity, because the generated
+code and the consumer have different runtime models: ``transpile`` emits **Taichi**
+operating on a **dense matrix field** ``A``, whereas the Newton seam
+(``mechdsl.solver.newton``) is **matrix-free numpy** — it passes the tangent as a
+matvec callback and never forms ``A``. Swapping the generated Taichi code in would
+break that matrix-free contract. A literal code replacement would require a numpy
+backend for algo2code that emits a matrix-free PCG matching ``LinearSolverInterface``
+(the numpy backend is currently a stub). Until then the adapter stays, but it is
+no longer a maintenance hazard: the parity test mechanically proves it stays
+faithful to this canonical LaTeX. Behaviour is also pinned by
+``...recovery_plan_latex_contract/test_p6_1.py``.
+"""
+
+from __future__ import annotations
+
+# ── Canonical algorithm source ───────────────────────────────────────────────
+PCG_ALGORITHM_LATEX: str = r"""% algorithm pcg
+% backend taichi
+% args A:matrix, b:vector, x:vector, apply_M_inv:callable, tol:scalar, maxiter:scalar
+
+% type r vector
+% type z vector
+% type p vector
+% type q vector
+% type rho scalar
+% type rho_new scalar
+% type alpha scalar
+% type beta scalar
+% type pq scalar
+% type r0_norm scalar
+% type r_norm scalar
+
+\begin{algorithmic}
+\State $r = b - A \cdot x$                                         % vector
+\State $r_0 = \lVert r \rVert_2$                                    % scalar
+\If{$r_0 = 0$}
+    \Return $x, 0, 0$
+\EndIf
+\State $z = \text{apply\_M\_inv}(r)$                                % vector
+\State $p = z$                                                      % vector
+\State $\rho = r^\top z$                                            % scalar
+\For{$k = 1, 2, \ldots, \text{maxiter}$}
+    \State $q = A \cdot p$                                          % vector
+    \State $pq = p^\top q$                                          % scalar
+    \If{$|pq| < 10^{-300}$}
+        \State \textbf{break}
+    \EndIf
+    \State $\alpha = \frac{\rho}{pq}$                               % scalar
+    \State $x = x + \alpha \, p$                                    % vector
+    \State $r = r - \alpha \, q$                                    % vector
+    \State $r_n = \lVert r \rVert_2$                                % scalar
+    \If{$r_n < \text{tol} \cdot r_0$}
+        \Return $x, k, r_n$
+    \EndIf
+    \State $z = \text{apply\_M\_inv}(r)$                            % vector
+    \State $\rho_{\text{new}} = r^\top z$                           % scalar
+    \State $\beta = \frac{\rho_{\text{new}}}{\rho}$                 % scalar
+    \State $p = z + \beta \, p$                                     % vector
+    \State $\rho = \rho_{\text{new}}$                               % scalar
+\EndFor
+\Return $x, \text{maxiter}, \lVert r \rVert_2$
+\end{algorithmic}"""
+
+
+def get_pcg_algorithm_latex() -> str:
+    """Return the canonical PCG algpseudocode LaTeX source.
+
+    Consumers (e.g. ``mechdsl.solver.import_adapter.Algo2CodePCGSolver``)
+    use the returned string both as the specification artifact for their
+    runtime translation and as input to ``algo2code.transpile`` once the
+    parser supports the full surface (see *Parser deferral note* in this
+    module's docstring).
+
+    Returns
+    -------
+    str
+        Verbatim LaTeX source of the canonical PCG algorithm, including
+        the leading ``% algorithm`` / ``% backend`` / ``% args`` / ``% type``
+        directive comments.
+    """
+    return PCG_ALGORITHM_LATEX
+
+
+__all__ = [
+    "PCG_ALGORITHM_LATEX",
+    "get_pcg_algorithm_latex",
+]

algo2code/library/radial_return_j2.py

@@ -0,0 +1,90 @@
+r"""Canonical J2 radial-return algorithm (algo2code interface hook).
+
+post_recovery_plan Phase 5 (P5-1, P5-3). Mirrors the
+``algo2code.library.pcg`` pattern but goes one step further:
+
+- :data:`RADIAL_RETURN_J2_LATEX` exposes the verbatim algpseudocode.
+- :func:`get_radial_return_j2_latex` returns it (accessor symmetry
+  with PCG).
+- :func:`transpile_radial_return_j2` runs ``algo2code.transpile`` on
+  the source and returns the emitted Python module text. Phase 5's
+  parser fixes (multi-letter scratch identifiers; binary ``/`` in
+  assignment LHS) and codegen fix (``n = b.shape[0]`` regression for
+  scalar-only algorithms) make this work end-to-end.
+
+The mechdsl-core wrapper at ``mechdsl.lib.plasticity`` execs the
+transpiled module text into a namespace at import time and consumes
+the resulting ``radial_return_j2`` callable inside its dispatcher.
+
+Runtime invariant
+-----------------
+
+This module imports **only stdlib** (and ``algo2code`` siblings). The
+runtime-free contract holds.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _load_canonical_source() -> str:
+    """Read the canonical algpseudocode source from
+    ``dev/algorithms/radial_return_j2.tex``.
+
+    Walks up from this module to the repo root, then reads the
+    file. Single source of truth — the LaTeX file is authoritative.
+    """
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "dev" / "algorithms" / "radial_return_j2.tex"
+        if candidate.is_file():
+            return candidate.read_text(encoding="utf-8")
+    raise FileNotFoundError(
+        "post_recovery_plan Phase 5 (P5-1): canonical algorithm source "
+        "not found. Expected at <repo>/dev/algorithms/radial_return_j2.tex."
+    )
+
+
+RADIAL_RETURN_J2_LATEX: str = _load_canonical_source()
+
+
+def get_radial_return_j2_latex() -> str:
+    """Return the canonical J2 radial-return algpseudocode LaTeX source."""
+    return RADIAL_RETURN_J2_LATEX
+
+
+def transpile_radial_return_j2(backend: str = "taichi") -> str:
+    """Transpile the canonical algpseudocode to ``backend`` and return
+    the emitted Python module source.
+
+    post_recovery_plan Phase 5 lifted the deferral that previously
+    blocked this round-trip: the algo2code expr_parser now handles
+    multi-letter scratch identifiers (``sy``, ``Hp``, ``ap``) and
+    binary ``/`` in assignment LHS contexts, and the Taichi codegen
+    no longer emits ``n = b.shape[0]`` for scalar-only algorithms.
+
+    Parameters
+    ----------
+    backend:
+        Target backend name. ``"taichi"`` is the only one consumed by
+        ``mechdsl-core`` today.
+
+    Returns
+    -------
+    str
+        Transpiled Python module source. Pass to ``exec`` with a fresh
+        namespace dict to load the ``radial_return_j2`` callable.
+    """
+    # Local import keeps the runtime-free invariant — algo2code itself
+    # has no third-party imports beyond stdlib.
+    from algo2code import transpile
+
+    return transpile(RADIAL_RETURN_J2_LATEX, backend=backend)
+
+
+__all__ = [
+    "RADIAL_RETURN_J2_LATEX",
+    "get_radial_return_j2_latex",
+    "transpile_radial_return_j2",
+]

algo2code/library/radial_return_j2_kinematic.py

@@ -0,0 +1,89 @@
+r"""J2 kinematic linear-hardening radial-return (algo2code interface hook).
+
+constitutive_latex Phase 6 (P6-2). Mirrors
+:mod:`algo2code.library.radial_return_j2` (the isotropic power-law
+variant) for the linear-kinematic (Prager) hardening model:
+
+- :data:`RADIAL_RETURN_J2_KINEMATIC_LATEX` exposes the verbatim
+  algpseudocode.
+- :func:`get_radial_return_j2_kinematic_latex` returns it.
+- :func:`transpile_radial_return_j2_kinematic` runs
+  ``algo2code.transpile`` on the source and returns the emitted module
+  text.
+
+The scalar source owns only the plastic-multiplier solve. The yield
+surface for kinematic hardening translates rather than expands, so the
+scalar loop operates on the trial RELATIVE-stress equivalent
+``xi_eq`` (von Mises of ``dev(S) - beta``) with a constant yield radius
+``sigy0``. The closed-form linear consistency condition
+``dl = (xi_eq - sigy0) / (3*mu + H_kin)`` is authored as the same
+fixed-iteration loop structure as the isotropic variant for
+transpile-pattern consistency.
+
+Runtime invariant
+-----------------
+
+This module imports **only stdlib** (and ``algo2code`` siblings). The
+runtime-free contract holds.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _load_canonical_source() -> str:
+    """Read the canonical algpseudocode source from
+    ``dev/algorithms/radial_return_j2_kinematic.tex``.
+
+    Walks up from this module to the repo root, then reads the file.
+    Single source of truth — the LaTeX file is authoritative.
+    """
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "dev" / "algorithms" / "radial_return_j2_kinematic.tex"
+        if candidate.is_file():
+            return candidate.read_text(encoding="utf-8")
+    raise FileNotFoundError(
+        "constitutive_latex Phase 6 (P6-2): canonical kinematic algorithm "
+        "source not found. Expected at "
+        "<repo>/dev/algorithms/radial_return_j2_kinematic.tex."
+    )
+
+
+RADIAL_RETURN_J2_KINEMATIC_LATEX: str = _load_canonical_source()
+
+
+def get_radial_return_j2_kinematic_latex() -> str:
+    """Return the canonical J2 kinematic radial-return algpseudocode LaTeX."""
+    return RADIAL_RETURN_J2_KINEMATIC_LATEX
+
+
+def transpile_radial_return_j2_kinematic(backend: str = "taichi") -> str:
+    """Transpile the canonical kinematic algpseudocode to ``backend`` and
+    return the emitted Python module source.
+
+    Parameters
+    ----------
+    backend:
+        Target backend name. ``"taichi"`` is the only one consumed by
+        ``mechdsl-core`` today.
+
+    Returns
+    -------
+    str
+        Transpiled Python module source. Pass to ``exec`` with a fresh
+        namespace dict to load the ``radial_return_j2_kinematic`` callable.
+    """
+    # Local import keeps the runtime-free invariant — algo2code itself
+    # has no third-party imports beyond stdlib.
+    from algo2code import transpile
+
+    return transpile(RADIAL_RETURN_J2_KINEMATIC_LATEX, backend=backend)
+
+
+__all__ = [
+    "RADIAL_RETURN_J2_KINEMATIC_LATEX",
+    "get_radial_return_j2_kinematic_latex",
+    "transpile_radial_return_j2_kinematic",
+]

algo2code/library/radial_return_j2_mixed.py

@@ -0,0 +1,91 @@
+r"""J2 mixed-hardening radial-return (algo2code interface hook).
+
+constitutive_latex Phase 6 (P6-3). Mirrors
+:mod:`algo2code.library.radial_return_j2` (isotropic power-law) and
+:mod:`algo2code.library.radial_return_j2_kinematic` (linear kinematic)
+for the MIXED-hardening model — the yield surface BOTH translates
+(back-stress ``beta``, Prager) AND expands (power-law radius
+``sigma_y(alpha) = sigy0 + K*alpha^n``) simultaneously:
+
+- :data:`RADIAL_RETURN_J2_MIXED_LATEX` exposes the verbatim algpseudocode.
+- :func:`get_radial_return_j2_mixed_latex` returns it.
+- :func:`transpile_radial_return_j2_mixed` runs ``algo2code.transpile``
+  on the source and returns the emitted module text.
+
+The scalar source owns only the plastic-multiplier solve. Yield is on
+the trial RELATIVE-stress equivalent ``xi_eq`` (von Mises of
+``dev(S) - beta``) against the EXPANDING radius ``sigma_y(alpha)``.
+Because the isotropic part is a nonlinear power law in
+``alpha = alpha_old + dl``, the consistency condition is nonlinear in
+``dl`` and is solved by the same scalar NEWTON loop as the isotropic
+variant — but with the kinematic ``(3*mu + H_kin)*dl`` linear term added
+to the residual and the Prager modulus folded into the Newton
+denominator alongside the isotropic slope.
+
+Runtime invariant
+-----------------
+
+This module imports **only stdlib** (and ``algo2code`` siblings). The
+runtime-free contract holds.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def _load_canonical_source() -> str:
+    """Read the canonical algpseudocode source from
+    ``dev/algorithms/radial_return_j2_mixed.tex``.
+
+    Walks up from this module to the repo root, then reads the file.
+    Single source of truth — the LaTeX file is authoritative.
+    """
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        candidate = parent / "dev" / "algorithms" / "radial_return_j2_mixed.tex"
+        if candidate.is_file():
+            return candidate.read_text(encoding="utf-8")
+    raise FileNotFoundError(
+        "constitutive_latex Phase 6 (P6-3): canonical mixed algorithm "
+        "source not found. Expected at "
+        "<repo>/dev/algorithms/radial_return_j2_mixed.tex."
+    )
+
+
+RADIAL_RETURN_J2_MIXED_LATEX: str = _load_canonical_source()
+
+
+def get_radial_return_j2_mixed_latex() -> str:
+    """Return the canonical J2 mixed radial-return algpseudocode LaTeX."""
+    return RADIAL_RETURN_J2_MIXED_LATEX
+
+
+def transpile_radial_return_j2_mixed(backend: str = "taichi") -> str:
+    """Transpile the canonical mixed algpseudocode to ``backend`` and
+    return the emitted Python module source.
+
+    Parameters
+    ----------
+    backend:
+        Target backend name. ``"taichi"`` is the only one consumed by
+        ``mechdsl-core`` today.
+
+    Returns
+    -------
+    str
+        Transpiled Python module source. Pass to ``exec`` with a fresh
+        namespace dict to load the ``radial_return_j2_mixed`` callable.
+    """
+    # Local import keeps the runtime-free invariant — algo2code itself
+    # has no third-party imports beyond stdlib.
+    from algo2code import transpile
+
+    return transpile(RADIAL_RETURN_J2_MIXED_LATEX, backend=backend)
+
+
+__all__ = [
+    "RADIAL_RETURN_J2_MIXED_LATEX",
+    "get_radial_return_j2_mixed_latex",
+    "transpile_radial_return_j2_mixed",
+]

algo2code/type_inference.py

@@ -0,0 +1,219 @@
+"""
+Type inference for algorithm AST nodes.
+
+Given type annotations on variables (from % comments or directives),
+propagate types through expressions to resolve:
+  - Which operations are scalar (stay in Python scope)
+  - Which operations are vector/matrix (become Taichi kernels)
+  - What each binary operator actually means:
+      * vector * vector   → dot product
+      * matrix * vector   → matvec
+      * scalar * vector   → axpy
+      * scalar / scalar   → division
+"""
+
+from __future__ import annotations
+
+from .ast_nodes import (
+    Algorithm,
+    Assign,
+    BinOp,
+    Branch,
+    Expr,
+    ForLoop,
+    FuncCall,
+    Number,
+    Return,
+    Stmt,
+    UnaryOp,
+    Var,
+    VarType,
+    WhileLoop,
+)
+
+
+class TypeInferrer:
+    """
+    Walk the AST and annotate every Expr node with its inferred VarType.
+    Also resolves BinOp.op to semantically specific operations:
+      '*' with (matrix, vector)  → 'matvec'
+      '*' with (vector, vector)  → 'dot'     (only when one is transposed)
+      '*' with (scalar, vector)  → 'scale'
+    """
+
+    def __init__(self, type_annotations: dict[str, VarType]):
+        self.types = dict(type_annotations)
+
+    def infer_algorithm(self, algo: Algorithm):
+        """Run type inference on the full algorithm."""
+        for name, vtype in algo.args:
+            if vtype != VarType.UNKNOWN:
+                self.types[name] = vtype
+
+        self._infer_block(algo.body)
+
+    def _infer_block(self, stmts: list[Stmt]):
+        for stmt in stmts:
+            self._infer_stmt(stmt)
+
+    def _infer_stmt(self, stmt: Stmt):
+        if isinstance(stmt, Assign):
+            self._infer_expr(stmt.value)
+            var_name = stmt.target.display
+            if var_name not in self.types:
+                self.types[var_name] = stmt.value.inferred_type
+            stmt.target.inferred_type = self.types.get(var_name, VarType.UNKNOWN)
+
+        elif isinstance(stmt, ForLoop):
+            self.types[stmt.var] = VarType.SCALAR
+            self._infer_block(stmt.body)
+
+        elif isinstance(stmt, WhileLoop):
+            self._infer_expr(stmt.condition)
+            self._infer_block(stmt.body)
+
+        elif isinstance(stmt, Branch):
+            self._infer_expr(stmt.condition)
+            self._infer_block(stmt.if_body)
+            for cond, body in stmt.elif_branches:
+                self._infer_expr(cond)
+                self._infer_block(body)
+            self._infer_block(stmt.else_body)
+
+        elif isinstance(stmt, Return):
+            for v in stmt.values:
+                self._infer_expr(v)
+
+    def _infer_expr(self, expr: Expr) -> VarType:
+        """Infer and set the type of an expression, returning the type."""
+        if isinstance(expr, Number):
+            expr.inferred_type = VarType.SCALAR
+            return VarType.SCALAR
+
+        if isinstance(expr, Var):
+            name = expr.display
+            t = self.types.get(name, VarType.UNKNOWN)
+            # Single-letter uppercase → default to matrix if unknown
+            if t == VarType.UNKNOWN and len(expr.name) == 1 and expr.name.isupper():
+                t = VarType.MATRIX
+            expr.inferred_type = t
+            return t
+
+        if isinstance(expr, UnaryOp):
+            inner = self._infer_expr(expr.operand)
+            if expr.op == "norm":
+                expr.inferred_type = VarType.SCALAR
+            elif expr.op == "transpose":
+                expr.inferred_type = inner  # transpose preserves type
+            elif expr.op == "neg" or expr.op == "inverse":
+                expr.inferred_type = inner
+            else:
+                expr.inferred_type = inner
+            return expr.inferred_type
+
+        if isinstance(expr, BinOp):
+            lt = self._infer_expr(expr.left)
+            rt = self._infer_expr(expr.right)
+            expr.inferred_type = self._resolve_binop(expr, lt, rt)
+            return expr.inferred_type
+
+        if isinstance(expr, FuncCall):
+            for arg in expr.args:
+                self._infer_expr(arg)
+            self._infer_expr(expr.func)
+            if expr.args:
+                expr.inferred_type = expr.args[0].inferred_type
+            else:
+                expr.inferred_type = VarType.UNKNOWN
+            # Check if func is an inverse of a callable
+            if isinstance(expr.func, UnaryOp) and expr.func.op == "inverse":
+                base = expr.func.operand
+                if isinstance(base, Var):
+                    self.types[base.display] = VarType.CALLABLE
+            return expr.inferred_type
+
+        expr.inferred_type = VarType.UNKNOWN
+        return VarType.UNKNOWN
+
+    def _resolve_binop(self, expr: BinOp, lt: VarType, rt: VarType) -> VarType:
+        """Resolve the semantic meaning of a binary operation given operand types."""
+        op = expr.op
+
+        if op in ("+", "-"):
+            if lt == VarType.VECTOR or rt == VarType.VECTOR:
+                return VarType.VECTOR
+            if lt == VarType.MATRIX or rt == VarType.MATRIX:
+                return VarType.MATRIX
+            return VarType.SCALAR
+
+        if op == "/":
+            return VarType.SCALAR
+
+        if op == "*":
+            return self._resolve_multiply(expr, lt, rt)
+
+        if op == "pow":
+            return lt
+
+        if op in ("<", ">", "<=", ">=", "==", "!="):
+            return VarType.SCALAR
+
+        return VarType.UNKNOWN
+
+    def _resolve_multiply(self, expr: BinOp, lt: VarType, rt: VarType) -> VarType:
+        """
+        Resolve multiplication semantics:
+          transposed_vector * vector  →  dot product (scalar result)
+          matrix * vector             →  matvec (vector result)
+          callable * vector           →  matvec (vector result, matrix-free seam)
+          scalar * vector             →  scale (vector result)
+          scalar * scalar             →  multiply (scalar result)
+        """
+        left_is_transposed = isinstance(expr.left, UnaryOp) and expr.left.op == "transpose"
+
+        if left_is_transposed and rt == VarType.VECTOR:
+            expr.op = "dot"
+            return VarType.SCALAR
+
+        if left_is_transposed and rt == VarType.MATRIX:
+            expr.op = "dot"
+            return VarType.VECTOR
+
+        if lt == VarType.MATRIX and rt == VarType.VECTOR:
+            expr.op = "matvec"
+            return VarType.VECTOR
+
+        # Matrix-free operator seam (11-ALGO2CODE §8.3): a `callable` operator A
+        # applied to a vector — `A \cdot p` — is a matvec whose body is an
+        # injected in-place call A(out, p), not a dense stored-matrix multiply.
+        # The backend distinguishes the two by the operand's CALLABLE type.
+        if lt == VarType.CALLABLE and rt == VarType.VECTOR:
+            expr.op = "matvec"
+            return VarType.VECTOR
+
+        if lt == VarType.MATRIX and rt == VarType.MATRIX:
+            expr.op = "matmul"
+            return VarType.MATRIX
+
+        if lt == VarType.SCALAR and rt == VarType.VECTOR:
+            expr.op = "scale"
+            return VarType.VECTOR
+
+        if lt == VarType.VECTOR and rt == VarType.SCALAR:
+            expr.op = "scale"
+            return VarType.VECTOR
+
+        if lt == VarType.SCALAR and rt == VarType.MATRIX:
+            expr.op = "scale"
+            return VarType.MATRIX
+
+        # Default: scalar multiply
+        return VarType.SCALAR
+
+
+def infer_types(algo: Algorithm):
+    """Run type inference on an Algorithm AST, mutating nodes in place."""
+    inferrer = TypeInferrer(algo.type_annotations)
+    inferrer.infer_algorithm(algo)
+    # Write back discovered types
+    algo.type_annotations = inferrer.types

algo2code-0.2.1.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: algo2code
+Version: 0.2.1
+Summary: Transpile LaTeX algorithm boxes (algpseudocode) to executable Taichi/NumPy/C code
+Project-URL: Repository, https://github.com/CEmM2/MechDSL
+Author: Shmuel Osovski
+License-Expression: MIT
+License-File: LICENSE
+Keywords: algorithm,code-generation,latex,taichi,transpiler
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+
+# algo2code
+
+Transpile LaTeX algorithm boxes (`algpseudocode`) to executable code targeting Taichi, NumPy, or C/PETSc.
+
+Parses `\begin{algorithmic}...\end{algorithmic}` environments with type-directed code generation.
+Zero runtime dependencies — standard library only.
+
+## Documentation
+
+- **User docs:** <https://sosovski.group/MechDSL/algo2code/> — introduction, getting
+  started, usage, and examples.
+- **Design spec:** `dev/design_docs/11-ALGO2CODE.md` (authoritative source of truth).
+- See the [monorepo root](../../README.md) for the full project overview.

algo2code-0.2.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+algo2code/__init__.py,sha256=FWaPHkz13pKOXfuA0ahh_uKXGRe80UGCz_1nUs_hpIc,2061
+algo2code/algo_parser.py,sha256=eC0Dl2X7vPojmViTk-3XCXBpySevBeptgI24vVS7KI4,15880
+algo2code/ast_nodes.py,sha256=p7n-ZPoR7SizrcbgIMUWigWrk8kfifBLYfSchlrlQxo,4561
+algo2code/errors.py,sha256=506gr0O_ufY1eqceHicuP8RcGzwNT1TuCGoquJHoA1Q,1098
+algo2code/expr_parser.py,sha256=R5PQ3ey3DQYTTl-xOJ4KvqKSpUbEvhrs82htSae6W0A,21564
+algo2code/type_inference.py,sha256=Pa3bK-QV_IlMx32jh1xx39lj_-dC4DOC-eO9aU1keF4,7596
+algo2code/backends/__init__.py,sha256=hNwHmY9S56cZsMNlP95kFYMz8qojJKqXl7s1aFcXg84,32
+algo2code/backends/c_petsc_codegen.py,sha256=YlRVHC8vwugD1ZGz0UVGMKzMzhZBlAzLBwkbO90FpXM,33
+algo2code/backends/numpy_codegen.py,sha256=WpOm7GkpD51L_kYkoZiVnv-lwn_5ZwtcveU9porEdWY,31
+algo2code/backends/taichi_codegen.py,sha256=ME7BGQDX8nOOYiQFe7Mw0hDYezGU-KVQ9f0bv-nKKYw,35942
+algo2code/library/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algo2code/library/__init__.py,sha256=HZf5doUkzAjS2D1It3Jc-9fUIRp04BH4wYteaOVPGqc,686
+algo2code/library/pcg.py,sha256=uFQnr3U5a0L3hz_d_S3g9D4pUu8vFthiN55bOy-FBeA,5639
+algo2code/library/radial_return_j2.py,sha256=qW-3avbzW9WQQytX2fZwg7zwQaWhDMYcJCx_B6m9aXM,3136
+algo2code/library/radial_return_j2_kinematic.py,sha256=MaP0IPmrZSafjzH8KuzdBtC2XbKw8tYK7uaLW3M7LQc,3100
+algo2code/library/radial_return_j2_mixed.py,sha256=q9AKkf6Z7uRtMcKTCFWXFI74xHJi0qiMje8hzGWdPl8,3298
+algo2code-0.2.1.dist-info/METADATA,sha256=EOl2z0f4pzkiX-les0_93qdcL-fZ_fHznqmLfGD9uUI,1215
+algo2code-0.2.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+algo2code-0.2.1.dist-info/licenses/LICENSE,sha256=09AX3cq_TtJwbbZ00zsqmmGL_p_FINJ4l8asH_rhVhk,1071
+algo2code-0.2.1.dist-info/RECORD,,

algo2code-0.2.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any