deepbox 0.1.0

package/dist/chunk-F3JWBINJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/random/index.ts","../src/random/random.ts"],"names":["crypto","beta"],"mappings":"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","file":"chunk-F3JWBINJ.js","sourcesContent":["import type { Device, DType, Shape } from \"../core\";\nimport {\n  DeepboxError,\n  DTypeError,\n  getConfig,\n  InvalidParameterError,\n  isTypedArray,\n  shapeToSize,\n  validateDevice,\n  validateShape,\n} from \"../core\";\nimport { arange, type Tensor, Tensor as TensorClass, type TypedArray, tensor } from \"../ndarray\";\nimport {\n  __clearSeed,\n  __gammaLarge,\n  __getSeed,\n  __normalRandom,\n  __random,\n  __randomUint32,\n  __randomUint53,\n  __setSeed,\n} from \"./random\";\n\nexport type RandomOptions = {\n  readonly dtype?: DType;\n  readonly device?: Device;\n};\n\ntype FloatDType = \"float32\" | \"float64\";\ntype IntegerDType = \"int32\" | \"int64\";\ntype FloatBuffer = Float32Array | Float64Array;\ntype IntegerBuffer = Int32Array | BigInt64Array;\n\nconst INT32_MIN = -2147483648;\nconst INT32_MAX = 2147483647;\nconst UINT32_RANGE = 2 ** 32;\nconst UINT53_RANGE = 2 ** 53;\n\nfunction resolveDevice(device?: Device): Device {\n  const resolved = device ?? getConfig().defaultDevice;\n  return validateDevice(resolved, \"device\");\n}\n\nfunction resolveFloatDType(dtype: DType | undefined, functionName: string): FloatDType {\n  const resolved = dtype ?? \"float32\";\n  if (resolved !== \"float32\" && resolved !== \"float64\") {\n    throw new DTypeError(`${functionName} only supports float32 or float64 dtype`);\n  }\n  return resolved;\n}\n\nfunction resolveIntegerDType(dtype: DType | undefined, functionName: string): IntegerDType {\n  const resolved = dtype ?? \"int32\";\n  if (resolved !== \"int32\" && resolved !== \"int64\") {\n    throw new DTypeError(`${functionName} only supports int32 or int64 dtype`);\n  }\n  return resolved;\n}\n\nfunction assertSafeInteger(value: number, name: string): void {\n  if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {\n    throw new InvalidParameterError(`${name} must be a safe integer`, name, value);\n  }\n}\n\nfunction assertInt32Bounds(value: number, name: string): void {\n  if (value < INT32_MIN || value > INT32_MAX) {\n    throw new InvalidParameterError(\n      `${name} must be within int32 range [${INT32_MIN}, ${INT32_MAX}]`,\n      name,\n      value\n    );\n  }\n}\n\nfunction randomIntBelow(maxExclusive: number): number {\n  if (!Number.isSafeInteger(maxExclusive) || maxExclusive <= 0) {\n    throw new InvalidParameterError(\"range must be a positive safe integer\", \"range\", maxExclusive);\n  }\n  if (maxExclusive <= UINT32_RANGE) {\n    const limit = Math.floor(UINT32_RANGE / maxExclusive) * maxExclusive;\n    let value = __randomUint32();\n    while (value >= limit) {\n      value = __randomUint32();\n    }\n    return value % maxExclusive;\n  }\n  if (maxExclusive <= UINT53_RANGE) {\n    const limit = Math.floor(UINT53_RANGE / maxExclusive) * maxExclusive;\n    let value = __randomUint53();\n    while (value >= limit) {\n      value = __randomUint53();\n    }\n    return value % maxExclusive;\n  }\n  throw new InvalidParameterError(\n    \"range must be <= 2^53 for unbiased sampling\",\n    \"range\",\n    maxExclusive\n  );\n}\n\nfunction allocateFloatBuffer(dtype: FloatDType, size: number): FloatBuffer {\n  return dtype === \"float32\" ? new Float32Array(size) : new Float64Array(size);\n}\n\nfunction allocateIntegerBuffer(dtype: IntegerDType, size: number): IntegerBuffer {\n  return dtype === \"int64\" ? new BigInt64Array(size) : new Int32Array(size);\n}\n\nfunction writeInteger(buffer: IntegerBuffer, index: number, value: number): void {\n  if (buffer instanceof BigInt64Array) {\n    buffer[index] = BigInt(value);\n  } else {\n    buffer[index] = value;\n  }\n}\n\nfunction randomOpenUnit(): number {\n  let u = __random();\n  while (u === 0) {\n    u = __random();\n  }\n  return u;\n}\n\n/**\n * Validate that a tensor is contiguous (no slicing/striding).\n * @param t - Tensor to validate\n * @param functionName - Name of the calling function for error messages\n */\nfunction validateContiguous(t: Tensor, functionName: string): void {\n  if (t.offset !== 0) {\n    throw new InvalidParameterError(\n      `${functionName} currently requires offset === 0`,\n      \"offset\",\n      t.offset\n    );\n  }\n  for (let axis = 0; axis < t.ndim; axis++) {\n    const expected = t.strides[axis];\n    const tail = t.shape.slice(axis + 1).reduce((acc, v) => acc * v, 1);\n    if (expected !== tail) {\n      throw new InvalidParameterError(\n        `${functionName} currently requires a contiguous tensor`,\n        \"strides\",\n        t.strides\n      );\n    }\n  }\n}\n\nconst LANCZOS_COEFFS = [\n  676.5203681218851, -1259.1392167224028, 771.3234287776531, -176.6150291621406, 12.507343278686905,\n  -0.13857109526572012, 0.000009984369578019572, 0.00000015056327351493116,\n];\n\n/**\n * Compute log Gamma(z) for z > 0 using Lanczos approximation.\n */\nfunction logGamma(z: number): number {\n  if (!Number.isFinite(z) || z <= 0) {\n    throw new InvalidParameterError(\"logGamma requires a positive finite input\", \"z\", z);\n  }\n  // Lanczos approximation with g=7, n=9 coefficients.\n  let x = 0.99999999999980993;\n  for (const [i, coeff] of LANCZOS_COEFFS.entries()) {\n    x += coeff / (z + i);\n  }\n  const g = 7;\n  const t = z + g - 0.5;\n  return 0.5 * Math.log(2 * Math.PI) + (z - 0.5) * Math.log(t) - t + Math.log(x);\n}\n\n/**\n * Compute log(n!) with high accuracy for all integer n >= 0.\n * For small n, use exact summation to avoid rounding error.\n */\nfunction logFactorial(n: number): number {\n  if (n <= 1) return 0;\n  if (n <= 20) {\n    // Exact computation for small n\n    let result = 0;\n    for (let i = 2; i <= n; i++) {\n      result += Math.log(i);\n    }\n    return result;\n  }\n  // Use logGamma for stable, accurate results for large n.\n  return logGamma(n + 1);\n}\n\nfunction sampleGammaUnit(shape: number): number {\n  if (shape < 1) {\n    const u = randomOpenUnit();\n    return __gammaLarge(shape + 1) * u ** (1 / shape);\n  }\n  return __gammaLarge(shape);\n}\n\n/**\n * Set global random seed.\n *\n * @param seed - Random seed value (any finite number). The seed is coerced to a uint64\n *               internally, so the same seed always produces the same sequence.\n *\n * @throws {InvalidParameterError} When seed is not finite (NaN or ±Infinity)\n *\n * @remarks\n * - Setting a seed makes all random operations deterministic and reproducible.\n * - The seed is truncated to uint64 range (0 to 2^64-1) for internal state.\n * - Use {@link getSeed} to retrieve the currently set seed.\n * - When no seed is set, random sampling uses a cryptographically secure RNG.\n *   Seeded mode is deterministic and **not** intended for cryptographic use.\n *\n * @example\n * ```js\n * import { setSeed, rand } from 'deepbox/random';\n *\n * setSeed(42);\n * const a = rand([5]);\n * setSeed(42);\n * const b = rand([5]);\n * // a and b contain identical values\n * ```\n */\nexport function setSeed(seed: number): void {\n  __setSeed(seed);\n}\n\n/**\n * Get current random seed.\n *\n * @returns Current seed value or undefined if not set\n *\n * @example\n * ```js\n * import { setSeed, getSeed } from 'deepbox/random';\n *\n * setSeed(12345);\n * console.log(getSeed()); // 12345\n * ```\n */\nexport function getSeed(): number | undefined {\n  return __getSeed();\n}\n\n/**\n * Clear the current random seed and revert to cryptographically secure randomness.\n *\n * @remarks\n * - After calling this, random sampling uses `crypto.getRandomValues`.\n * - Use this to leave deterministic mode after {@link setSeed}.\n *\n * @example\n * ```js\n * import { clearSeed, rand } from 'deepbox/random';\n *\n * clearSeed();\n * const x = rand([3]);  // cryptographically secure randomness\n * ```\n */\nexport function clearSeed(): void {\n  __clearSeed();\n}\n\n/**\n * Random values in half-open interval [0, 1).\n *\n * @param shape - Output shape\n * @param opts - Options (dtype, device)\n *\n * @remarks\n * - Values are uniformly distributed in [0, 1) (inclusive lower, exclusive upper bound).\n * - Uses deterministic PRNG when seed is set via {@link setSeed}.\n * - Default dtype is float32; use float64 for higher precision.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { rand, setSeed } from 'deepbox/random';\n *\n * const x = rand([2, 3]);  // 2x3 matrix of random values\n *\n * // Deterministic generation\n * setSeed(42);\n * const a = rand([5]);\n * setSeed(42);\n * const b = rand([5]);\n * // a and b are identical\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.rand.html | NumPy random.rand}\n */\nexport function rand(shape: Shape, opts: RandomOptions = {}): Tensor {\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"rand\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    data[i] = __random();\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from standard normal distribution.\n *\n * @param shape - Output shape\n * @param opts - Options (dtype, device)\n *\n * @remarks\n * - Uses Box-Muller transform to generate normally distributed values.\n * - Mean = 0, standard deviation = 1.\n * - All values are finite (no infinities from tail behavior).\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { randn } from 'deepbox/random';\n *\n * const x = randn([2, 3]);  // 2x3 matrix of normal random values\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.randn.html | NumPy random.randn}\n */\nexport function randn(shape: Shape, opts: RandomOptions = {}): Tensor {\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"randn\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    data[i] = __normalRandom();\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random integers in half-open interval [low, high).\n *\n * @param low - Lowest integer (inclusive)\n * @param high - Highest integer (exclusive)\n * @param shape - Output shape\n * @param opts - Options (dtype, device)\n *\n * @throws {InvalidParameterError} When low or high is not finite\n * @throws {InvalidParameterError} When low or high is not an integer\n * @throws {InvalidParameterError} When high <= low\n *\n * @remarks\n * - Generates integers uniformly in [low, high) range.\n * - Both low and high must be safe integers (within ±2^53-1).\n * - dtype must be int32 or int64; int32 output requires bounds within int32 range.\n * - Deterministic when seed is set via {@link setSeed}.\n *\n * @example\n * ```js\n * import { randint } from 'deepbox/random';\n *\n * const x = randint(0, 10, [5]);  // 5 random integers from 0 to 9\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html | NumPy random.randint}\n */\nexport function randint(low: number, high: number, shape: Shape, opts: RandomOptions = {}): Tensor {\n  assertSafeInteger(low, \"low\");\n  assertSafeInteger(high, \"high\");\n  if (high <= low) {\n    throw new InvalidParameterError(\"high must be > low\", \"high\", high);\n  }\n  const dtype = resolveIntegerDType(opts.dtype, \"randint\");\n  if (dtype === \"int32\") {\n    assertInt32Bounds(low, \"low\");\n    if (high > INT32_MAX + 1) {\n      throw new InvalidParameterError(\n        `high must be <= ${INT32_MAX + 1} for int32 output`,\n        \"high\",\n        high\n      );\n    }\n  }\n  const size = shapeToSize(shape);\n  const data = allocateIntegerBuffer(dtype, size);\n  const range = high - low;\n  if (!Number.isSafeInteger(range) || range <= 0) {\n    throw new InvalidParameterError(\"range must be a positive safe integer\", \"high\", high);\n  }\n\n  for (let i = 0; i < size; i++) {\n    const sample = randomIntBelow(range) + low;\n    writeInteger(data, i, sample);\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from continuous uniform distribution.\n *\n * @param low - Lower boundary (default: 0)\n * @param high - Upper boundary (default: 1)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When low or high is not finite\n * @throws {InvalidParameterError} When high < low\n *\n * @remarks\n * - Values are uniformly distributed in [low, high).\n * - For very large ranges, floating-point precision may affect uniformity.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { uniform } from 'deepbox/random';\n *\n * const x = uniform(-1, 1, [3, 3]);  // Values between -1 and 1\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.uniform.html | NumPy random.uniform}\n */\nexport function uniform(\n  low: number = 0,\n  high: number = 1,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  if (!Number.isFinite(low) || !Number.isFinite(high)) {\n    throw new InvalidParameterError(\"low and high must be finite\", \"low/high\", {\n      low,\n      high,\n    });\n  }\n  if (high < low) {\n    throw new InvalidParameterError(\"high must be >= low\", \"high\", high);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"uniform\");\n  const data = allocateFloatBuffer(dtype, size);\n  const range = high - low;\n\n  for (let i = 0; i < size; i++) {\n    data[i] = __random() * range + low;\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from normal (Gaussian) distribution.\n *\n * @param mean - Mean of distribution (default: 0)\n * @param std - Standard deviation (default: 1)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When mean or std is not finite\n * @throws {InvalidParameterError} When std < 0\n *\n * @remarks\n * - Uses Box-Muller transform internally.\n * - All values are finite due to RNG resolution (no infinities from log(0)).\n * - std=0 produces constant values equal to mean.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { normal } from 'deepbox/random';\n *\n * const x = normal(0, 2, [100]);  // Mean 0, std 2\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html | NumPy random.normal}\n */\nexport function normal(\n  mean: number = 0,\n  std: number = 1,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  if (!Number.isFinite(mean) || !Number.isFinite(std)) {\n    throw new InvalidParameterError(\"mean and std must be finite\", \"mean/std\", {\n      mean,\n      std,\n    });\n  }\n  if (std < 0) {\n    throw new InvalidParameterError(\"std must be >= 0\", \"std\", std);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"normal\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    data[i] = __normalRandom() * std + mean;\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\nfunction binomialSmallMean(n: number, logQ: number): number {\n  // Geometric waiting-time method: exact and efficient when mean is small.\n  let successes = 0;\n  let trials = 0;\n\n  while (true) {\n    const u = randomOpenUnit();\n    const gap = Math.floor(Math.log(u) / logQ) + 1;\n    if (gap > n - trials) {\n      return successes;\n    }\n    trials += gap;\n    successes++;\n  }\n}\n\nfunction binomialChopDown(n: number, p: number, q: number, mode: number, pmfMode: number): number {\n  const u = __random();\n  let cumulative = pmfMode;\n  if (u <= cumulative) {\n    return mode;\n  }\n\n  let left = mode;\n  let right = mode;\n  let pmfLeft = pmfMode;\n  let pmfRight = pmfMode;\n  const ratioLeft = q / p;\n  const ratioRight = p / q;\n\n  while (left > 0 || right < n) {\n    if (left > 0) {\n      pmfLeft *= (left / (n - left + 1)) * ratioLeft;\n      left -= 1;\n      cumulative += pmfLeft;\n      if (u <= cumulative) {\n        return left;\n      }\n    }\n    if (right < n) {\n      pmfRight *= ((n - right) / (right + 1)) * ratioRight;\n      right += 1;\n      cumulative += pmfRight;\n      if (u <= cumulative) {\n        return right;\n      }\n    }\n  }\n\n  // Fallback: due to rounding, return the closest boundary.\n  return u <= cumulative ? left : right;\n}\n\n/**\n * Random samples from binomial distribution.\n *\n * @param n - Number of trials (non-negative integer)\n * @param p - Probability of success (in [0, 1])\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When n is not finite, not an integer, or < 0\n * @throws {InvalidParameterError} When p is not finite or not in [0, 1]\n *\n * @remarks\n * - Generates number of successes in n independent Bernoulli trials.\n * - Uses an exact geometric waiting-time method for small means and\n *   a mode-centered chop-down inversion for larger means.\n * - Results are in range [0, n].\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only int32 and int64 dtypes are supported.\n *\n * @example\n * ```js\n * import { binomial } from 'deepbox/random';\n *\n * const x = binomial(10, 0.5, [100]);  // 10 coin flips, 100 times\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.binomial.html | NumPy random.binomial}\n */\nexport function binomial(\n  n: number,\n  p: number,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  assertSafeInteger(n, \"n\");\n  if (n < 0) {\n    throw new InvalidParameterError(\"n must be >= 0\", \"n\", n);\n  }\n  if (!Number.isFinite(p) || p < 0 || p > 1) {\n    throw new InvalidParameterError(\"p must be in [0, 1]\", \"p\", p);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveIntegerDType(opts.dtype, \"binomial\");\n  if (dtype === \"int32\") {\n    if (n > INT32_MAX) {\n      throw new InvalidParameterError(`n must be <= ${INT32_MAX} for int32 output`, \"n\", n);\n    }\n  }\n  const data = allocateIntegerBuffer(dtype, size);\n  if (n === 0) {\n    return TensorClass.fromTypedArray({\n      data,\n      shape,\n      dtype,\n      device: resolveDevice(opts.device),\n    });\n  }\n  if (p === 0) {\n    return TensorClass.fromTypedArray({\n      data,\n      shape,\n      dtype,\n      device: resolveDevice(opts.device),\n    });\n  }\n  if (p === 1) {\n    for (let i = 0; i < size; i++) {\n      writeInteger(data, i, n);\n    }\n    return TensorClass.fromTypedArray({\n      data,\n      shape,\n      dtype,\n      device: resolveDevice(opts.device),\n    });\n  }\n\n  const flip = p > 0.5;\n  const prob = flip ? 1 - p : p;\n  const q = 1 - prob;\n  if (q === 1) {\n    const value = flip ? n : 0;\n    for (let i = 0; i < size; i++) {\n      writeInteger(data, i, value);\n    }\n    return TensorClass.fromTypedArray({\n      data,\n      shape,\n      dtype,\n      device: resolveDevice(opts.device),\n    });\n  }\n  const mean = n * prob;\n  const logQ = Math.log(q);\n\n  if (mean < 10) {\n    for (let i = 0; i < size; i++) {\n      const sample = binomialSmallMean(n, logQ);\n      writeInteger(data, i, flip ? n - sample : sample);\n    }\n  } else {\n    const mode = Math.floor((n + 1) * prob);\n    const logP = Math.log(prob);\n    const logPmfMode =\n      logFactorial(n) -\n      logFactorial(mode) -\n      logFactorial(n - mode) +\n      mode * logP +\n      (n - mode) * logQ;\n    const pmfMode = Math.exp(logPmfMode);\n    if (!Number.isFinite(pmfMode) || pmfMode <= 0) {\n      throw new InvalidParameterError(\"Failed to initialize binomial sampler\", \"p\", p);\n    }\n    for (let i = 0; i < size; i++) {\n      const sample = binomialChopDown(n, prob, q, mode, pmfMode);\n      writeInteger(data, i, flip ? n - sample : sample);\n    }\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from Poisson distribution.\n *\n * @param lambda - Expected number of events (rate, must be >= 0)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When lambda is not finite or < 0\n *\n * @remarks\n * - Uses Knuth's method for lambda < 30, transformed rejection for lambda >= 30.\n * - Stable and efficient for all lambda values (tested up to lambda=1000+).\n * - lambda=0 always produces 0.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only int32 and int64 dtypes are supported.\n *\n * @example\n * ```js\n * import { poisson } from 'deepbox/random';\n *\n * const x = poisson(5, [100]);  // Rate = 5 events\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.poisson.html | NumPy random.poisson}\n */\nexport function poisson(lambda: number, shape: Shape = [], opts: RandomOptions = {}): Tensor {\n  if (!Number.isFinite(lambda) || lambda < 0) {\n    throw new InvalidParameterError(\"lambda must be a finite number >= 0\", \"lambda\", lambda);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveIntegerDType(opts.dtype, \"poisson\");\n  if (dtype === \"int32\") {\n    if (lambda > INT32_MAX) {\n      throw new InvalidParameterError(\n        `lambda must be <= ${INT32_MAX} for int32 output`,\n        \"lambda\",\n        lambda\n      );\n    }\n  }\n  const data = allocateIntegerBuffer(dtype, size);\n\n  if (lambda < 30) {\n    // Knuth's method for small lambda\n    const L = Math.exp(-lambda);\n    for (let i = 0; i < size; i++) {\n      let k = 0;\n      let p = 1;\n\n      do {\n        k++;\n        p *= __random();\n      } while (p > L);\n\n      const sample = k - 1;\n      if (!Number.isSafeInteger(sample)) {\n        throw new InvalidParameterError(\n          \"poisson sample exceeds safe integer range\",\n          \"lambda\",\n          lambda\n        );\n      }\n      if (dtype === \"int32\" && sample > INT32_MAX) {\n        throw new InvalidParameterError(\"poisson sample exceeds int32 range\", \"lambda\", lambda);\n      }\n      writeInteger(data, i, sample);\n    }\n  } else {\n    // Transformed rejection method for large lambda (Ahrens & Dieter)\n    const c = 0.767 - 3.36 / lambda;\n    const beta = Math.PI / Math.sqrt(3 * lambda);\n    const alpha = beta * lambda;\n    const k = Math.log(c) - lambda - Math.log(beta);\n\n    for (let i = 0; i < size; i++) {\n      while (true) {\n        const u = __random();\n        if (u === 0 || u === 1) continue;\n\n        const x = (alpha - Math.log((1 - u) / u)) / beta;\n        const n = Math.floor(x + 0.5);\n        if (n < 0 || !Number.isFinite(n)) continue;\n\n        const v = __random();\n        const y = alpha - beta * x;\n        const lhs = y + Math.log(v / (1 + Math.exp(y)) ** 2);\n        const rhs = k + n * Math.log(lambda) - logFactorial(n);\n\n        if (lhs <= rhs) {\n          if (!Number.isSafeInteger(n)) {\n            throw new InvalidParameterError(\n              \"poisson sample exceeds safe integer range\",\n              \"lambda\",\n              lambda\n            );\n          }\n          if (dtype === \"int32\" && n > INT32_MAX) {\n            throw new InvalidParameterError(\"poisson sample exceeds int32 range\", \"lambda\", lambda);\n          }\n          writeInteger(data, i, n);\n          break;\n        }\n      }\n    }\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from exponential distribution.\n *\n * @param scale - Scale parameter (1/lambda, default: 1, must be > 0)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When scale is not finite or <= 0\n *\n * @remarks\n * - Uses inverse transform sampling: -scale * log(U).\n * - All values are positive (u=0 is avoided to prevent infinities).\n * - Mean = scale, variance = scale^2.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { exponential } from 'deepbox/random';\n *\n * const x = exponential(2, [100]);\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.exponential.html | NumPy random.exponential}\n */\nexport function exponential(\n  scale: number = 1,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  if (!Number.isFinite(scale) || scale <= 0) {\n    throw new InvalidParameterError(\"scale must be a finite number > 0\", \"scale\", scale);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"exponential\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    const u = randomOpenUnit();\n    data[i] = -scale * Math.log(u);\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from gamma distribution.\n *\n * @param shape_param - Shape parameter (k, must be > 0)\n * @param scale - Scale parameter (theta, default: 1, must be > 0)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When shape_param is not finite or <= 0\n * @throws {InvalidParameterError} When scale is not finite or <= 0\n *\n * @remarks\n * - Uses Marsaglia and Tsang's method (2000) for efficient sampling.\n * - All values are positive.\n * - Mean = shape_param * scale, variance = shape_param * scale^2.\n * - For shape_param < 1, uses a transformation to handle the case.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { gamma } from 'deepbox/random';\n *\n * const x = gamma(2, 2, [100]);\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.gamma.html | NumPy random.gamma}\n */\nexport function gamma(\n  shape_param: number,\n  scale: number = 1,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  if (!Number.isFinite(shape_param) || shape_param <= 0) {\n    throw new InvalidParameterError(\n      \"shape_param must be a finite number > 0\",\n      \"shape_param\",\n      shape_param\n    );\n  }\n  if (!Number.isFinite(scale) || scale <= 0) {\n    throw new InvalidParameterError(\"scale must be a finite number > 0\", \"scale\", scale);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"gamma\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    data[i] = sampleGammaUnit(shape_param) * scale;\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\n/**\n * Random samples from beta distribution.\n *\n * @param alpha - Alpha parameter (must be > 0)\n * @param beta_param - Beta parameter (must be > 0)\n * @param shape - Output shape\n * @param opts - Options\n *\n * @throws {InvalidParameterError} When alpha is not finite or <= 0\n * @throws {InvalidParameterError} When beta_param is not finite or <= 0\n *\n * @remarks\n * - Uses ratio of two gamma distributions: X / (X + Y).\n * - All values are in the open interval (0, 1) up to floating-point rounding.\n * - Mean = alpha / (alpha + beta), useful for modeling proportions.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Only float32 and float64 dtypes are supported.\n *\n * @example\n * ```js\n * import { beta } from 'deepbox/random';\n *\n * const x = beta(2, 5, [100]);\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.beta.html | NumPy random.beta}\n */\nexport function beta(\n  alpha: number,\n  beta_param: number,\n  shape: Shape = [],\n  opts: RandomOptions = {}\n): Tensor {\n  if (!Number.isFinite(alpha) || alpha <= 0) {\n    throw new InvalidParameterError(\"alpha must be a finite number > 0\", \"alpha\", alpha);\n  }\n  if (!Number.isFinite(beta_param) || beta_param <= 0) {\n    throw new InvalidParameterError(\"beta must be a finite number > 0\", \"beta_param\", beta_param);\n  }\n  const size = shapeToSize(shape);\n  const dtype = resolveFloatDType(opts.dtype, \"beta\");\n  const data = allocateFloatBuffer(dtype, size);\n\n  for (let i = 0; i < size; i++) {\n    let sampled = false;\n    for (let attempt = 0; attempt < 1024; attempt++) {\n      const x = sampleGammaUnit(alpha);\n      const y = sampleGammaUnit(beta_param);\n      const sum = x + y;\n      if (!Number.isFinite(sum) || sum <= 0) {\n        continue;\n      }\n      const value = x / sum;\n      if (Number.isFinite(value) && value >= 0 && value <= 1) {\n        data[i] = value;\n        sampled = true;\n        break;\n      }\n    }\n    if (!sampled) {\n      throw new InvalidParameterError(\n        \"beta sampling failed to produce a finite sample\",\n        \"alpha/beta_param\",\n        { alpha, beta_param }\n      );\n    }\n  }\n\n  return TensorClass.fromTypedArray({\n    data,\n    shape,\n    dtype,\n    device: resolveDevice(opts.device),\n  });\n}\n\nfunction readNumericTensorValue(t: Tensor, index: number): number | bigint {\n  if (t.dtype === \"string\") {\n    throw new DTypeError(\"Expected numeric tensor\");\n  }\n  const value = t.data[index];\n  if (typeof value === \"number\" || typeof value === \"bigint\") {\n    return value;\n  }\n  throw new InvalidParameterError(\"Internal error: tensor index out of bounds\", \"index\", index);\n}\n\nfunction allocateNumericBuffer(dtype: DType, size: number): TypedArray {\n  switch (dtype) {\n    case \"float32\":\n      return new Float32Array(size);\n    case \"float64\":\n      return new Float64Array(size);\n    case \"int32\":\n      return new Int32Array(size);\n    case \"int64\":\n      return new BigInt64Array(size);\n    case \"uint8\":\n    case \"bool\":\n      return new Uint8Array(size);\n    case \"string\":\n      throw new DTypeError(\"choice() does not support string tensors\");\n  }\n}\n\nfunction writeNumericValue(out: TypedArray, index: number, value: number | bigint): void {\n  if (out instanceof BigInt64Array) {\n    out[index] = typeof value === \"bigint\" ? value : BigInt(Math.trunc(value));\n    return;\n  }\n  if (typeof value === \"bigint\") {\n    out[index] = Number(value);\n    return;\n  }\n  out[index] = value;\n}\n\nfunction buildNormalizedProbabilities(probabilities: Tensor, n: number): Float64Array {\n  if (probabilities.dtype === \"string\") {\n    throw new DTypeError(\"choice() probabilities must be numeric\");\n  }\n  if (probabilities.ndim !== 1) {\n    throw new InvalidParameterError(\"p must be a 1D tensor\", \"p\", probabilities.shape);\n  }\n  if (probabilities.size !== n) {\n    throw new InvalidParameterError(\n      \"p must have the same length as the population\",\n      \"p\",\n      probabilities.size\n    );\n  }\n  validateContiguous(probabilities, \"choice(p)\");\n\n  const normalized = new Float64Array(n);\n  let sum = 0;\n  for (let i = 0; i < n; i++) {\n    const value = Number(readNumericTensorValue(probabilities, i));\n    if (!Number.isFinite(value) || value < 0) {\n      throw new InvalidParameterError(\n        \"p must contain finite non-negative probabilities\",\n        \"p\",\n        value\n      );\n    }\n    normalized[i] = value;\n    sum += value;\n  }\n  if (!Number.isFinite(sum) || sum <= 0) {\n    throw new InvalidParameterError(\"sum(p) must be > 0 and finite\", \"p\", sum);\n  }\n  for (let i = 0; i < n; i++) {\n    normalized[i] = (normalized[i] ?? 0) / sum;\n  }\n  return normalized;\n}\n\nfunction sampleFromCdf(cdf: Float64Array): number {\n  const u = randomOpenUnit();\n  let left = 0;\n  let right = cdf.length - 1;\n  while (left < right) {\n    const mid = Math.floor((left + right) / 2);\n    const value = cdf[mid];\n    if (value === undefined) {\n      throw new InvalidParameterError(\"Internal error: invalid CDF index\", \"mid\", mid);\n    }\n    if (u <= value) {\n      right = mid;\n    } else {\n      left = mid + 1;\n    }\n  }\n  return left;\n}\n\n/**\n * Random sample from array.\n *\n * @param a - Input array or integer (if integer, sample from arange(a))\n * @param size - Number of samples or output shape\n * @param replace - Whether to sample with replacement (default: true)\n * @param p - Optional probability weights for weighted sampling\n *\n * @throws {InvalidParameterError} When population size is invalid (not finite, not integer, or < 0)\n * @throws {InvalidParameterError} When size > population and replace is false\n * @throws {InvalidParameterError} When tensor is not contiguous (offset !== 0 or non-standard strides)\n * @throws {DTypeError} When input tensor has string dtype\n *\n * @remarks\n * - Input tensor must be contiguous (no slicing/striding).\n * - With replacement: can sample more elements than population size.\n * - Without replacement: size must be <= population size.\n * - Does NOT modify the input tensor (returns a new tensor).\n * - Deterministic when seed is set via {@link setSeed}.\n * - If `a` is a number, the population is `0..a-1` and output dtype is int32.\n * - Numeric populations are limited to `a <= 2^31` for int32 output.\n *\n * @example\n * ```js\n * import { choice, tensor } from 'deepbox/random';\n *\n * const x = tensor([1, 2, 3, 4, 5]);\n * const sample = choice(x, 3);  // Pick 3 elements with replacement\n *\n * // Without replacement\n * const unique = choice(x, 3, false);  // All different elements\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html | NumPy random.choice}\n */\nexport function choice(\n  a: Tensor | number,\n  size?: number | Shape,\n  replace = true,\n  p?: Tensor\n): Tensor {\n  if (typeof a === \"number\") {\n    assertSafeInteger(a, \"a\");\n    if (a < 0) {\n      throw new InvalidParameterError(\"Invalid population size\", \"a\", a);\n    }\n    if (a > INT32_MAX + 1) {\n      throw new InvalidParameterError(\n        `Population size must be <= ${INT32_MAX + 1} for choice()`,\n        \"a\",\n        a\n      );\n    }\n  }\n\n  const aa: Tensor = typeof a === \"number\" ? arange(0, a, 1, { dtype: \"int32\" }) : a;\n\n  if (aa.dtype === \"string\") {\n    throw new DTypeError(\"choice() does not support string tensors\");\n  }\n\n  // Handle Tensor input: sample indices first, then gather values into a new tensor.\n  // Note: we currently require contiguous storage, because `choice` is defined over\n  // the flattened order. Using arbitrary strides would require computing a flat\n  // index mapping.\n  const n = aa.size;\n  if (!Number.isInteger(n) || n < 0) {\n    throw new InvalidParameterError(\"Invalid tensor size\", \"n\", n);\n  }\n  if (n > INT32_MAX + 1) {\n    throw new InvalidParameterError(`Population size must be <= ${INT32_MAX + 1}`, \"n\", n);\n  }\n\n  let outputSize: number;\n  if (typeof size === \"number\") {\n    outputSize = size;\n  } else if (size) {\n    validateShape(size);\n    outputSize = shapeToSize(size);\n  } else {\n    outputSize = 1;\n  }\n  if (!Number.isSafeInteger(outputSize) || outputSize < 0) {\n    throw new InvalidParameterError(\"size must be an integer >= 0\", \"size\", size);\n  }\n  if (outputSize > INT32_MAX) {\n    throw new InvalidParameterError(`size must be <= ${INT32_MAX}`, \"size\", outputSize);\n  }\n  if (n === 0 && outputSize > 0) {\n    throw new InvalidParameterError(\"Cannot sample from an empty population\", \"a\", a);\n  }\n\n  const indices = new Int32Array(outputSize);\n  const weights = p ? buildNormalizedProbabilities(p, n) : undefined;\n\n  if (weights) {\n    if (replace) {\n      const cdf = new Float64Array(weights.length);\n      let cumulative = 0;\n      for (let i = 0; i < weights.length; i++) {\n        cumulative += weights[i] ?? 0;\n        cdf[i] = cumulative;\n      }\n      cdf[cdf.length - 1] = 1;\n      for (let i = 0; i < outputSize; i++) {\n        indices[i] = sampleFromCdf(cdf);\n      }\n    } else {\n      let nonZeroCount = 0;\n      for (let i = 0; i < weights.length; i++) {\n        if ((weights[i] ?? 0) > 0) nonZeroCount++;\n      }\n      if (outputSize > nonZeroCount) {\n        throw new InvalidParameterError(\n          \"Cannot sample without replacement with zero-probability mass for requested size\",\n          \"size\",\n          outputSize\n        );\n      }\n\n      const remaining = new Float64Array(weights);\n      let remainingMass = 1;\n      for (let i = 0; i < outputSize; i++) {\n        if (remainingMass <= 0) {\n          throw new InvalidParameterError(\n            \"Insufficient probability mass to sample\",\n            \"p\",\n            remainingMass\n          );\n        }\n        const u = __random() * remainingMass;\n        let cumulative = 0;\n        let chosen = -1;\n        for (let j = 0; j < remaining.length; j++) {\n          const w = remaining[j] ?? 0;\n          if (w <= 0) {\n            continue;\n          }\n          cumulative += w;\n          if (u <= cumulative) {\n            chosen = j;\n            break;\n          }\n        }\n        if (chosen < 0) {\n          for (let j = remaining.length - 1; j >= 0; j--) {\n            if ((remaining[j] ?? 0) > 0) {\n              chosen = j;\n              break;\n            }\n          }\n        }\n        if (chosen < 0) {\n          throw new InvalidParameterError(\"Failed to select weighted sample\", \"p\", weights);\n        }\n        indices[i] = chosen;\n        remainingMass -= remaining[chosen] ?? 0;\n        remaining[chosen] = 0;\n      }\n    }\n  } else if (replace) {\n    for (let i = 0; i < outputSize; i++) {\n      indices[i] = randomIntBelow(n);\n    }\n  } else {\n    if (outputSize > n) {\n      throw new InvalidParameterError(\n        \"Cannot sample without replacement when size > population\",\n        \"size\",\n        outputSize\n      );\n    }\n    const pool = Array.from({ length: n }, (_, i) => i);\n    for (let i = 0; i < outputSize; i++) {\n      const j = randomIntBelow(n - i) + i;\n      const poolI = pool[i];\n      const poolJ = pool[j];\n      if (poolI === undefined || poolJ === undefined) {\n        throw new InvalidParameterError(\"Internal error: pool index out of bounds\", \"pool\", {\n          i,\n          j,\n          n,\n        });\n      }\n      pool[i] = poolJ;\n      pool[j] = poolI;\n      indices[i] = poolJ;\n    }\n  }\n\n  const outputShape: Shape = typeof size === \"number\" ? [size] : (size ?? [1]);\n\n  // Require contiguous layout for correctness.\n  validateContiguous(aa, \"choice()\");\n\n  // Allocate output buffer in the same dtype/device.\n  const out = allocateNumericBuffer(aa.dtype, outputSize);\n  for (let i = 0; i < outputSize; i++) {\n    const idx = indices[i];\n    if (idx === undefined) {\n      throw new InvalidParameterError(\"Internal error: undefined index\", \"indices\", i);\n    }\n    const value = readNumericTensorValue(aa, idx);\n    writeNumericValue(out, i, value);\n  }\n\n  return TensorClass.fromTypedArray({\n    data: out,\n    shape: outputShape,\n    dtype: aa.dtype,\n    device: aa.device,\n  });\n}\n\n/**\n * Randomly shuffle array in-place.\n *\n * @param x - Input tensor (**MODIFIED IN-PLACE**)\n *\n * @throws {InvalidParameterError} When tensor is not contiguous (offset !== 0 or non-standard strides)\n * @throws {DTypeError} When input tensor has string dtype\n *\n * @remarks\n * - **WARNING: This function mutates the input tensor directly.**\n * - Uses Fisher-Yates shuffle algorithm (O(n) time, optimal).\n * - Input tensor must be contiguous (no slicing/striding).\n * - All elements are preserved, only their order changes.\n * - Deterministic when seed is set via {@link setSeed}.\n * - If you need a shuffled copy without mutation, use {@link permutation} instead.\n *\n * @example\n * ```js\n * import { shuffle, tensor } from 'deepbox/random';\n *\n * const x = tensor([1, 2, 3, 4, 5]);\n * shuffle(x);  // x is now shuffled IN-PLACE\n * console.log(x);  // e.g., [3, 1, 5, 2, 4]\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.shuffle.html | NumPy random.shuffle}\n */\nexport function shuffle(x: Tensor): void {\n  if (x.dtype === \"string\") {\n    throw new DTypeError(\"shuffle() does not support string tensors\");\n  }\n  // For correctness, only allow shuffling of a contiguous tensor with offset 0.\n  // This ensures swapping elements maps to the logical flattened order.\n  validateContiguous(x, \"shuffle()\");\n\n  const data = x.data;\n  if (!isTypedArray(data)) {\n    throw new DTypeError(\"shuffle() does not support string tensors\");\n  }\n  const n = data.length;\n\n  // Fisher–Yates shuffle using the same RNG as the rest of the module.\n  // Split into two branches to maintain type safety without assertions.\n  if (data instanceof BigInt64Array) {\n    for (let i = n - 1; i > 0; i--) {\n      const j = randomIntBelow(i + 1);\n      const temp = data[i];\n      const swap = data[j];\n      if (temp === undefined || swap === undefined) {\n        throw new DeepboxError(\"Internal error: shuffle index out of bounds\");\n      }\n      data[i] = swap;\n      data[j] = temp;\n    }\n  } else {\n    for (let i = n - 1; i > 0; i--) {\n      const j = randomIntBelow(i + 1);\n      const temp = data[i];\n      const swap = data[j];\n      if (temp === undefined || swap === undefined) {\n        throw new DeepboxError(\"Internal error: shuffle index out of bounds\");\n      }\n      data[i] = swap;\n      data[j] = temp;\n    }\n  }\n}\n\n/**\n * Return random permutation of array.\n *\n * @param x - Input tensor or integer\n *\n * @throws {DTypeError} When input tensor has string dtype\n *\n * @remarks\n * - Returns a NEW tensor (does NOT modify input).\n * - If x is an integer, returns permutation of arange(x).\n * - If x is a tensor, returns a shuffled copy with the same shape.\n * - Tensor inputs must be contiguous (no slicing/striding).\n * - Uses Fisher-Yates shuffle algorithm internally.\n * - Deterministic when seed is set via {@link setSeed}.\n * - Numeric input is limited to `x <= 2^31` for int32 output.\n *\n * @example\n * ```js\n * import { permutation, tensor } from 'deepbox/random';\n *\n * // Permutation of integers\n * const x = permutation(10);  // Random permutation of [0...9]\n *\n * // Permutation of tensor (does not modify original)\n * const original = tensor([1, 2, 3, 4, 5]);\n * const shuffled = permutation(original);\n * // original is unchanged\n * ```\n *\n * @see {@link https://numpy.org/doc/stable/reference/random/generated/numpy.random.permutation.html | NumPy random.permutation}\n */\nexport function permutation(x: Tensor | number): Tensor {\n  if (typeof x === \"number\") {\n    assertSafeInteger(x, \"x\");\n    const n = x;\n    if (n < 0) {\n      throw new InvalidParameterError(\"x must be a non-negative integer\", \"x\", x);\n    }\n    if (n > INT32_MAX + 1) {\n      throw new InvalidParameterError(`x must be <= ${INT32_MAX + 1} for int32 output`, \"x\", x);\n    }\n    const indices = Array.from({ length: n }, (_, i) => i);\n\n    for (let i = n - 1; i > 0; i--) {\n      const j = randomIntBelow(i + 1);\n      const indicesI = indices[i];\n      const indicesJ = indices[j];\n      if (indicesI === undefined || indicesJ === undefined) {\n        throw new InvalidParameterError(\"Internal error: indices out of bounds\", \"indices\", {\n          i,\n          j,\n          n,\n        });\n      }\n      indices[i] = indicesJ;\n      indices[j] = indicesI;\n    }\n\n    return tensor(indices, { dtype: \"int32\" });\n  }\n\n  if (x.dtype === \"string\") {\n    throw new DTypeError(\"permutation() does not support string tensors\");\n  }\n\n  validateContiguous(x, \"permutation()\");\n  const data = x.data;\n  if (!isTypedArray(data)) {\n    throw new DTypeError(\"permutation() does not support string tensors\");\n  }\n  const copy = TensorClass.fromTypedArray({\n    data: data.slice(),\n    shape: x.shape,\n    dtype: x.dtype,\n    device: x.device,\n  });\n  shuffle(copy);\n  return copy;\n}\n","import { InvalidParameterError, NotImplementedError } from \"../core\";\n\n/**\n * Internal global seed.\n *\n * Note: we store the original user-provided number (after validation) so\n * `getSeed()` can return what the user set.\n */\nlet __globalSeed: number | undefined;\n\ntype CryptoLike = {\n  getRandomValues<T extends ArrayBufferView>(array: T): T;\n};\n\ndeclare const crypto: CryptoLike | undefined;\n\nconst UINT64_MASK = (1n << 64n) - 1n;\nconst PCG_MULT = 6364136223846793005n;\nconst SPLITMIX_GAMMA = 0x9e3779b97f4a7c15n;\nconst SPLITMIX_MIX1 = 0xbf58476d1ce4e5b9n;\nconst SPLITMIX_MIX2 = 0x94d049bb133111ebn;\n\nclass __SplitMix64 {\n  private state: bigint;\n\n  constructor(seed: bigint) {\n    this.state = seed & UINT64_MASK;\n  }\n\n  next(): bigint {\n    this.state = (this.state + SPLITMIX_GAMMA) & UINT64_MASK;\n    let z = this.state;\n    z = (z ^ (z >> 30n)) * SPLITMIX_MIX1;\n    z &= UINT64_MASK;\n    z = (z ^ (z >> 27n)) * SPLITMIX_MIX2;\n    z &= UINT64_MASK;\n    return z ^ (z >> 31n);\n  }\n}\n\n/**\n * PCG32 PRNG with 64-bit state.\n *\n * High statistical quality, fast, and deterministic across platforms.\n * Not cryptographically secure.\n */\nclass __SeededRandom {\n  /** Current uint64 state. */\n  private state: bigint;\n  /** Stream/sequence selector (must be odd). */\n  private inc: bigint;\n\n  /**\n   * Create a new PRNG from a seed.\n   *\n   * @param seedUint64 - Seed coerced to uint64.\n   */\n  constructor(seedUint64: bigint) {\n    const sm = new __SplitMix64(seedUint64);\n    this.state = sm.next();\n    this.inc = (sm.next() << 1n) | 1n;\n  }\n\n  /**\n   * Generate the next uint32 sample.\n   */\n  nextUint32(): number {\n    const oldstate = this.state;\n    this.state = (oldstate * PCG_MULT + this.inc) & UINT64_MASK;\n\n    // Output function: xorshift high bits, then rotate.\n    const xorshifted = Number(((oldstate >> 18n) ^ oldstate) >> 27n) >>> 0;\n    const rot = Number(oldstate >> 59n) & 31;\n    return ((xorshifted >>> rot) | (xorshifted << (-rot & 31))) >>> 0;\n  }\n\n  /**\n   * Generate the next uniform sample in [0, 1).\n   */\n  next(): number {\n    return this.nextUint32() / 2 ** 32;\n  }\n}\n\n/** Internal PRNG instance when a seed is set. */\nlet __rng: __SeededRandom | null = null;\n\n/**\n * Set the global seed for all random operations.\n *\n * @param seed - Any finite number. It will be coerced to uint64 for the PRNG.\n */\nexport function __setSeed(seed: number): void {\n  // Validate input.\n  if (!Number.isFinite(seed)) {\n    throw new InvalidParameterError(`seed must be a finite number; received ${seed}`, \"seed\", seed);\n  }\n\n  // Store the (validated) user value.\n  __globalSeed = seed;\n\n  // Coerce to uint64 for deterministic PRNG state.\n  const seedUint64 = BigInt.asUintN(64, BigInt(Math.trunc(seed)));\n  __rng = new __SeededRandom(seedUint64);\n}\n\n/**\n * Get the current global seed.\n */\nexport function __getSeed(): number | undefined {\n  return __globalSeed;\n}\n\n/**\n * Clear the global seed and revert to cryptographically secure randomness.\n */\nexport function __clearSeed(): void {\n  __globalSeed = undefined;\n  __rng = null;\n}\n\n/**\n * Generate a uniform random number in [0, 1).\n *\n * Uses the seeded PRNG when a seed is set; otherwise uses a cryptographically\n * secure RNG via `crypto.getRandomValues`.\n */\nfunction getCrypto(): CryptoLike | undefined {\n  if (typeof crypto === \"undefined\") {\n    return undefined;\n  }\n  if (typeof crypto.getRandomValues !== \"function\") {\n    return undefined;\n  }\n  return crypto;\n}\n\nfunction randomUint32FromCrypto(): number {\n  const crypto = getCrypto();\n  if (!crypto) {\n    throw new NotImplementedError(\n      \"Cryptographically secure randomness is unavailable in this environment. \" +\n        \"Provide a seed for deterministic randomness.\"\n    );\n  }\n  const buf = new Uint32Array(1);\n  crypto.getRandomValues(buf);\n  const value = buf[0];\n  if (value === undefined) {\n    throw new InvalidParameterError(\"Failed to read cryptographic randomness\", \"crypto\", value);\n  }\n  return value >>> 0;\n}\n\nexport function __random(): number {\n  // Use deterministic PRNG if available.\n  if (__rng) {\n    return __rng.next();\n  }\n\n  // Use cryptographically secure randomness when unseeded.\n  return randomUint32FromCrypto() / 2 ** 32;\n}\n\n/**\n * Generate a uniform uint32 random number in [0, 2^32).\n *\n * Uses the seeded PRNG when a seed is set; otherwise uses a cryptographically\n * secure RNG via `crypto.getRandomValues`.\n */\nexport function __randomUint32(): number {\n  if (__rng) {\n    return __rng.nextUint32();\n  }\n  return randomUint32FromCrypto();\n}\n\n/**\n * Generate a uniform integer in [0, 2^53).\n *\n * Uses two uint32 draws to build 53 bits of randomness.\n */\nexport function __randomUint53(): number {\n  const hi = __randomUint32() >>> 5; // 27 bits\n  const lo = __randomUint32() >>> 6; // 26 bits\n  return hi * 2 ** 26 + lo;\n}\n\n/**\n * Sample from the standard normal distribution (mean 0, std 1).\n *\n * Uses Box-Muller transform.\n *\n * Important: `log(0)` is `-Infinity`, so we avoid `u1 === 0`.\n */\nexport function __normalRandom(): number {\n  // Ensure u1 is in (0, 1] to avoid log(0).\n  let u1 = __random();\n  while (u1 === 0) {\n    u1 = __random();\n  }\n\n  // u2 can be 0 safely.\n  const u2 = __random();\n\n  // Box–Muller.\n  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);\n}\n\n/**\n * Sample from Gamma(shape, 1) using Marsaglia and Tsang's method (2000).\n *\n * Requires `shape > 1/3` (so that `d = shape - 1/3 > 0`).\n * For shape < 1, callers should use the transformation:\n * `Gamma(shape) = Gamma(shape+1) * U^(1/shape)` where U ~ Uniform(0,1).\n */\nexport function __gammaLarge(shape: number): number {\n  // Validate input.\n  // Marsaglia-Tsang requires d = shape - 1/3 > 0, i.e. shape > 1/3.\n  // Callers handle shape < 1 via Gamma(shape+1) * U^(1/shape).\n  if (!Number.isFinite(shape) || shape <= 1 / 3) {\n    throw new InvalidParameterError(\n      \"shape must be a finite number > 1/3 for Marsaglia-Tsang method\",\n      \"shape\",\n      shape\n    );\n  }\n\n  // Marsaglia-Tsang constants.\n  const d = shape - 1 / 3;\n  const c = 1 / Math.sqrt(9 * d);\n\n  // Rejection sampling loop.\n  while (true) {\n    let x: number;\n    let v: number;\n\n    // Generate a candidate using a standard normal.\n    do {\n      x = __normalRandom();\n      v = 1 + c * x;\n    } while (v <= 0);\n\n    // Cube v.\n    v = v * v * v;\n    const u = __random();\n\n    // Quick acceptance.\n    if (u < 1 - 0.0331 * x * x * x * x) {\n      return d * v;\n    }\n\n    // Squeeze test.\n    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) {\n      return d * v;\n    }\n  }\n}\n"]}