apc-model-parser 0.2.1__tar.gz → 0.2.2__tar.gz

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/AGENTS.md

@@ -22,8 +22,9 @@ ecosystem and must remain usable **standalone**.
 ```text
 authoring (ExprTk INI)  --parse-->  AST  --normalize-->  canonical IR (JSON)
                                                           |
-                                          emit julia  --> ModelingToolkit .jl
-                                          emit cpp    --> (planned) realtime C++
+                                          emit julia      --> ModelingToolkit .jl
+                                          emit julia-rhs  --> numerical f!/outputs! .jl
+                                          emit cpp        --> (planned) realtime C++
 ```
 
 ## Language

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apc-model-parser
-Version: 0.2.1
+Version: 0.2.2
 Summary: Convert process-model definitions to and from a canonical intermediate representation.
 Project-URL: Repository, https://github.com/Advanced-Process-Control/model-parser
 Author: Advanced Process Control
@@ -26,8 +26,9 @@ model script.
 ```text
 authoring (ExprTk INI)  --parse-->  AST  --normalize-->  canonical IR (JSON)
                                                           |
-                                          emit julia  --> ModelingToolkit .jl
-                                          emit cpp    --> (planned) realtime C++
+                                          emit julia      --> ModelingToolkit .jl
+                                          emit julia-rhs  --> numerical f!/outputs! .jl
+                                          emit cpp        --> (planned) realtime C++
 ```
 
 The IR is the single semantic contract. Adding a backend means writing one
@@ -80,6 +81,9 @@ uv run model-parser parse examples/models/model_monod_simple.ini -o monod.ir.jso
 # 2. canonical IR  ->  ModelingToolkit (v11) Julia model
 uv run model-parser emit julia monod.ir.json -o monod.jl
 
+# 2a. canonical IR  ->  plain numerical ODE RHS (SciML-style f!)
+uv run model-parser emit julia-rhs monod.ir.json -o monod_rhs.jl
+
 # Supporting commands
 uv run model-parser validate monod.ir.json --profile julia-analysis
 uv run model-parser inspect  monod.ir.json

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/README.md

@@ -13,8 +13,9 @@ model script.
 ```text
 authoring (ExprTk INI)  --parse-->  AST  --normalize-->  canonical IR (JSON)
                                                           |
-                                          emit julia  --> ModelingToolkit .jl
-                                          emit cpp    --> (planned) realtime C++
+                                          emit julia      --> ModelingToolkit .jl
+                                          emit julia-rhs  --> numerical f!/outputs! .jl
+                                          emit cpp        --> (planned) realtime C++
 ```
 
 The IR is the single semantic contract. Adding a backend means writing one
@@ -67,6 +68,9 @@ uv run model-parser parse examples/models/model_monod_simple.ini -o monod.ir.jso
 # 2. canonical IR  ->  ModelingToolkit (v11) Julia model
 uv run model-parser emit julia monod.ir.json -o monod.jl
 
+# 2a. canonical IR  ->  plain numerical ODE RHS (SciML-style f!)
+uv run model-parser emit julia-rhs monod.ir.json -o monod_rhs.jl
+
 # Supporting commands
 uv run model-parser validate monod.ir.json --profile julia-analysis
 uv run model-parser inspect  monod.ir.json

apc_model_parser-0.2.2/docs/chatlogs/2026-06-03_julia-rhs-emit-and-library-sync.md

