[−][src]Trait ndarray_rand::RandomExt
Constructors for n-dimensional arrays with random elements.
This trait extends ndarray’s ArrayBase
and can not be implemented
for other types.
The default RNG is a fast automatically seeded rng (currently
rand::rngs::SmallRng
, seeded from rand::thread_rng
).
Note that SmallRng
is cheap to initialize and fast, but it may generate
low-quality random numbers, and reproducibility is not guaranteed. See its
documentation for information. You can select a different RNG with
.random_using()
.
Required methods
pub fn random<Sh, IdS>(shape: Sh, distribution: IdS) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
[src]
IdS: Distribution<S::Elem>,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
Create an array with shape dim
with elements drawn from
distribution
using the default RNG.
Panics if creation of the RNG fails or if the number of elements overflows usize.
use ndarray::Array; use ndarray_rand::RandomExt; use ndarray_rand::rand_distr::Uniform; let a = Array::random((2, 5), Uniform::new(0., 10.)); println!("{:8.4}", a); // Example Output: // [[ 8.6900, 6.9824, 3.8922, 6.5861, 2.4890], // [ 0.0914, 5.5186, 5.8135, 5.2361, 3.1879]]
pub fn random_using<Sh, IdS, R: ?Sized>(
shape: Sh,
distribution: IdS,
rng: &mut R
) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
R: Rng,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
[src]
shape: Sh,
distribution: IdS,
rng: &mut R
) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
R: Rng,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
Create an array with shape dim
with elements drawn from
distribution
, using a specific Rng rng
.
Panics if the number of elements overflows usize.
use ndarray::Array; use ndarray_rand::RandomExt; use ndarray_rand::rand::SeedableRng; use ndarray_rand::rand_distr::Uniform; use rand_isaac::isaac64::Isaac64Rng; // Get a seeded random number generator for reproducibility (Isaac64 algorithm) let seed = 42; let mut rng = Isaac64Rng::seed_from_u64(seed); // Generate a random array using `rng` let a = Array::random_using((2, 5), Uniform::new(0., 10.), &mut rng); println!("{:8.4}", a); // Example Output: // [[ 8.6900, 6.9824, 3.8922, 6.5861, 2.4890], // [ 0.0914, 5.5186, 5.8135, 5.2361, 3.1879]]
pub fn sample_axis(
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy
) -> Array<A, D> where
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
[src]
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy
) -> Array<A, D> where
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
Sample n_samples
lanes slicing along axis
using the default RNG.
If strategy==SamplingStrategy::WithoutReplacement
, each lane can only be sampled once.
If strategy==SamplingStrategy::WithReplacement
, each lane can be sampled multiple times.
Panics when:
- creation of the RNG fails;
n_samples
is greater than the length ofaxis
(if sampling without replacement);- length of
axis
is 0.
use ndarray::{array, Axis}; use ndarray_rand::{RandomExt, SamplingStrategy}; let a = array![ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.], ]; // Sample 2 rows, without replacement let sample_rows = a.sample_axis(Axis(0), 2, SamplingStrategy::WithoutReplacement); println!("{:?}", sample_rows); // Example Output: (1st and 3rd rows) // [ // [1., 2., 3.], // [7., 8., 9.] // ] // Sample 2 columns, with replacement let sample_columns = a.sample_axis(Axis(1), 1, SamplingStrategy::WithReplacement); println!("{:?}", sample_columns); // Example Output: (2nd column, sampled twice) // [ // [2., 2.], // [5., 5.], // [8., 8.], // [11., 11.] // ]
pub fn sample_axis_using<R: ?Sized>(
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy,
rng: &mut R
) -> Array<A, D> where
R: Rng,
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
[src]
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy,
rng: &mut R
) -> Array<A, D> where
R: Rng,
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
Sample n_samples
lanes slicing along axis
using the specified RNG rng
.
If strategy==SamplingStrategy::WithoutReplacement
, each lane can only be sampled once.
If strategy==SamplingStrategy::WithReplacement
, each lane can be sampled multiple times.
Panics when:
- creation of the RNG fails;
n_samples
is greater than the length ofaxis
(if sampling without replacement);- length of
axis
is 0.
use ndarray::{array, Axis}; use ndarray_rand::{RandomExt, SamplingStrategy}; use ndarray_rand::rand::SeedableRng; use rand_isaac::isaac64::Isaac64Rng; // Get a seeded random number generator for reproducibility (Isaac64 algorithm) let seed = 42; let mut rng = Isaac64Rng::seed_from_u64(seed); let a = array![ [1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.], ]; // Sample 2 rows, without replacement let sample_rows = a.sample_axis_using(Axis(0), 2, SamplingStrategy::WithoutReplacement, &mut rng); println!("{:?}", sample_rows); // Example Output: (1st and 3rd rows) // [ // [1., 2., 3.], // [7., 8., 9.] // ] // Sample 2 columns, with replacement let sample_columns = a.sample_axis_using(Axis(1), 1, SamplingStrategy::WithReplacement, &mut rng); println!("{:?}", sample_columns); // Example Output: (2nd column, sampled twice) // [ // [2., 2.], // [5., 5.], // [8., 8.], // [11., 11.] // ]
Implementations on Foreign Types
impl<S, A, D> RandomExt<S, A, D> for ArrayBase<S, D> where
S: RawData<Elem = A>,
D: Dimension,
[src]
S: RawData<Elem = A>,
D: Dimension,
pub fn random<Sh, IdS>(shape: Sh, dist: IdS) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
[src]
IdS: Distribution<S::Elem>,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
pub fn random_using<Sh, IdS, R: ?Sized>(
shape: Sh,
dist: IdS,
rng: &mut R
) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
R: Rng,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
[src]
shape: Sh,
dist: IdS,
rng: &mut R
) -> ArrayBase<S, D> where
IdS: Distribution<S::Elem>,
R: Rng,
S: DataOwned<Elem = A>,
Sh: ShapeBuilder<Dim = D>,
pub fn sample_axis(
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy
) -> Array<A, D> where
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
[src]
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy
) -> Array<A, D> where
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
pub fn sample_axis_using<R: ?Sized>(
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy,
rng: &mut R
) -> Array<A, D> where
R: Rng,
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,
[src]
&self,
axis: Axis,
n_samples: usize,
strategy: SamplingStrategy,
rng: &mut R
) -> Array<A, D> where
R: Rng,
A: Copy,
S: Data<Elem = A>,
D: RemoveAxis,