numpy-ts 0.12.0 → 0.13.1

package/dist/types/common/ops/formatting.d.ts

@@ -0,0 +1,229 @@
+/**
+ * Array printing and formatting operations
+ *
+ * Functions for converting arrays and numbers to string representations.
+ * @module ops/formatting
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * Print options configuration
+ */
+export interface PrintOptions {
+    /** Total number of array elements that trigger summarization (default: 1000) */
+    threshold: number;
+    /** Number of elements to print at edges when summarizing (default: 3) */
+    edgeitems: number;
+    /** Number of digits of precision for floating point output (default: 8) */
+    precision: number;
+    /** Characters per line for array output (default: 75) */
+    linewidth: number;
+    /** If true, always use exponential format; if false, never; if null, auto (default: null) */
+    floatmode: 'fixed' | 'unique' | 'maxprec' | 'maxprec_equal';
+    /** If true, suppress printing of small floating point values (default: true) */
+    suppress: boolean;
+    /** String inserted between elements (default: ' ') */
+    separator: string;
+    /** Prefix for array string */
+    prefix: string;
+    /** Suffix for array string */
+    suffix: string;
+    /** String representation of nan (default: 'nan') */
+    nanstr: string;
+    /** String representation of inf (default: 'inf') */
+    infstr: string;
+    /** If true, use legacy printing mode (default: false) */
+    legacy: string | false;
+    /** Whether to print the sign of positive values (default: false) */
+    sign: ' ' | '+' | '-';
+}
+/**
+ * Set printing options for array output
+ *
+ * These options determine how arrays are converted to strings.
+ *
+ * @param options - Options to set
+ *
+ * @example
+ * ```typescript
+ * set_printoptions({ precision: 4, threshold: 100 });
+ * ```
+ */
+export declare function set_printoptions(options: Partial<PrintOptions>): void;
+/**
+ * Get current print options
+ *
+ * @returns Current print options
+ *
+ * @example
+ * ```typescript
+ * const opts = get_printoptions();
+ * console.log(opts.precision); // 8
+ * ```
+ */
+export declare function get_printoptions(): PrintOptions;
+/**
+ * Context manager for temporarily setting print options
+ *
+ * In JavaScript, this returns an object with enter/exit methods
+ * that can be used with try/finally.
+ *
+ * @param options - Options to set temporarily
+ * @returns Object with enter() and exit() methods
+ *
+ * @example
+ * ```typescript
+ * const ctx = printoptions({ precision: 2 });
+ * ctx.enter();
+ * try {
+ *   console.log(array2string(arr));
+ * } finally {
+ *   ctx.exit();
+ * }
+ * ```
+ */
+export declare function printoptions(options: Partial<PrintOptions>): {
+    enter: () => void;
+    exit: () => void;
+    apply: <T>(fn: () => T) => T;
+    _savedOptions: PrintOptions | null;
+};
+/**
+ * Format a floating-point number in positional notation
+ *
+ * @param x - Value to format
+ * @param precision - Number of digits after decimal point (default: from printoptions)
+ * @param unique - If true, use shortest representation (default: true)
+ * @param fractional - If true, always include fractional part (default: true)
+ * @param trim - Trim trailing zeros: 'k' (keep), '.' (trim after decimal), '0' (trim zeros), '-' (trim point and zeros)
+ * @param sign - Sign handling: '-' (only negative), '+' (always), ' ' (space for positive)
+ * @param pad_left - Pad left with spaces to this width
+ * @param pad_right - Pad right with zeros to this width
+ * @param min_digits - Minimum digits after decimal point
+ * @returns Formatted string
+ *
+ * @example
+ * ```typescript
+ * format_float_positional(3.14159265, 4); // '3.1416'
+ * format_float_positional(1000.0, 2);     // '1000.00'
+ * ```
+ */
+export declare function format_float_positional(x: number, precision?: number | null, unique?: boolean, fractional?: boolean, trim?: 'k' | '.' | '0' | '-', sign?: '-' | '+' | ' ', pad_left?: number | null, pad_right?: number | null, min_digits?: number | null): string;
+/**
+ * Format a floating-point number in scientific notation
+ *
+ * @param x - Value to format
+ * @param precision - Number of digits after decimal point (default: from printoptions)
+ * @param unique - If true, use shortest representation (default: true)
+ * @param trim - Trim trailing zeros: 'k' (keep), '.' (trim after decimal), '0' (trim zeros), '-' (trim point and zeros)
+ * @param sign - Sign handling: '-' (only negative), '+' (always), ' ' (space for positive)
+ * @param pad_left - Pad left with spaces to this width
+ * @param exp_digits - Minimum digits in exponent
+ * @param min_digits - Minimum digits after decimal point
+ * @returns Formatted string
+ *
+ * @example
+ * ```typescript
+ * format_float_scientific(3.14159265, 4); // '3.1416e+00'
+ * format_float_scientific(12345.0, 2);    // '1.23e+04'
+ * ```
+ */
+export declare function format_float_scientific(x: number, precision?: number | null, _unique?: boolean, trim?: 'k' | '.' | '0' | '-', sign?: '-' | '+' | ' ', pad_left?: number | null, exp_digits?: number, min_digits?: number | null): string;
+/**
+ * Return a string representation of a number in the given base
+ *
+ * For base 2, -36. Negative numbers are represented using two's complement
+ * if padding is specified, otherwise prefixed with '-'.
+ *
+ * @param number - Number to convert
+ * @param base - Base for representation (2-36, default: 2)
+ * @param padding - Minimum number of digits (pads with zeros)
+ * @returns String representation in the given base
+ *
+ * @example
+ * ```typescript
+ * base_repr(10, 2);      // '1010'
+ * base_repr(10, 16);     // 'A'
+ * base_repr(-10, 2, 8);  // '11110110' (two's complement)
+ * ```
+ */
+export declare function base_repr(number: number, base?: number, padding?: number): string;
+/**
+ * Return the binary representation of the input number as a string
+ *
+ * For negative numbers, two's complement is used if width is specified,
+ * otherwise a minus sign is prefixed.
+ *
+ * @param num - Integer to convert
+ * @param width - Minimum width of the result (pads with zeros, uses two's complement for negatives)
+ * @returns Binary string representation
+ *
+ * @example
+ * ```typescript
+ * binary_repr(10);      // '1010'
+ * binary_repr(-10);     // '-1010'
+ * binary_repr(-10, 8);  // '11110110' (two's complement)
+ * ```
+ */
+export declare function binary_repr(num: number, width?: number | null): string;
+/**
+ * Convert an array to a string representation
+ *
+ * @param a - Input array storage
+ * @param max_line_width - Maximum line width (default: from printoptions)
+ * @param precision - Number of digits of precision (default: from printoptions)
+ * @param suppress_small - Suppress small floating point values (default: from printoptions)
+ * @param separator - Separator between elements (default: from printoptions)
+ * @param prefix - Prefix string (default: '')
+ * @param suffix - Suffix string (default: '')
+ * @param threshold - Threshold for summarization (default: from printoptions)
+ * @param edgeitems - Number of edge items when summarizing (default: from printoptions)
+ * @returns String representation of the array
+ *
+ * @example
+ * ```typescript
+ * const arr = array([[1, 2, 3], [4, 5, 6]]);
+ * console.log(array2string(arr.storage));
+ * // [[1 2 3]
+ * //  [4 5 6]]
+ * ```
+ */
+export declare function array2string(a: ArrayStorage, max_line_width?: number | null, precision?: number | null, suppress_small?: boolean | null, separator?: string, prefix?: string, suffix?: string, threshold?: number | null, edgeitems?: number | null, floatmode?: 'fixed' | 'unique' | 'maxprec' | 'maxprec_equal' | null, sign?: ' ' | '+' | '-' | null): string;
+/**
+ * Return the string representation of an array
+ *
+ * Similar to array2string but includes the 'array(' prefix.
+ *
+ * @param a - Input array storage
+ * @param max_line_width - Maximum line width
+ * @param precision - Number of digits of precision
+ * @param suppress_small - Suppress small floating point values
+ * @returns String representation
+ *
+ * @example
+ * ```typescript
+ * const arr = array([1, 2, 3]);
+ * console.log(array_repr(arr.storage));
+ * // array([1, 2, 3])
+ * ```
+ */
+export declare function array_repr(a: ArrayStorage, max_line_width?: number | null, precision?: number | null, suppress_small?: boolean | null): string;
+/**
+ * Return a string representation of the data in an array
+ *
+ * Similar to array2string but returns just the data without array() wrapper.
+ *
+ * @param a - Input array storage
+ * @param max_line_width - Maximum line width
+ * @param precision - Number of digits of precision
+ * @param suppress_small - Suppress small floating point values
+ * @returns String representation of the data
+ *
+ * @example
+ * ```typescript
+ * const arr = array([1, 2, 3]);
+ * console.log(array_str(arr.storage));
+ * // [1 2 3]
+ * ```
+ */
+export declare function array_str(a: ArrayStorage, max_line_width?: number | null, precision?: number | null, suppress_small?: boolean | null): string;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/types/{ops → common/ops}/gradient.d.ts

