nx

The nx namespace — 67 functions.

globals/nx/add

globals/nx/add(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] += x (x scalar) or b[i] += x[i] (x buffer). Dispatches on type(x). For interleaved-stride writes use nx.addStrided.

globals/nx/addStrided

globals/nx/addStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided add: buf[k * stride + offset] += scalar for every valid k.

globals/nx/addStridedFrom

globals/nx/addStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided BLAS-axpy from src into dst: dst[k * dst_stride + dst_off] += scale * src[k * src_stride + src_off].

globals/nx/applyAbs

globals/nx/applyAbs(b: NxBuffer) -> boolean

In-place b[i] = abs(b[i]).

globals/nx/applyCeil

globals/nx/applyCeil(b: NxBuffer) -> boolean

In-place b[i] = ceil(b[i]).

globals/nx/applyCos

globals/nx/applyCos(b: NxBuffer) -> boolean

In-place b[i] = cos(b[i]).

globals/nx/applyExp

globals/nx/applyExp(b: NxBuffer) -> boolean

In-place b[i] = exp(b[i]).

globals/nx/applyFloor

globals/nx/applyFloor(b: NxBuffer) -> boolean

In-place b[i] = floor(b[i]).

globals/nx/applyFract

globals/nx/applyFract(b: NxBuffer) -> boolean

In-place b[i] = fract(b[i]) (fractional part).

globals/nx/applyLog

globals/nx/applyLog(b: NxBuffer) -> boolean

In-place b[i] = ln(b[i]).

globals/nx/applyLog2

globals/nx/applyLog2(b: NxBuffer) -> boolean

In-place b[i] = log2(b[i]).

globals/nx/applyNeg

globals/nx/applyNeg(b: NxBuffer) -> boolean

In-place b[i] = -b[i].

globals/nx/applyRecip

globals/nx/applyRecip(b: NxBuffer) -> boolean

In-place b[i] = 1 / b[i].

globals/nx/applyRecipSqrt

globals/nx/applyRecipSqrt(b: NxBuffer) -> boolean

In-place b[i] = 1 / sqrt(b[i]).

globals/nx/applyRound

globals/nx/applyRound(b: NxBuffer) -> boolean

In-place b[i] = round(b[i]).

globals/nx/applySign

globals/nx/applySign(b: NxBuffer) -> boolean

In-place b[i] = sign(b[i]) (returns -1, 0, or +1).

globals/nx/applySin

globals/nx/applySin(b: NxBuffer) -> boolean

In-place b[i] = sin(b[i]).

globals/nx/applySqrt

globals/nx/applySqrt(b: NxBuffer) -> boolean

In-place b[i] = sqrt(b[i]).

globals/nx/applySquare

globals/nx/applySquare(b: NxBuffer) -> boolean

In-place b[i] = b[i] * b[i].

globals/nx/applyTan

globals/nx/applyTan(b: NxBuffer) -> boolean

In-place b[i] = tan(b[i]).

globals/nx/applyTrunc

globals/nx/applyTrunc(b: NxBuffer) -> boolean

In-place b[i] = trunc(b[i]).

globals/nx/applyWindow

globals/nx/applyWindow(signal: NxBuffer, window: NxBuffer) -> boolean

Element-wise signal[i] *= window[i] in place. Operates over the shorter of the two — passing a longer window to window a shorter clip is intentional, not an error.

globals/nx/axpby

globals/nx/axpby(dst: NxBuffer, a: number, src: NxBuffer, b: number) -> boolean

BLAS axpby: dst[i] = a*dst[i] + b*src[i].

globals/nx/clamp

globals/nx/clamp(b: NxBuffer, min_v: number, max_v: number) -> boolean

In-place clamp: b[i] = clamp(b[i], min_v, max_v).

globals/nx/copy

globals/nx/copy(dst: NxBuffer, src: NxBuffer) -> boolean

Copy every record from src into dst (memcpy fast path).

globals/nx/copyStridedFrom

globals/nx/copyStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided copy from src into dst with optional scaling: dst[k * dst_stride + dst_off] = scale * src[k * src_stride + src_off].

globals/nx/create

