npm - numbl - Versions diffs - 0.2.0 → 0.3.3 - Mend

numbl 0.2.0 → 0.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (127) hide show

package/dist-plot-viewer/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>numbl - Figures</title>
-    <script type="module" crossorigin src="/assets/index-GiUNnMQg.js"></script>
+    <script type="module" crossorigin src="/assets/index-COAM8o1E.js"></script>
   </head>
   <body style="margin: 0; overflow: hidden">
     <div id="root"></div>

package/native/lapack_linsolve.cpp CHANGED Viewed

@@ -9,7 +9,7 @@
  *                   BRe: Float64Array, BIm: Float64Array, nrhs: number): {re, im}
  *
  *   A is m×n in column-major order; B is m×nrhs.
- *   Returns X (n×nrhs) in a new Float64Array in column-major order.
+ *   Returns X (n×nrhs) in a allocFloat64Array in column-major order.
  *
  *   Square (m == n):
  *     Uses dgesv / zgesv (LU with partial pivoting).  Throws if A is singular.

package/native/numbl_addon.cpp CHANGED Viewed

@@ -22,9 +22,11 @@
 #include "numbl_addon_common.h"
 #include <cstdlib>
+#ifndef __APPLE__
 extern "C" {
   void openblas_set_num_threads(int num_threads);
 }
+#endif
 // ── Addon version ────────────────────────────────────────────────────────────
 // Bump this integer whenever the addon's API changes (new functions, signature