@@ -7,7 +7,7 @@
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Calculate the n-th discrete difference along the given axis.
  *

package/dist/types/{ops → common/ops}/hyperbolic.d.ts

@@ -7,7 +7,7 @@
  * These functions are used by NDArray methods but are separated
  * to keep the codebase modular and testable.
  */
-import { ArrayStorage } from '../core/storage';
+import { ArrayStorage } from '../storage';
 /**
  * Hyperbolic sine of each element (element-wise)
  * NumPy behavior: Always promotes to float64 for integer types

package/dist/types/{ops → common/ops}/linalg.d.ts

@@ -4,8 +4,8 @@
  * Pure functions for matrix operations (matmul, etc.).
  * @module ops/linalg
  */
-import { ArrayStorage } from '../core/storage';
-import { Complex } from '../core/complex';
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
 /**
  * Dot product of two arrays (fully NumPy-compatible)
  *
@@ -158,7 +158,7 @@ export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @param axis - If defined, the axis of a, b and c that defines the vectors
  * @returns Cross product of a and b
  */
-export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number;
+export declare function cross(a: ArrayStorage, b: ArrayStorage, axisa?: number, axisb?: number, axisc?: number, axis?: number): ArrayStorage | number | Complex;
 /**
  * Vector norm.
  *
@@ -488,4 +488,25 @@ export declare function tensorinv(a: ArrayStorage, ind?: number): ArrayStorage;
  * @returns Solution tensor x
  */
 export declare function tensorsolve(a: ArrayStorage, b: ArrayStorage, axes?: number[] | null): ArrayStorage;