@@ -0,0 +1,80 @@
+---
+title: Julia numerical RHS emit target and model-library sync
+topic: codegen
+date_added: 2026-06-03
+tags: [chatlogs]
+links:
+  - AGENTS.md
+  - docs/design/model-parser.md
+  - docs/decisions/0006-julia-numerical-rhs-view.md
+  - src/model_parser/backends/julia_expr.py
+  - src/model_parser/backends/julia_rhs.py
+  - src/model_parser/cli.py
+---
+
+## Commit helper
+
+- **SemVer / version bump:** **PATCH** (`0.2.1` → `0.2.2`) — new CLI subcommand `emit julia-rhs` and new public Python API `emit_julia_rhs`; backward-compatible for existing `emit julia` users.
+- **Tags / GitHub Release:** **None** — stack on default branch; tag when cutting a PyPI release (existing `release.yml` on tag).
+- **Suggested commit message (model-parser repo):** `feat(emit): add julia-rhs numerical ODE view`
+- **Copy-paste git commands (model-parser):**
+
+```bash
+cd /path/to/model-parser
+git add AGENTS.md README.md docs/design/model-library-and-versioning.md \
+  docs/design/model-parser.md docs/design/storing-mtk-models.md \
+  docs/decisions/0006-julia-numerical-rhs-view.md docs/decisions/index.md \
+  docs/chatlogs/2026-06-03_julia-rhs-emit-and-library-sync.md \
+  examples/README.md examples/run.sh mkdocs.yml pyproject.toml \
+  src/model_parser/__init__.py src/model_parser/backends/__init__.py \
+  src/model_parser/backends/julia_expr.py src/model_parser/backends/julia_mtk.py \
+  src/model_parser/backends/julia_rhs.py src/model_parser/cli.py \
+  tests/test_cli.py tests/test_julia_rhs.py
+git commit -m "$(cat <<'EOF'
+feat(emit): add julia-rhs numerical ODE view
+
+Share IR→Julia expression lowering in julia_expr; emit f!/outputs! codegen;
+document packing and ADR 0006; extend examples and model-library design notes.
+EOF
+)"
+```
+
+- **Suggested commit message (model-library repo, separate clone):** `chore(views): add model_rhs.jl and lock digests from emit julia-rhs`
+- **Copy-paste git commands (model-library):**
+
+```bash
+cd /path/to/model-library
+git add README.md library.lock.json scripts/sync.sh scripts/update_lock.py \
+  models/*/model.ir.json models/*/views/model.jl models/*/views/model_rhs.jl
+git commit -m "$(cat <<'EOF'
+chore(views): sync numerical RHS views and lockfile
+
+Regenerate IR/MTK views; add model_rhs.jl and julia_rhs_* lock fields per sync.
+EOF
+)"
+```
+
+- **Git order when tagging:** commit / push branch (with version bump if releasing) → annotated tag on that commit → push tag.
+
+## How to try
+
+```bash
+cd /path/to/model-parser
+uv sync --all-groups
+uv run model-parser parse examples/models/model_monod_simple.ini -o /tmp/m.ir.json
+uv run model-parser emit julia-rhs /tmp/m.ir.json
+uv run pytest tests/test_julia_rhs.py tests/test_cli.py
+uv run mkdocs build --strict
+```
+
+**model-library:** `MODEL_PARSER_VENV=/path/to/model-parser/.venv ./scripts/sync.sh` then inspect `models/*/views/model_rhs.jl` and `library.lock.json`.
+
+## Session narrative
+
+**Goal:** Implement a second Julia backend that emits an explicit numerical RHS (`f!` and optional `outputs!`) from the canonical IR, and wire the sibling `model-library` sync + lockfile to generate and fingerprint `views/model_rhs.jl`.
+
+**Shipped (model-parser):** New module `julia_expr.py` (shared `expr_to_julia`, `julia_model_slug`, `julia_number_literal`, `JuliaCodegenError`); `julia_mtk.py` refactored to use it; `julia_rhs.py` with `emit_julia_rhs`; CLI `emit julia-rhs`; tests; PATCH version bump; ADR 0006; design/README/AGENTS/examples updates; MkDocs nav entry.
+
+**Shipped (model-library):** `sync.sh` runs `emit julia-rhs` to `views/model_rhs.jl`; `update_lock.py` records `julia_rhs_relpath` and `julia_rhs_content_hash`; README updated; all models re-synced (committed artifacts include new `.jl` files and refreshed lock).
+
+**Follow-ups:** Optional `ApcModelAnalysis.jl` helper to load `model_rhs.jl`; conformance tests comparing MTK trajectory vs plain `ODEProblem` built from `f!` for small fixtures.

apc_model_parser-0.2.2/docs/decisions/0006-julia-numerical-rhs-view.md