@@ -58,9 +60,16 @@ static Napi::Value AddonVersion(const Napi::CallbackInfo& info) {
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
   // Use single-threaded BLAS unless the user explicitly set the env var.
   // Multi-threaded BLAS adds overhead for the many small matmuls in numbl.
+#ifdef __APPLE__
+  // Accelerate reads VECLIB_MAXIMUM_THREADS from the environment on first use.
+  if (!std::getenv("VECLIB_MAXIMUM_THREADS")) {
+    setenv("VECLIB_MAXIMUM_THREADS", "1", 0);
+  }
+#else
   if (!std::getenv("OPENBLAS_NUM_THREADS")) {
     openblas_set_num_threads(1);
   }
+#endif
   exports.Set(Napi::String::New(env, "addonVersion"),
               Napi::Function::New(env, AddonVersion));
   exports.Set(Napi::String::New(env, "inv"),

package/native/numbl_addon_common.h CHANGED Viewed

@@ -227,14 +227,14 @@ inline std::vector<lapack_complex_double> splitToInterleaved(
   return out;
 }
-// Create a new Float64Array from a std::vector<double>.
+// Create a allocFloat64Array from a std::vector<double>.
 inline Napi::Float64Array vecToF64(Napi::Env env, const std::vector<double>& v) {
   auto arr = Napi::Float64Array::New(env, v.size());
   std::memcpy(arr.Data(), v.data(), v.size() * sizeof(double));
   return arr;
 }
-// Create a new Float64Array from raw pointer + count.
+// Create a allocFloat64Array from raw pointer + count.
 inline Napi::Float64Array ptrToF64(Napi::Env env, const double* data, size_t n) {
   auto arr = Napi::Float64Array::New(env, n);
   std::memcpy(arr.Data(), data, n * sizeof(double));

package/native/ops/comparison.c CHANGED Viewed

@@ -1,6 +1,6 @@
 /**
  * Real + complex comparison ops.  Output is a logical tensor stored as
- * 0.0 / 1.0 in a double buffer (numbl stores logicals as FloatXArray with
+ * 0.0 / 1.0 in a double buffer (numbl stores logicals as Float64Array with
  * an _isLogical flag on the runtime tensor).
  *
  * Caller-allocated input/output buffers; never copies.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "numbl",
-  "version": "0.2.0",
+  "version": "0.3.3",
   "description": "Run .m source files in the browser and on the command line by compiling to JavaScript",
   "license": "Apache-2.0",
   "type": "module",
@@ -45,7 +45,7 @@
     "copy:test-scripts": "tsx scripts/copy-test-scripts.ts",
     "bundle:stdlib": "tsx scripts/bundle-stdlib.ts",
     "build:web": "npm run bundle:stdlib && tsc -b && vite build",
-    "build:lib": "npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=neutral --format=esm --outfile=dist-lib/lib.js --loader:.wasm=file && tsc -p tsconfig.lib.json",
+    "build:lib": "npm run bundle:stdlib && esbuild src/lib.ts --bundle --platform=node --format=esm --outfile=dist-lib/lib.js --packages=external --loader:.wasm=file && tsc -p tsconfig.lib.json",
     "build:cli": "npm run bundle:stdlib && esbuild src/cli.ts --bundle --platform=node --format=esm --outfile=dist-cli/cli.js --packages=external --loader:.wasm=file",
     "install": "true",
     "build:addon": "node-gyp rebuild",
@@ -54,16 +54,11 @@
     "lint": "eslint .",
     "typecheck": "tsc -b",
     "preview": "vite preview",
-    "test": "npm run test:float64",
-    "test:float32": "NUMBL_USE_FLOAT32=true vitest run",
-    "test:float64": "NUMBL_USE_FLOAT32=false vitest run",
+    "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:coverage:all": "bash scripts/coverage-all.sh",
     "test:scripts": "bash numbl_test_scripts/run_all.sh",
     "test:browser": "playwright test",
-    "test:scripts:c-jit": "bash numbl_test_scripts/run_c_jit.sh",
-    "test:scripts:c-jit-fuse": "bash numbl_test_scripts/run_c_jit_fuse.sh",
-    "test:scripts:c-jit-parity": "bash numbl_test_scripts/run_c_jit_parity.sh",
     "build:wasm": "bash numbl_test_scripts/build_wasm.sh",
     "update-readme": "tsx scripts/update-readme-usage.ts",
     "check-readme": "tsx scripts/update-readme-usage.ts --check",

package/dist-lib/numbl-core/jit/c/abi.d.ts DELETED Viewed

@@ -1,90 +0,0 @@
-/**
- * The native ABI as an explicit slot schema — one source of truth shared
- * between the C-signature builder (assemble.ts) and the JS wrapper
- * marshaller (install.ts).
- *
- * Each `AbiSlot` carries everything either side needs: the C type for
- * the signature, the koffi type string (with `_Out_` prefix for
- * out-pointers), the identifier name in the emitted C, and a backref
- * (paramIdx / outputIdx) so the JS wrapper can locate the source value
- * or output buffer without reconstructing the param-to-slot mapping
- * itself.
- *
- * Adding a new ABI shape = add a slot kind here, emit it in
- * `buildAbiSlots`, and handle it in the JS marshaller.
- */
-import type { ClassificationResult } from "./classify.js";
-export type AbiSlotKind = "scalar" | "complexScalarRe" | "complexScalarIm" | "tensorData"
-/** Imaginary data pointer for a complex tensor param. Paired with
- *  `tensorData`. Marshaller passes the RuntimeTensor's `.imag` (a
- *  Float64Array) or NULL when `.imag === undefined`; the numbl_ops
- *  complex kernels treat NULL imag as all-zero. */
- | "tensorDataIm" | "tensorLen" | "tensorD0" | "tensorD1" | "scalarOut" | "complexScalarReOut" | "complexScalarImOut" | "fixedOutBuf"
-/** Imaginary fixed-output buffer (complex tensor output, non-dynamic). */
- | "fixedOutBufIm" | "fixedOutLen" | "dynOutBuf"
-/** Imaginary buffer pointer for a dynamic complex tensor output. C
- *  mallocs, transfers ownership via `double **`; wrapper decodes+copies
- *  into a fresh Float64Array then frees. */
- | "dynOutBufIm" | "dynOutLen" | "dynOutD0" | "dynOutD1" | "ticState" | "errFlag"
-/** Callback for `disp(...)` — JS-registered function pointer. The C
- *  body invokes it directly; the JS wrapper supplies a koffi-registered
- *  pointer that routes into `rt.output`. Signature:
- *    void __disp_cb(const char *s, double num, int kind)
- *  kind=0 => use `s`, kind=1 => use `num`. */
- | "dispCb";
-export interface AbiSlot {
-    kind: AbiSlotKind;
-    /** C type string for the signature, e.g. "double", "const double *",
-     *  "double **". */
-    cType: string;
-    /** Identifier as it appears in the C signature. */
-    cName: string;
-    /** koffi type string, with `_Out_` prefix where koffi must treat the
-     *  pointer as an out-param. */
-    koffiType: string;
-    /** Index into paramDescs, for "scalar" / "tensor*" kinds. */
-    paramIdx?: number;
-    /** Index into outputDescs, for output-allocated kinds. */
-    outputIdx?: number;
-}
-export interface CParamDesc {
-    name: string;
-    kind: "scalar" | "complexScalar" | "tensor";
-    /** For tensor params: max indexing arity the body uses (1, 2, or 3).
-     *  Drives the extra `_d0` / `_d1` shape args the JS wrapper must
-     *  marshal. `undefined` means the tensor is only used in whole-tensor
-     *  ops (legacy data/len ABI). */
-    ndim?: number;
-    /** True for complex tensor params. Adds an imag-data slot right after
-     *  the real-data slot; the marshaller supplies the tensor's `.imag`
-     *  Float64Array or NULL. Ignored for scalar kinds. */
-    isComplex?: boolean;
-    /** Ordered slots this param contributes to the ABI. One slot for a
-     *  scalar; two for a complex scalar (re + im); two or more
-     *  (data + [imag for complex] + len + optional d0/d1) for a tensor. */
-    slots: AbiSlot[];
-}
-/** Per-output descriptor. Tells the JS wrapper how to marshal outputs. */
-export interface COutputDesc {
-    name: string;
-    kind: "scalar" | "boolean" | "complexScalar" | "tensor";
-    /** True for tensor outputs using the dynamic-output ABI: the C code
-     *  malloc's the buffer and transfers ownership via `double **` and
-     *  extra d0/d1 out-slots. The JS wrapper decodes the pointer, copies
-     *  into a fresh Float64Array, and frees the C allocation. */
-    dynamic?: boolean;
-    /** True for complex tensor outputs. Fixed outputs add a paired imag
-     *  Float64Array buffer; dynamic outputs add a paired imag `double **`
-     *  out-pointer the caller decodes + frees after the call. */
-    isComplex?: boolean;
-    /** Ordered slots this output contributes to the ABI. One for scalars,
-     *  two for complex scalars (reOut + imOut), two for fixed real tensor
-     *  outputs (buf + lenOut), three for fixed complex (buf + bufIm +
-     *  lenOut), four for dynamic real tensor outputs, five for dynamic
-     *  complex (dynBuf + dynBufIm + dynLen + dynD0 + dynD1). */
-    slots: AbiSlot[];
-}
-/** Build the ABI schema for one generated function. Mutates paramDescs /
- *  outputDescs in place by filling in `slots`; returns the complete
- *  `abiSlots` array in calling order (params, then outputs, then trailers). */
-export declare function buildAbiSlots(paramDescs: CParamDesc[], outputDescs: COutputDesc[], cls: ClassificationResult, paramOutputTensors: Set<string>, unshareTensorParams: Set<string>, needsTicState: boolean, needsErrorFlag: boolean, needsDispCb: boolean): AbiSlot[];

package/dist-lib/numbl-core/jit/c/assemble.d.ts DELETED Viewed

@@ -1,56 +0,0 @@
-/**
- * JIT IR → pure C code generation (koffi path).
- *
- * Orchestration only: this file wires the classify / ABI / emit pieces
- * together and assembles the final C source (headers + per-callee
- * static functions + outer function).
- *
- *   classify.ts     — TensorMeta / analyzeTensorUsage, the single pass
- *                     feeding every downstream decision.
- *   abi.ts          — AbiSlot / CParamDesc / COutputDesc, buildAbiSlots.
- *                     The one schema walked by both signature and JS.
- *   emit/           — per-statement / per-expression C emission, split
- *                     by concern (scalar, complexScalar, tensor, assign,
- *                     userCall, stmt, fused). Reads ctx.cls for every
- *                     classification decision.
- *   context.ts   — EmitCtx + shared name/opcode helpers.
- *
- * UserCall support: when a feasible user-defined function is called
- * from the outer body, its lowered IR is already in `generatedIRBodies`
- * (populated by `lowerUserFuncCall` in jitLower.ts). We emit each
- * reachable callee as a `static void jit_<jitName>(...)` in the same
- * .c file, in post-order so callees are defined before callers. The
- * shared `__err_flag` pointer flows from outer to every callee.
- */
-import { type JitStmt, type JitType } from "../jitTypes.js";
-import type { GeneratedFn } from "../jitLower.js";
-import { type AbiSlot, type CParamDesc, type COutputDesc } from "./abi.js";
-export type { AbiSlot, AbiSlotKind } from "./abi.js";
-export type { CParamDesc, COutputDesc } from "./abi.js";
-export { mangle, mangleIm, tensorData, tensorDataIm, tensorLen, tensorD0, tensorD1, formatNumberLiteral, C_SCALAR_TARGET, } from "./context.js";
-export interface GenerateCResult {
-    cSource: string;
-    cFnName: string;
-    paramDescs: CParamDesc[];
-    outputDescs: COutputDesc[];
-    /** The full ABI slot list in calling order:
-     *    paramDescs[0].slots ++ paramDescs[1].slots ++ ...
-     *    ++ outputDescs[0].slots ++ ... ++ trailer slots (ticState/errFlag).
-     *  The JS wrapper walks this list to marshal values. */
-    abiSlots: AbiSlot[];
-    /** True when any tensor is involved (params, locals, or outputs). */
-    usesTensors: boolean;
-    /** koffi function signature string for declaring the C function. */
-    koffiSignature: string;
-    /** True when tic/toc are used — the function has an extra `double*` param. */
-    needsTicState: boolean;
-    /** True when any Index read was emitted — the function has an extra
-     *  `double *__err_flag` trailing param. */
-    needsErrorFlag: boolean;
-    /** True when a `disp(...)` call was emitted — the function has an
-     *  extra `void (*__disp_cb)(const char *, double, int)` trailing
-     *  param. The JS wrapper registers a callback that routes back to
-     *  `rt.output`. */
-    needsDispCb: boolean;
-}
-export declare function generateC(body: JitStmt[], params: string[], outputs: string[], nargout: number, localVars: Set<string>, argTypes: JitType[], _outputType: JitType | null, outputTypes: JitType[], fnName: string, fuse?: boolean, openmp?: boolean, generatedIRBodies?: Map<string, GeneratedFn>): GenerateCResult;

package/dist-lib/numbl-core/jit/c/classify.d.ts DELETED Viewed

@@ -1,70 +0,0 @@
-/**
- * C-JIT: unified classification pass for tensor names.
- *
- * Replaces the ten ad-hoc sets/maps (`tensorVars`, `paramTensorNames`,
- * `outputTensorNames`, `localTensorNames`, `assignIndexTargets`,
- * `unshareTensorParams`, `tensorMaxDim`, `freshAllocTensors`,
- * `dynamicOutputs`, `paramOutputTensors`) that the codegen used to
- * build from 7+ body walks. Everything downstream — signature builder,
- * prelude, epilogue, emit helpers, fusion call — now reads from the
- * `TensorMeta` table this pass produces.
- */
-import type { JitExpr, JitStmt, JitType } from "../jitTypes.js";
-export type TensorKind =
-/** Tensor param, never appears in the output list. */
-"param"
-/** Tensor param whose name is also in the output list. */
- | "paramOutput"
-/** Pure tensor output (not a param). */
- | "output"
-/** Tensor local (neither param nor output). */
- | "local";
-export interface TensorMeta {
-    kind: TensorKind;
-    /** Max index arity on this name (1/2/3). 0 means the name is never
-     *  used as an Index or AssignIndex base. */
-    maxIndexDim: number;
-    /** True when any `Assign(name, RHS)` has RHS ∈ {TensorLiteral,
-     *  VConcatGrow, Call(zeros|ones), Var(src) where src.hasFreshAlloc,
-     *  RangeSliceRead}. Propagated to fixed point. */
-    hasFreshAlloc: boolean;
-    /** True when any AssignIndex / AssignIndexRange / AssignIndexCol
-     *  uses this name as the base. */
-    isAssignIndexTarget: boolean;
-    /** Derived: `kind === "param"` and (`isAssignIndexTarget` or
-     *  `hasFreshAlloc`). Triggers the unshare-at-entry malloc+memcpy
-     *  prelude so writes don't leak to the caller's buffer. */
-    needsUnshare: boolean;
-    /** Derived: `hasFreshAlloc` and (`kind === "output"` or
-     *  `kind === "paramOutput"`). Triggers the `double **` dynamic-output
-     *  ABI. */
-    isDynamicOutput: boolean;
-    /** True when this tensor's `JitType.isComplex === true` — either at
-     *  the boundary (param / output type) or propagated from a complex
-     *  RHS for locals. Drives paired imag-buffer plumbing: every complex
-     *  tensor gets a `v_name_data_im` companion pointer, an extra ABI
-     *  slot for boundaries, and imag malloc / free / copy parallel to
-     *  the existing real path. */
-    isComplex: boolean;
-}
-export interface ClassificationResult {
-    /** All names with a tensor role, in insertion order (params first,
-     *  then outputs, then locals in body order). */
-    tensorNames: string[];
-    /** Per-name metadata. */
-    meta: Map<string, TensorMeta>;
-    /** True iff any name has `hasFreshAlloc`. Lets callers skip the
-     *  dynamic-output marshalling when no name uses it. */
-    hasAnyDynamic: boolean;
-    /** Name → is any tensor role. `meta.has(name)`. */
-    tensorVars: Set<string>;
-    /** Names with `kind === "param"` or `"paramOutput"`. */
-    paramTensorNames: Set<string>;
-    /** Names with `kind === "output"` or `"paramOutput"`. */
-    outputTensorNames: Set<string>;
-    /** Names with `kind === "local"`. */
-    localTensorNames: Set<string>;
-}
-/** Does this Assign RHS allocate a fresh C-owned buffer? */
-export declare function isFreshTensorRhs(expr: JitExpr): boolean;
-export declare function analyzeTensorUsage(body: JitStmt[], params: string[], argTypes: JitType[], outputNames: string[], outputTypes: JitType[]): ClassificationResult;

package/dist-lib/numbl-core/jit/c/compile.d.ts DELETED Viewed

@@ -1,37 +0,0 @@
-/**
- * C-JIT compilation driver (koffi path).
- *
- * Takes generated C source, compiles it into a `.so` shared library,
- * loads it via koffi, and returns the declared function.
- *
- * Strategy:
- *   1. Content-addressed cache under ~/.cache/numbl/c-jit/ — the hash
- *      includes the source bytes plus compiler/platform/numbl versions,
- *      so any input change forces a recompile.
- *   2. On cache miss, write `src.c` into a fresh tmpdir and shell out to
- *      the C compiler (`$NUMBL_CC` or `cc`) with `-shared -fPIC`.
- *   3. Load with koffi.load() and declare the function.
- *
- * No Node API headers are needed — functions are plain C with raw types.
- * No NAPI_MODULE_INIT, no module registration, no exit hooks.
- */
-export interface CompiledCFn {
-    fn: (...args: unknown[]) => unknown;
-    cachedPath: string;
-    /** The loaded koffi library handle, for declaring additional exports. */
-    lib: any;
-}
-/**
- * Compile + load a C function via koffi. Returns null on any failure.
- *
- * `koffiSignature` is the koffi type-string for the C function, e.g.:
- *   "void jit_fn(double, double *, int64_t, double *)"
- */
-export declare function compileAndLoad(cSource: string, koffiSignature: string, _cFnName: string, log?: (m: string) => void, extraFlags?: string[]): CompiledCFn | null;
-export declare function resetCEnvForTesting(): void;
-export declare function cJitUnavailableReason(): string | undefined;
-export declare function cJitCacheSize(): number;
-export declare function readCachedBuild(cachedPath: string): Buffer;
-/** True when the C compiler supports `-fopenmp` (thread-level parallelism).
- *  Triggers env discovery on first call so it can be used before compileAndLoad. */
-export declare function cJitOpenmpAvailable(log?: (m: string) => void): boolean;

package/dist-lib/numbl-core/jit/c/context.d.ts DELETED Viewed

@@ -1,152 +0,0 @@
-/**
- * Shared types, constants, and helpers used by both emit.ts (the per-
- * function emitter) and assemble.ts (the orchestration that builds
- * the final signature / prelude / epilogue).
- *
- * Contains no emit logic itself — pulling this out of the main file
- * breaks the otherwise-circular dependency between assemble.ts and
- * the emit helpers.
- */
-import { BinaryOperation } from "../../parser/types.js";
-import type { ScalarOpTarget } from "../scalarEmit.js";
-import type { ClassificationResult } from "./classify.js";
-import type { CParamDesc, COutputDesc } from "./abi.js";
-/** Per-callee ABI info the outer emitter uses to marshal its call sites.
- *  `emitUserCall` reads `paramDescs` to know what slots each param
- *  contributes (data + len + optional d0/d1 for tensors) and
- *  `outputDescs` to know whether the return uses the dynamic-output ABI. */
-export interface CalleeAbi {
-    paramDescs: CParamDesc[];
-    outputDescs: COutputDesc[];
-}
-/**
- * Minimum NUMBL_JIT_RT_VERSION the emitter needs at link time.
- *
- * Bump this in lockstep with NUMBL_JIT_RT_VERSION in
- * native/jit_runtime/jit_runtime.h whenever we add a helper the emitter
- * calls. The emitted C asserts `NUMBL_JIT_RT_VERSION >= N` so a stale
- * archive fails the per-JIT compile step with a clear message instead
- * of a cryptic linker "undefined reference" error.
- *
- * Version log:
- *   1 — initial: idx1r, mod, sign, reduce_flat, tic/toc/monotonic_time.
- *   2 — set1r_h (scalar linear Index write with soft-bail on OOB).
- *   3 — idx2r / idx3r / set2r_h / set3r_h (multi-index Index read/write).
- *   4 — setRange1r_h / setCol2r_h / copyRange1r (range/col slice r/w).
- *   5 — is_nan / is_inf / is_finite (predicates that survive -ffast-math
- *       by inspecting IEEE-754 bit patterns).
- */
-export declare const NUMBL_JIT_RT_REQUIRED_VERSION = 5;
-export declare function mangle(name: string): string;
-/** Imaginary part of a complex scalar local / param. Paired with
- *  `mangle(name)` (the real part). */
-export declare function mangleIm(name: string): string;
-/** Join a C type and an identifier with a space unless the type already
- *  ends in `*` (pointer types get no space between `*` and the name). */
-export declare function spaceBeforeName(cType: string): string;
-export declare const C_SCALAR_TARGET: ScalarOpTarget;
-export declare const TENSOR_BIN_OP: Partial<Record<BinaryOperation, string>>;
-export declare const TENSOR_COMPLEX_BIN_OP: Partial<Record<BinaryOperation, string>>;
-export declare const TENSOR_CMP_OP: Partial<Record<BinaryOperation, string>>;
-/**
- * Tensor-op dispatch helpers. Each reads `IBuiltin.jitCapabilities` for
- * the named builtin and returns the corresponding libnumbl_ops opcode
- * enum name / C function name — or `undefined` when the builtin has no
- * C-JIT tensor-op routing. These helpers are the single source of truth
- * for both the C feasibility check (feasibility.ts) and the C emitter
- * (emit.ts); registering a new tensor op is a single edit on the
- * IBuiltin, not three parallel table updates.
- */
-/** libnumbl_ops unary opcode enum name for a tensor-unary builtin. */
-export declare function getTensorUnaryOp(name: string): string | undefined;
-/** C function name for a 2-arg element-wise tensor binary builtin. */
-export declare function getTensorBinaryFn(name: string): string | undefined;
-/** libnumbl_ops reduce opcode enum name for a tensor-reduction builtin. */
-export declare function getTensorReductionOp(name: string): string | undefined;
-export declare function formatNumberLiteral(v: number): string;
-export declare function tensorData(name: string): string;
-/** Imaginary data pointer for a complex tensor. Pairs with
- *  `tensorData(name)` — both locals carry the same length and shape
- *  info. The kernels in numbl_ops accept NULL for the imag pointer as
- *  "all zero", so a nominally-complex tensor whose `.imag` is undefined
- *  can still be passed efficiently without allocating a zero buffer.
- *
- *  Uses the `__im_` prefix so a user variable `x_data_im` can't collide
- *  with the imag companion of `x`'s tensor data. */
-export declare function tensorDataIm(name: string): string;
-export declare function tensorLen(name: string): string;
-/** Row count (shape[0]) for a 2D/3D-indexed tensor param. Also reused
- *  as the mutable row-count local for fresh-alloc tensors (TensorLiteral/
- *  zeros/ones/VConcatGrow targets). */
-export declare function tensorD0(name: string): string;
-/** Column count. For 3D tensor params this is shape[1]; for fresh-alloc
- *  tensors it's shape[1] (i.e., the column count of a matrix or 1 for
- *  a column vector). */
-export declare function tensorD1(name: string): string;
-export interface EmitCtx {
-    /** Shared classification table: every tensor-name decision reads from
-     *  here (kind, maxIndexDim, hasFreshAlloc, needsUnshare,
-     *  isDynamicOutput, ...). See `classify.ts`. */
-    cls: ClassificationResult;
-    /** Counter for scratch buffer slots. Each tensor sub-expression that
-     *  doesn't have a top-level dest gets a scratch double* + int64_t pair. */
-    scratchCount: number;
-    /** Scratch indices whose tensor expression was complex — the prelude
-     *  declares a paired `__sN_data_im` for these, and epilogue frees both
-     *  buffers. Real scratches stay single-buffer. */
-    complexScratch: Set<number>;
-    /** Counter for for-loop step temps. */
-    tmp: {
-        n: number;
-    };
-    /** Set of scratch indices that were actually used. */
-    usedScratch: Set<number>;
-    /** When set, expression emission can prepend statements (e.g. for
-     *  reductions of complex tensor expressions that need scratch buffers). */
-    pendingStmts?: {
-        lines: string[];
-        indent: string;
-    };
-    /** Emit fused per-element loops for tensor chains (--fuse). */
-    fuse: boolean;
-    /** Set when tic or toc is used — triggers __tic_state parameter. */
-    needsTicState: boolean;
-    /** Set when any Index read is emitted — triggers __err_flag parameter
-     *  and the __numbl_idx1r helper. JS wrapper checks the flag after the
-     *  call and throws "Index exceeds array bounds" if set. */
-    needsErrorFlag: boolean;
-    /** Set when a `disp(...)` call is emitted — triggers the __disp_cb
-     *  trailer parameter. The JS wrapper registers a koffi callback that
-     *  routes back into `rt.output` with MATLAB-style formatting. */
-    needsDispCb: boolean;
-    /** Emit `#pragma omp parallel for` on fused non-reduction loops. */
-    openmp: boolean;
-    /** ABI of every reachable UserCall callee (keyed by `jitName`). Populated
-     *  by `generateC` as each callee is emitted, then handed to the outer
-     *  emitter so `emitUserCall` can walk the callee's paramDescs to marshal
-     *  tensor args (and decide scalar-vs-tensor return shape) at the call
-     *  site. Absent during tests that only emit a single function. */
-    calleeAbi?: Map<string, CalleeAbi>;
-    /** Names (params + locals + outputs) that hold `complex_or_number`
-     *  scalar values and thus have paired `v_name` / `v_name_im` locals. */
-    complexScalarVars: Set<string>;
-}
-export declare function isTensorVar(ctx: EmitCtx, name: string): boolean;
-export declare function isComplexTensorVar(ctx: EmitCtx, name: string): boolean;
-export declare function isComplexScalarVar(ctx: EmitCtx, name: string): boolean;
-export declare function hasFreshAlloc(ctx: EmitCtx, name: string): boolean;
-export declare function isDynamicOutput(ctx: EmitCtx, name: string): boolean;
-export declare function isLocalTensor(ctx: EmitCtx, name: string): boolean;
-export declare function isOutputTensor(ctx: EmitCtx, name: string): boolean;
-export declare function tensorMaxDim(ctx: EmitCtx, name: string): number;
-/** Allocate a scratch buffer pair (__s{n}_data, __s{n}_len). */
-export declare function allocScratch(ctx: EmitCtx): number;
-/** Allocate a complex scratch triple (__s{n}_data, __s{n}_data_im,
- *  __s{n}_len) — the emitter tags the index so the prelude declares
- *  and the epilogue frees the imag companion. */
-export declare function allocComplexScratch(ctx: EmitCtx): number;
-export declare function scratchData(n: number): string;
-/** Imaginary companion for a complex scratch buffer. Only declared in
- *  the prelude when the scratch index appears in ctx.complexScratch. */
-export declare function scratchDataIm(n: number): string;
-export declare function scratchLen(n: number): string;

package/dist-lib/numbl-core/jit/c/emit/assign.d.ts DELETED Viewed

@@ -1,20 +0,0 @@
-import { type JitExpr } from "../../jitTypes.js";
-import { type EmitCtx } from "../context.js";
-/** Complex-tensor Assign: parallels emitTensorAssign but writes paired
- *  re+im buffers. RHS sub-exprs route through emitComplexTensorExprToStmts
- *  / emitComplexTensorBinaryStmts. For a real RHS (e.g. a Var pointing
- *  to a real tensor), imag is widened via NULL pointer or a zero buffer.
- *
- *  Runs inside a pendingStmts frame so nested complex scalar sub-expressions
- *  (`1i`, `3+4i`, `re(z) + 1i*im(z)`, ...) can materialize their pair
- *  locals into the same `lines` stream ahead of the kernel call. */
-export declare function emitComplexTensorAssign(lines: string[], indent: string, destName: string, expr: JitExpr, ctx: EmitCtx): void;
-/** Emit a tensor-result Assign: handles Binary, Unary, Call on tensors. */
-export declare function emitTensorAssign(lines: string[], indent: string, destName: string, expr: JitExpr, ctx: EmitCtx): void;
-/** Emit an Assign where the RHS is a reduction on a tensor sub-
- *  expression (not just a Var) — e.g. `y = sum(x .* z)`. The tensor
- *  expression is materialised into a scratch buffer first, then the
- *  scalar reduction reads that buffer. */
-export declare function emitReductionOfTensorExpr(lines: string[], indent: string, destName: string, callExpr: JitExpr & {
-    tag: "Call";
-}, ctx: EmitCtx): void;

package/dist-lib/numbl-core/jit/c/emit/complexScalar.d.ts DELETED Viewed

@@ -1,18 +0,0 @@
-import type { JitExpr } from "../../jitTypes.js";
-import { type EmitCtx } from "../context.js";
-import { type ComplexPair } from "./helpers.js";
-/** Materialize a ComplexPair into two fresh `__cN_re` / `__cN_im` locals
- *  prepended to `ctx.pendingStmts.lines`. Used when the emitted formula
- *  would otherwise evaluate either sub-expression more than once (e.g.
- *  both Mul and Div reference each operand twice in the per-component
- *  formula). Returns references to the new locals. */
-export declare function materializeComplexPair(pair: ComplexPair, ctx: EmitCtx): ComplexPair;
-/** Emit a complex-valued scalar expression, returning (re, im) C
- *  expression strings. Call sites that need a pair (complex RHS, complex
- *  operand of a complex op, arg of real/imag/conj on complex) route
- *  through here. Real sub-expressions widen implicitly (im = 0). */
-export declare function emitComplex(expr: JitExpr, ctx: EmitCtx): ComplexPair;
-/** Emit a scalar sub-expression at a complex tensor op boundary. Returns
- *  a (re, im) pair of C expressions. Real scalars become (expr, "0.0");
- *  complex scalars go through emitComplex for their pair form. */
-export declare function emitComplexScalarPair(expr: JitExpr, ctx: EmitCtx): ComplexPair;

package/dist-lib/numbl-core/jit/c/emit/fused.d.ts DELETED Viewed

@@ -1,42 +0,0 @@
-/**
- * Fused per-element loop emission for the C-JIT.
- *
- * Given a FusibleChain (from fusion.ts), emits a single
- *   `for (int64_t __i = 0; __i < N; __i++) { ... }`
- * loop that evaluates all the chain's tensor assigns as inline scalar
- * expressions per element — no libnumbl_ops calls, no intermediate
- * buffers.
- *
- * Scalar expressions (number literals, scalar vars, scalar math calls)
- * pass through unchanged. Tensor var references become either:
- *   - `v_name_data[__i]`  for input params / pre-existing tensors
- *   - `__f_name`           for chain-produced intermediates (scalar local)
- *
- * The optional trailing reduction is absorbed as an inline accumulator
- * (`__f_acc += expr`) inside the same loop, eliminating the need to
- * materialise the tensor result at all when it is only consumed by the
- * reduction.
- */
-import type { FusibleChain } from "../../fusion.js";
-/**
- * Emit a fused per-element loop for the given chain.
- *
- * Appends C source lines to `lines`. All scalar math helpers the inner
- * body may reference (mod, sign, ...) live in jit_runtime.a, so this
- * function no longer reports back "helpers needed" — the emitter simply
- * calls them as library symbols.
- *
- * Dispatches to the real or complex per-element emitter based on whether
- * any assign in the chain produces a complex tensor. Both paths share
- * the outer shell (lenVar, writeBack, parallel-for decision, loop open);
- * only the buffer sizing, per-element emission, and write-back differ.
- *
- * `allTensorVars` is the full set of tensor-typed variable names.
- * `paramTensors` is the subset that are input parameters.
- * `outputTensorNames` is the subset that are function outputs.
- * `localTensorNames` is the subset that are non-param, non-output locals.
- * `complexTensorNames` is the subset whose tensor has a paired imag buffer.
- * `complexScalarVars` is the set of scalar vars that hold complex values
- * (pair-of-doubles `v_name` / `__im_v_name`).
- */
-export declare function emitFusedChain(lines: string[], indent: string, chain: FusibleChain, allTensorVars: ReadonlySet<string>, paramTensors: ReadonlySet<string>, outputTensorNames: ReadonlySet<string>, localTensorNames: ReadonlySet<string>, dynamicOutputNames: ReadonlySet<string>, complexTensorNames: ReadonlySet<string>, complexScalarVars: ReadonlySet<string>, openmp?: boolean): void;

package/dist-lib/numbl-core/jit/c/emit/helpers.d.ts DELETED Viewed

@@ -1,40 +0,0 @@
-/**
- * Small shared helpers used across the emit/ modules.
- *
- * These are one-liners and trivial utilities that don't belong in any
- * one topic file — keeping them here avoids either duplicating them
- * across topic files or inflating a topic file with unrelated detail.
- */
-import type { JitExpr } from "../../jitTypes.js";
-import type { TensorMeta } from "../classify.js";
-import type { EmitCtx } from "../context.js";
-export declare function isTensorExpr(expr: JitExpr): boolean;
-export declare function isComplexExpr(expr: JitExpr): boolean;
-/** Pair of C expressions holding the real and imaginary parts of a
- *  complex scalar value. Produced by `emitComplex`. */
-export interface ComplexPair {
-    re: string;
-    im: string;
-}
-/** Complex tensor expression result: data + dataIm + len in C. For a
- *  Var whose JitType is a real tensor, `dataIm` is the literal string
- *  `"NULL"` — the numbl_ops complex kernels treat that as "all zero",
- *  so a real tensor flowing into a complex op doesn't need a zero
- *  buffer. */
-export interface ComplexTensorResult {
-    data: string;
-    dataIm: string;
-    len: string;
-}
-/** Widen a real scalar C expression to a complex pair (im = 0). */
-export declare function widenRealToComplex(realCode: string): ComplexPair;
-/** Escape a JS string into a C string literal (double-quoted, with C
- *  escapes for backslash, double-quote, and common control chars;
- *  non-ASCII bytes encoded as `\xNN` octets of their UTF-8 encoding). */
-export declare function cStringLiteral(s: string): string;
-/** Resolve a tensor name's meta or throw — the tensor-creation emit
- *  helpers depend on the name being classified (with `hasFreshAlloc`)
- *  for the d0/d1 locals they write to actually exist at runtime.
- *  Failing loudly here beats emitting C that references undeclared
- *  identifiers. */
-export declare function requireFreshAllocMeta(ctx: EmitCtx, destName: string, site: string): TensorMeta;