numbl 0.1.2 → 0.1.3

package/dist-lib/numbl-core/fileIOAdapter.d.ts

@@ -5,6 +5,16 @@
  * Concrete implementations (e.g. NodeFileIOAdapter) are injected
  * from the CLI or other host environments via ExecOptions.fileIO.
  */
+/** Options extracted from a weboptions struct for websave/webread. */
+export interface WebOptions {
+    timeout?: number;
+    requestMethod?: string;
+    headerFields?: [string, string][];
+    username?: string;
+    password?: string;
+    keyName?: string;
+    keyValue?: string;
+}
 export interface FileIOAdapter {
     /** Open a file, returns an integer file identifier (fid). */
     fopen(filename: string, permission: string): number;
@@ -39,9 +49,9 @@ export interface FileIOAdapter {
     /** Create a directory (and parents). Returns true on success. Optional. */
     mkdir?(dirPath: string): boolean;
     /** Download a URL to a file. Optional. */
-    websave?(url: string, filename: string): void;
+    websave?(url: string, filename: string, options?: WebOptions): void;
     /** Fetch content from a URL and return as a string. Optional. */
-    webread?(url: string): string;
+    webread?(url: string, options?: WebOptions): string;
     /** Delete files matching a pattern (supports globs). Optional. */
     deleteFile?(pattern: string): void;
     /** Remove a directory. If recursive is true, remove contents first. Returns true on success. Optional. */

package/dist-lib/numbl-core/helpers/prng.d.ts

@@ -2,12 +2,15 @@
  * Seedable PRNG (xoshiro128**) for random number generation
  */
 import { RuntimeValue } from "../runtime/index.js";
+import { type FloatXArrayType } from "../runtime/types.js";
 export declare function setRngShuffle(): void;
 export declare function setRngSeed(seed: number): void;
 export declare function seedRng(seed: number): void;
 /** Return a random float in [0, 1) using seeded or unseeded PRNG */
 export declare function rngRandom(): number;
 export declare function boxMullerRandom(): number;
+/** Fill a typed array with normal random values (bulk polar method) */
+export declare function fillRandn(data: FloatXArrayType): void;
 /** Return the current RNG state as a struct {Type, Seed, State} */
 export declare function getRngStateStruct(): RuntimeValue;
 /** Restore RNG state from a struct previously returned by rng() */

package/dist-lib/numbl-core/interpreter/builtins/time-system.d.ts

@@ -2,4 +2,4 @@
  * Time and system builtins: tic, toc, clock, etime, warning, computer, version,
  * ismac, ispc, isunix.
  */
-export {};
+export declare function getTicTime(): number;

package/dist-lib/numbl-core/interpreter/builtins/types.d.ts

@@ -43,7 +43,6 @@ export declare function mkc(re: number, im: number): number | RuntimeComplexNumb
 export declare function makeTensor(data: InstanceType<typeof FloatXArray>, imag: InstanceType<typeof FloatXArray> | undefined, shape: number[]): RuntimeTensor;
 /** Type rule requiring two scalar numbers */
 export declare function binaryNumberOnly(argTypes: JitType[]): JitType[] | null;
-/** Apply a unary element-wise function with complex support */
 export declare function applyUnaryElemwise(v: RuntimeValue, realFn: (x: number) => number, complexFn: (re: number, im: number) => {
     re: number;
     im: number;

package/dist-lib/numbl-core/native/lapack-bridge.d.ts

@@ -375,8 +375,26 @@ export interface LapackBridge {
         WRe?: Float64Array;
         WIm?: Float64Array;
     };
+    /**
+     * Bulk fill normal random values using Marsaglia polar + xoshiro128**.
+     * State is mutated in-place. Spare is passed in/out to preserve pair caching.
+     */
+    fillRandn?(state: Uint32Array, n: number, spare: number, hasSpare: boolean): {
+        data: Float64Array;
+        spare: number;
+        hasSpare: boolean;
+    };
+    /**
+     * Unary element-wise math on a real Float64Array.
+     * op: 0=exp, 1=log, 2=log2, 3=log10, 4=sqrt, 5=abs, 6=floor, 7=ceil,
+     *     8=round, 9=trunc, 10=sin, 11=cos, 12=tan, 13=asin, 14=acos, 15=atan,
+     *     16=sinh, 17=cosh, 18=tanh, 19=sign
+     */
+    unaryElemwise?(arr: Float64Array, op: number): Float64Array;
     /** Element-wise binary op on real Float64Arrays. op: 0=add, 1=sub, 2=mul, 3=div */
     elemwise?(a: Float64Array, b: Float64Array, op: number): Float64Array;
+    /** Scalar-tensor element-wise op. scalarOnLeft: true → scalar op arr[i], false → arr[i] op scalar */
+    elemwiseScalar?(scalar: number, arr: Float64Array, op: number, scalarOnLeft: boolean): Float64Array;
     /** Element-wise binary op on complex Float64Arrays. op: 0=add, 1=sub, 2=mul, 3=div */
     elemwiseComplex?(aRe: Float64Array, aIm: Float64Array | null, bRe: Float64Array, bIm: Float64Array | null, op: number): {
         re: Float64Array;

package/dist-lib/numbl-core/version.d.ts

@@ -1,2 +1,2 @@
 /** Numbl version, used for JIT disk cache invalidation. */
-export declare const NUMBL_VERSION = "0.1.2";
+export declare const NUMBL_VERSION = "0.1.3";

package/native/elemwise.cpp

@@ -5,6 +5,11 @@
  *   elemwise(a: Float64Array, b: Float64Array, op: number): Float64Array
  *     op: 0=add, 1=sub, 2=mul, 3=div
  *
+ *   elemwiseScalar(scalar: number, arr: Float64Array, op: number, scalarOnLeft: boolean): Float64Array
+ *     op: 0=add, 1=sub, 2=mul, 3=div
+ *     scalarOnLeft=true:  result[i] = scalar op arr[i]
+ *     scalarOnLeft=false: result[i] = arr[i] op scalar
+ *
  * Complex:
  *   elemwiseComplex(aRe: Float64Array, aIm: Float64Array,
  *                   bRe: Float64Array, bIm: Float64Array,
@@ -166,3 +171,56 @@ Napi::Value ElemwiseComplex(const Napi::CallbackInfo& info) {
   }
   return result;
 }
+
+// ── elemwiseScalar() — scalar-tensor element-wise binary op ────────────────
+
+Napi::Value ElemwiseScalar(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4
+      || !info[0].IsNumber()
+      || !info[1].IsTypedArray()
+      || !info[2].IsNumber()
+      || !info[3].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "elemwiseScalar: expected (number scalar, Float64Array arr, number op, boolean scalarOnLeft)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  double scalar = info[0].As<Napi::Number>().DoubleValue();
+  auto arr = info[1].As<Napi::Float64Array>();
+  int op = info[2].As<Napi::Number>().Int32Value();
+  bool scalarOnLeft = info[3].As<Napi::Boolean>().Value();
+
+  size_t n = arr.ElementLength();
+  auto result = Napi::Float64Array::New(env, n);
+  const double* a = arr.Data();
+  double* out = result.Data();
+
+  if (scalarOnLeft) {
+    switch (op) {
+      case 0: for (size_t i = 0; i < n; i++) out[i] = scalar + a[i]; break;
+      case 1: for (size_t i = 0; i < n; i++) out[i] = scalar - a[i]; break;
+      case 2: for (size_t i = 0; i < n; i++) out[i] = scalar * a[i]; break;
+      case 3: for (size_t i = 0; i < n; i++) out[i] = scalar / a[i]; break;
+      default:
+        Napi::RangeError::New(env, "elemwiseScalar: op must be 0-3")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+  } else {
+    switch (op) {
+      case 0: for (size_t i = 0; i < n; i++) out[i] = a[i] + scalar; break;
+      case 1: for (size_t i = 0; i < n; i++) out[i] = a[i] - scalar; break;
+      case 2: for (size_t i = 0; i < n; i++) out[i] = a[i] * scalar; break;
+      case 3: for (size_t i = 0; i < n; i++) out[i] = a[i] / scalar; break;
+      default:
+        Napi::RangeError::New(env, "elemwiseScalar: op must be 0-3")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+  }
+
+  return result;
+}

package/native/numbl_addon.cpp

@@ -93,8 +93,14 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
               Napi::Function::New(env, FftAlongDim));
   exports.Set(Napi::String::New(env, "elemwise"),
               Napi::Function::New(env, Elemwise));
+  exports.Set(Napi::String::New(env, "elemwiseScalar"),
+              Napi::Function::New(env, ElemwiseScalar));
   exports.Set(Napi::String::New(env, "elemwiseComplex"),
               Napi::Function::New(env, ElemwiseComplex));
+  exports.Set(Napi::String::New(env, "fillRandn"),
+              Napi::Function::New(env, FillRandn));
+  exports.Set(Napi::String::New(env, "unaryElemwise"),
+              Napi::Function::New(env, UnaryElemwise));
   return exports;
 }
 

package/native/numbl_addon_common.h

@@ -282,4 +282,7 @@ Napi::Value Fft1d(const Napi::CallbackInfo& info);
 Napi::Value Fft1dComplex(const Napi::CallbackInfo& info);
 Napi::Value FftAlongDim(const Napi::CallbackInfo& info);
 Napi::Value Elemwise(const Napi::CallbackInfo& info);
+Napi::Value ElemwiseScalar(const Napi::CallbackInfo& info);
 Napi::Value ElemwiseComplex(const Napi::CallbackInfo& info);
+Napi::Value FillRandn(const Napi::CallbackInfo& info);
+Napi::Value UnaryElemwise(const Napi::CallbackInfo& info);

package/native/randn.cpp

@@ -0,0 +1,101 @@
+/**
+ * Native bulk fill for randn (Marsaglia polar method + xoshiro128**).
+ *
+ * fillRandn(state: Uint32Array(4), n: number, spare: number, hasSpare: boolean)
+ *   → { data: Float64Array, spare: number, hasSpare: boolean }
+ *
+ * The xoshiro128** state is mutated in-place through the Uint32Array.
+ * The caller passes in any cached Box-Muller spare and gets the updated spare back.
+ */
+
+#include "numbl_addon_common.h"
+#include <cmath>
+
+// Inline xoshiro128** — returns a uint32 and advances state in place.
+static inline uint32_t xoshiro128ss(uint32_t* s) {
+  uint32_t tmp = s[1] * 5;
+  uint32_t result = ((tmp << 7) | (tmp >> 25)) * 9;
+  uint32_t t = s[1] << 9;
+  s[2] ^= s[0];
+  s[3] ^= s[1];
+  s[1] ^= s[2];
+  s[0] ^= s[3];
+  s[2] ^= t;
+  s[3] = (s[3] << 11) | (s[3] >> 21);
+  return result;
+}
+
+static inline double rngUniform(uint32_t* s) {
+  return static_cast<double>(xoshiro128ss(s)) / 4294967296.0;
+}
+
+Napi::Value FillRandn(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 4
+      || !info[0].IsTypedArray()
+      || !info[1].IsNumber()
+      || !info[2].IsNumber()
+      || !info[3].IsBoolean()) {
+    Napi::TypeError::New(env,
+      "fillRandn: expected (Uint32Array state, number n, number spare, boolean hasSpare)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto stateArr = info[0].As<Napi::Uint32Array>();
+  int n = info[1].As<Napi::Number>().Int32Value();
+  double spare = info[2].As<Napi::Number>().DoubleValue();
+  bool hasSpare = info[3].As<Napi::Boolean>().Value();
+
+  if (stateArr.ElementLength() < 4) {
+    Napi::RangeError::New(env, "fillRandn: state must have 4 elements")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  uint32_t* state = stateArr.Data();
+  auto result = Napi::Float64Array::New(env, static_cast<size_t>(n));
+  double* out = result.Data();
+
+  int i = 0;
+
+  // Drain cached spare
+  if (hasSpare && i < n) {
+    out[i++] = spare;
+    hasSpare = false;
+  }
+
+  // Generate pairs via Marsaglia polar method
+  for (; i + 1 < n; i += 2) {
+    double u, v, s;
+    do {
+      u = 2.0 * rngUniform(state) - 1.0;
+      v = 2.0 * rngUniform(state) - 1.0;
+      s = u * u + v * v;
+    } while (s >= 1.0 || s == 0.0);
+    double mul = std::sqrt((-2.0 * std::log(s)) / s);
+    out[i] = u * mul;
+    out[i + 1] = v * mul;
+  }
+
+  // Handle odd trailing element
+  if (i < n) {
+    double u, v, s;
+    do {
+      u = 2.0 * rngUniform(state) - 1.0;
+      v = 2.0 * rngUniform(state) - 1.0;
+      s = u * u + v * v;
+    } while (s >= 1.0 || s == 0.0);
+    double mul = std::sqrt((-2.0 * std::log(s)) / s);
+    out[i] = u * mul;
+    spare = v * mul;
+    hasSpare = true;
+  }
+
+  auto obj = Napi::Object::New(env);
+  obj.Set("data", result);
+  obj.Set("spare", Napi::Number::New(env, spare));
+  obj.Set("hasSpare", Napi::Boolean::New(env, hasSpare));
+  return obj;
+}

package/native/unary_elemwise.cpp

@@ -0,0 +1,67 @@
+/**
+ * Native unary element-wise math operations on Float64Arrays.
+ *
+ *   unaryElemwise(arr: Float64Array, op: number): Float64Array
+ *     op codes:
+ *       0=exp, 1=log, 2=log2, 3=log10,
+ *       4=sqrt, 5=abs, 6=floor, 7=ceil, 8=round, 9=trunc (fix),
+ *       10=sin, 11=cos, 12=tan, 13=asin, 14=acos, 15=atan,
+ *       16=sinh, 17=cosh, 18=tanh, 19=sign
+ */
+
+#include "numbl_addon_common.h"
+#include <cmath>
+
+Napi::Value UnaryElemwise(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 2
+      || !info[0].IsTypedArray()
+      || !info[1].IsNumber()) {
+    Napi::TypeError::New(env,
+      "unaryElemwise: expected (Float64Array arr, number op)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  auto arr = info[0].As<Napi::Float64Array>();
+  int op = info[1].As<Napi::Number>().Int32Value();
+
+  size_t n = arr.ElementLength();
+  auto result = Napi::Float64Array::New(env, n);
+  const double* a = arr.Data();
+  double* out = result.Data();
+
+  switch (op) {
+    case 0:  for (size_t i = 0; i < n; i++) out[i] = std::exp(a[i]);   break;
+    case 1:  for (size_t i = 0; i < n; i++) out[i] = std::log(a[i]);   break;
+    case 2:  for (size_t i = 0; i < n; i++) out[i] = std::log2(a[i]);  break;
+    case 3:  for (size_t i = 0; i < n; i++) out[i] = std::log10(a[i]); break;
+    case 4:  for (size_t i = 0; i < n; i++) out[i] = std::sqrt(a[i]);  break;
+    case 5:  for (size_t i = 0; i < n; i++) out[i] = std::abs(a[i]);   break;
+    case 6:  for (size_t i = 0; i < n; i++) out[i] = std::floor(a[i]); break;
+    case 7:  for (size_t i = 0; i < n; i++) out[i] = std::ceil(a[i]);  break;
+    case 8:  for (size_t i = 0; i < n; i++) out[i] = std::round(a[i]); break;
+    case 9:  for (size_t i = 0; i < n; i++) out[i] = std::trunc(a[i]); break;
+    case 10: for (size_t i = 0; i < n; i++) out[i] = std::sin(a[i]);   break;
+    case 11: for (size_t i = 0; i < n; i++) out[i] = std::cos(a[i]);   break;
+    case 12: for (size_t i = 0; i < n; i++) out[i] = std::tan(a[i]);   break;
+    case 13: for (size_t i = 0; i < n; i++) out[i] = std::asin(a[i]);  break;
+    case 14: for (size_t i = 0; i < n; i++) out[i] = std::acos(a[i]);  break;
+    case 15: for (size_t i = 0; i < n; i++) out[i] = std::atan(a[i]);  break;
+    case 16: for (size_t i = 0; i < n; i++) out[i] = std::sinh(a[i]);  break;
+    case 17: for (size_t i = 0; i < n; i++) out[i] = std::cosh(a[i]);  break;
+    case 18: for (size_t i = 0; i < n; i++) out[i] = std::tanh(a[i]);  break;
+    case 19:
+      for (size_t i = 0; i < n; i++) {
+        out[i] = (a[i] > 0.0) ? 1.0 : (a[i] < 0.0) ? -1.0 : 0.0;
+      }
+      break;
+    default:
+      Napi::RangeError::New(env, "unaryElemwise: unknown op code")
+          .ThrowAsJavaScriptException();
+      return env.Null();
+  }
+
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -71,7 +71,9 @@
     "fflate": "^0.8.2",
     "node-addon-api": "^8.3.0",
     "pako": "^2.1.0",
+    "react-markdown": "^10.1.0",
     "react-syntax-highlighter": "^16.1.1",
+    "remark-gfm": "^4.0.1",
     "three": "^0.183.2"
   },
   "devDependencies": {