@@ -0,0 +1,52 @@
+# ADR 0006: Julia numerical RHS view (`emit julia-rhs`)
+
+## Status
+
+accepted
+
+## Context
+
+Some analysis workflows (explicit vector ODEs, custom sensitivity tooling, or
+bridges that do not use ModelingToolkit) need a **plain in-place RHS**
+`f!(du, u, p, t)` with stable symbol-to-index packing, while the ecosystem
+standard remains an MTK-generated `System` from the same IR.
+
+## Decision
+
+Add a second Julia **codegen** target, `emit julia-rhs`, that lowers the same
+canonical IR to:
+
+- `f_<model_slug>!(du, u, p, t)` when the scaffold has no inputs, or
+  `f_<model_slug>!(du, u, p, t, inp)` when it has inputs (`inp` order = IR inputs
+  list order);
+- `outputs_<model_slug>!(y, u, p, t)` (same optional `inp`) when the IR
+  carries output equations.
+
+Packing rules: `u` and `du` follow `ir.states` order; `p` follows `ir.parameters`
+order (defaults in the IR are **not** applied inside `f!` — callers supply
+numeric `p`). Locals are emitted as sequential assignments in IR order, aligned
+with the MTK lowering order.
+
+Expression rendering is shared with the MTK backend via `julia_expr.py` so
+semantics are not duplicated.
+
+## Consequences
+
+- **Positive:** One IR, two diffable Julia views; numerical and symbolic stacks
+  stay aligned.
+- **Negative:** Callers must respect documented packing; no automatic wiring to
+  MTK `ODEProblem` from the RHS view alone.
+
+## Alternatives considered
+
+1. **Generate RHS only in downstream repos** — rejected: duplicates expression
+   semantics and drifts from the IR contract.
+2. **Single `emit julia` with a flag** — rejected: CLI stays clearer with
+   separate targets (`emit cpp`, etc.) per ADR 0005.
+
+## References
+
+- ADR 0002 (codegen over serialized `System`)
+- ADR 0003 (explicit expression IR)
+- ADR 0005 (CLI `emit <target>` shape)
+- `docs/design/model-parser.md` §5 (CLI)

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/docs/decisions/index.md

@@ -17,6 +17,7 @@ code and review naturally in pull requests.
 | [0003](0003-explicit-expression-ir.md) | Explicit expression IR, not string rewrites | accepted | 2026-06-01 |
 | [0004](0004-target-mtk-v11-idioms.md) | Generated Julia targets ModelingToolkit v11 idioms | accepted | 2026-06-01 |
 | [0005](0005-cli-verbs-parse-emit.md) | CLI shape: `parse` and `emit <target>` as core verbs | accepted | 2026-06-01 |
+| [0006](0006-julia-numerical-rhs-view.md) | Second Julia view: plain `f!` / `outputs!` from IR (`emit julia-rhs`) | accepted | 2026-06-03 |
 
 ## Format
 

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/docs/design/model-library-and-versioning.md

@@ -73,7 +73,8 @@ models/<name>/
   model.ir.json          # canonical IR (generated by model-parser parse)
   views/
     model.jl             # generated by model-parser emit julia
-library.lock.json        # index: names, paths, content_hash, optional view hashes
+    model_rhs.jl         # generated by model-parser emit julia-rhs
+library.lock.json        # index: names, paths, content_hash, view SHA-256 digests
 ```
 
 A thin driver (`scripts/sync.sh`, `just`, or Makefile) invokes the installed `model-parser`. CI runs the same pipeline with `--strict` checks (e.g. `git diff --exit-code` after sync).
@@ -86,7 +87,7 @@ flowchart TD
     B --> C{content_hash changed vs baseline?}
     C -- no --> Z[No semantic change; optional doc-only commit]
     C -- yes --> D[model-parser diff / bump vs previous release IR]
-    D --> E[Regenerate views emit julia …]
+    D --> E[Regenerate views: emit julia, emit julia-rhs …]
     E --> F[Update library.lock.json and changelog]
     F --> G[Commit; tag if releasing]
     G --> H[CI: re-sync or re-emit; fail on drift]

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/docs/design/model-parser.md

@@ -13,9 +13,10 @@ backend-independent IR, and lowers that IR into target views.
 ```text
 authoring (ExprTk INI)  --parse-->  AST  --normalize-->  canonical IR (JSON)
                                                           |
