Diff Grok: LaTeX: Loop upd

Update export to md and latex of models with loops

Author: vmakarichev

.claude/settings.local.json

@@ -16,7 +16,8 @@
       "Bash(xargs wc:*)",
       "Bash(ls -la /c/Users/vmaka/Datagrok/diff-grok/src/latex-export/examples/*.ts)",
       "WebFetch(domain:datagrok.ai)",
-      "Bash(npx tsx:*)"
+      "Bash(npx tsx:*)",
+      "Bash(node -e \":*)"
     ]
   }
 }

src/latex-export/generator/document-builder.ts

@@ -50,6 +50,13 @@ export function buildLatexDocument(
     parts.push(buildLatexAlign(model.expressions));
   }
 
+  const loopInfo = extractLoopInfo(model);
+  if (loopInfo && loopInfo.updates.length > 0) {
+    parts.push('\\subsection{Cyclic Update}');
+    const lines = loopInfo.updates.map((u) => `  ${renderLoopUpdateLine(u)}`);
+    parts.push(`Before each cycle:\n\\begin{align}\n${lines.join(' \\\\\n')}\n\\end{align}`);
+  }
+
   if (opts.includeInits && model.inits.length > 0) {
     parts.push(`\\subsection{${initsTitle(model)}}`);
     parts.push(buildLatexTable(model.inits));
@@ -104,6 +111,13 @@ export function buildMarkdownDocument(
     parts.push(buildMarkdownAlign(model.expressions));
   }
 
+  const loopInfo = extractLoopInfo(model);
+  if (loopInfo && loopInfo.updates.length > 0) {
+    parts.push('### Cyclic Update');
+    const lines = loopInfo.updates.map((u) => `  ${renderLoopUpdateLine(u)}`);
+    parts.push(`Before each cycle:\n\n$$\n\\begin{aligned}\n${lines.join(' \\\\\n')}\n\\end{aligned}\n$$`);
+  }
+
   if (opts.includeInits && model.inits.length > 0) {
     parts.push(`### ${initsTitle(model)}`);
     parts.push(buildMarkdownTable(model.inits));
@@ -133,7 +147,26 @@ function buildArgRangeLatex(model: ParsedModel): string {
   const start = model.argument.entries[0].value;
   const finish = model.argument.entries[1].value;
   const step = model.argument.entries[2].value;
-  return `${arg} \\in \\left[${start},\\, ${finish}\\right], \\quad \\Delta ${arg} = ${step}`;
+
+  const loopInfo = extractLoopInfo(model);
+  let effectiveFinish = finish;
+  if (loopInfo) {
+    const s = parseFloat(start);
+    const f = parseFloat(finish);
+    const n = parseFloat(loopInfo.count);
+    if (!isNaN(s) && !isNaN(f) && !isNaN(n))
+      effectiveFinish = String(s + n * (f - s));
+    else
+      effectiveFinish = `${start} + ${loopInfo.count} \\cdot (${finish} - ${start})`;
+  }
+
+  let result = `${arg} \\in \\left[${start},\\, ${effectiveFinish}\\right], \\quad \\Delta ${arg} = ${step}`;
+  if (loopInfo) {
+    const duration = (!isNaN(parseFloat(start)) && !isNaN(parseFloat(finish))) ?
+      String(parseFloat(finish) - parseFloat(start)) : `${finish} - ${start}`;
+    result += `, \\quad ${arg}_{\\text{cycle}} = ${duration}`;
+  }
+  return result;
 }
 
 function buildLatexArgRange(model: ParsedModel): string {
@@ -208,6 +241,32 @@ function compactExprItems(model: ParsedModel): string[] {
   });
 }
 
+interface LoopUpdate { variable: string; value: string }
+
+interface LoopInfo { count: string; updates: LoopUpdate[] }
+
+function extractLoopInfo(model: ParsedModel): LoopInfo | undefined {
+  if (model.loops.length === 0) return undefined;
+  const loop = model.loops[0];
+  let count = '';
+  const updates: LoopUpdate[] = [];
+  for (const entry of loop.entries) {
+    if (entry.name === 'count')
+      count = entry.value;
+    else {
+      const variable = entry.name.replace(/\s*\+$/, '');
+      updates.push({variable, value: entry.value});
+    }
+  }
+  return count ? {count, updates} : undefined;
+}
+
+function renderLoopUpdateLine(u: LoopUpdate): string {
+  const varLatex = identifierToLatex(u.variable);
+  const valLatex = expressionToLatex(u.value);
+  return `${varLatex} \\leftarrow ${varLatex} + ${valLatex}`;
+}
+
 function buildLatexCompact(model: ParsedModel, opts: ConvertOptions): string {
   const parts: string[] = [];
 
@@ -231,11 +290,17 @@ function buildLatexCompact(model: ParsedModel, opts: ConvertOptions): string {
     parts.push(`where\n${lines.join('\n')}`);
   }
 
+  const loopInfo = extractLoopInfo(model);
+  if (loopInfo && loopInfo.updates.length > 0) {
+    const lines = loopInfo.updates.map((u) => `\\[ ${renderLoopUpdateLine(u)} \\]`);
+    parts.push(`before each cycle:\n${lines.join('\n')}`);
+  }
+
   if (opts.includeParameters && model.parameters.length > 0)
-    parts.push(`${plural('Parameter', model.parameters.length)}:\n\n${buildLatexTable(model.parameters)}`);
+    parts.push(`${plural('Parameter', model.parameters.length)}:\n${buildLatexList(model.parameters)}`);
 
   if (opts.includeConstants && model.constants.length > 0)
-    parts.push(`${plural('Constant', model.constants.length)}:\n\n${buildLatexTable(model.constants)}`);
+    parts.push(`${plural('Constant', model.constants.length)}:\n${buildLatexList(model.constants)}`);
 
   return parts.join('\n\n');
 }
@@ -263,15 +328,40 @@ function buildMarkdownCompact(model: ParsedModel, opts: ConvertOptions): string
     parts.push(`where\n${lines.join('\n')}`);
   }
 
