numbl 0.0.20 → 0.0.22

package/README.md

@@ -53,6 +53,10 @@ Commands:
   mip <subcommand>   Package manager (install, uninstall, list, avail, info)
   (no command)       Start interactive REPL
 
+Global options:
+  --version, -V      Print version and exit
+  --help, -h         Print this help message
+
 Options (for REPL):
   --plot             Enable plot server
   --plot-port <port> Set plot server port (implies --plot)
@@ -73,6 +77,10 @@ Environment variables:
 ```
 <!-- END CLI HELP -->
 
+## VS Code extension
+
+The [Numbl extension for VS Code](https://marketplace.visualstudio.com/items?itemName=jmagland.numbl) lets you run `.m` scripts directly in the editor with inline error diagnostics and a built-in figure viewer.
+
 ## Upgrading
 
 ```bash

package/dist-cli/cli.js

@@ -19028,6 +19028,16 @@ function complexBinaryOp(a, b, op) {
   );
 }
 function mAdd(a, b) {
+  if (typeof a === "object" && a !== null && a.kind === "tensor" && typeof b === "object" && b !== null && b.kind === "tensor") {
+    const at = a;
+    const bt = b;
+    if (!at.imag && !bt.imag && at.data.length === bt.data.length && at.shape.length === bt.shape.length && at.shape.every((d, i) => d === bt.shape[i])) {
+      const result = new FloatXArray(at.data.length);
+      for (let i = 0; i < result.length; i++)
+        result[i] = at.data[i] + bt.data[i];
+      return RTV.tensor(result, at.shape);
+    }
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mAddSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19064,6 +19074,16 @@ function mMul(a, b) {
   return binaryOp(a, b, (x, y) => x * y);
 }
 function mElemMul(a, b) {
+  if (typeof a === "object" && a !== null && a.kind === "tensor" && typeof b === "object" && b !== null && b.kind === "tensor") {
+    const at = a;
+    const bt = b;
+    if (!at.imag && !bt.imag && at.data.length === bt.data.length && at.shape.length === bt.shape.length && at.shape.every((d, i) => d === bt.shape[i])) {
+      const result = new FloatXArray(at.data.length);
+      for (let i = 0; i < result.length; i++)
+        result[i] = at.data[i] * bt.data[i];
+      return RTV.tensor(result, at.shape);
+    }
+  }
   if (isRuntimeSparseMatrix(a) || isRuntimeSparseMatrix(b))
     return mElemMulSparse(a, b);
   if (isComplexOrMixed(a, b)) {
@@ -19189,6 +19209,31 @@ function mPow(a, b) {
   return binaryOp(a, b, (x, y) => Math.pow(x, y));
 }
 function mElemPow(a, b) {
+  if (isRuntimeTensor(a) && !a.imag && isRuntimeNumber(b)) {
+    const exp = b;
+    if (exp === 2) {
+      const result = new FloatXArray(a.data.length);
+      for (let i = 0; i < result.length; i++) result[i] = a.data[i] * a.data[i];
+      return RTV.tensor(result, a.shape);
+    }
+    if (Number.isInteger(exp) || exp >= 0) {
+      let hasNeg2 = false;
+      if (!Number.isInteger(exp)) {
+        for (let i = 0; i < a.data.length; i++) {
+          if (a.data[i] < 0) {
+            hasNeg2 = true;
+            break;
+          }
+        }
+      }
+      if (!hasNeg2) {
+        const result = new FloatXArray(a.data.length);
+        for (let i = 0; i < result.length; i++)
+          result[i] = Math.pow(a.data[i], exp);
+        return RTV.tensor(result, a.shape);
+      }
+    }
+  }
   const complexPow = (aRe, aIm, bRe, bIm) => {
     const r = Math.sqrt(aRe * aRe + aIm * aIm);
     if (r === 0) {
@@ -19239,17 +19284,22 @@ function mElemPow(a, b) {
   return binaryOp(a, b, (x, y) => Math.pow(x, y));
 }
 function mNeg(v) {
-  if (isRuntimeSparseMatrix(v)) return sparseNeg(v);
-  if (isRuntimeComplexNumber(v)) return RTV.complex(-v.re, -v.im);
-  if (isRuntimeTensor(v) && v.imag !== void 0) {
-    const resultRe = new FloatXArray(v.data.length);
-    const resultIm = new FloatXArray(v.imag.length);
-    for (let i = 0; i < v.data.length; i++) {
-      resultRe[i] = -v.data[i];
-      resultIm[i] = -v.imag[i];
+  if (isRuntimeTensor(v)) {
+    if (v.imag !== void 0) {
+      const resultRe2 = new FloatXArray(v.data.length);
+      const resultIm = new FloatXArray(v.imag.length);
+      for (let i = 0; i < v.data.length; i++) {
+        resultRe2[i] = -v.data[i];
+        resultIm[i] = -v.imag[i];
+      }
+      return RTV.tensor(resultRe2, v.shape, resultIm);
     }
-    return RTV.tensor(resultRe, v.shape, resultIm);
+    const resultRe = new FloatXArray(v.data.length);
+    for (let i = 0; i < v.data.length; i++) resultRe[i] = -v.data[i];
+    return RTV.tensor(resultRe, v.shape);
   }
+  if (isRuntimeSparseMatrix(v)) return sparseNeg(v);
+  if (isRuntimeComplexNumber(v)) return RTV.complex(-v.re, -v.im);
   return unaryOp(v, (x) => -x);
 }
 function transposeCellArray(v) {
@@ -19524,6 +19574,40 @@ function broadcastComparison(a, b, outShape, op) {
   return t;
 }
 function binaryOp(a, b, op) {
+  if (isRuntimeTensor(a) && a.data.length > 1) {
+    if (isRuntimeTensor(b) && b.data.length > 1) {
+      if (a.data.length === b.data.length && a.shape.length === b.shape.length && a.shape.every((d, i) => d === b.shape[i])) {
+        const result = new FloatXArray(a.data.length);
+        for (let i = 0; i < result.length; i++) {
+          result[i] = op(a.data[i], b.data[i]);
+        }
+        return RTV.tensor(result, a.shape);
+      }
+      const broadcastShape2 = getBroadcastShape(a.shape, b.shape);
+      if (broadcastShape2 !== null) {
+        return broadcastBinary(a, b, broadcastShape2, op);
+      }
+      throw new RuntimeError(
+        `Matrix dimensions must agree: [${a.shape.join(",")}] vs [${b.shape.join(",")}]`
+      );
+    }
+    if (isRuntimeNumber(b)) {
+      const result = new FloatXArray(a.data.length);
+      const sv = b;
+      for (let i = 0; i < result.length; i++) {
+        result[i] = op(a.data[i], sv);
+      }
+      return RTV.tensor(result, a.shape);
+    }
+  }
+  if (isRuntimeTensor(b) && b.data.length > 1 && isRuntimeNumber(a)) {
+    const result = new FloatXArray(b.data.length);
+    const sv = a;
+    for (let i = 0; i < result.length; i++) {
+      result[i] = op(sv, b.data[i]);
+    }
+    return RTV.tensor(result, b.shape);
+  }
   const an = asNumeric(a);
   const bn = asNumeric(b);
   if (an.scalar && bn.scalar) {
@@ -19567,6 +19651,13 @@ function binaryOp(a, b, op) {
   );
 }
 function unaryOp(v, op) {
+  if (isRuntimeTensor(v) && v.data.length > 1) {
+    const result2 = new FloatXArray(v.data.length);
+    for (let i = 0; i < result2.length; i++) {
+      result2[i] = op(v.data[i]);
+    }
+    return RTV.tensor(result2, v.shape);
+  }
   const n = asNumeric(v);
   if (n.scalar) {
     const val = n.isComplex ? n.re : n.value;
@@ -20486,6 +20577,11 @@ function storeIntoTensor(base, indices, rhs) {
     return deleteTensorElements(base, indices[0]);
   }
   if (isRuntimeTensor(rhs) && rhs.data.length === 0 && indices.length === 2) {
+    const nrows = base.shape[0] ?? 1;
+    const ncols = base.shape.length >= 2 ? base.shape[1] : 1;
+    const rowCount = isColonIndex(indices[0]) ? nrows : resolveIndex(indices[0], nrows).length;
+    const colCount = isColonIndex(indices[1]) ? ncols : resolveIndex(indices[1], ncols).length;
+    if (rowCount === 0 || colCount === 0) return base;
     return deleteTensorRowsOrCols(base, indices);
   }
   if (base._rc > 1) {
@@ -20983,7 +21079,7 @@ function storeIntoTensorND(base, indices, rhs) {
   }
   return base;
 }
-function storeIntoCell(base, indices, rhs) {
+function storeIntoCell(base, indices, rhs, parenAssign = false) {
   if (base._rc > 1) {
     base._rc--;
     const sharedData = base.data.map((elem) => shareRuntimeValue(elem));
@@ -20997,14 +21093,20 @@ function storeIntoCell(base, indices, rhs) {
     c.shape = isColVec ? [newLen, 1] : [1, newLen];
   };
   if (indices.length === 1) {
-    return storeIntoCell1D(base, indices[0], rhs, updateShapeAfterLinearAssign);
+    return storeIntoCell1D(
+      base,
+      indices[0],
+      rhs,
+      updateShapeAfterLinearAssign,
+      parenAssign
+    );
   }
   if (indices.length === 2) {
-    return storeIntoCell2D(base, indices, rhs);
+    return storeIntoCell2D(base, indices, rhs, parenAssign);
   }
   throw new RuntimeError(`Cannot index-assign into cell`);
 }
-function storeIntoCell1D(base, idx, rhs, updateShape) {
+function storeIntoCell1D(base, idx, rhs, updateShape, parenAssign = false) {
   if (isRuntimeTensor(idx)) {
     let positions;
     if (idx._isLogical) {
@@ -21052,11 +21154,11 @@ function storeIntoCell1D(base, idx, rhs, updateShape) {
     while (base.data.length <= i)
       base.data.push(RTV.tensor(new FloatXArray(0), [0, 0]));
   }
-  base.data[i] = isRuntimeCell(rhs) && rhs.data.length === 1 ? rhs.data[0] : rhs;
+  base.data[i] = parenAssign && isRuntimeCell(rhs) && rhs.data.length === 1 ? rhs.data[0] : rhs;
   updateShape(oldLen);
   return base;
 }
-function storeIntoCell2D(base, indices, rhs) {
+function storeIntoCell2D(base, indices, rhs, parenAssign = false) {
   let rows = base.shape[0];
   let cols = base.shape.length >= 2 ? base.shape[1] : 1;
   const rowIndices = resolveIndex(indices[0], rows, 0);
@@ -21082,7 +21184,7 @@ function storeIntoCell2D(base, indices, rhs) {
   const nSelectedRows = rowIndices.length;
   const nSelectedCols = colIndices.length;
   const totalSelected = nSelectedRows * nSelectedCols;
-  if (isRuntimeCell(rhs)) {
+  if (parenAssign && isRuntimeCell(rhs)) {
     if (rhs.data.length !== totalSelected && rhs.data.length !== 1) {
       throw new RuntimeError("Subscripted assignment dimension mismatch");
     }
@@ -21100,7 +21202,7 @@ function storeIntoCell2D(base, indices, rhs) {
   }
   return base;
 }
-function storeIntoRTValueIndex(base, indices, rhs) {
+function storeIntoRTValueIndex(base, indices, rhs, parenAssign = false) {
   if (isRuntimeSparseMatrix(base)) {
     return storeIntoSparse(base, indices, rhs);
   }
@@ -21121,7 +21223,7 @@ function storeIntoRTValueIndex(base, indices, rhs) {
     return storeIntoTensor(base, indices, rhs);
   }
   if (isRuntimeCell(base)) {
-    return storeIntoCell(base, indices, rhs);
+    return storeIntoCell(base, indices, rhs, parenAssign);
   }
   throw new RuntimeError(`Cannot index-assign into ${kstr(base)}`);
 }
@@ -23031,11 +23133,8 @@ var CommandParser = class extends ExpressionParser {
         scanPos++;
         continue;
       }
-      if (ch === "\n" || ch === "\r" || ch === ";" || ch === "%") break;
-      if (ch === ",") {
-        scanPos++;
-        continue;
-      }
+      if (ch === "\n" || ch === "\r" || ch === ";" || ch === "%" || ch === ",")
+        break;
       if (ch === "." && scanPos + 2 < this.input.length && this.input[scanPos + 1] === "." && this.input[scanPos + 2] === ".") {
         scanPos += 3;
         while (scanPos < this.input.length && this.input[scanPos] !== "\n") {
@@ -25256,6 +25355,13 @@ function complexElemwise(realFn, complexFn, complexOutKind, o) {
         const isReal = complexOutKind === "Number" || resultIm2.every((x) => x === 0);
         return RTV.tensor(resultRe2, v.shape, isReal ? void 0 : resultIm2);
       }
+      if (o?.realSafe) {
+        const resultRe2 = new FloatXArray(v.data.length);
+        for (let i = 0; i < v.data.length; i++) {
+          resultRe2[i] = realFn(v.data[i]);
+        }
+        return RTV.tensor(resultRe2, v.shape);
+      }
       const resultRe = new FloatXArray(v.data.length);
       const resultIm = new FloatXArray(v.data.length);
       let hasImag = false;
@@ -25430,7 +25536,7 @@ function registerMathFunctions() {
         im: Math.cos(re) * Math.sinh(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.sin" }
+      { nativeJs: "Math.sin", realSafe: true }
     ),
     1
   );
@@ -25443,7 +25549,7 @@ function registerMathFunctions() {
         im: -Math.sin(re) * Math.sinh(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.cos" }
+      { nativeJs: "Math.cos", realSafe: true }
     ),
     1
   );
@@ -25456,7 +25562,7 @@ function registerMathFunctions() {
         return { re: Math.sin(2 * re) / denom, im: Math.sinh(2 * im) / denom };
       },
       "ComplexNumber",
-      { nativeJs: "Math.tan" }
+      { nativeJs: "Math.tan", realSafe: true }
     ),
     1
   );
@@ -25502,7 +25608,7 @@ function registerMathFunctions() {
         im: Math.cosh(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.sinh" }
+      { nativeJs: "Math.sinh", realSafe: true }
     ),
     1
   );
@@ -25515,7 +25621,7 @@ function registerMathFunctions() {
         im: Math.sinh(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.cosh" }
+      { nativeJs: "Math.cosh", realSafe: true }
     ),
     1
   );
@@ -25531,7 +25637,7 @@ function registerMathFunctions() {
         };
       },
       "ComplexNumber",
-      { nativeJs: "Math.tanh" }
+      { nativeJs: "Math.tanh", realSafe: true }
     ),
     1
   );
@@ -25581,7 +25687,7 @@ function registerMathFunctions() {
         im: Math.exp(re) * Math.sin(im)
       }),
       "ComplexNumber",
-      { nativeJs: "Math.exp" }
+      { nativeJs: "Math.exp", realSafe: true }
     ),
     1
   );
@@ -25683,7 +25789,7 @@ function registerMathFunctions() {
       Math.abs,
       (re, im) => ({ re: Math.sqrt(re * re + im * im), im: 0 }),
       "Number",
-      { nativeJs: "Math.abs" }
+      { nativeJs: "Math.abs", realSafe: true }
     ),
     1
   );
@@ -29011,6 +29117,27 @@ function dimReduce(v, dim, reduceFn, initialValue, finalizeFn) {
   const imOut = resultImag && resultImag.some((x) => x !== 0) ? resultImag : void 0;
   return RTV.tensor(result, info.resultShape, imOut);
 }
+function dimReduceOmitNaN(v, dim, reduceFn, initialValue, finalizeFn) {
+  if (!isRuntimeTensor(v))
+    throw new RuntimeError("dimReduceOmitNaN: argument must be a tensor");
+  const info = forEachSlice(v.shape, dim, () => {
+  });
+  if (!info) return copyTensor(v);
+  const result = new FloatXArray(info.totalElems);
+  forEachSlice(v.shape, dim, (outIdx, srcIndices) => {
+    let acc = initialValue;
+    let count = 0;
+    for (let k = 0; k < srcIndices.length; k++) {
+      const val = v.data[srcIndices[k]];
+      if (!isNaN(val)) {
+        acc = reduceFn(acc, val);
+        count++;
+      }
+    }
+    result[outIdx] = finalizeFn ? finalizeFn(acc, count) : acc;
+  });
+  return RTV.tensor(result, info.resultShape);
+}
 function sliceDimReduce(v, dim, sliceFn) {
   const info = forEachSlice(v.shape, dim, () => {
   });
@@ -29236,23 +29363,44 @@ function preserveTypeCheck(argTypes, nargout) {
   if (nargout === 2) return { outputTypes: [outType, outType] };
   return null;
 }
-function makeReduction(name, kernel) {
+function parseNanFlag(args) {
+  if (args.length >= 2) {
+    const last = args[args.length - 1];
+    if (isRuntimeChar(last)) {
+      const s = toString(last).toLowerCase();
+      if (s === "omitnan") return { args: args.slice(0, -1), omitNaN: true };
+      if (s === "includenan")
+        return { args: args.slice(0, -1), omitNaN: false };
+    }
+  }
+  return { args, omitNaN: false };
+}
+function filterNaN(arr) {
+  const out2 = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (!isNaN(arr[i])) out2.push(arr[i]);
+  }
+  return new Float64Array(out2);
+}
+function makeReduction(name, kernel, omitNaNKernel) {
   return {
     check: reductionCheck,
-    apply: (args) => {
-      if (args.length < 1)
+    apply: (rawArgs) => {
+      if (rawArgs.length < 1)
         throw new RuntimeError(`${name} requires at least 1 argument`);
+      const { args, omitNaN } = parseNanFlag(rawArgs);
+      const k = omitNaN && omitNaNKernel ? omitNaNKernel : kernel;
       const v = args[0];
       if (isRuntimeNumber(v)) return v;
       if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
       if (isRuntimeTensor(v)) {
         if (args.length >= 2) {
           if (isRuntimeChar(args[1]) && toString(args[1]) === "all")
-            return kernel.reduceAll(v);
-          return kernel.reduceDim(v, Math.round(toNumber(args[1])));
+            return k.reduceAll(v);
+          return k.reduceDim(v, Math.round(toNumber(args[1])));
         }
         const d = firstReduceDim(v.shape);
-        return d === 0 ? kernel.reduceAll(v) : kernel.reduceDim(v, d);
+        return d === 0 ? k.reduceAll(v) : k.reduceDim(v, d);
       }
       throw new RuntimeError(`${name}: argument must be numeric`);
     }
@@ -29282,6 +29430,42 @@ function sliceKernel(sliceFn) {
     reduceDim: (v, dim) => sliceDimReduce(v, dim, sliceFn)
   };
 }
+function accumKernelOmitNaN(reduceFn, initial, finalizeFn) {
+  return {
+    reduceAll: (v) => {
+      let acc = initial;
+      let count = 0;
+      for (let i = 0; i < v.data.length; i++) {
+        if (!isNaN(v.data[i])) {
+          acc = reduceFn(acc, v.data[i]);
+          count++;
+        }
+      }
+      const re = finalizeFn ? finalizeFn(acc, count) : acc;
+      if (v.imag) {
+        let accIm = initial;
+        let countIm = 0;
+        for (let i = 0; i < v.imag.length; i++) {
+          if (!isNaN(v.imag[i])) {
+            accIm = reduceFn(accIm, v.imag[i]);
+            countIm++;
+          }
+        }
+        const im = finalizeFn ? finalizeFn(accIm, countIm) : accIm;
+        if (im !== 0) return RTV.complex(re, im);
+      }
+      return RTV.num(re);
+    },
+    reduceDim: (v, dim) => dimReduceOmitNaN(v, dim, reduceFn, initial, finalizeFn)
+  };
+}
+function sliceKernelOmitNaN(sliceFn) {
+  const filteredFn = (slice) => sliceFn(filterNaN(slice));
+  return {
+    reduceAll: (v) => RTV.num(filteredFn(v.data)),
+    reduceDim: (v, dim) => sliceDimReduce(v, dim, filteredFn)
+  };
+}
 function toNumArray(v, name) {
   if (isRuntimeNumber(v)) return [v];
   if (isRuntimeTensor(v)) return Array.from(v.data);
@@ -29293,15 +29477,16 @@ function registerBasicReductions() {
   register("sum", [
     {
       check: reductionCheck,
-      apply: (args) => {
-        if (args.length < 1)
+      apply: (rawArgs) => {
+        if (rawArgs.length < 1)
           throw new RuntimeError("sum requires at least 1 argument");
+        const { args, omitNaN } = parseNanFlag(rawArgs);
         const v = args[0];
         if (isRuntimeSparseMatrix(v)) {
           const dim = args.length >= 2 ? Math.round(toNumber(args[1])) : v.m > 1 ? 1 : v.n > 1 ? 2 : 1;
           return sparseSum(v, dim);
         }
-        const kernel = accumKernel((acc, val) => acc + val, 0);
+        const kernel = omitNaN ? accumKernelOmitNaN((acc, val) => acc + val, 0) : accumKernel((acc, val) => acc + val, 0);
         if (isRuntimeNumber(v)) return v;
         if (isRuntimeLogical(v)) return RTV.num(v ? 1 : 0);
         if (isRuntimeTensor(v)) {
@@ -29317,13 +29502,14 @@ function registerBasicReductions() {
       }
     }
   ]);
-  const prodKernel = accumKernel((acc, val) => acc * val, 1);
   register("prod", [
     {
       check: reductionCheck,
-      apply: (args) => {
-        if (args.length < 1)
+      apply: (rawArgs) => {
+        if (rawArgs.length < 1)
           throw new RuntimeError("prod requires at least 1 argument");
+        const { args: parsedArgs, omitNaN } = parseNanFlag(rawArgs);
+        let args = parsedArgs;
         let v = args[0];
         if (isRuntimeSparseMatrix(v)) {
           v = sparseToDense(v);
@@ -29337,13 +29523,14 @@ function registerBasicReductions() {
               args.length >= 2 ? Math.round(toNumber(args[1])) : void 0
             );
           }
+          const kernel = omitNaN ? accumKernelOmitNaN((acc, val) => acc * val, 1) : accumKernel((acc, val) => acc * val, 1);
           if (args.length >= 2) {
             if (isRuntimeChar(args[1]) && toString(args[1]) === "all")
-              return prodKernel.reduceAll(v);
-            return prodKernel.reduceDim(v, Math.round(toNumber(args[1])));
+              return kernel.reduceAll(v);
+            return kernel.reduceDim(v, Math.round(toNumber(args[1])));
           }
           const d = firstReduceDim(v.shape);
-          return d === 0 ? prodKernel.reduceAll(v) : prodKernel.reduceDim(v, d);
+          return d === 0 ? kernel.reduceAll(v) : kernel.reduceDim(v, d);
         }
         throw new RuntimeError("prod: argument must be numeric");
       }
@@ -29356,31 +29543,40 @@ function registerBasicReductions() {
         (acc, val) => acc + val,
         0,
         (sum, count) => sum / count
+      ),
+      accumKernelOmitNaN(
+        (acc, val) => acc + val,
+        0,
+        (sum, count) => count === 0 ? NaN : sum / count
       )
     )
   ]);
-  const varianceOf = (slice, w) => {
-    const n = slice.length;
+  const varianceOf = (slice, w, omitNaN) => {
+    let data = slice;
+    if (omitNaN) data = filterNaN(slice);
+    const n = data.length;
+    if (n === 0) return NaN;
     if (n <= 1 && w === 0) return 0;
     let s = 0;
-    for (let i = 0; i < n; i++) s += slice[i];
+    for (let i = 0; i < n; i++) s += data[i];
     const m = s / n;
     let ss = 0;
-    for (let i = 0; i < n; i++) ss += (slice[i] - m) ** 2;
+    for (let i = 0; i < n; i++) ss += (data[i] - m) ** 2;
     const denom = w === 1 ? n : n - 1;
     return ss / denom;
   };
   const stdVarApply = (name, transform) => {
-    return (args) => {
-      if (args.length < 1)
+    return (rawArgs) => {
+      if (rawArgs.length < 1)
         throw new RuntimeError(`${name} requires at least 1 argument`);
+      const { args, omitNaN } = parseNanFlag(rawArgs);
       const v = args[0];
       const w = args.length >= 2 ? toNumber(args[1]) : 0;
       const dimArg = args.length >= 3 ? Math.round(toNumber(args[2])) : 0;
       if (isRuntimeNumber(v)) return RTV.num(0);
       if (isRuntimeTensor(v)) {
         const kernel = sliceKernel(
-          (slice) => transform(varianceOf(slice, w))
+          (slice) => transform(varianceOf(slice, w, omitNaN))
         );
         if (dimArg > 0) return kernel.reduceDim(v, dimArg);
         const d = firstReduceDim(v.shape);
@@ -29408,7 +29604,13 @@ function registerBasicReductions() {
     if (n % 2 === 1) return sorted[(n - 1) / 2];
     return (sorted[n / 2 - 1] + sorted[n / 2]) / 2;
   };
-  register("median", [makeReduction("median", sliceKernel(medianOf))]);
+  register("median", [
+    makeReduction(
+      "median",
+      sliceKernel(medianOf),
+      sliceKernelOmitNaN(medianOf)
+    )
+  ]);
   const modeOf = (arr) => {
     const counts = /* @__PURE__ */ new Map();
     for (let i = 0; i < arr.length; i++) {
@@ -29423,7 +29625,9 @@ function registerBasicReductions() {
     }
     return bestVal;
   };
-  register("mode", [makeReduction("mode", sliceKernel(modeOf))]);
+  register("mode", [
+    makeReduction("mode", sliceKernel(modeOf), sliceKernelOmitNaN(modeOf))
+  ]);
 }
 
 // src/numbl-core/builtins/reduction/min-max.ts
@@ -30051,6 +30255,11 @@ function registerSortUnique() {
             dim = idx >= 0 ? idx + 1 : 1;
           }
           const dimIdx = dim - 1;
+          if (!im && !descend && nargout <= 1 && re.length === shape[dimIdx]) {
+            const sorted2 = new FloatXArray(re);
+            sorted2.sort();
+            return RTV.tensor(sorted2, [...shape]);
+          }
           if (dimIdx >= shape.length) {
             const cp = RTV.tensor(
               new FloatXArray(re),
@@ -32884,51 +33093,61 @@ function registerDet() {
   register("cross", [
     {
       check: (argTypes, nargout) => {
-        if (argTypes.length !== 2 || nargout !== 1) return null;
+        if (argTypes.length !== 2 && argTypes.length !== 3 || nargout !== 1)
+          return null;
         return { outputTypes: [IType.Unknown] };
       },
       apply: (args) => {
-        if (args.length !== 2)
-          throw new RuntimeError("cross requires 2 arguments");
+        if (args.length < 2 || args.length > 3)
+          throw new RuntimeError("cross requires 2 or 3 arguments");
         const a = args[0], b = args[1];
         if (!isRuntimeTensor(a) || !isRuntimeTensor(b))
-          throw new RuntimeError("cross: arguments must be vectors");
-        const aRows = a.shape[0];
-        const aCols = a.shape.length >= 2 ? a.shape[1] : 1;
-        const bRows = b.shape[0];
-        const bCols = b.shape.length >= 2 ? b.shape[1] : 1;
-        const isColVector = aRows === 3 && aCols === 1;
-        const isRowVector = aRows === 1 && aCols === 3;
-        const isMatrix = aRows === 3 && aCols > 1;
-        if (isColVector || isRowVector) {
-          if (a.data.length !== 3 || b.data.length !== 3)
-            throw new RuntimeError("cross: vectors must have 3 elements");
-          const ax = a.data[0], ay = a.data[1], az = a.data[2];
-          const bx = b.data[0], by = b.data[1], bz = b.data[2];
-          const result = new FloatXArray(3);
-          result[0] = ay * bz - az * by;
-          result[1] = az * bx - ax * bz;
-          result[2] = ax * by - ay * bx;
-          return RTV.tensor(result, isColVector ? [3, 1] : [1, 3]);
-        } else if (isMatrix) {
-          if (bRows !== 3 || bCols !== aCols)
-            throw new RuntimeError("cross: matrix dimensions must agree");
-          const cols = aCols;
-          const result = new FloatXArray(3 * cols);
-          for (let c = 0; c < cols; c++) {
-            const off = c * 3;
-            const ax = a.data[off], ay = a.data[off + 1], az = a.data[off + 2];
-            const bx = b.data[off], by = b.data[off + 1], bz = b.data[off + 2];
-            result[off] = ay * bz - az * by;
-            result[off + 1] = az * bx - ax * bz;
-            result[off + 2] = ax * by - ay * bx;
-          }
-          return RTV.tensor(result, [3, cols]);
+          throw new RuntimeError("cross: arguments must be vectors or arrays");
+        const shape = a.shape;
+        if (shape.length !== b.shape.length || shape.some((s, i) => s !== b.shape[i]))
+          throw new RuntimeError("cross: A and B must have the same size");
+        let dim;
+        if (args.length === 3) {
+          dim = toNumber(args[2]);
+          if (!Number.isInteger(dim) || dim < 1)
+            throw new RuntimeError("cross: dim must be a positive integer");
         } else {
+          dim = shape.indexOf(3) + 1;
+          if (dim === 0)
+            throw new RuntimeError(
+              "cross: A and B must have at least one dimension of length 3"
+            );
+        }
+        const dimIdx = dim - 1;
+        if (dimIdx >= shape.length || shape[dimIdx] !== 3)
           throw new RuntimeError(
-            "cross: inputs must be 3-element vectors or 3xN matrices"
+            `cross: size(A,${dim}) and size(B,${dim}) must be 3`
           );
-        }
+        const totalLen = a.data.length;
+        const result = new FloatXArray(totalLen);
+        const strides = new Array(shape.length);
+        strides[0] = 1;
+        for (let d = 1; d < shape.length; d++)
+          strides[d] = strides[d - 1] * shape[d - 1];
+        const dimStride = strides[dimIdx];
+        const outerStride = dimIdx + 1 < shape.length ? strides[dimIdx + 1] : totalLen;
+        const innerSize = dimStride;
+        const numOuter = totalLen / outerStride;
+        for (let outer = 0; outer < numOuter; outer++) {
+          const blockBase = outer * outerStride;
+          for (let inner = 0; inner < innerSize; inner++) {
+            const base = blockBase + inner;
+            const i0 = base;
+            const i1 = base + dimStride;
+            const i2 = base + 2 * dimStride;
+            const ax = a.data[i0], ay = a.data[i1], az = a.data[i2];
+            const bx = b.data[i0], by = b.data[i1], bz = b.data[i2];
+            result[i0] = ay * bz - az * by;
+            result[i1] = az * bx - ax * bz;
+            result[i2] = ax * by - ay * bx;
+          }
+        }
+        return RTV.tensor(result, [...shape]);
       }
     }
   ]);
@@ -38367,6 +38586,67 @@ function endResolver(mv, numIndices) {
   };
 }
 function index(rt, base, indices, nargout = 1, skipSubsref = false) {
+  if (typeof base === "object" && base !== null && base.kind === "tensor") {
+    const t = base;
+    const nIdx = indices.length;
+    if (nIdx === 1) {
+      const idx = indices[0];
+      if (typeof idx === "number") {
+        const i = Math.round(idx) - 1;
+        if (i < 0 || i >= t.data.length)
+          throw new RuntimeError("Index exceeds array bounds");
+        if (t.imag !== void 0) {
+          const im = t.imag[i];
+          return im === 0 ? t.data[i] : RTV.complex(t.data[i], im);
+        }
+        return t.data[i];
+      }
+    } else if (nIdx === 2) {
+      const ri = indices[0];
+      const ci = indices[1];
+      if (typeof ri === "number" && typeof ci === "number") {
+        const s = t.shape;
+        const rows = s.length === 0 ? 1 : s.length === 1 ? 1 : s[0];
+        const cols = s.length === 0 ? 1 : s.length === 1 ? s[0] : s[1];
+        const r = Math.round(ri) - 1;
+        const c = Math.round(ci) - 1;
+        if (r < 0 || r >= rows || c < 0 || c >= cols)
+          throw new RuntimeError("Index exceeds array bounds");
+        const lin = c * rows + r;
+        if (t.imag !== void 0) {
+          const im = t.imag[lin];
+          return im === 0 ? t.data[lin] : RTV.complex(t.data[lin], im);
+        }
+        return t.data[lin];
+      }
+    } else if (nIdx >= 3) {
+      let allNumeric = true;
+      for (let k = 0; k < nIdx; k++) {
+        if (typeof indices[k] !== "number") {
+          allNumeric = false;
+          break;
+        }
+      }
+      if (allNumeric) {
+        const s = t.shape;
+        let lin = 0;
+        let stride = 1;
+        for (let k = 0; k < nIdx; k++) {
+          const dimSize = k < s.length ? s[k] : 1;
+          const sub = Math.round(indices[k]) - 1;
+          if (sub < 0 || sub >= dimSize)
+            throw new RuntimeError("Index exceeds array bounds");
+          lin += sub * stride;
+          stride *= dimSize;
+        }
+        if (t.imag !== void 0) {
+          const im = t.imag[lin];
+          return im === 0 ? t.data[lin] : RTV.complex(t.data[lin], im);
+        }
+        return t.data[lin];
+      }
+    }
+  }
   if (typeof base === "function") {
     return base(...indices);
   }
@@ -38451,6 +38731,13 @@ function resolveIndicesForClassInstance(rt, mv, base, indices) {
   });
 }
 function indexCell(rt, base, indices) {
+  if (indices.length === 1 && typeof indices[0] === "number" && typeof base === "object" && base !== null && base.kind === "cell") {
+    const cell = base;
+    const i = Math.round(indices[0]) - 1;
+    if (i < 0 || i >= cell.data.length)
+      throw new RuntimeError("Cell index exceeds bounds");
+    return cell.data[i];
+  }
   const mv = ensureRuntimeValue(base);
   if (isRuntimeClassInstance(mv)) {
     const subsrefFn = rt.cachedResolveClassMethod(mv.className, "subsref");
@@ -38589,7 +38876,7 @@ function indexStore(rt, base, indices, rhs, skipSubsasgn = false) {
   if (isRuntimeCell(mv)) {
     const idxMvals2 = resolveIndices(indices, endResolver(mv, indices.length));
     const rhsMv2 = ensureRuntimeValue(rhs);
-    return storeIntoRTValueIndex(mv, idxMvals2, rhsMv2);
+    return storeIntoRTValueIndex(mv, idxMvals2, rhsMv2, true);
   }
   if (isRuntimeStruct(mv)) {
     return ensureRuntimeValue(rhs);
@@ -40148,15 +40435,23 @@ var Runtime = class _Runtime {
   // ── Builtin initialization ──────────────────────────────────────────
   initBuiltins() {
     for (const name of getAllBuiltinNames()) {
+      const builtin = getBuiltin(name);
+      const singleBranch = builtin.length === 1 ? builtin[0] : null;
       this.builtins[name] = (nargout, args) => {
-        const builtin = getBuiltin(name);
         const margs = args.map((a) => ensureRuntimeValue(a));
-        const argItemTypes = margs.map((arg) => getItemTypeFromRuntimeValue(arg));
-        let branch = builtin[0];
-        for (let i = 0; i < builtin.length; i++) {
-          if (builtin[i].check(argItemTypes, nargout)) {
-            branch = builtin[i];
-            break;
+        let branch;
+        if (singleBranch) {
+          branch = singleBranch;
+        } else {
+          const argItemTypes = margs.map(
+            (arg) => getItemTypeFromRuntimeValue(arg)
+          );
+          branch = builtin[0];
+          for (let i = 0; i < builtin.length; i++) {
+            if (builtin[i].check(argItemTypes, nargout)) {
+              branch = builtin[i];
+              break;
+            }
           }
         }
         if (this.profilingEnabled) {
@@ -44579,8 +44874,6 @@ function genClassInstantiation(cg, kind) {
   return createExpr;
 }
 var NATIVE_MATH_1 = {
-  // Note: sqrt, asin, acos, log are NOT here because they can produce
-  // complex results from real inputs (e.g., sqrt(-1) = 1i).
   abs: "Math.abs",
   floor: "Math.floor",
   ceil: "Math.ceil",
@@ -44594,6 +44887,14 @@ var NATIVE_MATH_1 = {
   log10: "Math.log10",
   sign: "Math.sign"
 };
+var GUARDED_MATH_1 = {
+  sqrt: { fn: "Math.sqrt", guard: "$x >= 0" },
+  log: { fn: "Math.log", guard: "$x > 0" },
+  asin: { fn: "Math.asin", guard: "$x >= -1 && $x <= 1" },
+  acos: { fn: "Math.acos", guard: "$x >= -1 && $x <= 1" },
+  acosh: { fn: "Math.acosh", guard: "$x >= 1" },
+  atanh: { fn: "Math.atanh", guard: "$x > -1 && $x < 1" }
+};
 var NATIVE_MATH_2 = {
   // Note: max/min are NOT here because Math.max/Math.min propagate NaN,
   // but max/min ignore NaN (returning the non-NaN value).
@@ -44605,6 +44906,15 @@ function tryNativeMathCodegen(cg, name, nargout, irArgs, jsArgs) {
   if (jsArgs.length === 1 && itemTypeForExprKind(irArgs[0].kind, cg.typeEnv).kind === "Number") {
     const fn = NATIVE_MATH_1[name];
     if (fn) return `${fn}(${jsArgs[0]})`;
+    const guarded = GUARDED_MATH_1[name];
+    if (guarded) {
+      const arg = jsArgs[0];
+      const tmp = cg.freshTemp("$gm");
+      cg.emit(`var ${tmp};`);
+      const guard = guarded.guard.replace(/\$x/g, tmp);
+      const fallback = `${cg.useBuiltin(name)}(1, [${tmp}])`;
+      return `(${tmp} = ${arg}, ${guard} ? ${guarded.fn}(${tmp}) : ${fallback})`;
+    }
   }
   if (jsArgs.length === 2 && itemTypeForExprKind(irArgs[0].kind, cg.typeEnv).kind === "Number" && itemTypeForExprKind(irArgs[1].kind, cg.typeEnv).kind === "Number") {
     const fn = NATIVE_MATH_2[name];
@@ -46318,6 +46628,21 @@ function instantiateWasm(wasmData) {
   }
   return new WebAssembly.Instance(wasmModule, importObject);
 }
+function resolveBindings(file, directives, getWasmInstance, nativeBridge2) {
+  const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
+  let nativeLib;
+  if (directives.native && nativeBridge2) {
+    const libFile = nativeLibFilename(directives.native);
+    const dir = file.name.substring(0, file.name.lastIndexOf("/") + 1);
+    const libPath = dir + libFile;
+    try {
+      nativeLib = nativeBridge2.load(libPath);
+    } catch {
+    }
+  }
+  return { wasmInstance, nativeLib };
+}
+var LOADING = /* @__PURE__ */ Symbol("loading");
 function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
   const result = /* @__PURE__ */ new Map();
   const wasmMap = wasmFiles ? buildWasmMap(wasmFiles) : /* @__PURE__ */ new Map();
@@ -46331,7 +46656,68 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
     wasmInstanceCache.set(name, instance);
     return instance;
   }
+  const libraryFiles = /* @__PURE__ */ new Map();
+  const functionFiles = [];
   for (const file of jsFiles) {
+    const base = file.name.split("/").pop();
+    if (base.startsWith("_")) {
+      const libName = base.replace(/\.js$/, "");
+      libraryFiles.set(libName, file);
+    } else {
+      functionFiles.push(file);
+    }
+  }
+  const libCache = /* @__PURE__ */ new Map();
+  function importJS(name) {
+    const cached = libCache.get(name);
+    if (cached === LOADING) {
+      throw new RuntimeError(`Circular dependency detected: ${name}.js`);
+    }
+    if (libCache.has(name)) return cached;
+    const libFile = libraryFiles.get(name);
+    if (!libFile) {
+      throw new RuntimeError(
+        `importJS: library '${name}.js' not found in workspace`
+      );
+    }
+    libCache.set(name, LOADING);
+    const directives = parseDirectives(libFile.source);
+    const { wasmInstance, nativeLib } = resolveBindings(
+      libFile,
+      directives,
+      getWasmInstance,
+      nativeBridge2
+    );
+    const dummyRegister = () => {
+      throw new RuntimeError(
+        `Library file '${name}.js' must not call register(). Use return {...} to export values.`
+      );
+    };
+    const factory = new Function(
+      "RTV",
+      "RuntimeError",
+      "FloatXArray",
+      "IType",
+      "register",
+      "wasm",
+      "native",
+      "importJS",
+      libFile.source
+    );
+    const exports = factory(
+      RTV,
+      RuntimeError,
+      FloatXArray,
+      IType,
+      dummyRegister,
+      wasmInstance,
+      nativeLib,
+      importJS
+    );
+    libCache.set(name, exports);
+    return exports;
+  }
+  for (const file of functionFiles) {
     const funcName = funcNameFromFile(file.name);
     try {
       const branches = [];
@@ -46345,17 +46731,12 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         });
       };
       const directives = parseDirectives(file.source);
-      const wasmInstance = directives.wasm ? getWasmInstance(directives.wasm) : void 0;
-      let nativeLib;
-      if (directives.native && nativeBridge2) {
-        const libFile = nativeLibFilename(directives.native);
-        const dir = file.name.substring(0, file.name.lastIndexOf("/") + 1);
-        const libPath = dir + libFile;
-        try {
-          nativeLib = nativeBridge2.load(libPath);
-        } catch {
-        }
-      }
+      const { wasmInstance, nativeLib } = resolveBindings(
+        file,
+        directives,
+        getWasmInstance,
+        nativeBridge2
+      );
       const factory = new Function(
         "RTV",
         "RuntimeError",
@@ -46364,6 +46745,7 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         "register",
         "wasm",
         "native",
+        "importJS",
         file.source
       );
       factory(
@@ -46373,7 +46755,8 @@ function loadJsUserFunctions(jsFiles, wasmFiles, nativeBridge2) {
         IType,
         registerFn,
         wasmInstance,
-        nativeLib
+        nativeLib,
+        importJS
       );
       if (branches.length === 0) {
         throw new Error(
@@ -47188,6 +47571,9 @@ Call stack (most recent call first):`;
   return result;
 }
 
+// src/numbl-core/version.ts
+var NUMBL_VERSION = "0.0.22";
+
 // src/cli-repl.ts
 import { createInterface } from "readline";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync } from "fs";
@@ -47982,6 +48368,10 @@ Commands:
   mip <subcommand>   Package manager (install, uninstall, list, avail, info)
   (no command)       Start interactive REPL
 
+Global options:
+  --version, -V      Print version and exit
+  --help, -h         Print this help message
+
 Options (for REPL):
   --plot             Enable plot server
   --plot-port <port> Set plot server port (implies --plot)
@@ -48376,6 +48766,7 @@ async function cmdBuildAddon() {
 function cmdInfo() {
   process.stdout.write(
     JSON.stringify({
+      version: NUMBL_VERSION,
       nativeAddon: nativeAddonLoaded,
       nativeAddonPath: addonPath,
       packageDir: packageDir2
@@ -48534,6 +48925,10 @@ function cmdShowProfile(args) {
 }
 async function main() {
   const args = process.argv.slice(2);
+  if (args.includes("--version") || args.includes("-V")) {
+    console.log(NUMBL_VERSION);
+    process.exit(0);
+  }
   if (args.includes("--help") || args.includes("-h")) {
     printHelp();
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -106,10 +106,11 @@
     "vitest": "^4.0.18"
   },
   "lint-staged": {
-    "*.{js,jsx,ts,tsx}": [
+    "*.{ts,tsx}": [
       "prettier --write",
       "eslint"
     ],
+    "*.{js,jsx}": "prettier --write",
     "*.{json,css,md,yml}": "prettier --write"
   },
   "optionalDependencies": {