-                                          emit julia  --> ModelingToolkit .jl
-                                          emit cpp    --> (planned) realtime C++
-                                          emit ini    --> (planned) round-trip
+                                          emit julia      --> ModelingToolkit .jl
+                                          emit julia-rhs  --> numerical f!/outputs! .jl
+                                          emit cpp        --> (planned) realtime C++
+                                          emit ini        --> (planned) round-trip
 ```
 
 The IR is the **single semantic contract**. Adding a backend is one `lower` +
@@ -36,8 +37,9 @@ In scope:
   versioned JSON Schema.
 - **Validation** — semantic checks (undeclared symbols, duplicate names,
   missing equations, local ordering) and backend-profile checks.
-- **Backends** — lower the IR into a target view. The first backend generates a
-  ModelingToolkit (Julia) model script; a Julia companion package
+- **Backends** — lower the IR into a target view. Backends today: a
+  ModelingToolkit (Julia) model script (`emit julia`) and a plain numerical
+  ODE RHS plus optional output map (`emit julia-rhs`). A Julia companion package
   (`ModelParserJL`) loads the IR in memory.
 
 Out of scope (sibling tools that *consume* the IR):
@@ -58,7 +60,7 @@ scaffold contract, not an everything-bucket (see the org risk note on
 | **Authoring** | What the engineer writes (ExprTk INI today). | yes (`.ini`) |
 | **AST** | Syntax-oriented tree from the parser. Internal. | debug only |
 | **Canonical IR** | Normalized, backend-independent scaffold semantics. | yes (`.ir.json`) |
-| **Backend view** | A lowered target (MTK `.jl`, future C++). | yes (generated) |
+| **Backend view** | A lowered target (MTK `.jl`, numerical RHS `.jl`, future C++). | yes (generated) |
 
 The AST is in-memory; the IR is the durable interchange contract. The full IR
 shape and the expression sub-language are specified in
@@ -82,7 +84,8 @@ contracts ("initial values live in the scenario, not the scaffold").
 
 ```text
 model-parser parse   <authoring-file> [--from exprtk-ini] [-o out.ir.json]
-model-parser emit julia <model.ir.json>                     [-o out.jl]
+model-parser emit julia      <model.ir.json>             [-o out.jl]
+model-parser emit julia-rhs  <model.ir.json>             [-o out.jl]
 model-parser validate <model.ir.json | authoring-file> [--profile <name>]
 model-parser inspect  <model.ir.json | authoring-file>
 model-parser diff     <old.ir.json> <new.ir.json>         [--json]
@@ -93,8 +96,10 @@ model-parser schema                                         [-o schema.json]
 
 - `parse` is the **authoring → IR** transformation. Default and only frontend
   today is `exprtk-ini`.
-- `emit <target>` is the **IR → view** transformation. Today: `julia`. Designed
-  to grow (`emit cpp`, `emit ini`) without touching existing targets.
+- `emit <target>` is the **IR → view** transformation. Julia targets: `julia`
+  (ModelingToolkit v11 scaffold) and `julia-rhs` (plain `f!` / optional
+  `outputs!`). Designed to grow (`emit cpp`, `emit ini`) without touching
+  existing targets.
 - `validate` accepts either an IR `.json` or an authoring file (parsed on the
   fly), and an optional `--profile`.
 - `inspect` prints a human summary; `ast` exports a debug tree; `schema` exports
@@ -113,6 +118,7 @@ Diagnostics use the `OK` / `WARN` / `ERROR` vocabulary.
 uv run model-parser parse  examples/models/model_monod_simple.ini -o monod.ir.json
 uv run model-parser validate monod.ir.json --profile julia-analysis
 uv run model-parser emit julia monod.ir.json -o monod.jl
