numbl 0.0.4 → 0.0.6

package/README.md

@@ -26,6 +26,32 @@ numbl                          # interactive REPL
 numbl --info                   # check native addon status
 ```
 
+## Try it with Docker
+
+Run the REPL instantly — no installation required:
+
+```bash
+docker run -it node:22 npx numbl
+```
+
+With plotting support (open http://localhost:8234 in your browser):
+
+```bash
+docker run -it -p 8234:8234 node:22 npx numbl --plot-port 8234
+```
+
+With native LAPACK support for fast linear algebra:
+
+```bash
+docker run -it node:22 bash -c "apt-get update && apt-get install -y libopenblas-dev && npx numbl build-addon && npx numbl"
+```
+
+With both LAPACK and plotting:
+
+```bash
+docker run -it -p 8234:8234 node:22 bash -c "apt-get update && apt-get install -y libopenblas-dev && npx numbl build-addon && npx numbl --plot-port 8234"
+```
+
 ## Upgrading
 
 ```bash

package/dist-cli/cli.js

@@ -202,6 +202,21 @@ function shareRuntimeValue(v) {
       _rc: v._rc
     };
   }
+  if (v.kind === "class_instance" && !v.isHandleClass) {
+    const newFields = /* @__PURE__ */ new Map();
+    for (const [k, fv] of v.fields) {
+      newFields.set(k, shareRuntimeValue(fv));
+    }
+    const copy = {
+      kind: "class_instance",
+      className: v.className,
+      fields: newFields,
+      isHandleClass: false
+    };
+    if (v.$m) copy.$m = v.$m;
+    if (v._builtinData) copy._builtinData = shareRuntimeValue(v._builtinData);
+    return copy;
+  }
   return v;
 }
 
@@ -12679,6 +12694,13 @@ function indexIntoRTValue(base, indices) {
       return base;
     }
   }
