Struct RandomState 

pub struct RandomState { /* private fields */ }

RandomState for managing the state of random number generators

This struct is a wrapper around different types of random number generators. In the current implementation, it uses StdRng, but can be extended to support other RNG types in the future.

Implementations

impl RandomState

Extend RandomState with enhanced distribution methods

pub fn truncated_normal<T>( &self, mean: T, std: T, low: T, high: T, shape: &[usize], ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a truncated normal distribution

pub fn vonmises<T>(&self, mu: T, kappa: T, shape: &[usize]) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a von Mises distribution

pub fn noncentral_chisquare<T>( &self, df: T, nonc: T, shape: &[usize], ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a non-central chi-square distribution

pub fn noncentral_f<T>( &self, dfnum: T, dfden: T, nonc: T, shape: &[usize], ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a non-central F distribution

pub fn maxwell<T>(&self, scale: T, shape: &[usize]) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a Maxwell distribution

pub fn power<T>(&self, a: T, shape: &[usize]) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random values from a power distribution

pub fn multivariate_normal_cholesky<T>( &self, means: &[T], cov: &Array<T>, size: usize, ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate correlated random variables using the Cholesky decomposition

pub fn random_correlation_matrix<T>(&self, n: usize) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display + SampleUniform,

Generate a random correlation matrix

pub fn mixture_of_normals<T>( &self, weights: &[T], means: &[T], stds: &[T], shape: &[usize], ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate random samples from a mixture of distributions

pub fn sobol_sequence<T>(&self, dim: usize, n: usize) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate Sobol sequence for quasi-Monte Carlo methods

pub fn latin_hypercube<T>(&self, dim: usize, n: usize) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate Latin Hypercube samples

pub fn copula<T>( &self, corr: &Array<T>, n: usize, copula_type: &str, ) -> Result<Array<T>>

where T: Float + NumCast + Clone + Debug + Display,

Generate copula samples with a specified correlation structure

impl RandomState

pub fn new() -> Self

Create a new RandomState with a random seed

pub fn with_seed(seed: u64) -> Self

Create a new RandomState with the given seed

pub fn get_rng(&self) -> Result<MutexGuard<'_, StdRng>>

Get a locked reference to the RNG

pub fn random<T>(&self, shape: &[usize]) -> Result<Array<T>>

where T: Clone + SampleUniform + NumCast,

Generate uniform random values in [0, 1)

pub fn integers<T: Clone + PartialOrd + SampleUniform + Into<i64> + TryFrom<i64> + ToPrimitive>( &self, low: T, high: T, shape: &[usize], ) -> Result<Array<T>>

where <T as TryFrom<i64>>::Error: Debug,

Generate integers in the range [low, high)

Arguments

• low - Lower bound (inclusive)
• high - Upper bound (exclusive)
• shape - Shape of the output array

Returns

An array of random integers.

pub fn normal<T: Float + NumCast + Clone + Debug + Display>( &self, mean: T, std: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a normal (Gaussian) distribution

pub fn lognormal<T: Float + NumCast + Clone + Debug + Display>( &self, mean: T, sigma: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a log-normal distribution

pub fn beta<T: Float + NumCast + Clone + Debug + Display>( &self, a: T, b: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Beta distribution

pub fn chisquare<T: Float + NumCast + Clone + Debug + Display>( &self, df: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Chi-Square distribution

pub fn dirichlet<T: Float + NumCast + Clone + Debug + Display>( &self, alpha: &[T], shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Dirichlet distribution

pub fn student_t<T: Float + NumCast + Clone + Debug + Display>( &self, df: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Student’s t-distribution

pub fn poisson<T: NumCast + Clone + Debug>( &self, lam: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Poisson distribution

pub fn binomial<T: NumCast + Clone + Debug>( &self, n: u64, p: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Binomial distribution

pub fn cauchy<T: Float + NumCast + Clone + Debug + Display>( &self, loc: T, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Cauchy (Lorentz) distribution

pub fn uniform<T: Clone + PartialOrd + SampleUniform + ToPrimitive + NumCast>( &self, low: T, high: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a uniform distribution

pub fn bernoulli<T: Float + NumCast + Clone + Debug + Display>( &self, p: T, shape: &[usize], ) -> Result<Array<T>>

Generate binary random values with given probability of success

pub fn gamma<T: Float + NumCast + Clone + Debug + Display>( &self, shape_param: T, scale: T, size_shape: &[usize], ) -> Result<Array<T>>

Generate random values from a gamma distribution

pub fn exponential<T: Float + NumCast + Clone + Debug + Display>( &self, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from an exponential distribution

pub fn weibull<T: Float + NumCast + Clone + Debug + Display>( &self, shape_param: T, scale: T, size_shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Weibull distribution

pub fn shuffle<T: Clone>(&self, array: &mut Array<T>) -> Result<()>

Shuffle an array in-place

pub fn choice<T: Clone>( &self, array: &Array<T>, size: Option<usize>, replace: Option<bool>, ) -> Result<Array<T>>

Random choice from elements in an array

pub fn permutation<T: NumCast + Clone>(&self, n: usize) -> Result<Array<T>>

Generate a permutation of integers from 0 to n-1

pub fn standard_normal<T: Float + NumCast + Clone + Debug + Display>( &self, shape: &[usize], ) -> Result<Array<T>>

Generate a standard normal distribution

pub fn pareto<T: Float + NumCast + Clone + Debug + Display>( &self, alpha: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Pareto distribution

pub fn triangular<T: Float + NumCast + Clone + Debug + Display>( &self, low: T, mode: T, high: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Triangular distribution

pub fn pert<T: Float + NumCast + Clone + Debug + Display>( &self, min: T, mode: T, max: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a PERT distribution

impl RandomState

pub fn multivariate_normal<T: Float + NumCast + Clone + Debug + Display>( &self, mean: &[T], cov: &Array<T>, size: Option<&[usize]>, ) -> Result<Array<T>>

Generate random values from a multivariate normal distribution

pub fn multivariate_normal_with_rotation<T: Float + NumCast + Clone + Debug + Display>( &self, mean: &[T], cov: &Array<T>, size: Option<&[usize]>, rotation: Option<&Array<T>>, ) -> Result<Array<T>>

Generate random values from a multivariate normal distribution with rotation

Arguments

• mean - Mean vector
• cov - Covariance matrix
• size - Optional shape of the output array
• rotation - Optional rotation matrix

Returns

An array of random values from the multivariate normal distribution with rotation

pub fn laplace<T: Float + NumCast + Clone + Debug + Display>( &self, loc: T, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Laplace (double exponential) distribution

pub fn gumbel<T: Float + NumCast + Clone + Debug + Display>( &self, loc: T, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Gumbel distribution

pub fn logistic<T: Float + NumCast + Clone + Debug + Display>( &self, loc: T, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a logistic distribution

pub fn rayleigh<T: Float + NumCast + Clone + Debug + Display>( &self, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a rayleigh distribution

pub fn wald<T: Float + NumCast + Clone + Debug + Display>( &self, mean: T, scale: T, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Wald (inverse Gaussian) distribution

pub fn negative_binomial<T: NumCast + Clone + Debug>( &self, n: f64, p: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a negative binomial distribution

pub fn geometric<T: NumCast + Clone + Debug>( &self, p: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a geometric distribution

pub fn multinomial<T: NumCast + Clone + Debug>( &self, n: usize, pvals: &[f64], shape: Option<&[usize]>, ) -> Result<Array<T>>

Generate random values from a multinomial distribution

pub fn hypergeometric<T: NumCast + Clone + Debug>( &self, ngood: usize, nbad: usize, nsample: usize, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a hypergeometric distribution

pub fn zipf<T: NumCast + Clone + Debug>( &self, a: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a zipf distribution

pub fn logseries<T: NumCast + Clone + Debug>( &self, p: f64, shape: &[usize], ) -> Result<Array<T>>

Generate random values from a logseries distribution

pub fn multivariate_t<T: Float + NumCast + Clone + Debug + Display>( &self, mean: &[T], cov: &Array<T>, df: T, size: Option<&[usize]>, ) -> Result<Array<T>>

Generate random values from a multivariate t-distribution

The multivariate t-distribution is a generalization of the Student’s t-distribution to multiple dimensions. It’s characterized by a mean vector, covariance matrix, and degrees of freedom parameter.

Arguments

• mean - Mean vector (length n)
• cov - Covariance matrix (n x n, must be positive definite)
• df - Degrees of freedom (must be positive)
• size - Optional shape of the output array

Returns

An array of random values from the multivariate t-distribution

Errors

Returns an error if:

• Mean vector is empty
• Covariance matrix is not square or doesn’t match mean vector dimensions
• Covariance matrix is not positive definite
• Degrees of freedom is not positive

pub fn wishart<T: Float + NumCast + Clone + Debug + Display>( &self, df: T, scale: &Array<T>, size: Option<&[usize]>, ) -> Result<Array<T>>

Generate random values from a Wishart distribution

The Wishart distribution is a generalization of the chi-squared distribution to positive-definite matrices. It’s commonly used as the conjugate prior for the precision matrix (inverse covariance) in multivariate normal distributions.

Arguments

• df - Degrees of freedom (must be >= dimension of scale matrix)
• scale - Scale matrix (positive definite, p x p)
• size - Optional shape of the output array

Returns

An array of random positive-definite matrices from the Wishart distribution

Errors

Returns an error if:

• Scale matrix is not square
• Scale matrix is not positive definite
• Degrees of freedom is less than the dimension

pub fn frechet<T: Float + NumCast + Clone + Debug + Display>( &self, shape: T, loc: T, scale: T, output_shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Frechet distribution

The Frechet distribution (Type II extreme value distribution) is used in extreme value theory to model the maximum of a large sample of random variables.

Arguments

• shape - Shape parameter (alpha, must be positive)
• loc - Location parameter
• scale - Scale parameter (must be positive)
• output_shape - Shape of the output array

Returns

An array of random values from the Frechet distribution

Errors

Returns an error if:

• Shape parameter is not positive
• Scale parameter is not positive

pub fn gev<T: Float + NumCast + Clone + Debug + Display>( &self, shape: T, loc: T, scale: T, output_shape: &[usize], ) -> Result<Array<T>>

Generate random values from a Generalized Extreme Value (GEV) distribution

The GEV distribution combines three types of extreme value distributions:

• Type I (Gumbel): xi = 0
• Type II (Frechet): xi > 0
• Type III (Weibull): xi < 0

Arguments

• shape - Shape parameter (xi)
• loc - Location parameter (mu)
• scale - Scale parameter (sigma, must be positive)
• output_shape - Shape of the output array

Returns

An array of random values from the GEV distribution

Errors

Returns an error if:

• Scale parameter is not positive

Trait Implementations

impl Default for RandomState

fn default() -> Self

Returns the “default value” for a type.