+  const loopInfo = extractLoopInfo(model);
+  if (loopInfo && loopInfo.updates.length > 0) {
+    const lines = loopInfo.updates.map((u) => `$$${renderLoopUpdateLine(u)}$$`);
+    parts.push(`before each cycle:\n${lines.join('\n')}`);
+  }
+
   if (opts.includeParameters && model.parameters.length > 0)
-    parts.push(`${plural('Parameter', model.parameters.length)}:\n\n${buildMarkdownTable(model.parameters)}`);
+    parts.push(`${plural('Parameter', model.parameters.length)}:\n${buildMarkdownList(model.parameters)}`);
 
   if (opts.includeConstants && model.constants.length > 0)
-    parts.push(`${plural('Constant', model.constants.length)}:\n\n${buildMarkdownTable(model.constants)}`);
+    parts.push(`${plural('Constant', model.constants.length)}:\n${buildMarkdownList(model.constants)}`);
 
   return parts.join('\n\n');
 }
 
+function buildLatexList(entries: AnnotatedLine[]): string {
+  const items = entries.map((e) => {
+    const name = `$${identifierToLatex(e.name)}$`;
+    const value = `$${e.value}$`;
+    const units = e.units ? ` (${e.units})` : '';
+    return `  \\item ${name} = ${value}${units}`;
+  }).join('\n');
+  return `\\begin{itemize}\n${items}\n\\end{itemize}`;
+}
+
+function buildMarkdownList(entries: AnnotatedLine[]): string {
+  return entries.map((e) => {
+    const name = `$${identifierToLatex(e.name)}$`;
+    const value = `$${e.value}$`;
+    const units = e.units ? ` (${e.units})` : '';
+    return `- ${name} = ${value}${units}`;
+  }).join('\n');
+}
+
 function buildLatexTable(entries: AnnotatedLine[]): string {
   const hasUnits = entries.some((e) => e.units);
   const cols = hasUnits ? 'lll' : 'll';

src/latex-export/generator/latex-generator.ts

@@ -60,8 +60,12 @@ export function nodeToLatex(
 function renderBinary(node: ASTNode & { type: 'binary' }): string {
   const {op, left, right} = node;
 
-  // Division → \frac (no extra brackets needed)
+  // Division → \frac; flatten into product of fractions when chain has multiple divisions
   if (op === '/') {
+    const factors = flattenMulDivChain(node);
+    const divisorCount = factors.filter((f) => f.isDivisor).length;
+    if (divisorCount > 1)
+      return renderProductOfFractions(factors);
     const l = nodeToLatex(left);
     const r = nodeToLatex(right);
     return operatorToLatex('/', l, r);
@@ -98,6 +102,65 @@ function getNodeOp(node: ASTNode): string | undefined {
   return undefined;
 }
 
+/** Flatten a left-associative * / chain into factors with divisor flags. */
+function flattenMulDivChain(node: ASTNode & {type: 'binary'}):
+  Array<{node: ASTNode; isDivisor: boolean}> {
+  const factors: Array<{node: ASTNode; isDivisor: boolean}> = [];
+  function collect(n: ASTNode): void {
+    if (n.type === 'binary' && (n.op === '*' || n.op === '/')) {
+      collect(n.left);
+      factors.push({node: n.right, isDivisor: n.op === '/'});
+    } else
+      factors.push({node: n, isDivisor: false});
+  }
+  collect(node);
+  return factors;
+}
+
+/** Render a list of factors joined with \cdot, adding parens where needed. */
+function renderProductTerm(nodes: ASTNode[]): string {
+  if (nodes.length === 0) return '1';
+  if (nodes.length === 1) return nodeToLatex(nodes[0]);
+  return nodes.map((n) => {
+    const latex = nodeToLatex(n);
+    if (n.type === 'binary' && (n.op === '+' || n.op === '-'))
+      return `\\left(${latex}\\right)`;
+    if (n.type === 'ternary')
+      return `\\left(${latex}\\right)`;
+    return latex;
+  }).join(' \\cdot ');
+}
+
+/** Render factors as a product of fractions. */
+function renderProductOfFractions(
+  factors: Array<{node: ASTNode; isDivisor: boolean}>,
+): string {
+  const groups: Array<{nums: ASTNode[]; dens: ASTNode[]}> = [];
+  let cur: {nums: ASTNode[]; dens: ASTNode[]} = {nums: [], dens: []};
+
+  for (const f of factors) {
+    if (f.isDivisor) {
+      cur.dens.push(f.node);
+    } else {
+      if (cur.dens.length > 0) {
+        groups.push(cur);
+        cur = {nums: [], dens: []};
+      }
+      cur.nums.push(f.node);
+    }
+  }
+  groups.push(cur);
+
+  const parts = groups.map((g) => {
+    const num = renderProductTerm(g.nums);
+    if (g.dens.length === 0) return num;
+    const den = renderProductTerm(g.dens);
+    return `\\frac{${num}}{${den}}`;
+  });
+
+  return parts.join(' \\cdot ');
+}
+
 /** Convert a derivative LHS to LaTeX (e.g. "dy/dt" → "\frac{dy}{dt}").
  *  @param lhs  derivative string, e.g. "d(X)/dt" or "dX/dt"
  *  @returns    LaTeX string