+uv run model-parser emit julia-rhs monod.ir.json -o monod_rhs.jl
 ```
 
 ## 6. Language split

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/docs/design/storing-mtk-models.md

@@ -29,19 +29,21 @@ long-term storage to one symbolic library's internal API is exactly the
 
 ## 2. The chosen approach
 
-Two durable artifacts, both derived from the IR:
+A durable **canonical IR JSON** plus **one or more generated Julia views** from
+the same IR:
 
 1. **Canonical IR JSON** — the source of truth. Language-neutral, diffable,
    schema-validated, content-hashed. This is what we persist and version.
-2. **Generated `.jl` script** — produced by `model-parser emit julia`. A
-   plain-text, re-runnable artifact that constructs the `System` with current
-   MTK idioms. Regenerated whenever the IR changes; never hand-edited.
+2. **Generated `.jl` scripts** — produced by `model-parser emit julia` (MTK
+   `System` builder) and, when needed, `model-parser emit julia-rhs` (plain
+   `f!` / `outputs!` for vector ODE workflows). Plain-text, re-runnable artifacts
+   regenerated whenever the IR changes; never hand-edited.
 
 ```text
                  store / version
                  ┌──────────────┐
-  authoring ──►  │ IR JSON      │  ──emit julia──►  generated .jl  ──include──►  System
-   (.ini)        │ (.ir.json)   │                   (re-runnable)               (in memory)
+  authoring ──►  │ IR JSON      │  ──emit julia──►  MTK builder .jl ──►  System
+   (.ini)        │ (.ir.json)   │  ──emit julia-rhs──►  f!/outputs! .jl
                  └──────────────┘
                         │
                         └────────  ModelParserJL.build_system(ir)  ──►  System

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/examples/README.md

@@ -9,7 +9,7 @@ commands assume you have run `uv sync` in the repository root.
 |---|---|
 | [`models/model_monod_simple.ini`](models/model_monod_simple.ini) | A 2-state Monod CSTR, no inputs. |
 | [`models/model_thermal_tank.ini`](models/model_thermal_tank.ini) | A 2-state heated tank with 3 inputs. |
-| [`run.sh`](run.sh) | Runs the full `parse → validate → emit` pipeline for both models. |
+| [`run.sh`](run.sh) | Runs the full `parse → validate → emit julia → emit julia-rhs` pipeline for both models. |
 
 Generated artifacts are written to `outputs/` (git-ignored).
 
@@ -22,6 +22,9 @@ uv run model-parser parse examples/models/model_monod_simple.ini -o examples/out
 # canonical IR  ->  ModelingToolkit (v11) Julia model
 uv run model-parser emit julia examples/outputs/monod.ir.json -o examples/outputs/monod.jl
 
+# canonical IR  ->  plain numerical RHS (f! / outputs!)
+uv run model-parser emit julia-rhs examples/outputs/monod.ir.json -o examples/outputs/monod_rhs.jl
+
 # validate against a backend profile
 uv run model-parser validate examples/outputs/monod.ir.json --profile julia-analysis
 uv run model-parser validate examples/models/model_thermal_tank.ini --profile realtime-cpp
@@ -37,6 +40,8 @@ Or run everything at once:
 
 - `parse` warns that `[x0]` / `[u0]` initial values are **dropped** from the
   scaffold: initial values belong to a *scenario*, not the model IR.
-- The generated `.jl` is a standalone artifact; load it with `include("monod.jl")`
+- The generated MTK `.jl` is a standalone artifact; load it with `include("monod.jl")`
   and call `build_monod_simple()`. Provide initial conditions and parameter
   overrides at `ODEProblem` construction time.
+- The `emit julia-rhs` view defines `f_<model>!(du, u, p, t)` (and optional
+  `outputs_<model>!`); see header comments in the file for `u` / `p` / `inp` packing.

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/examples/run.sh

@@ -11,6 +11,7 @@ for model in monod_simple thermal_tank; do
   ini="$here/models/model_${model}.ini"
   ir="$out/${model}.ir.json"
   jl="$out/${model}.jl"
+  rhs="$out/${model}_rhs.jl"
 
   echo "== $model: parse =="
   uv run model-parser parse "$ini" -o "$ir"
@@ -21,7 +22,11 @@ for model in monod_simple thermal_tank; do
   echo "== $model: emit julia =="
   uv run model-parser emit julia "$ir" -o "$jl"
   echo "wrote $jl"
+
+  echo "== $model: emit julia-rhs =="
+  uv run model-parser emit julia-rhs "$ir" -o "$rhs"
+  echo "wrote $rhs"
   echo
 done
 
-echo "Done. Generated IR + Julia in $out"
+echo "Done. Generated IR + Julia views in $out"

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/mkdocs.yml

