numbl 0.4.2 → 0.4.3

package/dist-lib/lib.js

@@ -19452,9 +19452,9 @@ function airyAllComplex(zr, zi) {
     sfpi += m3k * tfi;
     sgpr += (m3k + 1) * tgr;
     sgpi += (m3k + 1) * tgi;
-    const mag = Math.abs(tfr) + Math.abs(tfi) + Math.abs(tgr) + Math.abs(tgi);
+    const mag2 = Math.abs(tfr) + Math.abs(tfi) + Math.abs(tgr) + Math.abs(tgi);
     const ref = Math.abs(sfr) + Math.abs(sfi) + Math.abs(sgr) + Math.abs(sgi) + 1e-300;
-    if (mag < 1e-16 * ref) break;
+    if (mag2 < 1e-16 * ref) break;
   }
   const gr = zr * sgr - zi * sgi;
   const gi = zr * sgi + zi * sgr;
@@ -22329,8 +22329,8 @@ function sinpi(x) {
   return Math.sin(Math.PI * x);
 }
 function negRealPow(negBase, exponent) {
-  const mag = Math.pow(-negBase, exponent);
-  return { re: mag * cospi(exponent), im: mag * sinpi(exponent) };
+  const mag2 = Math.pow(-negBase, exponent);
+  return { re: mag2 * cospi(exponent), im: mag2 * sinpi(exponent) };
 }
 function mPow(a, b) {
   if (isComplexOrMixed(a, b)) {
@@ -29285,9 +29285,9 @@ function complexSqrt(re, im) {
     if (re >= 0) return { re: Math.sqrt(re), im: 0 };
     return { re: 0, im: Math.sqrt(-re) };
   }
-  const mag = Math.hypot(re, im);
-  if (mag === 0) return { re: 0, im: 0 };
-  const r = Math.sqrt(mag);
+  const mag2 = Math.hypot(re, im);
+  if (mag2 === 0) return { re: 0, im: 0 };
+  const r = Math.sqrt(mag2);
   const angle2 = Math.atan2(im, re) / 2;
   return { re: r * Math.cos(angle2), im: r * Math.sin(angle2) };
 }
@@ -29335,9 +29335,9 @@ defineBuiltin({
   )
 });
 registerUnary("sign", Math.sign, (re, im) => {
-  const mag = Math.hypot(re, im);
-  if (mag === 0) return { re: 0, im: 0 };
-  return { re: re / mag, im: im / mag };
+  const mag2 = Math.hypot(re, im);
+  if (mag2 === 0) return { re: 0, im: 0 };
+  return { re: re / mag2, im: im / mag2 };
 });
 function registerRounding(name, fn) {
   defineBuiltin({
@@ -34070,10 +34070,10 @@ function sortTensor(v, dim, descend, nargout) {
   const dimSize = shape[dimIdx];
   let cmpFlatIdx;
   if (im && !im.every((x) => x === 0)) {
-    const mag = (i) => Math.sqrt(re[i] * re[i] + im[i] * im[i]);
+    const mag2 = (i) => Math.sqrt(re[i] * re[i] + im[i] * im[i]);
     const phase = (i) => Math.atan2(im[i], re[i]);
     cmpFlatIdx = (a, b) => {
-      const diff2 = mag(a) - mag(b);
+      const diff2 = mag2(a) - mag2(b);
       if (diff2 !== 0) return descend ? -diff2 : diff2;
       const pDiff = phase(a) - phase(b);
       return descend ? -pDiff : pDiff;
@@ -35501,9 +35501,9 @@ function invComplexJS(dataRe, dataIm, n) {
     let maxRow = col;
     let maxMag = augRe[col * 2 * n + col] ** 2 + augIm[col * 2 * n + col] ** 2;
     for (let row = col + 1; row < n; row++) {
-      const mag = augRe[row * 2 * n + col] ** 2 + augIm[row * 2 * n + col] ** 2;
-      if (mag > maxMag) {
-        maxMag = mag;
+      const mag2 = augRe[row * 2 * n + col] ** 2 + augIm[row * 2 * n + col] ** 2;
+      if (mag2 > maxMag) {
+        maxMag = mag2;
         maxRow = row;
       }
     }
@@ -35548,6 +35548,88 @@ function invComplexJS(dataRe, dataIm, n) {
     }
   return { re: resultRe, im: resultIm };
 }
+defineBuiltin({
+  name: "expm",
+  cases: [
+    {
+      match: (argTypes, nargout) => {
+        if (argTypes.length !== 1 || nargout > 1) return null;
+        if (!isNumericJitType(argTypes[0])) return null;
+        const a = argTypes[0];
+        if (a.kind === "number" || a.kind === "boolean") return [NUM];
+        if (a.kind === "complex_or_number") return [COMPLEX_OR_NUM];
+        if (a.kind === "tensor")
+          return [{ kind: "tensor", isComplex: a.isComplex }];
+        return null;
+      },
+      apply: (args) => expmApply(args)
+    }
+  ]
+});
+function expmApply(args) {
+  if (args.length !== 1) throw new RuntimeError("expm requires 1 argument");
+  const A = args[0];
+  if (isRuntimeNumber(A)) return RTV.num(Math.exp(A));
+  if (isRuntimeComplexNumber(A)) {
+    const ex = Math.exp(A.re);
+    return RTV.complex(ex * Math.cos(A.im), ex * Math.sin(A.im));
+  }
+  if (!isRuntimeTensor(A))
+    throw new RuntimeError("expm: argument must be a numeric matrix");
+  const [m, n] = tensorSize2D(A);
+  if (m !== n) throw new RuntimeError("expm: input must be a square matrix");
+  if (n === 0) return A;
+  if (n === 1) {
+    const ex = Math.exp(A.data[0]);
+    if (A.imag)
+      return RTV.tensor(
+        Float64Array.of(ex * Math.cos(A.imag[0])),
+        [1, 1],
+        Float64Array.of(ex * Math.sin(A.imag[0]))
+      );
+    return RTV.tensor(Float64Array.of(ex), [1, 1]);
+  }
+  let s = 0;
+  for (let scaled = matrixOneNorm(A, n); scaled > 0.5; scaled /= 2) s++;
+  const As = mMul(A, RTV.num(Math.pow(2, -s)));
+  const q = 6;
+  const I = identityTensor(n);
+  let c = 0.5;
+  let E = mAdd(I, mMul(As, RTV.num(c)));
+  let D = mSub(I, mMul(As, RTV.num(c)));
+  let X = As;
+  let plus2 = true;
+  for (let k = 2; k <= q; k++) {
+    c = c * (q - k + 1) / (k * (2 * q - k + 1));
+    X = mMul(As, X);
+    const cX = mMul(X, RTV.num(c));
+    E = mAdd(E, cX);
+    D = plus2 ? mAdd(D, cX) : mSub(D, cX);
+    plus2 = !plus2;
+  }
+  let R = mLeftDiv(D, E);
+  for (let i = 0; i < s; i++) R = mMul(R, R);
+  return R;
+}
+function matrixOneNorm(A, n) {
+  const re = A.data;
+  const im = A.imag;
+  let maxSum = 0;
+  for (let j = 0; j < n; j++) {
+    let colSum = 0;
+    for (let i = 0; i < n; i++) {
+      const idx = i + j * n;
+      colSum += im ? Math.hypot(re[idx], im[idx]) : Math.abs(re[idx]);
+    }
+    if (colSum > maxSum) maxSum = colSum;
+  }
+  return maxSum;
+}
+function identityTensor(n) {
+  const data = allocFloat64Array(n * n);
+  for (let i = 0; i < n; i++) data[i + i * n] = 1;
+  return RTV.tensor(data, [n, n]);
+}
 registerIBuiltin({
   name: "svd",
   resolve: (argTypes, nargout) => {
@@ -37074,8 +37156,8 @@ function isFiberConjugateSymmetric(re, im) {
   if (N <= 1) return Math.abs(im[0]) < 1e-14;
   let maxMag = 0;
   for (let i = 0; i < N; i++) {
-    const mag = Math.abs(re[i]) + Math.abs(im[i]);
-    if (mag > maxMag) maxMag = mag;
+    const mag2 = Math.abs(re[i]) + Math.abs(im[i]);
+    if (mag2 > maxMag) maxMag = mag2;
   }
   const tol = Math.max(1e-14, maxMag * 1e-12);
   if (Math.abs(im[0]) > tol) return false;
@@ -45645,6 +45727,10 @@ var H = {
     signatures: ["B = inv(A)"],
     description: "Matrix inverse."
   },
+  expm: {
+    signatures: ["Y = expm(X)"],
+    description: "Matrix exponential of square matrix X (scaling-and-squaring Pad\xE9). Use exp for the element-wise exponential."
+  },
   trace: {
     signatures: ["T = trace(A)"],
     description: "Sum of diagonal elements."
@@ -45653,6 +45739,17 @@ var H = {
     signatures: ["E = eig(A)", "[V, D] = eig(A)", "[V, D, W] = eig(A)"],
     description: "Eigenvalues and eigenvectors of square matrix. With three outputs, W contains left eigenvectors."
   },
+  eigs: {
+    signatures: [
+      "d = eigs(A)",
+      "d = eigs(A, k)",
+      "d = eigs(A, k, sigma)",
+      "d = eigs(A, B, ...)",
+      "d = eigs(Afun, n, ...)",
+      "[V, D, flag] = eigs(...)"
+    ],
+    description: "Subset of k eigenvalues/eigenvectors (default 6). sigma selects which: 'largestabs' (default), 'smallestabs', 'largestreal', 'smallestreal', 'bothendsreal', 'largestimag', 'smallestimag', 'bothendsimag', or a scalar (eigenvalues closest to it). Supports the generalized problem A*V = B*V*D and a function handle Afun. Computed densely via eig, so convergence options are accepted but ignored and flag is always 0."
+  },
   svd: {
     signatures: [
       "S = svd(A)",
@@ -46454,6 +46551,17 @@ var H = {
     signatures: ["colorbar", "colorbar(MODE)"],
     description: "Display colorbar on current axes."
   },
+  axis: {
+    signatures: [
+      "axis([xmin xmax ymin ymax])",
+      "axis STYLE",
+      "axis MODE",
+      "axis ij | xy",
+      "axis on | off",
+      "LIM = axis"
+    ],
+    description: "Set or query axis limits, scaling, direction, and visibility. LIMITS is a 4-, 6-, or 8-element vector (inf bounds stay automatic). STYLE is tight | padded | fill | equal | image | square | vis3d | normal | tickaligned. MODE is manual | auto | 'auto x' | 'auto y' | 'auto z' (and xy combinations). 'ij' reverses the y-axis; 'off' hides the axes lines and background. LIM = axis returns the current limits."
+  },
   xlim: {
     signatures: ["xlim(LIMITS)"],
     description: "Set x-axis limits."
@@ -49627,6 +49735,134 @@ function stream2Call(args) {
   return RTV.cell(cellData, [1, cellData.length]);
 }
 
+// src/numbl-core/runtime/axisCommand.ts
+var STYLE_WORDS = /* @__PURE__ */ new Set([
+  "tight",
+  "padded",
+  "fill",
+  "equal",
+  "image",
+  "square",
+  "vis3d",
+  "normal",
+  "tickaligned"
+]);
+var STYLE_RESETS_LIMITS = /* @__PURE__ */ new Set([
+  "tight",
+  "padded",
+  "equal",
+  "image",
+  "tickaligned"
+]);
+var AUTO_AXIS_TOKENS = {
+  auto: ["x", "y", "z"],
+  "auto x": ["x"],
+  "auto y": ["y"],
+  "auto z": ["z"],
+  "auto xy": ["x", "y"],
+  "auto yx": ["x", "y"],
+  "auto xz": ["x", "z"],
+  "auto zx": ["x", "z"],
+  "auto yz": ["y", "z"],
+  "auto zy": ["y", "z"]
+};
+function isHandle(v) {
+  return isRuntimeDummyHandle(v) || isRuntimeGraphicsHandle(v);
+}
+function numericValues(v) {
+  if (isRuntimeTensor(v)) return Array.from(v.data);
+  if (isRuntimeNumber(v)) return [v];
+  if (isRuntimeLogical(v)) return [v ? 1 : 0];
+  return null;
+}
+function bound(v) {
+  return Number.isFinite(v) ? v : null;
+}
+function clearLimits(axes) {
+  const instr = {
+    type: "set_axis_limits"
+  };
+  if (axes.includes("x")) instr.xlim = "auto";
+  if (axes.includes("y")) instr.ylim = "auto";
+  if (axes.includes("z")) instr.zlim = "auto";
+  return instr;
+}
+function applyAxisCommand(args, instructions, freezeLimits) {
+  let i = 0;
+  while (i < args.length && isHandle(args[i])) i++;
+  let applied = false;
+  const styles = [];
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    const nums = numericValues(arg);
+    if (nums !== null) {
+      applied = true;
+      if (nums.length === 1) {
+        instructions.push({ type: "set_axis_visible", value: nums[0] !== 0 });
+        continue;
+      }
+      if (nums.length === 4 || nums.length === 6 || nums.length === 8) {
+        const instr = {
+          type: "set_axis_limits",
+          xlim: [bound(nums[0]), bound(nums[1])],
+          ylim: [bound(nums[2]), bound(nums[3])]
+        };
+        if (nums.length >= 6) instr.zlim = [bound(nums[4]), bound(nums[5])];
+        instructions.push(instr);
+        if (nums.length === 8 && Number.isFinite(nums[6]) && Number.isFinite(nums[7])) {
+          instructions.push({ type: "set_caxis", limits: [nums[6], nums[7]] });
+        }
+        continue;
+      }
+      throw new RuntimeError(
+        "axis: limit vector must have 4, 6, or 8 elements"
+      );
+    }
+    const kw = toString(arg).trim().replace(/^["']|["']$/g, "").toLowerCase();
+    applied = true;
+    if (STYLE_WORDS.has(kw)) {
+      styles.push(kw);
+      if (STYLE_RESETS_LIMITS.has(kw)) {
+        instructions.push(clearLimits(["x", "y", "z"]));
+      }
+      continue;
+    }
+    if (kw === "manual") {
+      const lim = freezeLimits?.();
+      if (lim && lim.length >= 4) {
+        const instr = {
+          type: "set_axis_limits",
+          xlim: [lim[0], lim[1]],
+          ylim: [lim[2], lim[3]]
+        };
+        if (lim.length >= 6) instr.zlim = [lim[4], lim[5]];
+        instructions.push(instr);
+      }
+      continue;
+    }
+    if (kw in AUTO_AXIS_TOKENS) {
+      instructions.push(clearLimits(AUTO_AXIS_TOKENS[kw]));
+      continue;
+    }
+    if (kw === "xy" || kw === "ij") {
+      instructions.push({
+        type: "set_axis_ydir",
+        dir: kw === "ij" ? "reverse" : "normal"
+      });
+      continue;
+    }
+    if (kw === "on" || kw === "off") {
+      instructions.push({ type: "set_axis_visible", value: kw === "on" });
+      continue;
+    }
+    throw new RuntimeError(`axis: unknown option '${kw}'`);
+  }
+  if (styles.length > 0) {
+    instructions.push({ type: "set_axis", value: styles.join(" ") });
+  }
+  return applied;
+}
+
 // src/numbl-core/runtime/plotBuiltinDispatch.ts
 function dispatchPlotBuiltin(name, args, instructions, state) {
   switch (name) {
@@ -49815,10 +50051,7 @@ function dispatchPlotBuiltin(name, args, instructions, state) {
       dispatchColormap(args, instructions);
       return true;
     case "axis": {
-      if (args.length > 0) {
-        const val = toString(args[0]).replace(/^"|"$/g, "");
-        plotInstr(instructions, { type: "set_axis", value: val });
-      }
+      applyAxisCommand(args, instructions);
       return true;
     }
     case "caxis":
@@ -50513,6 +50746,85 @@ function quadgkAdaptive(integrand, a, b, opts = {}) {
   };
 }
 
+// src/numbl-core/helpers/eigs-select.ts
+var SIGMA_ALIASES = {
+  lm: "largestabs",
+  largestabs: "largestabs",
+  sm: "smallestabs",
+  smallestabs: "smallestabs",
+  lr: "largestreal",
+  la: "largestreal",
+  largestreal: "largestreal",
+  sr: "smallestreal",
+  sa: "smallestreal",
+  smallestreal: "smallestreal",
+  be: "bothendsreal",
+  bothendsreal: "bothendsreal",
+  li: "largestimag",
+  largestimag: "largestimag",
+  si: "smallestimag",
+  smallestimag: "smallestimag",
+  bothendsimag: "bothendsimag"
+};
+function normalizeSigmaString(s) {
+  return SIGMA_ALIASES[s.trim().toLowerCase()] ?? null;
+}
+var mag = (re, im) => Math.hypot(re, im);
+function sortedBy(n, key, descending) {
+  const idx = Array.from({ length: n }, (_, i) => i);
+  idx.sort((a, b) => {
+    const ka = key(a);
+    const kb = key(b);
+    if (ka !== kb) return descending ? kb - ka : ka - kb;
+    return a - b;
+  });
+  return idx;
+}
+function bothEnds(n, key, k) {
+  const nHigh = Math.ceil(k / 2);
+  const nLow = Math.floor(k / 2);
+  const desc = sortedBy(n, key, true);
+  const high = desc.slice(0, nHigh);
+  const highSet = new Set(high);
+  const low = [];
+  for (let i = desc.length - 1; i >= 0 && low.length < nLow; i--) {
+    if (!highSet.has(desc[i])) low.push(desc[i]);
+  }
+  return { high, low };
+}
+function selectEigsIndices(re, im, k, sigma) {
+  const n = re.length;
+  const kk = Math.max(0, Math.min(k, n));
+  switch (sigma.kind) {
+    case "largestabs":
+      return sortedBy(n, (i) => mag(re[i], im[i]), true).slice(0, kk);
+    case "smallestabs":
+      return sortedBy(n, (i) => mag(re[i], im[i]), false).slice(0, kk);
+    case "largestreal":
+      return sortedBy(n, (i) => re[i], true).slice(0, kk);
+    case "smallestreal":
+      return sortedBy(n, (i) => re[i], false).slice(0, kk);
+    case "largestimag":
+      return sortedBy(n, (i) => im[i], true).slice(0, kk);
+    case "smallestimag":
+      return sortedBy(n, (i) => im[i], false).slice(0, kk);
+    case "scalar": {
+      const { re: sr, im: si } = sigma;
+      return sortedBy(n, (i) => mag(re[i] - sr, im[i] - si), false).slice(0, kk);
+    }
+    case "bothendsreal": {
+      const { high, low } = bothEnds(n, (i) => re[i], kk);
+      return [...high, ...low].sort((a, b) => re[a] - re[b] || a - b);
+    }
+    case "bothendsimag": {
+      const { high, low } = bothEnds(n, (i) => im[i], kk);
+      return [...high, ...low].sort(
+        (a, b) => Math.abs(im[b]) - Math.abs(im[a]) || a - b
+      );
+    }
+  }
+}
+
 // src/numbl-core/runtime/specialBuiltinNames.ts
 var SPECIAL_BUILTIN_NAMES = [
   "help",
@@ -50631,6 +50943,7 @@ var SPECIAL_BUILTIN_NAMES = [
   "toc",
   "quadgk",
   "gmres",
+  "eigs",
   "onCleanup"
 ];
 
@@ -52008,6 +52321,9 @@ function registerSpecialBuiltins(rt) {
   registerSpecial("gmres", (nargout, args) => {
     return _gmresImpl(rt, nargout, args);
   });
+  registerSpecial("eigs", (nargout, args) => {
+    return _eigsImpl(rt, nargout, args);
+  });
   registerSpecial("onCleanup", (_nargout, args) => {
     if (args.length !== 1 || !isRuntimeFunction(args[0]))
       throw new RuntimeError("onCleanup requires a function handle argument");
@@ -52015,6 +52331,271 @@ function registerSpecialBuiltins(rt) {
     return RTV.classInstance("onCleanup", [], false);
   });
 }
+function eigsReIm(v) {
+  if (isRuntimeNumber(v)) return { re: [v], im: [0] };
+  if (isRuntimeComplexNumber(v)) return { re: [v.re], im: [v.im] };
+  if (isRuntimeTensor(v)) {
+    const re = Array.from(v.data);
+    const im = v.imag ? Array.from(v.imag) : re.map(() => 0);
+    return { re, im };
+  }
+  throw new RuntimeError("eigs: expected a numeric value");
+}
+function eigsAsTensor(v) {
+  const rv = ensureRuntimeValue(v);
+  if (isRuntimeTensor(rv)) return rv;
+  if (isRuntimeNumber(rv))
+    return RTV.tensor(allocFloat64Array([rv]), [1, 1]);
+  if (isRuntimeComplexNumber(rv))
+    return RTV.tensor(
+      allocFloat64Array([rv.re]),
+      [1, 1],
+      allocFloat64Array([rv.im])
+    );
+  throw new RuntimeError("eigs: expected a numeric matrix");
+}
+function eigsMatrixSize(A) {
+  if (isRuntimeNumber(A) || isRuntimeComplexNumber(A)) return 1;
+  if (isRuntimeTensor(A)) {
+    const rows = A.shape[0] ?? 1;
+    const cols = A.shape[1] ?? 1;
+    if (rows !== cols)
+      throw new RuntimeError("eigs: input matrix must be square");
+    return rows;
+  }
+  throw new RuntimeError("eigs: input must be a numeric matrix");
+}
+function eigsIsScalar(v) {
+  return isRuntimeNumber(v) || isRuntimeComplexNumber(v) || isRuntimeTensor(v) && v.data.length === 1;
+}
+function eigsIsMatrixArg(v) {
+  if (!isRuntimeTensor(v)) return false;
+  if (v.data.length === 0) return true;
+  const rows = v.shape[0] ?? 1;
+  const cols = v.shape[1] ?? 1;
+  return rows > 1 || cols > 1;
+}
+function eigsToBool(v) {
+  if (isRuntimeLogical(v)) return v;
+  if (isRuntimeNumber(v)) return v !== 0;
+  if (isRuntimeTensor(v) && v.data.length >= 1) return v.data[0] !== 0;
+  return false;
+}
+function eigsParseSigma(v) {
+  if (isRuntimeString(v) || isRuntimeChar(v)) {
+    const s = typeof v === "string" ? v : v.value;
+    const kind = normalizeSigmaString(s);
+    if (!kind) throw new RuntimeError(`eigs: unknown sigma option '${s}'`);
+    return { kind };
+  }
+  let re;
+  let im = 0;
+  if (isRuntimeComplexNumber(v)) {
+    re = v.re;
+    im = v.im;
+  } else if (isRuntimeNumber(v)) {
+    re = v;
+  } else if (isRuntimeTensor(v) && v.data.length >= 1) {
+    re = v.data[0];
+    im = v.imag ? v.imag[0] : 0;
+  } else {
+    throw new RuntimeError("eigs: invalid sigma argument");
+  }
+  if (re === 0 && im === 0) return { kind: "smallestabs" };
+  return { kind: "scalar", re, im };
+}
+function eigsReconstructOperator(rt, afun, n) {
+  const re = allocFloat64Array(n * n);
+  const im = allocFloat64Array(n * n);
+  let anyImag = false;
+  for (let j = 0; j < n; j++) {
+    const e = allocFloat64Array(n);
+    e[j] = 1;
+    const col = ensureRuntimeValue(
+      rt.index(afun, [RTV.tensor(e, [n, 1])], 1)
+    );
+    const { re: cre, im: cim } = eigsReIm(col);
+    for (let i = 0; i < n; i++) {
+      re[j * n + i] = cre[i] ?? 0;
+      im[j * n + i] = cim[i] ?? 0;
+      if (im[j * n + i] !== 0) anyImag = true;
+    }
+  }
+  return anyImag ? RTV.tensor(re, [n, n], im) : RTV.tensor(re, [n, n]);
+}
+function eigsRecoverAfunMatrix(rt, M, sigma, B, n) {
+  if (sigma.kind === "smallestabs") {
+    return eigsAsTensor(rt.dispatch("inv", 1, [M]));
+  }
+  if (sigma.kind === "scalar") {
+    const base = eigsAsTensor(rt.dispatch("inv", 1, [M]));
+    const shiftRe = allocFloat64Array(n * n);
+    const shiftIm = allocFloat64Array(n * n);
+    if (B && isRuntimeTensor(B)) {
+      for (let i = 0; i < n * n; i++) {
+        shiftRe[i] = (B.data[i] ?? 0) * sigma.re - (B.imag?.[i] ?? 0) * sigma.im;
+        shiftIm[i] = (B.data[i] ?? 0) * sigma.im + (B.imag?.[i] ?? 0) * sigma.re;
+      }
+    } else {
+      for (let d = 0; d < n; d++) {
+        shiftRe[d * n + d] = sigma.re;
+        shiftIm[d * n + d] = sigma.im;
+      }
+    }
+    const shift = maybeComplexTensor(shiftRe, [n, n], shiftIm);
+    return eigsAsTensor(rt.dispatch("plus", 1, [base, shift]));
+  }
+  return M;
+}
+function eigsReconstructCholesky(R, perm, n) {
+  if (!isRuntimeTensor(R))
+    throw new RuntimeError("eigs: Cholesky factor must be a matrix");
+  const r = R.data;
+  const rtr = allocFloat64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      let s = 0;
+      for (let kk = 0; kk < n; kk++) s += r[i * n + kk] * r[j * n + kk];
+      rtr[j * n + i] = s;
+    }
+  }
+  if (!perm) return RTV.tensor(rtr, [n, n]);
+  const b = allocFloat64Array(n * n);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const pi2 = (perm[i] ?? i + 1) - 1;
+      const pj = (perm[j] ?? j + 1) - 1;
+      b[pj * n + pi2] = rtr[j * n + i];
+    }
+  }
+  return RTV.tensor(b, [n, n]);
+}
+function _eigsImpl(rt, nargout, args) {
+  const margs = args.map((a) => ensureRuntimeValue(a));
+  if (margs.length < 1)
+    throw new RuntimeError("eigs requires at least 1 argument");
+  let afun = null;
+  let A = null;
+  let n;
+  let pos;
+  if (isRuntimeFunction(margs[0])) {
+    afun = margs[0];
+    if (margs.length < 2 || !eigsIsScalar(margs[1]))
+      throw new RuntimeError(
+        "eigs: a function handle must be followed by the matrix size n"
+      );
+    n = Math.floor(toNumber(margs[1]));
+    pos = 2;
+  } else {
+    A = margs[0];
+    n = eigsMatrixSize(A);
+    pos = 1;
+  }
+  let B = null;
+  if (pos < margs.length && eigsIsMatrixArg(margs[pos])) {
+    const b = margs[pos];
+    if (!(isRuntimeTensor(b) && b.data.length === 0)) B = b;
+    pos++;
+  }
+  let kReq = null;
+  if (pos < margs.length && eigsIsScalar(margs[pos])) {
+    kReq = Math.max(1, Math.floor(toNumber(margs[pos])));
+    pos++;
+  }
+  let sigma = { kind: "largestabs" };
+  if (pos < margs.length) {
+    const a = margs[pos];
+    if (isRuntimeString(a) || isRuntimeChar(a)) {
+      const s = typeof a === "string" ? a : a.value;
+      if (normalizeSigmaString(s)) {
+        sigma = eigsParseSigma(a);
+        pos++;
+      }
+    } else if (eigsIsScalar(a)) {
+      sigma = eigsParseSigma(a);
+      pos++;
+    }
+  }
+  let isCholesky = false;
+  let cholPerm = null;
+  const applyOption = (key, val) => {
+    const lk = key.toLowerCase();
+    if (lk === "ischolesky" || lk === "cholb") isCholesky = eigsToBool(val);
+    else if (lk === "choleskypermutation" || lk === "permb") {
+      if (isRuntimeTensor(val)) cholPerm = Array.from(val.data);
+    }
+  };
+  while (pos < margs.length) {
+    const a = margs[pos];
+    if (isRuntimeStruct(a)) {
+      for (const [key, val] of a.fields) applyOption(key, val);
+      pos++;
+    } else if (pos + 1 < margs.length) {
+      applyOption(
+        isRuntimeChar(margs[pos]) ? margs[pos].value : String(toString(margs[pos])),
+        margs[pos + 1]
+      );
+      pos += 2;
+    } else {
+      break;
+    }
+  }
+  const k = kReq == null ? Math.min(6, n) : Math.min(kReq, n);
+  let actualA;
+  if (afun) {
+    const M = eigsReconstructOperator(rt, afun, n);
+    actualA = eigsRecoverAfunMatrix(rt, M, sigma, B, n);
+  } else {
+    actualA = A;
+  }
+  let effective = actualA;
+  if (B) {
+    const Bmat = isCholesky ? eigsReconstructCholesky(B, cholPerm, n) : B;
+    effective = eigsAsTensor(rt.dispatch("mldivide", 1, [Bmat, actualA]));
+  }
+  if (nargout <= 1) {
+    const d = ensureRuntimeValue(rt.dispatch("eig", 1, [effective]));
+    const { re: re2, im: im2 } = eigsReIm(d);
+    const order2 = selectEigsIndices(re2, im2, k, sigma);
+    const outRe = allocFloat64Array(order2.length);
+    const outIm = allocFloat64Array(order2.length);
+    for (let c = 0; c < order2.length; c++) {
+      outRe[c] = re2[order2[c]];
+      outIm[c] = im2[order2[c]];
+    }
+    return maybeComplexTensor(outRe, [order2.length, 1], outIm);
+  }
+  const res = rt.dispatch("eig", 2, [effective]);
+  const Vall = eigsAsTensor(res[0]);
+  const Dall = eigsAsTensor(res[1]);
+  const p2 = Dall.shape[0] ?? 1;
+  const vrows = Vall.shape[0] ?? p2;
+  const re = [];
+  const im = [];
+  for (let j = 0; j < p2; j++) {
+    re.push(Dall.data[j * p2 + j]);
+    im.push(Dall.imag ? Dall.imag[j * p2 + j] : 0);
+  }
+  const order = selectEigsIndices(re, im, k, sigma);
+  const kk = order.length;
+  const Vre = allocFloat64Array(vrows * kk);
+  const Vim = allocFloat64Array(vrows * kk);
+  const Dre = allocFloat64Array(kk * kk);
+  const Dim = allocFloat64Array(kk * kk);
+  for (let c = 0; c < kk; c++) {
+    const s = order[c];
+    for (let r = 0; r < vrows; r++) {
+      Vre[c * vrows + r] = Vall.data[s * vrows + r];
+      if (Vall.imag) Vim[c * vrows + r] = Vall.imag[s * vrows + r];
+    }
+    Dre[c * kk + c] = re[s];
+    Dim[c * kk + c] = im[s];
+  }
+  const V = maybeComplexTensor(Vre, [vrows, kk], Vim);
+  const D = maybeComplexTensor(Dre, [kk, kk], Dim);
+  if (nargout === 2) return [V, D];
+  return [V, D, RTV.num(0)];
+}
 function _ode45Impl(rt, nargout, args, tableau = dormandPrince45) {
   const solverName = tableau.name;
   if (args.length < 3)
@@ -54372,6 +54953,484 @@ function memberChainAssign(rt, base, names, rhs) {
   return subsasgnFallback(rt, base, names, rhs);
 }
 
+// src/graphics/figuresReducer.ts
+var defaultAxes = {
+  holdOn: false,
+  traces: [],
+  plot3Traces: [],
+  surfTraces: [],
+  pcolorTraces: [],
+  contourTraces: [],
+  barTraces: [],
+  barhTraces: [],
+  bar3Traces: [],
+  bar3hTraces: [],
+  errorBarTraces: [],
+  boxTraces: [],
+  quiverTraces: [],
+  quiver3Traces: [],
+  areaTraces: [],
+  areaBaseValue: 0
+};
+function getAxes(fig) {
+  return fig.axes[fig.currentAxesIndex] || { ...defaultAxes };
+}
+function setAxes(fig, axes) {
+  return {
+    ...fig,
+    axes: { ...fig.axes, [fig.currentAxesIndex]: axes }
+  };
+}
+var initialFiguresState = {
+  currentHandle: 1,
+  figs: {}
+};
+var defaultFigure = {
+  currentAxesIndex: 1,
+  axes: {}
+};
+function ensureFig(state) {
+  return state.figs[state.currentHandle] || { ...defaultFigure };
+}
+function updateAxes(state, update) {
+  const fig = ensureFig(state);
+  const axes = getAxes(fig);
+  return {
+    ...state,
+    figs: {
+      ...state.figs,
+      [state.currentHandle]: setAxes(fig, { ...axes, ...update })
+    }
+  };
+}
+function addTraces(state, update) {
+  const fig = ensureFig(state);
+  const axes = getAxes(fig);
+  const hold = axes.holdOn;
+  return {
+    ...state,
+    figs: {
+      ...state.figs,
+      [state.currentHandle]: setAxes(fig, {
+        ...axes,
+        traces: update.traces ?? (hold ? axes.traces : []),
+        plot3Traces: update.plot3Traces ?? (hold ? axes.plot3Traces : []),
+        surfTraces: update.surfTraces ?? (hold ? axes.surfTraces : []),
+        pcolorTraces: update.pcolorTraces ?? (hold ? axes.pcolorTraces : []),
+        contourTraces: update.contourTraces ?? (hold ? axes.contourTraces : []),
+        barTraces: update.barTraces ?? (hold ? axes.barTraces : []),
+        barhTraces: update.barhTraces ?? (hold ? axes.barhTraces : []),
+        bar3Traces: update.bar3Traces ?? (hold ? axes.bar3Traces : []),
+        bar3hTraces: update.bar3hTraces ?? (hold ? axes.bar3hTraces : []),
+        errorBarTraces: update.errorBarTraces ?? (hold ? axes.errorBarTraces : []),
+        boxTraces: update.boxTraces ?? (hold ? axes.boxTraces : []),
+        pieTrace: update.pieTrace ?? (hold ? axes.pieTrace : void 0),
+        heatmapTrace: update.heatmapTrace ?? (hold ? axes.heatmapTrace : void 0),
+        quiverTraces: update.quiverTraces ?? (hold ? axes.quiverTraces : []),
+        quiver3Traces: update.quiver3Traces ?? (hold ? axes.quiver3Traces : []),
+        areaTraces: update.areaTraces ?? (hold ? axes.areaTraces : []),
+        areaBaseValue: update.areaBaseValue ?? axes.areaBaseValue,
+        ...update.imagescTrace !== void 0 ? { imagescTrace: update.imagescTrace } : {}
+      })
+    }
+  };
+}
+var figuresReducer = (state, action) => {
+  switch (action.type) {
+    case "set_figure_handle":
+      return { ...state, currentHandle: action.handle };
+    case "set_hold":
+      return updateAxes(state, { holdOn: action.value });
+    case "plot": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        traces: axes.holdOn ? [...axes.traces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "plot3": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        plot3Traces: axes.holdOn ? [...axes.plot3Traces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "surf": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        surfTraces: axes.holdOn ? [...axes.surfTraces, action.trace] : [action.trace]
+      });
+    }
+    case "surface": {
+      const axes = getAxes(ensureFig(state));
+      return updateAxes(state, {
+        surfTraces: [...axes.surfTraces, action.trace]
+      });
+    }
+    case "imagesc":
+      return addTraces(state, { imagescTrace: action.trace });
+    case "pcolor": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        pcolorTraces: axes.holdOn ? [...axes.pcolorTraces, action.trace] : [action.trace]
+      });
+    }
+    case "contour": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        contourTraces: axes.holdOn ? [...axes.contourTraces, action.trace] : [action.trace]
+      });
+    }
+    case "mesh": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        surfTraces: axes.holdOn ? [...axes.surfTraces, action.trace] : [action.trace]
+      });
+    }
+    case "bar": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        barTraces: axes.holdOn ? [...axes.barTraces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "barh": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        barhTraces: axes.holdOn ? [...axes.barhTraces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "bar3": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        bar3Traces: axes.holdOn ? [...axes.bar3Traces, action.trace] : [action.trace]
+      });
+    }
+    case "bar3h": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        bar3hTraces: axes.holdOn ? [...axes.bar3hTraces, action.trace] : [action.trace]
+      });
+    }
+    case "errorbar": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        errorBarTraces: axes.holdOn ? [...axes.errorBarTraces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "boxchart": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        boxTraces: axes.holdOn ? [...axes.boxTraces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "piechart":
+      return addTraces(state, { pieTrace: action.trace });
+    case "heatmap":
+      return addTraces(state, { heatmapTrace: action.trace });
+    case "quiver": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        quiverTraces: axes.holdOn ? [...axes.quiverTraces, ...action.traces] : [...action.traces]
+      });
+    }
+    case "quiver3": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        quiver3Traces: axes.holdOn ? [...axes.quiver3Traces, action.trace] : [action.trace]
+      });
+    }
+    case "area": {
+      const axes = getAxes(ensureFig(state));
+      return addTraces(state, {
+        areaTraces: axes.holdOn ? [...axes.areaTraces, ...action.traces] : [...action.traces],
+        areaBaseValue: action.baseValue
+      });
+    }
+    case "close": {
+      const remainingFigs = Object.fromEntries(
+        Object.entries(state.figs).filter(
+          ([k]) => Number(k) !== state.currentHandle
+        )
+      );
+      const handles = Object.keys(remainingFigs).map(Number).sort((a, b) => a - b);
+      return {
+        ...state,
+        currentHandle: handles.length > 0 ? handles[handles.length - 1] : 1,
+        figs: remainingFigs
+      };
+    }
+    case "close_all":
+    case "clear":
+      return initialFiguresState;
+    case "set_title":
+      return updateAxes(state, { title: action.text });
+    case "set_xlabel":
+      return updateAxes(state, { xlabel: action.text });
+    case "set_ylabel":
+      return updateAxes(state, { ylabel: action.text });
+    case "set_zlabel":
+      return updateAxes(state, { zlabel: action.text });
+    case "set_shading":
+      return updateAxes(state, { shading: action.shading });
+    case "set_legend":
+      return updateAxes(state, { legend: action.labels });
+    case "set_sgtitle": {
+      const fig = ensureFig(state);
+      return {
+        ...state,
+        figs: {
+          ...state.figs,
+          [state.currentHandle]: { ...fig, sgtitle: action.text }
+        }
+      };
+    }
+    case "set_grid":
+      return updateAxes(state, { gridOn: action.value });
+    case "set_colorbar":
+      return updateAxes(state, {
+        colorbar: action.value !== "off",
+        colorbarLocation: action.location ?? "eastoutside"
+      });
+    case "set_colormap":
+      return updateAxes(state, {
+        colormap: action.name,
+        colormapData: action.data
+      });
+    case "set_view":
+      return updateAxes(state, { view: { az: action.az, el: action.el } });
+    case "set_axis":
+      return updateAxes(state, { axisMode: action.value });
+    case "set_axis_limits": {
+      const axes = getAxes(ensureFig(state));
+      const resolve = (prev, spec) => {
+        if (spec === void 0) return prev;
+        if (spec === "auto") return void 0;
+        return spec;
+      };
+      return updateAxes(state, {
+        xlim: resolve(axes.xlim, action.xlim),
+        ylim: resolve(axes.ylim, action.ylim),
+        zlim: resolve(axes.zlim, action.zlim)
+      });
+    }
+    case "set_axis_ydir":
+      return updateAxes(state, { yDir: action.dir });
+    case "set_axis_visible":
+      return updateAxes(state, { axisVisible: action.value });
+    case "set_axis_scale":
+      return updateAxes(state, { axisScale: action.value });
+    case "set_caxis":
+      return updateAxes(state, { caxis: action.limits });
+    case "clf": {
+      const fig = state.figs[state.currentHandle];
+      if (!fig) return state;
+      return {
+        ...state,
+        figs: {
+          ...state.figs,
+          [state.currentHandle]: { ...defaultFigure }
+        }
+      };
+    }
+    case "cla": {
+      const fig = ensureFig(state);
+      const prev = getAxes(fig);
+      const cleared = action.reset ? { ...defaultAxes } : {
+        ...defaultAxes,
+        title: prev.title,
+        xlabel: prev.xlabel,
+        ylabel: prev.ylabel,
+        zlabel: prev.zlabel,
+        gridOn: prev.gridOn,
+        colorbar: prev.colorbar,
+        colorbarLocation: prev.colorbarLocation,
+        colormap: prev.colormap,
+        colormapData: prev.colormapData,
+        view: prev.view,
+        axisMode: prev.axisMode,
+        axisScale: prev.axisScale,
+        caxis: prev.caxis,
+        xlim: prev.xlim,
+        ylim: prev.ylim,
+        zlim: prev.zlim,
+        yDir: prev.yDir,
+        axisVisible: prev.axisVisible,
+        shading: prev.shading
+      };
+      return {
+        ...state,
+        figs: {
+          ...state.figs,
+          [state.currentHandle]: setAxes(fig, cleared)
+        }
+      };
+    }
+    case "set_subplot": {
+      const fig = ensureFig(state);
+      const newFig = {
+        ...fig,
+        subplotGrid: { rows: action.rows, cols: action.cols },
+        currentAxesIndex: action.index
+      };
+      if (!newFig.axes[action.index]) {
+        newFig.axes = { ...newFig.axes, [action.index]: { ...defaultAxes } };
+      }
+      return {
+        ...state,
+        figs: { ...state.figs, [state.currentHandle]: newFig }
+      };
+    }
+    default:
+      return state;
+  }
+};
+
+// src/graphics/axisLimits.ts
+var EMPTY = { min: Infinity, max: -Infinity };
+function include(e, v) {
+  if (Number.isFinite(v)) {
+    if (v < e.min) e.min = v;
+    if (v > e.max) e.max = v;
+  }
+}
+function includeAll(e, vs) {
+  if (!vs) return;
+  for (let i = 0; i < vs.length; i++) include(e, vs[i]);
+}
+function axesIs3D(axes) {
+  return (axes.surfTraces?.length ?? 0) > 0 || (axes.plot3Traces?.length ?? 0) > 0 || (axes.bar3Traces?.length ?? 0) > 0 || (axes.bar3hTraces?.length ?? 0) > 0 || (axes.quiver3Traces?.length ?? 0) > 0;
+}
+function dataExtents(axes) {
+  const x = { ...EMPTY };
+  const y = { ...EMPTY };
+  const z = { ...EMPTY };
+  for (const t of axes.traces ?? []) {
+    includeAll(x, t.x);
+    includeAll(y, t.y);
+  }
+  for (const t of axes.plot3Traces ?? []) {
+    includeAll(x, t.x);
+    includeAll(y, t.y);
+    includeAll(z, t.z);
+  }
+  for (const t of [...axes.surfTraces ?? []]) {
+    includeAll(x, t.x);
+    includeAll(y, t.y);
+    includeAll(z, t.z);
+  }
+  if (axes.imagescTrace) {
+    include(x, axes.imagescTrace.x[0]);
+    include(x, axes.imagescTrace.x[1]);
+    include(y, axes.imagescTrace.y[0]);
+    include(y, axes.imagescTrace.y[1]);
+  }
+  for (const t of axes.pcolorTraces ?? []) {
+    includeAll(x, t.x);
+    includeAll(y, t.y);
+  }
+  for (const t of axes.contourTraces ?? []) {
+    includeAll(x, t.x);
+    includeAll(y, t.y);
+  }
+  for (const bt of axes.barTraces ?? []) {
+    const hw = bt.width / 2;
+    for (let i = 0; i < bt.x.length; i++) {
+      include(x, bt.x[i] - hw);
+      include(x, bt.x[i] + hw);
+      include(y, bt.y[i]);
+    }
+    include(y, 0);
+  }
+  for (const bt of axes.barhTraces ?? []) {
+    const hh = bt.width / 2;
+    for (let i = 0; i < bt.x.length; i++) {
+      include(y, bt.x[i] - hh);
+      include(y, bt.x[i] + hh);
+      include(x, bt.y[i]);
+    }
+    include(x, 0);
+  }
+  for (const bt of [...axes.bar3Traces ?? [], ...axes.bar3hTraces ?? []]) {
+    includeAll(x, bt.x);
+    includeAll(y, bt.y);
+    includeAll(z, bt.z);
+    include(z, 0);
+  }
+  for (const et of axes.errorBarTraces ?? []) {
+    for (let i = 0; i < et.x.length; i++) {
+      include(x, et.xNeg ? et.x[i] - et.xNeg[i] : et.x[i]);
+      include(x, et.xPos ? et.x[i] + et.xPos[i] : et.x[i]);
+      include(y, et.y[i] - et.yNeg[i]);
+      include(y, et.y[i] + et.yPos[i]);
+    }
+  }
+  for (const bt of axes.boxTraces ?? []) {
+    const hw = bt.width / 2;
+    include(x, bt.x - hw);
+    include(x, bt.x + hw);
+    include(y, bt.whiskerLow);
+    include(y, bt.whiskerHigh);
+    for (const o of bt.outliers) include(y, o);
+  }
+  if (axes.areaTraces && axes.areaTraces.length > 0) {
+    const base = axes.areaBaseValue ?? 0;
+    include(y, base);
+    const n = axes.areaTraces[0].x.length;
+    for (let i = 0; i < n; i++) {
+      let cum = base;
+      for (const t of axes.areaTraces) {
+        if (i < t.x.length) {
+          include(x, t.x[i]);
+          cum += t.y[i] - base;
+          include(y, cum);
+        }
+      }
+    }
+  }
+  for (const qt of axes.quiverTraces ?? []) {
+    for (let i = 0; i < qt.x.length; i++) {
+      include(x, qt.x[i]);
+      include(x, qt.x[i] + qt.u[i]);
+      include(y, qt.y[i]);
+      include(y, qt.y[i] + qt.v[i]);
+    }
+  }
+  for (const qt of axes.quiver3Traces ?? []) {
+    for (let i = 0; i < qt.x.length; i++) {
+      include(x, qt.x[i]);
+      include(x, qt.x[i] + qt.u[i]);
+      include(y, qt.y[i]);
+      include(y, qt.y[i] + qt.v[i]);
+      include(z, qt.z[i]);
+      include(z, qt.z[i] + qt.w[i]);
+    }
+  }
+  return { x, y, z };
+}
+function padExtent(e, tight) {
+  if (!Number.isFinite(e.min) || !Number.isFinite(e.max)) return [0, 1];
+  let { min: min2, max: max2 } = e;
+  if (max2 === min2) {
+    min2 -= 1;
+    max2 += 1;
+    return [min2, max2];
+  }
+  if (tight) return [min2, max2];
+  const pad = (max2 - min2) * 0.05;
+  return [min2 - pad, max2 + pad];
+}
+function applyExplicit(auto, explicit) {
+  if (!explicit) return auto;
+  return [explicit[0] ?? auto[0], explicit[1] ?? auto[1]];
+}
+function computeAxisLimits(axes) {
+  const tight = axes.axisMode?.includes("tight") || axes.axisMode?.includes("image") ? true : false;
+  const ext = dataExtents(axes);
+  const xl = applyExplicit(padExtent(ext.x, tight), axes.xlim);
+  const yl = applyExplicit(padExtent(ext.y, tight), axes.ylim);
+  if (!axesIs3D(axes)) return [xl[0], xl[1], yl[0], yl[1]];
+  const zl = applyExplicit(padExtent(ext.z, tight), axes.zlim);
+  return [xl[0], xl[1], yl[0], yl[1], zl[0], zl[1]];
+}
+
 // src/numbl-core/runtime/runtime.ts
 var Runtime = class _Runtime {
   constructor(options, initialVariableValues) {
@@ -54593,6 +55652,18 @@ var Runtime = class _Runtime {
       }
       return RTV.dummyHandle();
     };
+    this.builtins["axis"] = (nargout, args) => {
+      const margs = args.map((a) => ensureRuntimeValue(a));
+      const applied = applyAxisCommand(
+        margs,
+        this.plotInstructions,
+        () => this.currentAxisLimits()
+      );
+      if (!applied && nargout >= 1) {
+        return RTV.row(this.currentAxisLimits());
+      }
+      return void 0;
+    };
     this.builtins["fplot"] = (_nargout, args) => {
       fplotCall(this, this.plotInstructions, args.map(ensureRuntimeValue));
     };
@@ -55496,6 +56567,21 @@ var Runtime = class _Runtime {
   ishold() {
     return RTV.logical(this.holdState);
   }
+  /** Current axis limits of the active axes, as MATLAB's `axis` query
+   *  returns them: `[xmin xmax ymin ymax]` (2-D) or with `zmin zmax`
+   *  appended (3-D). Reduces the accumulated plot instructions into a figure
+   *  state and reads the current axes' explicit/data-derived limits. */
+  currentAxisLimits() {
+    let state = initialFiguresState;
+    for (const instr of this.plotInstructions) {
+      state = figuresReducer(state, instr);
+    }
+    const fig = state.figs[state.currentHandle];
+    if (!fig) return [0, 1, 0, 1];
+    const axes = fig.axes[fig.currentAxesIndex];
+    if (!axes) return [0, 1, 0, 1];
+    return computeAxisLimits(axes);
+  }
   // ── Drawnow / Pause ─────────────────────────────────────────────────
   drawnow() {
     return drawnow(this.plotInstructions, this.options);
@@ -59257,11 +60343,11 @@ function instantiateClass(className, args, nargout) {
     } catch {
     }
   }
-  const isHandle2 = this.isHandleClass(classInfo);
+  const isHandle3 = this.isHandleClass(classInfo);
   const instance = RTV.classInstance(
     className,
     propertyNames,
-    isHandle2,
+    isHandle3,
     defaults
   );
   if (classInfo.constructorName) {
@@ -61313,7 +62399,7 @@ function isNumeric2(t) {
 function isVoid(t) {
   return t.kind === "Void";
 }
-function isHandle(t) {
+function isHandle2(t) {
   return t.kind === "Handle";
 }
 function isStruct(t) {
@@ -64780,17 +65866,17 @@ function complex_sort_indices(a, descending) {
     });
     return idx;
   }
-  const mag = new Float64Array(n);
+  const mag2 = new Float64Array(n);
   const ph = new Float64Array(n);
   for (let i = 0; i < n; i++) {
     const re = a.data[i];
     const xi = im !== void 0 ? im[i] : 0;
-    mag[i] = Math.hypot(re, xi);
+    mag2[i] = Math.hypot(re, xi);
     ph[i] = Math.atan2(xi, re);
   }
   idx.sort((p2, q) => {
-    if (mag[p2] < mag[q]) return descending ? 1 : -1;
-    if (mag[p2] > mag[q]) return descending ? -1 : 1;
+    if (mag2[p2] < mag2[q]) return descending ? 1 : -1;
+    if (mag2[p2] > mag2[q]) return descending ? -1 : 1;
     if (ph[p2] < ph[q]) return descending ? 1 : -1;
     if (ph[p2] > ph[q]) return descending ? -1 : 1;
     return p2 - q;
@@ -67611,7 +68697,7 @@ var ge = defineCompare("ge", ">=", (a, b) => a >= b);
 // src/numbl-core/jit/codegen/cHelpers.ts
 function cTypeFor(t) {
   if (isMultiElement(t)) return "mtoc2_tensor_t";
-  if (isHandle(t)) return handleTypedefName(t);
+  if (isHandle2(t)) return handleTypedefName(t);
   if (t.kind === "Struct") return structTypedefName(t);
   if (t.kind === "Class") return classTypedefName(t);
   if (t.kind === "Cell") return cellTypedefName(t);
@@ -73247,7 +74333,7 @@ function staticAnswer(t) {
   }
   if (isString(t)) return true;
   if (isChar(t)) return false;
-  if (isStruct(t) || isClass(t) || isHandle(t)) return false;
+  if (isStruct(t) || isClass(t) || isHandle2(t)) return false;
   return void 0;
 }
 function requireKnown(t) {
@@ -73366,7 +74452,7 @@ var isstruct = {
 function staticClassNameOf(t) {
   if (isClass(t)) return t.className;
   if (isStruct(t)) return "struct";
-  if (isHandle(t)) return "function_handle";
+  if (isHandle2(t)) return "function_handle";
   if (isChar(t)) return "char";
   if (isString(t)) return "string";
   if (isCell(t)) return "cell";
@@ -78446,7 +79532,7 @@ function lowerFuncCall(e) {
   if (envEntry === void 0 && e.name === "feval") {
     return lowerFevalCall.call(this, e);
   }
-  if (envEntry !== void 0 && isHandle(envEntry.ty)) {
+  if (envEntry !== void 0 && isHandle2(envEntry.ty)) {
     return dispatchHandleCall.call(this, e.name, envEntry, e.args, e.span);
   }
   if (envEntry === void 0 && this.workspace.isClass(e.name)) {
@@ -78893,7 +79979,7 @@ function lowerMultiAssign(s) {
   s = { ...s, lvalues: expandedLvalues };
   if (s.expr.type === "FuncCall") {
     const envEntry = this.env.get(callName);
-    if (envEntry !== void 0 && isHandle(envEntry.ty)) {
+    if (envEntry !== void 0 && isHandle2(envEntry.ty)) {
       return dispatchHandleMultiAssign.call(
         this,
         callName,