globals/nx/create(type_: NxType, n: number) -> NxBuffer?

Allocate a CPU buffer of type × len records. Thin alias for substrate.createBuffer({type=type_, len=n, kind="cpu"}) — kept here so the public nx library is the canonical entry point and users never need to import buffer separately.

globals/nx/div

globals/nx/div(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] /= x (x scalar) or b[i] /= x[i] (x buffer).

globals/nx/dot

globals/nx/dot(a: NxBuffer, b: NxBuffer) -> number?

Reduction: dot product of two same-shaped buffers.

globals/nx/fft1d

globals/nx/fft1d(re: NxBuffer, im: NxBuffer, inverse: boolean?) -> boolean

In-place 1D FFT over parallel re / im CPU buffers. inverse=true runs the inverse transform scaled by 1/N (so ifft(fft(x)) ≈ x).

globals/nx/fft2d

globals/nx/fft2d(re: NxBuffer, im: NxBuffer, width: number, height: number, inverse: boolean?) -> boolean

In-place 2D FFT over row-major parallel re / im buffers of length width*height. inverse=true is scaled by 1 / (width * height).

globals/nx/fill

globals/nx/fill(b: NxBuffer, value: number?) -> boolean

Fill the buffer with value (default 0.0). Equivalent to the scalar form of nx.add against a zeroed buffer, but skips the type-dispatch.

globals/nx/fillRandomNormal

globals/nx/fillRandomNormal(b: NxBuffer, mean: number?, stddev: number?, seed: NxSeed) -> boolean

Fill the buffer with Gaussian samples (Box-Muller), with the given mean and standard deviation, using a splitmix-keyed PRNG.

globals/nx/fillRandomUniform

globals/nx/fillRandomUniform(b: NxBuffer, min_v: number?, max_v: number?, seed: NxSeed) -> boolean

Fill the buffer with uniform-random samples in [min, max), using a splitmix-keyed deterministic PRNG.

globals/nx/fillStrided

globals/nx/fillStrided(b: NxBuffer, value: number, stride: number, offset: number?) -> boolean

Strided fill: buf[k * stride + offset] = value for every valid k.

globals/nx/fromTable

globals/nx/fromTable(arr: { number }, type_: NxType?) -> NxBuffer?

Build a CPU buffer from a Lua table of numbers. The table is written through buf:write in a single FFI crossing — no per-element Lua loop. For large arrays, prefer one of the nx.* constructors + a kernel pass over building a Lua array first.

globals/nx/full

globals/nx/full(n: number, type_: NxType?, value: number?) -> NxBuffer?

Allocate a buffer of type × len records and fill with value.

globals/nx/ifft1d

globals/nx/ifft1d(re: NxBuffer, im: NxBuffer) -> boolean

Convenience: nx.fft1d(re, im, true).

globals/nx/ifft2d

globals/nx/ifft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> boolean

Convenience: nx.fft2d(re, im, w, h, true).

globals/nx/integratePosition

globals/nx/integratePosition(pos: NxBuffer, vel: NxBuffer, dt: number) -> boolean

Per-vec3: pos[i] += vel[i] * dt — semi-implicit Euler position integration. Both buffers must be vec3 (stride 3).

globals/nx/irfft1d

globals/nx/irfft1d(re: NxBuffer, im: NxBuffer) -> NxBuffer?

Real-output inverse 1D FFT. Input re / im are length N/2 + 1. Returns a fresh CPU f32 buffer of length 2 * (N/2 + 1 - 1) = N real samples.

globals/nx/irfft2d

globals/nx/irfft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> NxBuffer?

Real-output inverse 2D FFT. Input re / im are (width/2 + 1) * height row-major. Returns a fresh f32 buffer of length width * height.

globals/nx/lerpTo

globals/nx/lerpTo(dst: NxBuffer, src: NxBuffer, t: number) -> boolean

dst[i] += t * (src[i] - dst[i]) — element-wise lerp toward src by t.

globals/nx/max

globals/nx/max(b: NxBuffer) -> number?

Reduction: maximum of all elements.

globals/nx/maxOp

globals/nx/maxOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = max(b[i], x) (scalar) or b[i] = max(b[i], x[i]) (buffer).