@@ -61,6 +61,7 @@ nav:
       - "0003: Explicit expression IR": decisions/0003-explicit-expression-ir.md
       - "0004: Target MTK v11 idioms": decisions/0004-target-mtk-v11-idioms.md
       - "0005: CLI verbs parse / emit": decisions/0005-cli-verbs-parse-emit.md
+      - "0006: Julia numerical RHS view": decisions/0006-julia-numerical-rhs-view.md
   - API reference: api.md
   - Deployment: deployment/ci-cd.md
 

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apc-model-parser"
-version = "0.2.1"
+version = "0.2.2"
 description = "Convert process-model definitions to and from a canonical intermediate representation."
 readme = "README.md"
 requires-python = ">=3.11"

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/src/model_parser/__init__.py

@@ -5,7 +5,7 @@ models and the transformations around it:
 
 - **frontends** parse an authoring format (e.g. ExprTk INI) into the IR;
 - **backends** lower the IR into a target view (e.g. a ModelingToolkit Julia
-  script);
+  script or a plain numerical ``f!`` RHS);
 - **validation** checks an IR against the schema and backend profiles.
 
 See ``docs/design/model-parser.md`` for the authoritative product specification.
@@ -15,4 +15,4 @@ from model_parser.ir import IR_VERSION, IRModel
 
 __all__ = ["IRModel", "IR_VERSION", "__version__"]
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

apc_model_parser-0.2.2/src/model_parser/backends/__init__.py

@@ -0,0 +1,7 @@
+"""Backends: lower the canonical IR into target views."""
+
+from model_parser.backends.julia_expr import JuliaCodegenError, expr_to_julia
+from model_parser.backends.julia_mtk import emit_julia
+from model_parser.backends.julia_rhs import emit_julia_rhs
+
+__all__ = ["emit_julia", "emit_julia_rhs", "expr_to_julia", "JuliaCodegenError"]

apc_model_parser-0.2.2/src/model_parser/backends/julia_expr.py

@@ -0,0 +1,84 @@
+"""Shared Julia expression lowering from the IR expression tree.
+
+Used by multiple Julia codegen backends so expression semantics stay in one
+place (see ADR 0003).
+"""
+
+from __future__ import annotations
+
+from model_parser.ir import Call, Expr, IRModel, Num, Sym
+
+# IR op name -> Julia infix operator.
+_INFIX: dict[str, str] = {
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "^": "^",
+    "==": "==",
+    "!=": "!=",
+    "<": "<",
+    ">": ">",
+    "<=": "<=",
+    ">=": ">=",
+}
+
+# IR op name -> Julia function name.
+_FUNCS: dict[str, str] = {
+    "max": "max",
+    "min": "min",
+    "sqrt": "sqrt",
+    "exp": "exp",
+    "log": "log",
+    "abs": "abs",
+    "ifelse": "ifelse",
+}
+
+
+class JuliaCodegenError(ValueError):
+    """Raised when an IR construct cannot be lowered to Julia."""
+
+
+def julia_model_slug(ir: IRModel) -> str:
+    """Return a safe Julia identifier fragment derived from ``ir.model.name``."""
+    name = ir.model.name or "model"
+    cleaned = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in name)
+    if not cleaned or not (cleaned[0].isalpha() or cleaned[0] == "_"):
+        cleaned = f"m_{cleaned}"
+    return cleaned
+
+
+def julia_number_literal(value: float) -> str:
+    """Format a floating IR literal as Julia source text."""
+    if value.is_integer():
+        return f"{value:.1f}"
+    return repr(value)
+
+
+def expr_to_julia(expr: Expr) -> str:
+    """Render an IR expression as a parenthesized Julia expression string."""
+    if isinstance(expr, Num):
+        return julia_number_literal(expr.value)
+    if isinstance(expr, Sym):
+        return expr.name
+    if isinstance(expr, Call):
+        return _render_call(expr)
+    raise JuliaCodegenError(f"unknown expression node: {expr!r}")
+
+
+def _render_call(call: Call) -> str:
+    op = call.op
+    args = call.args
+    if op == "neg":
+        if len(args) != 1:
+            raise JuliaCodegenError("'neg' expects exactly one argument")
+        return f"(-{expr_to_julia(args[0])})"
+    if op in _INFIX:
+        if len(args) != 2:
+            raise JuliaCodegenError(f"operator {op!r} expects two arguments")
+        left, right = (expr_to_julia(a) for a in args)
+        return f"({left} {_INFIX[op]} {right})"
+    if op in _FUNCS:
+        rendered = ", ".join(expr_to_julia(a) for a in args)
+        return f"{_FUNCS[op]}({rendered})"
+    raise JuliaCodegenError(f"unsupported operator/function {op!r}")

