deepbox 0.1.0

package/dist/chunk-F3JWBINJ.js

@@ -0,0 +1,1054 @@
+import { Tensor, arange, tensor } from './chunk-BCR7G3A6.js';
+import { __export, shapeToSize, InvalidParameterError, DTypeError, validateShape, isTypedArray, DeepboxError, getConfig, validateDevice, NotImplementedError } from './chunk-4S73VUBD.js';
+
+// src/random/index.ts
+var random_exports = {};
+__export(random_exports, {
+  beta: () => beta,
+  binomial: () => binomial,
+  choice: () => choice,
+  clearSeed: () => clearSeed,
+  exponential: () => exponential,
+  gamma: () => gamma,
+  getSeed: () => getSeed,
+  normal: () => normal,
+  permutation: () => permutation,
+  poisson: () => poisson,
+  rand: () => rand,
+  randint: () => randint,
+  randn: () => randn,
+  setSeed: () => setSeed,
+  shuffle: () => shuffle,
+  uniform: () => uniform
+});
+
+// src/random/random.ts
+var __globalSeed;
+var UINT64_MASK = (1n << 64n) - 1n;
+var PCG_MULT = 6364136223846793005n;
+var SPLITMIX_GAMMA = 0x9e3779b97f4a7c15n;
+var SPLITMIX_MIX1 = 0xbf58476d1ce4e5b9n;
+var SPLITMIX_MIX2 = 0x94d049bb133111ebn;
+var __SplitMix64 = class {
+  state;
+  constructor(seed) {
+    this.state = seed & UINT64_MASK;
+  }
+  next() {
+    this.state = this.state + SPLITMIX_GAMMA & UINT64_MASK;
+    let z = this.state;
+    z = (z ^ z >> 30n) * SPLITMIX_MIX1;
+    z &= UINT64_MASK;
+    z = (z ^ z >> 27n) * SPLITMIX_MIX2;
+    z &= UINT64_MASK;
+    return z ^ z >> 31n;
+  }
+};
+var __SeededRandom = class {
+  /** Current uint64 state. */
+  state;
+  /** Stream/sequence selector (must be odd). */
+  inc;
+  /**
+   * Create a new PRNG from a seed.
+   *
+   * @param seedUint64 - Seed coerced to uint64.
+   */
+  constructor(seedUint64) {
+    const sm = new __SplitMix64(seedUint64);
+    this.state = sm.next();
+    this.inc = sm.next() << 1n | 1n;
+  }
+  /**
+   * Generate the next uint32 sample.
+   */
+  nextUint32() {
+    const oldstate = this.state;
+    this.state = oldstate * PCG_MULT + this.inc & UINT64_MASK;
+    const xorshifted = Number((oldstate >> 18n ^ oldstate) >> 27n) >>> 0;
+    const rot = Number(oldstate >> 59n) & 31;
+    return (xorshifted >>> rot | xorshifted << (-rot & 31)) >>> 0;
+  }
+  /**
+   * Generate the next uniform sample in [0, 1).
+   */
+  next() {
+    return this.nextUint32() / 2 ** 32;
+  }
+};
+var __rng = null;
+function __setSeed(seed) {
+  if (!Number.isFinite(seed)) {
+    throw new InvalidParameterError(`seed must be a finite number; received ${seed}`, "seed", seed);
+  }
+  __globalSeed = seed;
+  const seedUint64 = BigInt.asUintN(64, BigInt(Math.trunc(seed)));
+  __rng = new __SeededRandom(seedUint64);
+}
+function __getSeed() {
+  return __globalSeed;
+}
+function __clearSeed() {
+  __globalSeed = void 0;
+  __rng = null;
+}
+function getCrypto() {
+  if (typeof crypto === "undefined") {
+    return void 0;
+  }
+  if (typeof crypto.getRandomValues !== "function") {
+    return void 0;
+  }
+  return crypto;
+}
+function randomUint32FromCrypto() {
+  const crypto2 = getCrypto();
+  if (!crypto2) {
+    throw new NotImplementedError(
+      "Cryptographically secure randomness is unavailable in this environment. Provide a seed for deterministic randomness."
+    );
+  }
+  const buf = new Uint32Array(1);
+  crypto2.getRandomValues(buf);
+  const value = buf[0];
+  if (value === void 0) {
+    throw new InvalidParameterError("Failed to read cryptographic randomness", "crypto", value);
+  }
+  return value >>> 0;
+}
+function __random() {
+  if (__rng) {
+    return __rng.next();
+  }
+  return randomUint32FromCrypto() / 2 ** 32;
+}
+function __randomUint32() {
+  if (__rng) {
+    return __rng.nextUint32();
+  }
+  return randomUint32FromCrypto();
+}
+function __randomUint53() {
+  const hi = __randomUint32() >>> 5;
+  const lo = __randomUint32() >>> 6;
+  return hi * 2 ** 26 + lo;
+}
+function __normalRandom() {
+  let u1 = __random();
+  while (u1 === 0) {
+    u1 = __random();
+  }
+  const u2 = __random();
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function __gammaLarge(shape) {
+  if (!Number.isFinite(shape) || shape <= 1 / 3) {
+    throw new InvalidParameterError(
+      "shape must be a finite number > 1/3 for Marsaglia-Tsang method",
+      "shape",
+      shape
+    );
+  }
+  const d = shape - 1 / 3;
+  const c = 1 / Math.sqrt(9 * d);
+  while (true) {
+    let x;
+    let v;
+    do {
+      x = __normalRandom();
+      v = 1 + c * x;
+    } while (v <= 0);
+    v = v * v * v;
+    const u = __random();
+    if (u < 1 - 0.0331 * x * x * x * x) {
+      return d * v;
+    }
+    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {
+      return d * v;
+    }
+  }
+}
+
+// src/random/index.ts
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var UINT32_RANGE = 2 ** 32;
+var UINT53_RANGE = 2 ** 53;
+function resolveDevice(device) {
+  const resolved = device ?? getConfig().defaultDevice;
+  return validateDevice(resolved, "device");
+}
+function resolveFloatDType(dtype, functionName) {
+  const resolved = dtype ?? "float32";
+  if (resolved !== "float32" && resolved !== "float64") {
+    throw new DTypeError(`${functionName} only supports float32 or float64 dtype`);
+  }
+  return resolved;
+}
+function resolveIntegerDType(dtype, functionName) {
+  const resolved = dtype ?? "int32";
+  if (resolved !== "int32" && resolved !== "int64") {
+    throw new DTypeError(`${functionName} only supports int32 or int64 dtype`);
+  }
+  return resolved;
+}
+function assertSafeInteger(value, name) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+    throw new InvalidParameterError(`${name} must be a safe integer`, name, value);
+  }
+}
+function assertInt32Bounds(value, name) {
+  if (value < INT32_MIN || value > INT32_MAX) {
+    throw new InvalidParameterError(
+      `${name} must be within int32 range [${INT32_MIN}, ${INT32_MAX}]`,
+      name,
+      value
+    );
+  }
+}
+function randomIntBelow(maxExclusive) {
+  if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0) {
+    throw new InvalidParameterError("range must be a positive safe integer", "range", maxExclusive);
+  }
+  if (maxExclusive <= UINT32_RANGE) {
+    const limit = Math.floor(UINT32_RANGE / maxExclusive) * maxExclusive;
+    let value = __randomUint32();
+    while (value >= limit) {
+      value = __randomUint32();
+    }
+    return value % maxExclusive;
+  }
+  if (maxExclusive <= UINT53_RANGE) {
+    const limit = Math.floor(UINT53_RANGE / maxExclusive) * maxExclusive;
+    let value = __randomUint53();
+    while (value >= limit) {
+      value = __randomUint53();
+    }
+    return value % maxExclusive;
+  }
+  throw new InvalidParameterError(
+    "range must be <= 2^53 for unbiased sampling",
+    "range",
+    maxExclusive
+  );
+}
+function allocateFloatBuffer(dtype, size) {
+  return dtype === "float32" ? new Float32Array(size) : new Float64Array(size);
+}
+function allocateIntegerBuffer(dtype, size) {
+  return dtype === "int64" ? new BigInt64Array(size) : new Int32Array(size);
+}
+function writeInteger(buffer, index, value) {
+  if (buffer instanceof BigInt64Array) {
+    buffer[index] = BigInt(value);
+  } else {
+    buffer[index] = value;
+  }
+}
+function randomOpenUnit() {
+  let u = __random();
+  while (u === 0) {
+    u = __random();
+  }
+  return u;
+}
+function validateContiguous(t, functionName) {
+  if (t.offset !== 0) {
+    throw new InvalidParameterError(
+      `${functionName} currently requires offset === 0`,
+      "offset",
+      t.offset
+    );
+  }
+  for (let axis = 0; axis < t.ndim; axis++) {
+    const expected = t.strides[axis];
+    const tail = t.shape.slice(axis + 1).reduce((acc, v) => acc * v, 1);
+    if (expected !== tail) {
+      throw new InvalidParameterError(
+        `${functionName} currently requires a contiguous tensor`,
+        "strides",
+        t.strides
+      );
+    }
+  }
+}
+var LANCZOS_COEFFS = [
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function logGamma(z) {
+  if (!Number.isFinite(z) || z <= 0) {
+    throw new InvalidParameterError("logGamma requires a positive finite input", "z", z);
+  }
+  let x = 0.9999999999998099;
+  for (const [i, coeff] of LANCZOS_COEFFS.entries()) {
+    x += coeff / (z + i);
+  }
+  const g = 7;
+  const t = z + g - 0.5;
+  return 0.5 * Math.log(2 * Math.PI) + (z - 0.5) * Math.log(t) - t + Math.log(x);
+}
+function logFactorial(n) {
+  if (n <= 1) return 0;
+  if (n <= 20) {
+    let result = 0;
+    for (let i = 2; i <= n; i++) {
+      result += Math.log(i);
+    }
+    return result;
+  }
+  return logGamma(n + 1);
+}
+function sampleGammaUnit(shape) {
+  if (shape < 1) {
+    const u = randomOpenUnit();
+    return __gammaLarge(shape + 1) * u ** (1 / shape);
+  }
+  return __gammaLarge(shape);
+}
+function setSeed(seed) {
+  __setSeed(seed);
+}
+function getSeed() {
+  return __getSeed();
+}
+function clearSeed() {
+  __clearSeed();
+}
+function rand(shape, opts = {}) {
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "rand");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    data[i] = __random();
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function randn(shape, opts = {}) {
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "randn");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    data[i] = __normalRandom();
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function randint(low, high, shape, opts = {}) {
+  assertSafeInteger(low, "low");
+  assertSafeInteger(high, "high");
+  if (high <= low) {
+    throw new InvalidParameterError("high must be > low", "high", high);
+  }
+  const dtype = resolveIntegerDType(opts.dtype, "randint");
+  if (dtype === "int32") {
+    assertInt32Bounds(low, "low");
+    if (high > INT32_MAX + 1) {
+      throw new InvalidParameterError(
+        `high must be <= ${INT32_MAX + 1} for int32 output`,
+        "high",
+        high
+      );
+    }
+  }
+  const size = shapeToSize(shape);
+  const data = allocateIntegerBuffer(dtype, size);
+  const range = high - low;
+  if (!Number.isSafeInteger(range) || range <= 0) {
+    throw new InvalidParameterError("range must be a positive safe integer", "high", high);
+  }
+  for (let i = 0; i < size; i++) {
+    const sample = randomIntBelow(range) + low;
+    writeInteger(data, i, sample);
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function uniform(low = 0, high = 1, shape = [], opts = {}) {
+  if (!Number.isFinite(low) || !Number.isFinite(high)) {
+    throw new InvalidParameterError("low and high must be finite", "low/high", {
+      low,
+      high
+    });
+  }
+  if (high < low) {
+    throw new InvalidParameterError("high must be >= low", "high", high);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "uniform");
+  const data = allocateFloatBuffer(dtype, size);
+  const range = high - low;
+  for (let i = 0; i < size; i++) {
+    data[i] = __random() * range + low;
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function normal(mean = 0, std = 1, shape = [], opts = {}) {
+  if (!Number.isFinite(mean) || !Number.isFinite(std)) {
+    throw new InvalidParameterError("mean and std must be finite", "mean/std", {
+      mean,
+      std
+    });
+  }
+  if (std < 0) {
+    throw new InvalidParameterError("std must be >= 0", "std", std);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "normal");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    data[i] = __normalRandom() * std + mean;
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function binomialSmallMean(n, logQ) {
+  let successes = 0;
+  let trials = 0;
+  while (true) {
+    const u = randomOpenUnit();
+    const gap = Math.floor(Math.log(u) / logQ) + 1;
+    if (gap > n - trials) {
+      return successes;
+    }
+    trials += gap;
+    successes++;
+  }
+}
+function binomialChopDown(n, p, q, mode, pmfMode) {
+  const u = __random();
+  let cumulative = pmfMode;
+  if (u <= cumulative) {
+    return mode;
+  }
+  let left = mode;
+  let right = mode;
+  let pmfLeft = pmfMode;
+  let pmfRight = pmfMode;
+  const ratioLeft = q / p;
+  const ratioRight = p / q;
+  while (left > 0 || right < n) {
+    if (left > 0) {
+      pmfLeft *= left / (n - left + 1) * ratioLeft;
+      left -= 1;
+      cumulative += pmfLeft;
+      if (u <= cumulative) {
+        return left;
+      }
+    }
+    if (right < n) {
+      pmfRight *= (n - right) / (right + 1) * ratioRight;
+      right += 1;
+      cumulative += pmfRight;
+      if (u <= cumulative) {
+        return right;
+      }
+    }
+  }
+  return u <= cumulative ? left : right;
+}
+function binomial(n, p, shape = [], opts = {}) {
+  assertSafeInteger(n, "n");
+  if (n < 0) {
+    throw new InvalidParameterError("n must be >= 0", "n", n);
+  }
+  if (!Number.isFinite(p) || p < 0 || p > 1) {
+    throw new InvalidParameterError("p must be in [0, 1]", "p", p);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveIntegerDType(opts.dtype, "binomial");
+  if (dtype === "int32") {
+    if (n > INT32_MAX) {
+      throw new InvalidParameterError(`n must be <= ${INT32_MAX} for int32 output`, "n", n);
+    }
+  }
+  const data = allocateIntegerBuffer(dtype, size);
+  if (n === 0) {
+    return Tensor.fromTypedArray({
+      data,
+      shape,
+      dtype,
+      device: resolveDevice(opts.device)
+    });
+  }
+  if (p === 0) {
+    return Tensor.fromTypedArray({
+      data,
+      shape,
+      dtype,
+      device: resolveDevice(opts.device)
+    });
+  }
+  if (p === 1) {
+    for (let i = 0; i < size; i++) {
+      writeInteger(data, i, n);
+    }
+    return Tensor.fromTypedArray({
+      data,
+      shape,
+      dtype,
+      device: resolveDevice(opts.device)
+    });
+  }
+  const flip = p > 0.5;
+  const prob = flip ? 1 - p : p;
+  const q = 1 - prob;
+  if (q === 1) {
+    const value = flip ? n : 0;
+    for (let i = 0; i < size; i++) {
+      writeInteger(data, i, value);
+    }
+    return Tensor.fromTypedArray({
+      data,
+      shape,
+      dtype,
+      device: resolveDevice(opts.device)
+    });
+  }
+  const mean = n * prob;
+  const logQ = Math.log(q);
+  if (mean < 10) {
+    for (let i = 0; i < size; i++) {
+      const sample = binomialSmallMean(n, logQ);
+      writeInteger(data, i, flip ? n - sample : sample);
+    }
+  } else {
+    const mode = Math.floor((n + 1) * prob);
+    const logP = Math.log(prob);
+    const logPmfMode = logFactorial(n) - logFactorial(mode) - logFactorial(n - mode) + mode * logP + (n - mode) * logQ;
+    const pmfMode = Math.exp(logPmfMode);
+    if (!Number.isFinite(pmfMode) || pmfMode <= 0) {
+      throw new InvalidParameterError("Failed to initialize binomial sampler", "p", p);
+    }
+    for (let i = 0; i < size; i++) {
+      const sample = binomialChopDown(n, prob, q, mode, pmfMode);
+      writeInteger(data, i, flip ? n - sample : sample);
+    }
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function poisson(lambda, shape = [], opts = {}) {
+  if (!Number.isFinite(lambda) || lambda < 0) {
+    throw new InvalidParameterError("lambda must be a finite number >= 0", "lambda", lambda);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveIntegerDType(opts.dtype, "poisson");
+  if (dtype === "int32") {
+    if (lambda > INT32_MAX) {
+      throw new InvalidParameterError(
+        `lambda must be <= ${INT32_MAX} for int32 output`,
+        "lambda",
+        lambda
+      );
+    }
+  }
+  const data = allocateIntegerBuffer(dtype, size);
+  if (lambda < 30) {
+    const L = Math.exp(-lambda);
+    for (let i = 0; i < size; i++) {
+      let k = 0;
+      let p = 1;
+      do {
+        k++;
+        p *= __random();
+      } while (p > L);
+      const sample = k - 1;
+      if (!Number.isSafeInteger(sample)) {
+        throw new InvalidParameterError(
+          "poisson sample exceeds safe integer range",
+          "lambda",
+          lambda
+        );
+      }
+      if (dtype === "int32" && sample > INT32_MAX) {
+        throw new InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
+      }
+      writeInteger(data, i, sample);
+    }
+  } else {
+    const c = 0.767 - 3.36 / lambda;
+    const beta2 = Math.PI / Math.sqrt(3 * lambda);
+    const alpha = beta2 * lambda;
+    const k = Math.log(c) - lambda - Math.log(beta2);
+    for (let i = 0; i < size; i++) {
+      while (true) {
+        const u = __random();
+        if (u === 0 || u === 1) continue;
+        const x = (alpha - Math.log((1 - u) / u)) / beta2;
+        const n = Math.floor(x + 0.5);
+        if (n < 0 || !Number.isFinite(n)) continue;
+        const v = __random();
+        const y = alpha - beta2 * x;
+        const lhs = y + Math.log(v / (1 + Math.exp(y)) ** 2);
+        const rhs = k + n * Math.log(lambda) - logFactorial(n);
+        if (lhs <= rhs) {
+          if (!Number.isSafeInteger(n)) {
+            throw new InvalidParameterError(
+              "poisson sample exceeds safe integer range",
+              "lambda",
+              lambda
+            );
+          }
+          if (dtype === "int32" && n > INT32_MAX) {
+            throw new InvalidParameterError("poisson sample exceeds int32 range", "lambda", lambda);
+          }
+          writeInteger(data, i, n);
+          break;
+        }
+      }
+    }
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function exponential(scale = 1, shape = [], opts = {}) {
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new InvalidParameterError("scale must be a finite number > 0", "scale", scale);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "exponential");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    const u = randomOpenUnit();
+    data[i] = -scale * Math.log(u);
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function gamma(shape_param, scale = 1, shape = [], opts = {}) {
+  if (!Number.isFinite(shape_param) || shape_param <= 0) {
+    throw new InvalidParameterError(
+      "shape_param must be a finite number > 0",
+      "shape_param",
+      shape_param
+    );
+  }
+  if (!Number.isFinite(scale) || scale <= 0) {
+    throw new InvalidParameterError("scale must be a finite number > 0", "scale", scale);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "gamma");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    data[i] = sampleGammaUnit(shape_param) * scale;
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function beta(alpha, beta_param, shape = [], opts = {}) {
+  if (!Number.isFinite(alpha) || alpha <= 0) {
+    throw new InvalidParameterError("alpha must be a finite number > 0", "alpha", alpha);
+  }
+  if (!Number.isFinite(beta_param) || beta_param <= 0) {
+    throw new InvalidParameterError("beta must be a finite number > 0", "beta_param", beta_param);
+  }
+  const size = shapeToSize(shape);
+  const dtype = resolveFloatDType(opts.dtype, "beta");
+  const data = allocateFloatBuffer(dtype, size);
+  for (let i = 0; i < size; i++) {
+    let sampled = false;
+    for (let attempt = 0; attempt < 1024; attempt++) {
+      const x = sampleGammaUnit(alpha);
+      const y = sampleGammaUnit(beta_param);
+      const sum = x + y;
+      if (!Number.isFinite(sum) || sum <= 0) {
+        continue;
+      }
+      const value = x / sum;
+      if (Number.isFinite(value) && value >= 0 && value <= 1) {
+        data[i] = value;
+        sampled = true;
+        break;
+      }
+    }
+    if (!sampled) {
+      throw new InvalidParameterError(
+        "beta sampling failed to produce a finite sample",
+        "alpha/beta_param",
+        { alpha, beta_param }
+      );
+    }
+  }
+  return Tensor.fromTypedArray({
+    data,
+    shape,
+    dtype,
+    device: resolveDevice(opts.device)
+  });
+}
+function readNumericTensorValue(t, index) {
+  if (t.dtype === "string") {
+    throw new DTypeError("Expected numeric tensor");
+  }
+  const value = t.data[index];
+  if (typeof value === "number" || typeof value === "bigint") {
+    return value;
+  }
+  throw new InvalidParameterError("Internal error: tensor index out of bounds", "index", index);
+}
+function allocateNumericBuffer(dtype, size) {
+  switch (dtype) {
+    case "float32":
+      return new Float32Array(size);
+    case "float64":
+      return new Float64Array(size);
+    case "int32":
+      return new Int32Array(size);
+    case "int64":
+      return new BigInt64Array(size);
+    case "uint8":
+    case "bool":
+      return new Uint8Array(size);
+    case "string":
+      throw new DTypeError("choice() does not support string tensors");
+  }
+}
+function writeNumericValue(out, index, value) {
+  if (out instanceof BigInt64Array) {
+    out[index] = typeof value === "bigint" ? value : BigInt(Math.trunc(value));
+    return;
+  }
+  if (typeof value === "bigint") {
+    out[index] = Number(value);
+    return;
+  }
+  out[index] = value;
+}
+function buildNormalizedProbabilities(probabilities, n) {
+  if (probabilities.dtype === "string") {
+    throw new DTypeError("choice() probabilities must be numeric");
+  }
+  if (probabilities.ndim !== 1) {
+    throw new InvalidParameterError("p must be a 1D tensor", "p", probabilities.shape);
+  }
+  if (probabilities.size !== n) {
+    throw new InvalidParameterError(
+      "p must have the same length as the population",
+      "p",
+      probabilities.size
+    );
+  }
+  validateContiguous(probabilities, "choice(p)");
+  const normalized = new Float64Array(n);
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    const value = Number(readNumericTensorValue(probabilities, i));
+    if (!Number.isFinite(value) || value < 0) {
+      throw new InvalidParameterError(
+        "p must contain finite non-negative probabilities",
+        "p",
+        value
+      );
+    }
+    normalized[i] = value;
+    sum += value;
+  }
+  if (!Number.isFinite(sum) || sum <= 0) {
+    throw new InvalidParameterError("sum(p) must be > 0 and finite", "p", sum);
+  }
+  for (let i = 0; i < n; i++) {
+    normalized[i] = (normalized[i] ?? 0) / sum;
+  }
+  return normalized;
+}
+function sampleFromCdf(cdf) {
+  const u = randomOpenUnit();
+  let left = 0;
+  let right = cdf.length - 1;
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const value = cdf[mid];
+    if (value === void 0) {
+      throw new InvalidParameterError("Internal error: invalid CDF index", "mid", mid);
+    }
+    if (u <= value) {
+      right = mid;
+    } else {
+      left = mid + 1;
+    }
+  }
+  return left;
+}
+function choice(a, size, replace = true, p) {
+  if (typeof a === "number") {
+    assertSafeInteger(a, "a");
+    if (a < 0) {
+      throw new InvalidParameterError("Invalid population size", "a", a);
+    }
+    if (a > INT32_MAX + 1) {
+      throw new InvalidParameterError(
+        `Population size must be <= ${INT32_MAX + 1} for choice()`,
+        "a",
+        a
+      );
+    }
+  }
+  const aa = typeof a === "number" ? arange(0, a, 1, { dtype: "int32" }) : a;
+  if (aa.dtype === "string") {
+    throw new DTypeError("choice() does not support string tensors");
+  }
+  const n = aa.size;
+  if (!Number.isInteger(n) || n < 0) {
+    throw new InvalidParameterError("Invalid tensor size", "n", n);
+  }
+  if (n > INT32_MAX + 1) {
+    throw new InvalidParameterError(`Population size must be <= ${INT32_MAX + 1}`, "n", n);
+  }
+  let outputSize;
+  if (typeof size === "number") {
+    outputSize = size;
+  } else if (size) {
+    validateShape(size);
+    outputSize = shapeToSize(size);
+  } else {
+    outputSize = 1;
+  }
+  if (!Number.isSafeInteger(outputSize) || outputSize < 0) {
+    throw new InvalidParameterError("size must be an integer >= 0", "size", size);
+  }
+  if (outputSize > INT32_MAX) {
+    throw new InvalidParameterError(`size must be <= ${INT32_MAX}`, "size", outputSize);
+  }
+  if (n === 0 && outputSize > 0) {
+    throw new InvalidParameterError("Cannot sample from an empty population", "a", a);
+  }
+  const indices = new Int32Array(outputSize);
+  const weights = p ? buildNormalizedProbabilities(p, n) : void 0;
+  if (weights) {
+    if (replace) {
+      const cdf = new Float64Array(weights.length);
+      let cumulative = 0;
+      for (let i = 0; i < weights.length; i++) {
+        cumulative += weights[i] ?? 0;
+        cdf[i] = cumulative;
+      }
+      cdf[cdf.length - 1] = 1;
+      for (let i = 0; i < outputSize; i++) {
+        indices[i] = sampleFromCdf(cdf);
+      }
+    } else {
+      let nonZeroCount = 0;
+      for (let i = 0; i < weights.length; i++) {
+        if ((weights[i] ?? 0) > 0) nonZeroCount++;
+      }
+      if (outputSize > nonZeroCount) {
+        throw new InvalidParameterError(
+          "Cannot sample without replacement with zero-probability mass for requested size",
+          "size",
+          outputSize
+        );
+      }
+      const remaining = new Float64Array(weights);
+      let remainingMass = 1;
+      for (let i = 0; i < outputSize; i++) {
+        if (remainingMass <= 0) {
+          throw new InvalidParameterError(
+            "Insufficient probability mass to sample",
+            "p",
+            remainingMass
+          );
+        }
+        const u = __random() * remainingMass;
+        let cumulative = 0;
+        let chosen = -1;
+        for (let j = 0; j < remaining.length; j++) {
+          const w = remaining[j] ?? 0;
+          if (w <= 0) {
+            continue;
+          }
+          cumulative += w;
+          if (u <= cumulative) {
+            chosen = j;
+            break;
+          }
+        }
+        if (chosen < 0) {
+          for (let j = remaining.length - 1; j >= 0; j--) {
+            if ((remaining[j] ?? 0) > 0) {
+              chosen = j;
+              break;
+            }
+          }
+        }
+        if (chosen < 0) {
+          throw new InvalidParameterError("Failed to select weighted sample", "p", weights);
+        }
+        indices[i] = chosen;
+        remainingMass -= remaining[chosen] ?? 0;
+        remaining[chosen] = 0;
+      }
+    }
+  } else if (replace) {
+    for (let i = 0; i < outputSize; i++) {
+      indices[i] = randomIntBelow(n);
+    }
+  } else {
+    if (outputSize > n) {
+      throw new InvalidParameterError(
+        "Cannot sample without replacement when size > population",
+        "size",
+        outputSize
+      );
+    }
+    const pool = Array.from({ length: n }, (_, i) => i);
+    for (let i = 0; i < outputSize; i++) {
+      const j = randomIntBelow(n - i) + i;
+      const poolI = pool[i];
+      const poolJ = pool[j];
+      if (poolI === void 0 || poolJ === void 0) {
+        throw new InvalidParameterError("Internal error: pool index out of bounds", "pool", {
+          i,
+          j,
+          n
+        });
+      }
+      pool[i] = poolJ;
+      pool[j] = poolI;
+      indices[i] = poolJ;
+    }
+  }
+  const outputShape = typeof size === "number" ? [size] : size ?? [1];
+  validateContiguous(aa, "choice()");
+  const out = allocateNumericBuffer(aa.dtype, outputSize);
+  for (let i = 0; i < outputSize; i++) {
+    const idx = indices[i];
+    if (idx === void 0) {
+      throw new InvalidParameterError("Internal error: undefined index", "indices", i);
+    }
+    const value = readNumericTensorValue(aa, idx);
+    writeNumericValue(out, i, value);
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outputShape,
+    dtype: aa.dtype,
+    device: aa.device
+  });
+}
+function shuffle(x) {
+  if (x.dtype === "string") {
+    throw new DTypeError("shuffle() does not support string tensors");
+  }
+  validateContiguous(x, "shuffle()");
+  const data = x.data;
+  if (!isTypedArray(data)) {
+    throw new DTypeError("shuffle() does not support string tensors");
+  }
+  const n = data.length;
+  if (data instanceof BigInt64Array) {
+    for (let i = n - 1; i > 0; i--) {
+      const j = randomIntBelow(i + 1);
+      const temp = data[i];
+      const swap = data[j];
+      if (temp === void 0 || swap === void 0) {
+        throw new DeepboxError("Internal error: shuffle index out of bounds");
+      }
+      data[i] = swap;
+      data[j] = temp;
+    }
+  } else {
+    for (let i = n - 1; i > 0; i--) {
+      const j = randomIntBelow(i + 1);
+      const temp = data[i];
+      const swap = data[j];
+      if (temp === void 0 || swap === void 0) {
+        throw new DeepboxError("Internal error: shuffle index out of bounds");
+      }
+      data[i] = swap;
+      data[j] = temp;
+    }
+  }
+}
+function permutation(x) {
+  if (typeof x === "number") {
+    assertSafeInteger(x, "x");
+    const n = x;
+    if (n < 0) {
+      throw new InvalidParameterError("x must be a non-negative integer", "x", x);
+    }
+    if (n > INT32_MAX + 1) {
+      throw new InvalidParameterError(`x must be <= ${INT32_MAX + 1} for int32 output`, "x", x);
+    }
+    const indices = Array.from({ length: n }, (_, i) => i);
+    for (let i = n - 1; i > 0; i--) {
+      const j = randomIntBelow(i + 1);
+      const indicesI = indices[i];
+      const indicesJ = indices[j];
+      if (indicesI === void 0 || indicesJ === void 0) {
+        throw new InvalidParameterError("Internal error: indices out of bounds", "indices", {
+          i,
+          j,
+          n
+        });
+      }
+      indices[i] = indicesJ;
+      indices[j] = indicesI;
+    }
+    return tensor(indices, { dtype: "int32" });
+  }
+  if (x.dtype === "string") {
+    throw new DTypeError("permutation() does not support string tensors");
+  }
+  validateContiguous(x, "permutation()");
+  const data = x.data;
+  if (!isTypedArray(data)) {
+    throw new DTypeError("permutation() does not support string tensors");
+  }
+  const copy = Tensor.fromTypedArray({
+    data: data.slice(),
+    shape: x.shape,
+    dtype: x.dtype,
+    device: x.device
+  });
+  shuffle(copy);
+  return copy;
+}
+
+export { beta, binomial, choice, clearSeed, exponential, gamma, getSeed, normal, permutation, poisson, rand, randint, randn, random_exports, setSeed, shuffle, uniform };
+//# sourceMappingURL=chunk-F3JWBINJ.js.map
+//# sourceMappingURL=chunk-F3JWBINJ.js.map