globals/nx/mean

globals/nx/mean(b: NxBuffer) -> number?

Reduction: arithmetic mean of all elements.

globals/nx/min

globals/nx/min(b: NxBuffer) -> number?

Reduction: minimum of all elements.

globals/nx/minOp

globals/nx/minOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = min(b[i], x) (scalar) or b[i] = min(b[i], x[i]) (buffer).

globals/nx/mul

globals/nx/mul(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] *= x (x scalar) or b[i] *= x[i] (x buffer).

globals/nx/mulStrided

globals/nx/mulStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided multiply: buf[k * stride + offset] *= scalar for every valid k.

globals/nx/normL1

globals/nx/normL1(b: NxBuffer) -> number?

Reduction: L1 norm — sum(|b[i]|).

globals/nx/normL2

globals/nx/normL2(b: NxBuffer) -> number?

Reduction: L2 norm — sqrt(sum(b[i]^2)).

globals/nx/normalizeVec3

globals/nx/normalizeVec3(b: NxBuffer) -> boolean

Normalise each vec3 in-place. Vectors below 1e-8 are left untouched.

globals/nx/ones

globals/nx/ones(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 1.0.

globals/nx/pow

globals/nx/pow(b: NxBuffer, p: number) -> boolean

In-place b[i] = b[i] ^ p (scalar exponent).

globals/nx/quatFromYaw

globals/nx/quatFromYaw(dst: NxBuffer, yaw: NxBuffer) -> boolean

Per-quat: dst[i] = (0, sin(yaw[i]/2), 0, cos(yaw[i]/2)) — the pure-Y axis-angle quaternion for each yaw value. dst must be stride-4 (quat); yaw must be stride-1 (f32).

globals/nx/rfft1d

globals/nx/rfft1d(signal: NxBuffer?) -> (NxBuffer?, NxBuffer?)

Real-input forward 1D FFT. Allocates two new CPU f32 buffers of length N/2 + 1 holding the (re, im) parts of the Hermitian-symmetric spectrum (same convention as NumPy np.fft.rfft).

globals/nx/rfft2d

globals/nx/rfft2d(signal: NxBuffer, width: number, height: number) -> (NxBuffer?, NxBuffer?)

Real-input forward 2D FFT. Input signal is row-major width*height. Returns (re_buf, im_buf) of length (width/2 + 1) * height each (matches np.fft.rfft2 layout).

globals/nx/scale

globals/nx/scale(b: NxBuffer, s: number) -> boolean

In-place b[i] *= s.

globals/nx/sinCosTo

globals/nx/sinCosTo(src: NxBuffer, sin_dst: NxBuffer, cos_dst: NxBuffer) -> boolean

Compute sin_dst[i] = sin(src[i]) and cos_dst[i] = cos(src[i]) in one pass using cheaper paired-trig argument reduction.

globals/nx/sub

globals/nx/sub(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] -= x (x scalar) or b[i] -= x[i] (x buffer).

globals/nx/sum

globals/nx/sum(b: NxBuffer) -> number?

Reduction: sum of all elements.

globals/nx/wanderYaw

globals/nx/wanderYaw(args: NxWanderArgs) -> boolean

Fused per-entity wander step. Each entity's yaw[i] walks by a uniform random delta in [-yawDelta, +yawDelta], then pos[i] advances forward in the (sin yaw, cos yaw) direction by step. Optional rot quat output writes a pure-Y axis-angle rotation. Replaces the per-entity Luau loop pattern (~12 ms / 5000 in interpreter) with a single Rust pass (~0.2 ms / 5000). Buffer requirements: pos vec3 (stride 3), yaw f32 (stride 1), rot optional quat (stride 4). All counts should match (kernel walks min(count_i)).

globals/nx/window/blackman

globals/nx/window.blackman(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Blackman window (NumPy np.blackman convention).

globals/nx/window/hamming

globals/nx/window.hamming(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Hamming window (NumPy np.hamming convention).

globals/nx/window/hann

globals/nx/window.hann(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Hann window (NumPy np.hanning convention).

globals/nx/zeros

globals/nx/zeros(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 0.0.