+  if (base.kind === "struct" || base.kind === "class_instance") {
+    if (indices.length === 1) {
+      const i = Math.round(toNumber(indices[0]));
+      if (i !== 1) throw new RuntimeError("Index exceeds struct dimensions");
+      return base;
+    }
+  }
   if (base.kind === "struct_array") {
     if (indices.length === 1) {
       const idx = indices[0];
@@ -12717,6 +12739,12 @@ function storeIntoRTValueIndex(base, indices, rhs) {
       const idx = indices[0];
       if (idx.kind === "number") {
         toDelete.add(Math.round(idx.value) - 1);
+      } else if (idx.kind === "logical") {
+        if (idx.value) toDelete.add(0);
+      } else if (idx.kind === "tensor" && idx._isLogical) {
+        for (let i = 0; i < idx.data.length; i++) {
+          if (idx.data[i] !== 0) toDelete.add(i);
+        }
       } else if (idx.kind === "tensor") {
         for (let i = 0; i < idx.data.length; i++) {
           toDelete.add(Math.round(idx.data[i]) - 1);
@@ -12743,6 +12771,12 @@ function storeIntoRTValueIndex(base, indices, rhs) {
         const s = /* @__PURE__ */ new Set();
         if (idx.kind === "number") {
           s.add(Math.round(idx.value) - 1);
+        } else if (idx.kind === "logical") {
+          if (idx.value) s.add(0);
+        } else if (idx.kind === "tensor" && idx._isLogical) {
+          for (let i = 0; i < idx.data.length; i++) {
+            if (idx.data[i] !== 0) s.add(i);
+          }
         } else if (idx.kind === "tensor") {
           for (let i = 0; i < idx.data.length; i++)
             s.add(Math.round(idx.data[i]) - 1);
@@ -13281,6 +13315,26 @@ function storeIntoRTValueIndex(base, indices, rhs) {
       base = RTV.cell([...base.data], [...base.shape]);
     }
     if (indices.length === 1) {
+      if (indices[0].kind === "tensor" && !indices[0]._isLogical) {
+        const idx = indices[0];
+        if (rhs.kind !== "cell" || rhs.data.length !== idx.data.length) {
+          throw new RuntimeError("Subscripted assignment dimension mismatch");
+        }
+        let maxIdx = -1;
+        for (let j = 0; j < idx.data.length; j++) {
+          const pos = Math.round(idx.data[j]) - 1;
+          if (pos < 0) throw new RuntimeError("Cell index exceeds bounds");
+          if (pos > maxIdx) maxIdx = pos;
+        }
+        while (base.data.length <= maxIdx)
+          base.data.push(RTV.tensor(new FloatXArray(0), [0, 0]));
+        for (let j = 0; j < idx.data.length; j++) {
+          const pos = Math.round(idx.data[j]) - 1;
+          base.data[pos] = rhs.data[j];
+        }
+        base.shape = [1, base.data.length];
+        return base;
+      }
       const i = Math.round(toNumber(indices[0])) - 1;
       if (i < 0) throw new RuntimeError("Cell index exceeds bounds");
       if (i >= base.data.length) {
@@ -16718,8 +16772,14 @@ function elemwise(fn, o) {
   const apply = (args) => {
     if (args.length !== 1) throw new RuntimeError(`Expected 1 argument`);
     const v = args[0];
-    if (v.kind === "number") return RTV.num(fn(v.value));
-    if (v.kind === "logical") return RTV.num(fn(v.value ? 1 : 0));
+    if (v.kind === "number") {
+      const result = fn(v.value);
+      return o?.isLogical ? RTV.logical(!!result) : RTV.num(result);
+    }
+    if (v.kind === "logical") {
+      const result = fn(v.value ? 1 : 0);
+      return o?.isLogical ? RTV.logical(!!result) : RTV.num(result);
+    }
     if (v.kind === "tensor") {
       const result = new FloatXArray(v.data.length);
       for (let i = 0; i < v.data.length; i++) result[i] = fn(v.data[i]);
@@ -16731,14 +16791,18 @@ function elemwise(fn, o) {
     throw new RuntimeError("Expected numeric argument");
   };
   if (o?.nativeJs) {
+    const outKind = o.isLogical ? "Logical" : "Num";
     ret.push({
       check: (argTypes) => {
         if (argTypes.length !== 1) return null;
         if (argTypes[0].kind !== "Num") return null;
-        return { outputTypes: [{ kind: "Num" }] };
+        return { outputTypes: [{ kind: outKind }] };
       },
       apply,
-      nativeJsFn: o.nativeJs
+      // Disable native JS fast-path for logical builtins — their scalar
+      // results must stay as RuntimeValue logicals so the codegen emits
+      // $rt.not() instead of the `=== 0` fast path.
+      nativeJsFn: o.isLogical ? void 0 : o.nativeJs
     });
   }
   ret.push({
@@ -17311,20 +17375,17 @@ function registerArrayFunctions() {
       }
     }
   ]);
-  register("NaN", [
-    {
-      check: arrayConstructorCheck,
-      apply: (args) => {
-        if (args.length === 0) return RTV.num(NaN);
-        const shape = parseShapeArgs2(args);
-        if (shape.length === 1) shape.push(shape[0]);
-        const n = numel(shape);
-        const data = new FloatXArray(n);
-        data.fill(NaN);
-        return RTV.tensor(data, shape);
-      }
-    }
-  ]);
+  const nanApply = (args) => {
+    if (args.length === 0) return RTV.num(NaN);
+    const shape = parseShapeArgs2(args);
+    if (shape.length === 1) shape.push(shape[0]);
+    const n = numel(shape);
+    const data = new FloatXArray(n);
+    data.fill(NaN);
+    return RTV.tensor(data, shape);
+  };
+  register("NaN", [{ check: arrayConstructorCheck, apply: nanApply }]);
+  register("nan", [{ check: arrayConstructorCheck, apply: nanApply }]);
   register("eye", [
     {
       check: arrayConstructorCheck,
@@ -19600,7 +19661,52 @@ function registerReductionFunctions() {
         if (args.length < 2)
           throw new RuntimeError("ismember requires 2 arguments");
         const v = args[0];
-        const bArr = toNumArray(args[1], "ismember");
+        const b = args[1];
+        const isStringLike = (x) => x.kind === "string" || x.kind === "char";
+        const isCellOfStrings = (x) => x.kind === "cell" && x.data.every(
+          (e) => e.kind === "string" || e.kind === "char"
+        );
+        if (isStringLike(v) || isCellOfStrings(v) || isStringLike(b) || isCellOfStrings(b)) {
+          const bStrings = [];
+          if (isStringLike(b)) {
+            bStrings.push(toString(b));
+          } else if (isCellOfStrings(b)) {
+            if (b.kind !== "cell") throw new RuntimeError("unexpected type");
+            for (const e of b.data)
+              bStrings.push(toString(e));
+          } else {
+            throw new RuntimeError("ismember: incompatible argument types");
+          }
+          const bSet = new Set(bStrings);
+          if (isStringLike(v)) {
+            const found = bSet.has(toString(v));
+            const lia = RTV.logical(found);
+            if (nargout > 1) {
+              const idx = found ? bStrings.indexOf(toString(v)) + 1 : 0;
+              return [lia, RTV.num(idx)];
+            }
+            return lia;
+          }
+          if (v.kind === "cell" && isCellOfStrings(v)) {
+            const vData = v.data;
+            const tfData = new FloatXArray(vData.length);
+            const locData = nargout > 1 ? new FloatXArray(vData.length) : void 0;
+            for (let i = 0; i < vData.length; i++) {
+              const s = toString(vData[i]);
+              const found = bSet.has(s);
+              tfData[i] = found ? 1 : 0;
+              if (locData) locData[i] = found ? bStrings.indexOf(s) + 1 : 0;
+            }
+            const t = RTV.tensor(tfData, [...v.shape]);
+            t._isLogical = true;
+            if (nargout > 1) {
+              return [t, RTV.tensor(locData, [...v.shape])];
+            }
+            return t;
+          }
+          throw new RuntimeError("ismember: incompatible argument types");
+        }
+        const bArr = toNumArray(b, "ismember");
         const bMap = /* @__PURE__ */ new Map();
         for (let i = 0; i < bArr.length; i++) {
           if (!bMap.has(bArr[i])) bMap.set(bArr[i], i + 1);
@@ -21541,21 +21647,20 @@ function registerMiscFunctions() {
       return RTV.struct(fields);
     })
   );
-  register(
-    "fieldnames",
-    builtinSingle((args) => {
-      if (args.length !== 1)
-        throw new RuntimeError("fieldnames requires 1 argument");
-      const v = args[0];
-      if (v.kind !== "struct" && v.kind !== "class_instance")
-        throw new RuntimeError("fieldnames: argument must be a struct");
-      const names = [...v.fields.keys()];
-      return RTV.cell(
-        names.map((n) => RTV.string(n)),
-        [names.length, 1]
-      );
-    })
-  );
+  const fieldnamesApply = builtinSingle((args) => {
+    if (args.length !== 1)
+      throw new RuntimeError("fieldnames requires 1 argument");
+    const v = args[0];
+    if (v.kind !== "struct" && v.kind !== "class_instance")
+      throw new RuntimeError("fieldnames: argument must be a struct");
+    const names = [...v.fields.keys()];
+    return RTV.cell(
+      names.map((n) => RTV.string(n)),
+      [names.length, 1]
+    );
+  });
+  register("fieldnames", fieldnamesApply);
+  register("fields", fieldnamesApply);
   register(
     "isfield",
     builtinSingle((args) => {
@@ -22361,7 +22466,6 @@ var dummyHandleFunctions = [
   "gcf",
   "gca",
   "shg",
-  "ishold",
   "dir",
   "newplot",
   "caxis",
@@ -22401,7 +22505,7 @@ function registerDummyArrayFunctions() {
     register(name, fn);
   }
 }
-var returnDummyBooleanFunctions = ["ispc", "ismac", "isunix"];
+var returnDummyBooleanFunctions = ["ispc", "ismac", "isunix", "ishold"];
 function registerDummyBooleanFunctions() {
   const fn = builtinSingle(() => RTV.logical(false), {
     outputType: IType.Logical
@@ -22419,12 +22523,27 @@ function registerDummyCellArrayFunctions() {
     register(name, fn);
   }
 }
+function registerHandleGetSet() {
+  register(
+    "get",
+    builtinSingle(() => RTV.dummyHandle(), {
+      outputType: IType.DummyHandle
+    })
+  );
+  register(
+    "set",
+    builtinSingle(() => void 0, {
+      outputType: IType.Void
+    })
+  );
+}
 var registerDummyFunctions = () => {
   registerDummyHandleFunctions();
   registerDummyStringFunctions();
   registerDummyArrayFunctions();
   registerDummyBooleanFunctions();
   registerDummyCellArrayFunctions();
+  registerHandleGetSet();
 };
 
 // src/numbl-core/builtins/index.ts
@@ -25823,9 +25942,6 @@ var CodegenExprs = class extends CodegenBase {
     if (kind.name === "isa") return `$rt.isa(${args[0]}, ${args[1]})`;
     if (kind.name === "figure")
       return `$rt.plot_instr({type: "set_figure_handle", handle: ${args[0] ?? "1"}})`;
-    if (kind.name === "plot") {
-      return `$rt.plot_call([${args.join(", ")}])`;
-    }
     if (kind.name === "hold")
       return `$rt.plot_instr({type: "set_hold", value: ${args[0]}})`;
     if (kind.name === "drawnow") {
@@ -28358,6 +28474,7 @@ var Runtime = class {
   }
   /** Unwrap a RuntimeValue result to native JS types for the fast path */
   unwrapResult(result) {
+    if (result === void 0) return void 0;
     if (Array.isArray(result)) {
       return result.map((r) => {
         if (r.kind === "number") return r.value;
@@ -29595,6 +29712,9 @@ var Runtime = class {
       );
       if (fn) return fn.fn(nargout, ...args);
     }
+    if (name === "plot") {
+      return this.plot_call(args);
+    }
     const builtin = this.builtins[name];
     if (builtin) return builtin(nargout, args);
     throw new RuntimeError(`Undefined function or variable: '${name}'`);
@@ -30212,7 +30332,7 @@ var MIME_TYPES = {
   ".png": "image/png",
   ".json": "application/json"
 };
-async function startPlotServer() {
+async function startPlotServer(options) {
   const thisDir = fileURLToPath(new URL(".", import.meta.url));
   const distDir = join(thisDir, "..", "dist-plot-viewer");
   if (!existsSync(distDir)) {
@@ -30266,11 +30386,13 @@ Expected directory: ${distDir}`
       res.end("Not found");
     }
   });
+  const listenPort = options?.port ?? 0;
+  const listenHost = options?.host ?? "127.0.0.1";
   await new Promise((resolve2) => {
-    server.listen(0, "127.0.0.1", () => resolve2());
+    server.listen(listenPort, listenHost, () => resolve2());
   });
   const port = server.address().port;
-  const url = `http://127.0.0.1:${port}/`;
+  const url = `http://${listenHost}:${port}/`;
   console.error(`[numbl] Plot server at ${url}`);
   openBrowser(url);
   let closedResolve;
@@ -30526,9 +30648,11 @@ function jsonReplacer(_key, value) {
   }
   return value;
 }
-async function runRepl() {
+async function runRepl(plot, plotPort) {
   const workspaceFiles = scanMFiles(process.cwd());
   let variableValues = {};
+  const plotOpts = plotPort !== void 0 ? { port: plotPort, host: "0.0.0.0" } : void 0;
+  const { onDrawnow } = createPlotHandler(!plot, plotOpts);
   const rl = createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -30553,12 +30677,16 @@ async function runRepl() {
           onOutput: (text) => {
             process.stdout.write(text);
           },
+          onDrawnow,
           initialVariableValues: variableValues
         },
         workspaceFiles,
         "repl"
       );
       variableValues = result.variableValues;
+      if (result.plotInstructions.length > 0 && onDrawnow) {
+        onDrawnow(result.plotInstructions);
+      }
     } catch (error) {
       const diags = diagnoseErrors(error, trimmed, "repl", workspaceFiles);
       console.error(formatDiagnostics(diags));
@@ -30750,6 +30878,7 @@ async function main() {
   let noAsync = false;
   let noDce = false;
   let plot = false;
+  let plotPort;
   let addScriptPath = false;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--dump-js") {
@@ -30781,6 +30910,18 @@ async function main() {
       noDce = true;
     } else if (args[i] === "--plot") {
       plot = true;
+    } else if (args[i] === "--plot-port") {
+      i++;
+      if (i >= args.length) {
+        console.error("Error: --plot-port requires a port number");
+        process.exit(1);
+      }
+      plotPort = parseInt(args[i], 10);
+      if (isNaN(plotPort)) {
+        console.error("Error: --plot-port requires a valid port number");
+        process.exit(1);
+      }
+      plot = true;
     } else if (args[i] === "--add-script-path") {
       addScriptPath = true;
     } else if (args[i] === "--path") {
@@ -30810,7 +30951,7 @@ async function main() {
     return;
   }
   if (evalCode === null && positional.length === 0) {
-    await runRepl();
+    await runRepl(plot, plotPort);
     return;
   }
   let code = "";
@@ -30945,14 +31086,19 @@ async function main() {
         workspaceFiles,
         mainFileName
       );
+      const syncPlotOpts = plotPort !== void 0 ? { port: plotPort, host: "0.0.0.0" } : void 0;
       if (result.plotInstructions.length > 0 && plot) {
-        const plotServer = await startPlotServer();
+        const plotServer = await startPlotServer(syncPlotOpts);
         plotServer.sendInstructions(result.plotInstructions);
         plotServer.scriptDone();
         await plotServer.closed;
       }
     } else {
-      const { onDrawnow, flushAndWait } = createPlotHandler(!plot);
+      const asyncPlotOpts = plotPort !== void 0 ? { port: plotPort, host: "0.0.0.0" } : void 0;
+      const { onDrawnow, flushAndWait } = createPlotHandler(
+        !plot,
+        asyncPlotOpts
+      );
       const result = await executeCode(
         code,
         {
@@ -30975,7 +31121,7 @@ async function main() {
     process.exit(1);
   }
 }
-function createPlotHandler(disabled) {
+function createPlotHandler(disabled, plotOpts) {
   if (disabled) {
     return {
       onDrawnow: void 0,
@@ -30992,7 +31138,7 @@ function createPlotHandler(disabled) {
     } else {
       pendingBatches.push(instructions);
       if (!serverStarting) {
-        serverStarting = startPlotServer().then((ps) => {
+        serverStarting = startPlotServer(plotOpts).then((ps) => {
           plotServer = ps;
           for (const batch of pendingBatches) {
             ps.sendInstructions(batch);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",