{apc_model_parser-0.2.1 → apc_model_parser-0.2.2}/src/model_parser/backends/julia_mtk.py

@@ -17,87 +17,15 @@ The emitted code targets **ModelingToolkit v11** idioms (see ADR 0004):
 
 from __future__ import annotations
 
-from model_parser.ir import Call, Expr, IRModel, Num, Sym
+from model_parser.backends.julia_expr import expr_to_julia, julia_model_slug, julia_number_literal
+from model_parser.ir import IRModel
 
 GENERATOR = "model-parser julia-mtk backend"
 
-# IR op name -> Julia infix operator.
-_INFIX: dict[str, str] = {
-    "+": "+",
-    "-": "-",
-    "*": "*",
-    "/": "/",
-    "^": "^",
-    "==": "==",
-    "!=": "!=",
-    "<": "<",
-    ">": ">",
-    "<=": "<=",
-    ">=": ">=",
-}
-
-# IR op name -> Julia function name.
-_FUNCS: dict[str, str] = {
-    "max": "max",
-    "min": "min",
-    "sqrt": "sqrt",
-    "exp": "exp",
-    "log": "log",
-    "abs": "abs",
-    "ifelse": "ifelse",
-}
-
-
-class JuliaCodegenError(ValueError):
-    """Raised when an IR construct cannot be lowered to Julia."""
-
-
-def expr_to_julia(expr: Expr) -> str:
-    """Render an IR expression as a parenthesized Julia expression string."""
-    if isinstance(expr, Num):
-        return _render_number(expr.value)
-    if isinstance(expr, Sym):
-        return expr.name
-    if isinstance(expr, Call):
-        return _render_call(expr)
-    raise JuliaCodegenError(f"unknown expression node: {expr!r}")
-
-
-def _render_number(value: float) -> str:
-    if value.is_integer():
-        return f"{value:.1f}"
-    return repr(value)
-
-
-def _render_call(call: Call) -> str:
-    op = call.op
-    args = call.args
-    if op == "neg":
-        if len(args) != 1:
-            raise JuliaCodegenError("'neg' expects exactly one argument")
-        return f"(-{expr_to_julia(args[0])})"
-    if op in _INFIX:
-        if len(args) != 2:
-            raise JuliaCodegenError(f"operator {op!r} expects two arguments")
-        left, right = (expr_to_julia(a) for a in args)
-        return f"({left} {_INFIX[op]} {right})"
-    if op in _FUNCS:
-        rendered = ", ".join(expr_to_julia(a) for a in args)
-        return f"{_FUNCS[op]}({rendered})"
-    raise JuliaCodegenError(f"unsupported operator/function {op!r}")
-
-
-def _julia_name(ir: IRModel) -> str:
-    name = ir.model.name or "model"
-    cleaned = "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in name)
-    if not cleaned or not (cleaned[0].isalpha() or cleaned[0] == "_"):
-        cleaned = f"m_{cleaned}"
-    return cleaned
-
 
 def emit_julia(ir: IRModel) -> str:
     """Generate a ModelingToolkit v11 Julia script that builds ``ir`` as a System."""
-    name = _julia_name(ir)
+    name = julia_model_slug(ir)
     iv = ir.independent_variable
     lines: list[str] = []
 
@@ -122,7 +50,7 @@ def emit_julia(ir: IRModel) -> str:
             if param.default is None:
                 decls.append(param.name)
             else:
-                decls.append(f"{param.name} = {_render_number(param.default)}")
+                decls.append(f"{param.name} = {julia_number_literal(param.default)}")
         lines.append(f"    @parameters {' '.join(decls)}")
 
     # Time-dependent variables: states, inputs, outputs, locals.