+/**
+ * Evaluate the lowest cost contraction order for an einsum expression
+ *
+ * This function analyzes an einsum expression and finds an optimized contraction
+ * path that minimizes the total number of operations (FLOPs).
+ *
+ * @param subscripts - Einsum subscript string (e.g., 'ij,jk,kl->il')
+ * @param operands - Input arrays (or their shapes)
+ * @param optimize - Optimization strategy: 'greedy' (default), 'optimal', or false for no optimization
+ * @returns A tuple of [path, string_representation] where path is an array of index pairs
+ *
+ * @example
+ * ```typescript
+ * const a = ones([10, 10]);
+ * const b = ones([10, 10]);
+ * const c = ones([10, 10]);
+ * const [path, info] = einsum_path('ij,jk,kl->il', a.storage, b.storage, c.storage);
+ * // path: [[0, 1], [0, 1]] - contract first two, then result with third
+ * ```
+ */
+export declare function einsum_path(subscripts: string, ...operands: (ArrayStorage | number[])[]): [Array<[number, number] | number[]>, string];
 //# sourceMappingURL=linalg.d.ts.map

package/dist/types/{ops → common/ops}/logic.d.ts

@@ -8,8 +8,8 @@
  * These operations convert values to boolean (non-zero = true, zero = false)
  * and return boolean arrays (dtype: 'bool').
  */
-import { ArrayStorage } from '../core/storage';
-import { type DType } from '../core/dtype';
+import { ArrayStorage } from '../storage';
+import { type DType } from '../dtype';
 /**
  * Logical AND of two arrays or array and scalar
  *

package/dist/types/common/ops/random.d.ts

@@ -0,0 +1,376 @@
+/**
+ * Random number generation module
+ *
+ * Implements NumPy-compatible random functions:
+ * - Legacy API (np.random.seed, random, rand, uniform, etc.) uses MT19937
+ * - Modern API (np.random.default_rng) uses PCG64 with SeedSequence
+ *
+ * Both implementations produce identical output to NumPy when seeded.
+ */
+import { ArrayStorage } from '../storage';
+import { type DType } from '../dtype';
+/**
+ * Random number generator class (matches NumPy's Generator from default_rng)
+ */
+export declare class Generator {
+    private _pcgState;
+    constructor(seedValue?: number);
+    private _randomFloat;
+    random(size?: number | number[]): ArrayStorage | number;
+    integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    standard_normal(size?: number | number[]): ArrayStorage | number;
+    normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+    uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+    choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+    permutation(x: number | ArrayStorage): ArrayStorage;
+    shuffle(x: ArrayStorage): void;
+    exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+    poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+    binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+}
+/**
+ * Create a new Generator instance (matches np.random.default_rng)
+ * @param seedValue - Optional seed value
+ */
+export declare function default_rng(seedValue?: number): Generator;
+/**
+ * Seed the random number generator (legacy API)
+ * @param seedValue - Seed value (integer)
+ */
+export declare function seed(seedValue?: number | null): void;
+/**
+ * Get the internal state of the random number generator
+ * @returns State object that can be used with set_state
+ */
+export declare function get_state(): {
+    mt: number[];
+    mti: number;
+};
+/**
+ * Set the internal state of the random number generator
+ * @param state - State object from get_state
+ */
+export declare function set_state(state: {
+    mt: number[];
+    mti: number;
+}): void;
+/**
+ * Generate random floats in the half-open interval [0.0, 1.0)
+ * @param size - Output shape. If not provided, returns a single float.
+ */
+export declare function random(size?: number | number[]): ArrayStorage | number;
+/**
+ * Random values in a given shape (alias for random with shape)
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function rand(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random floats from standard normal distribution
+ * @param d0, d1, ..., dn - The dimensions of the returned array
+ */
+export declare function randn(...shape: number[]): ArrayStorage | number;
+/**
+ * Return random integers from low (inclusive) to high (exclusive)
+ * @param low - Lowest integer (or high if high is not provided)
+ * @param high - One above the highest integer (optional)
+ * @param size - Output shape
+ * @param dtype - Output dtype (default 'int64')
+ */
+export declare function randint(low: number, high?: number | null, size?: number | number[], dtype?: DType): ArrayStorage | number;
+/**
+ * Draw samples from a uniform distribution
+ * @param low - Lower boundary (default 0)
+ * @param high - Upper boundary (default 1)
+ * @param size - Output shape
+ */
+export declare function uniform(low?: number, high?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a normal (Gaussian) distribution
+ * @param loc - Mean of the distribution (default 0)
+ * @param scale - Standard deviation (default 1)
+ * @param size - Output shape
+ */
+export declare function normal(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard normal distribution (mean=0, std=1)
+ * @param size - Output shape
+ */
+export declare function standard_normal(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from an exponential distribution
+ * @param scale - The scale parameter (beta = 1/lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function exponential(scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Poisson distribution
+ * @param lam - Expected number of events (lambda) (default 1)
+ * @param size - Output shape
+ */
+export declare function poisson(lam?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a binomial distribution
+ * @param n - Number of trials
+ * @param p - Probability of success
+ * @param size - Output shape
+ */
+export declare function binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Generate a random sample from a given 1-D array
+ * @param a - Input array or int. If int, samples from arange(a)
+ * @param size - Output shape
+ * @param replace - Whether sampling with replacement (default true)
+ * @param p - Probabilities associated with each entry
+ */
+export declare function choice(a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]): ArrayStorage | number;
+/**
+ * Randomly permute a sequence, or return a permuted range
+ * @param x - Input array or int. If int, returns permutation of arange(x)
+ */
+export declare function permutation(x: number | ArrayStorage): ArrayStorage;
+/**
+ * Modify a sequence in-place by shuffling its contents
+ * @param x - Array to be shuffled
+ */
+export declare function shuffle(x: ArrayStorage): void;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function random_sample(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function ranf(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random floats in the half-open interval [0.0, 1.0)
+ * Alias for random()
+ * @param size - Output shape
+ */
+export declare function sample(size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random integers between low and high, inclusive (DEPRECATED)
+ * @deprecated Use randint instead
+ * @param low - Lowest integer
+ * @param high - Highest integer (inclusive, unlike randint)
+ * @param size - Output shape
+ */
+export declare function random_integers(low: number, high?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Return random bytes
+ * @param length - Number of bytes to return
+ */
+export declare function bytes(length: number): Uint8Array;
+interface BitGenerator {
+    name: string;
+    state: object;
+}
+/**
+ * Get the current bit generator
+ * @returns The current bit generator object
+ */
+export declare function get_bit_generator(): BitGenerator;
+/**
+ * Set the bit generator
+ * @param bitgen - The bit generator to use
+ */
+export declare function set_bit_generator(bitgen: BitGenerator): void;
+/**
+ * Draw samples from the standard exponential distribution (scale=1)
+ * @param size - Output shape
+ */
+export declare function standard_exponential(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard gamma distribution
+ * Uses Marsaglia and Tsang's method
+ * @param shape - Shape parameter (alpha, must be > 0)
+ * @param size - Output shape
+ */
+export declare function standard_gamma(shape: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard Cauchy distribution
+ * @param size - Output shape
+ */
+export declare function standard_cauchy(size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a standard Student's t distribution with df degrees of freedom
+ * @param df - Degrees of freedom (must be > 0)
+ * @param size - Output shape
+ */
+export declare function standard_t(df: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Gamma distribution
+ * @param shape - Shape parameter (k, alpha) (must be > 0)
+ * @param scale - Scale parameter (theta) (default 1.0)
+ * @param size - Output shape
+ */
+export declare function gamma(shape: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Beta distribution
+ * @param a - Alpha parameter (must be > 0)
+ * @param b - Beta parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function beta(a: number, b: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Laplace (double exponential) distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function laplace(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a logistic distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function logistic(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a log-normal distribution
+ * @param mean - Mean of the underlying normal distribution (default 0)
+ * @param sigma - Standard deviation of the underlying normal (default 1)
+ * @param size - Output shape
+ */
+export declare function lognormal(mean?: number, sigma?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Gumbel distribution
+ * @param loc - Location parameter (default 0)
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function gumbel(loc?: number, scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Pareto II (Lomax) distribution
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function pareto(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a power distribution with positive exponent a-1
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function power(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Rayleigh distribution
+ * @param scale - Scale parameter (default 1)
+ * @param size - Output shape
+ */
+export declare function rayleigh(scale?: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a triangular distribution
+ * @param left - Lower limit
+ * @param mode - Mode (peak)
+ * @param right - Upper limit
+ * @param size - Output shape
+ */
+export declare function triangular(left: number, mode: number, right: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Wald (inverse Gaussian) distribution
+ * @param mean - Mean of distribution (must be > 0)
+ * @param scale - Scale parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function wald(mean: number, scale: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Weibull distribution
+ * @param a - Shape parameter (must be > 0)
+ * @param size - Output shape
+ */
+export declare function weibull(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a chi-square distribution
+ * @param df - Degrees of freedom (must be > 0)
+ * @param size - Output shape
+ */
+export declare function chisquare(df: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a noncentral chi-square distribution
+ * @param df - Degrees of freedom (must be > 0)
+ * @param nonc - Non-centrality parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function noncentral_chisquare(df: number, nonc: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from an F distribution
+ * @param dfnum - Degrees of freedom in numerator (must be > 0)
+ * @param dfden - Degrees of freedom in denominator (must be > 0)
+ * @param size - Output shape
+ */
+export declare function f(dfnum: number, dfden: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a noncentral F distribution
+ * @param dfnum - Degrees of freedom in numerator (must be > 0)
+ * @param dfden - Degrees of freedom in denominator (must be > 0)
+ * @param nonc - Non-centrality parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function noncentral_f(dfnum: number, dfden: number, nonc: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a geometric distribution
+ * @param p - Probability of success (0 < p <= 1)
+ * @param size - Output shape
+ */
+export declare function geometric(p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a hypergeometric distribution
+ * @param ngood - Number of good elements in population
+ * @param nbad - Number of bad elements in population
+ * @param nsample - Number of items to sample
+ * @param size - Output shape
+ */
+export declare function hypergeometric(ngood: number, nbad: number, nsample: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a logarithmic series distribution
+ * @param p - Shape parameter (0 < p < 1)
+ * @param size - Output shape
+ */
+export declare function logseries(p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a negative binomial distribution
+ * @param n - Number of successes (must be > 0)
+ * @param p - Probability of success (0 < p <= 1)
+ * @param size - Output shape
+ */
+export declare function negative_binomial(n: number, p: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a Zipf distribution
+ * @param a - Distribution parameter (must be > 1)
+ * @param size - Output shape
+ */
+export declare function zipf(a: number, size?: number | number[]): ArrayStorage | number;
+/**
+ * Draw samples from a multinomial distribution
+ * @param n - Number of experiments
+ * @param pvals - Probabilities of each category (must sum to 1)
+ * @param size - Output shape (number of experiments to run)
+ */
+export declare function multinomial(n: number, pvals: number[] | ArrayStorage, size?: number | number[]): ArrayStorage;
+/**
+ * Draw samples from a multivariate normal distribution
+ * @param mean - Mean of the distribution (1-D array of length N)
+ * @param cov - Covariance matrix (N x N array)
+ * @param size - Number of samples to draw
+ * @param check_valid - Check validity of covariance matrix (default 'warn')
+ * @param tol - Tolerance for checking positive semi-definiteness
+ */
+export declare function multivariate_normal(mean: number[] | ArrayStorage, cov: number[][] | ArrayStorage, size?: number | number[], check_valid?: 'warn' | 'raise' | 'ignore', tol?: number): ArrayStorage;
+/**
+ * Draw samples from a Dirichlet distribution
+ * @param alpha - Concentration parameters (must all be > 0)
+ * @param size - Number of samples to draw
+ */
+export declare function dirichlet(alpha: number[] | ArrayStorage, size?: number | number[]): ArrayStorage;
+/**
+ * Draw samples from a von Mises distribution
+ * @param mu - Mode (center) of the distribution (in radians)
+ * @param kappa - Concentration parameter (must be >= 0)
+ * @param size - Output shape
+ */
+export declare function vonmises(mu: number, kappa: number, size?: number | number[]): ArrayStorage | number;
+export {};
+//# sourceMappingURL=random.d.ts.map