Skip to content

Commit 4f8257a

Browse files
vksvks
authored
Rename Rng::gen to Rng::random (#1438)
1 parent 089d993 commit 4f8257a

File tree

16 files changed

+76
-67
lines changed

16 files changed

+76
-67
lines changed

‎CHANGELOG.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
1111
## [Unreleased]
1212
- Add `rand::distributions::WeightedIndex::{weight, weights, total_weight}` (#1420)
1313
- Bump the MSRV to 1.61.0
14+
- Rename `Rng::gen` to `Rng::random` to avoid conflict with the new `gen` keyword in Rust 2024 (#1435)
1415
- Move all benchmarks to new `benches` crate (#1439)
1516

1617
## [0.9.0-alpha.1] - 2024-03-18

‎benches/benches/misc.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,7 @@ fn gen_1kb_u16_iter_repeat(b: &mut Bencher) {
101101
use core::iter;
102102
let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
103103
b.iter(|| {
104-
let v: Vec<u16> = iter::repeat(()).map(|()| rng.gen()).take(512).collect();
104+
let v: Vec<u16> = iter::repeat(()).map(|()| rng.random()).take(512).collect();
105105
v
106106
});
107107
b.bytes = 1024;
@@ -122,7 +122,7 @@ fn gen_1kb_u16_gen_array(b: &mut Bencher) {
122122
let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
123123
b.iter(|| {
124124
// max supported array length is 32!
125-
let v: [[u16; 32]; 16] = rng.gen();
125+
let v: [[u16; 32]; 16] = rng.random();
126126
v
127127
});
128128
b.bytes = 1024;
@@ -144,7 +144,7 @@ fn gen_1kb_u64_iter_repeat(b: &mut Bencher) {
144144
use core::iter;
145145
let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
146146
b.iter(|| {
147-
let v: Vec<u64> = iter::repeat(()).map(|()| rng.gen()).take(128).collect();
147+
let v: Vec<u64> = iter::repeat(()).map(|()| rng.random()).take(128).collect();
148148
v
149149
});
150150
b.bytes = 1024;
@@ -165,7 +165,7 @@ fn gen_1kb_u64_gen_array(b: &mut Bencher) {
165165
let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
166166
b.iter(|| {
167167
// max supported array length is 32!
168-
let v: [[u64; 32]; 4] = rng.gen();
168+
let v: [[u64; 32]; 4] = rng.random();
169169
v
170170
});
171171
b.bytes = 1024;

‎examples/monty-hall.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ fn simulate<R: Rng>(random_door: &Uniform<u32>, rng: &mut R) -> SimulationResult
4545
let open = game_host_open(car, choice, rng);
4646

4747
// Shall we switch?
48-
let switch = rng.gen();
48+
let switch = rng.random();
4949
if switch {
5050
choice = switch_door(choice, open);
5151
}

‎src/distributions/bernoulli.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -136,7 +136,7 @@ impl Distribution<bool> for Bernoulli {
136136
if self.p_int == ALWAYS_TRUE {
137137
return true;
138138
}
139-
let v: u64 = rng.gen();
139+
let v: u64 = rng.random();
140140
v < self.p_int
141141
}
142142
}

‎src/distributions/float.rs

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -115,7 +115,7 @@ macro_rules! float_impls {
115115
let precision = $fraction_bits + 1;
116116
let scale = 1.0 / ((1 as $u_scalar << precision) as $f_scalar);
117117

118-
let value: $uty = rng.gen();
118+
let value: $uty = rng.random();
119119
let value = value >> $uty::splat(float_size - precision);
120120
$ty::splat(scale) * $ty::cast_from_int(value)
121121
}
@@ -132,7 +132,7 @@ macro_rules! float_impls {
132132
let precision = $fraction_bits + 1;
133133
let scale = 1.0 / ((1 as $u_scalar << precision) as $f_scalar);
134134

135-
let value: $uty = rng.gen();
135+
let value: $uty = rng.random();
136136
let value = value >> $uty::splat(float_size - precision);
137137
// Add 1 to shift up; will not overflow because of right-shift:
138138
$ty::splat(scale) * $ty::cast_from_int(value + $uty::splat(1))
@@ -149,7 +149,7 @@ macro_rules! float_impls {
149149
use core::$f_scalar::EPSILON;
150150
let float_size = mem::size_of::<$f_scalar>() as $u_scalar * 8;
151151

152-
let value: $uty = rng.gen();
152+
let value: $uty = rng.random();
153153
let fraction = value >> $uty::splat(float_size - $fraction_bits);
154154
fraction.into_float_with_exponent(0) - $ty::splat(1.0 - EPSILON / 2.0)
155155
}
@@ -192,11 +192,11 @@ mod tests {
192192

193193
// Standard
194194
let mut zeros = StepRng::new(0, 0);
195-
assert_eq!(zeros.gen::<$ty>(), $ZERO);
195+
assert_eq!(zeros.random::<$ty>(), $ZERO);
196196
let mut one = StepRng::new(1 << 8 | 1 << (8 + 32), 0);
197-
assert_eq!(one.gen::<$ty>(), $EPSILON / two);
197+
assert_eq!(one.random::<$ty>(), $EPSILON / two);
198198
let mut max = StepRng::new(!0, 0);
199-
assert_eq!(max.gen::<$ty>(), $ty::splat(1.0) - $EPSILON / two);
199+
assert_eq!(max.random::<$ty>(), $ty::splat(1.0) - $EPSILON / two);
200200

201201
// OpenClosed01
202202
let mut zeros = StepRng::new(0, 0);
@@ -234,11 +234,11 @@ mod tests {
234234

235235
// Standard
236236
let mut zeros = StepRng::new(0, 0);
237-
assert_eq!(zeros.gen::<$ty>(), $ZERO);
237+
assert_eq!(zeros.random::<$ty>(), $ZERO);
238238
let mut one = StepRng::new(1 << 11, 0);
239-
assert_eq!(one.gen::<$ty>(), $EPSILON / two);
239+
assert_eq!(one.random::<$ty>(), $EPSILON / two);
240240
let mut max = StepRng::new(!0, 0);
241-
assert_eq!(max.gen::<$ty>(), $ty::splat(1.0) - $EPSILON / two);
241+
assert_eq!(max.random::<$ty>(), $ty::splat(1.0) - $EPSILON / two);
242242

243243
// OpenClosed01
244244
let mut zeros = StepRng::new(0, 0);

‎src/distributions/integer.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,7 @@ macro_rules! impl_int_from_uint {
8181
impl Distribution<$ty> for Standard {
8282
#[inline]
8383
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
84-
rng.gen::<$uty>() as $ty
84+
rng.random::<$uty>() as $ty
8585
}
8686
}
8787
};
@@ -99,7 +99,7 @@ macro_rules! impl_nzint {
9999
impl Distribution<$ty> for Standard {
100100
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
101101
loop {
102-
if let Some(nz) = $new(rng.gen()) {
102+
if let Some(nz) = $new(rng.random()) {
103103
break nz;
104104
}
105105
}

‎src/distributions/mod.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@
1111
//!
1212
//! This module is the home of the [`Distribution`] trait and several of its
1313
//! implementations. It is the workhorse behind some of the convenient
14-
//! functionality of the [`Rng`] trait, e.g. [`Rng::gen`] and of course
14+
//! functionality of the [`Rng`] trait, e.g. [`Rng::random`] and of course
1515
//! [`Rng::sample`].
1616
//!
1717
//! Abstractly, a [probability distribution] describes the probability of
@@ -31,13 +31,13 @@
3131
//! # The `Standard` distribution
3232
//!
3333
//! The [`Standard`] distribution is important to mention. This is the
34-
//! distribution used by [`Rng::gen`] and represents the "default" way to
34+
//! distribution used by [`Rng::random`] and represents the "default" way to
3535
//! produce a random value for many different types, including most primitive
3636
//! types, tuples, arrays, and a few derived types. See the documentation of
3737
//! [`Standard`] for more details.
3838
//!
3939
//! Implementing `Distribution<T>` for [`Standard`] for user types `T` makes it
40-
//! possible to generate type `T` with [`Rng::gen`], and by extension also
40+
//! possible to generate type `T` with [`Rng::random`], and by extension also
4141
//! with the [`random`] function.
4242
//!
4343
//! ## Random characters
@@ -181,7 +181,7 @@ use crate::Rng;
181181
///
182182
/// impl Distribution<MyF32> for Standard {
183183
/// fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> MyF32 {
184-
/// MyF32 { x: rng.gen() }
184+
/// MyF32 { x: rng.random() }
185185
/// }
186186
/// }
187187
/// ```

‎src/distributions/other.rs

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -156,10 +156,10 @@ impl Distribution<bool> for Standard {
156156
///
157157
/// ```ignore
158158
/// // this may be faster...
159-
/// let x = unsafe { _mm_blendv_epi8(a.into(), b.into(), rng.gen::<__m128i>()) };
159+
/// let x = unsafe { _mm_blendv_epi8(a.into(), b.into(), rng.random::<__m128i>()) };
160160
///
161161
/// // ...than this
162-
/// let x = rng.gen::<mask8x16>().select(b, a);
162+
/// let x = rng.random::<mask8x16>().select(b, a);
163163
/// ```
164164
///
165165
/// Since most bits are unused you could also generate only as many bits as you need, i.e.:
@@ -169,7 +169,7 @@ impl Distribution<bool> for Standard {
169169
/// use rand::prelude::*;
170170
/// let mut rng = thread_rng();
171171
///
172-
/// let x = u16x8::splat(rng.gen::<u8>() as u16);
172+
/// let x = u16x8::splat(rng.random::<u8>() as u16);
173173
/// let mask = u16x8::splat(1) << u16x8::from([0, 1, 2, 3, 4, 5, 6, 7]);
174174
/// let rand_mask = (x & mask).simd_eq(mask);
175175
/// ```
@@ -189,7 +189,7 @@ where
189189
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Mask<T, LANES> {
190190
// `MaskElement` must be a signed integer, so this is equivalent
191191
// to the scalar `i32 < 0` method
192-
let var = rng.gen::<Simd<T, LANES>>();
192+
let var = rng.random::<Simd<T, LANES>>();
193193
var.simd_lt(Simd::default())
194194
}
195195
}
@@ -208,7 +208,7 @@ macro_rules! tuple_impl {
208208
let out = ($(
209209
// use the $tyvar's to get the appropriate number of
210210
// repeats (they're not actually needed)
211-
rng.gen::<$tyvar>()
211+
rng.random::<$tyvar>()
212212
,)*);
213213

214214
// Suppress the unused variable warning for empty tuple
@@ -247,7 +247,7 @@ where Standard: Distribution<T>
247247
let mut buff: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
248248

249249
for elem in &mut buff {
250-
*elem = MaybeUninit::new(_rng.gen());
250+
*elem = MaybeUninit::new(_rng.random());
251251
}
252252

253253
unsafe { mem::transmute_copy::<_, _>(&buff) }
@@ -260,8 +260,8 @@ where Standard: Distribution<T>
260260
#[inline]
261261
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<T> {
262262
// UFCS is needed here: https://github.com/rust-lang/rust/issues/24066
263-
if rng.gen::<bool>() {
264-
Some(rng.gen())
263+
if rng.random::<bool>() {
264+
Some(rng.random())
265265
} else {
266266
None
267267
}
@@ -273,7 +273,7 @@ where Standard: Distribution<T>
273273
{
274274
#[inline]
275275
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Wrapping<T> {
276-
Wrapping(rng.gen())
276+
Wrapping(rng.random())
277277
}
278278
}
279279

@@ -300,7 +300,7 @@ mod tests {
300300
// Test by generating a relatively large number of chars, so we also
301301
// take the rejection sampling path.
302302
let word: String = iter::repeat(())
303-
.map(|()| rng.gen::<char>())
303+
.map(|()| rng.random::<char>())
304304
.take(1000)
305305
.collect();
306306
assert!(!word.is_empty());

‎src/distributions/uniform.rs

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -515,12 +515,12 @@ macro_rules! uniform_int_impl {
515515
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
516516
let range = self.range as $uty as $sample_ty;
517517
if range == 0 {
518-
return rng.gen();
518+
return rng.random();
519519
}
520520

521521
let thresh = self.thresh as $uty as $sample_ty;
522522
let hi = loop {
523-
let (hi, lo) = rng.gen::<$sample_ty>().wmul(range);
523+
let (hi, lo) = rng.random::<$sample_ty>().wmul(range);
524524
if lo >= thresh {
525525
break hi;
526526
}
@@ -563,16 +563,16 @@ macro_rules! uniform_int_impl {
563563
let range = high.wrapping_sub(low).wrapping_add(1) as $uty as $sample_ty;
564564
if range == 0 {
565565
// Range is MAX+1 (unrepresentable), so we need a special case
566-
return Ok(rng.gen());
566+
return Ok(rng.random());
567567
}
568568

569569
// generate a sample using a sensible integer type
570-
let (mut result, lo_order) = rng.gen::<$sample_ty>().wmul(range);
570+
let (mut result, lo_order) = rng.random::<$sample_ty>().wmul(range);
571571

572572
// if the sample is biased...
573573
if lo_order > range.wrapping_neg() {
574574
// ...generate a new sample to reduce bias...
575-
let (new_hi_order, _) = (rng.gen::<$sample_ty>()).wmul(range as $sample_ty);
575+
let (new_hi_order, _) = (rng.random::<$sample_ty>()).wmul(range as $sample_ty);
576576
// ... incrementing result on overflow
577577
let is_overflow = lo_order.checked_add(new_hi_order as $sample_ty).is_none();
578578
result += is_overflow as $sample_ty;
@@ -602,11 +602,11 @@ macro_rules! uniform_int_impl {
602602
return Ok(rng.gen());
603603
}
604604

605-
let (mut result, mut lo) = rng.gen::<$sample_ty>().wmul(range);
605+
let (mut result, mut lo) = rng.random::<$sample_ty>().wmul(range);
606606

607607
// In contrast to the biased sampler, we use a loop:
608608
while lo > range.wrapping_neg() {
609-
let (new_hi, new_lo) = (rng.gen::<$sample_ty>()).wmul(range);
609+
let (new_hi, new_lo) = (rng.random::<$sample_ty>()).wmul(range);
610610
match lo.checked_add(new_hi) {
611611
Some(x) if x < $sample_ty::MAX => {
612612
// Anything less than MAX: last term is 0
@@ -732,7 +732,7 @@ macro_rules! uniform_simd_int_impl {
732732
// rejection. The replacement method does however add a little
733733
// overhead. Benchmarking or calculating probabilities might
734734
// reveal contexts where this replacement method is slower.
735-
let mut v: Simd<$unsigned, LANES> = rng.gen();
735+
let mut v: Simd<$unsigned, LANES> = rng.random();
736736
loop {
737737
let (hi, lo) = v.wmul(range);
738738
let mask = lo.simd_ge(thresh);
@@ -747,7 +747,7 @@ macro_rules! uniform_simd_int_impl {
747747
return range.simd_gt(Simd::splat(0)).select(result, v);
748748
}
749749
// Replace only the failing lanes
750-
v = mask.select(v, rng.gen());
750+
v = mask.select(v, rng.random());
751751
}
752752
}
753753
}
@@ -970,7 +970,7 @@ macro_rules! uniform_float_impl {
970970

971971
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
972972
// Generate a value in the range [1, 2)
973-
let value1_2 = (rng.gen::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
973+
let value1_2 = (rng.random::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
974974

975975
// Get a value in the range [0, 1) to avoid overflow when multiplying by scale
976976
let value0_1 = value1_2 - <$ty>::splat(1.0);
@@ -1006,7 +1006,7 @@ macro_rules! uniform_float_impl {
10061006
loop {
10071007
// Generate a value in the range [1, 2)
10081008
let value1_2 =
1009-
(rng.gen::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
1009+
(rng.random::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
10101010

10111011
// Get a value in the range [0, 1) to avoid overflow when multiplying by scale
10121012
let value0_1 = value1_2 - <$ty>::splat(1.0);
@@ -1079,7 +1079,7 @@ macro_rules! uniform_float_impl {
10791079

10801080
// Generate a value in the range [1, 2)
10811081
let value1_2 =
1082-
(rng.gen::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
1082+
(rng.random::<$uty>() >> $uty::splat($bits_to_discard)).into_float_with_exponent(0);
10831083

10841084
// Get a value in the range [0, 1) to avoid overflow when multiplying by scale
10851085
let value0_1 = value1_2 - <$ty>::splat(1.0);

‎src/lib.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@
2929
//! }
3030
//!
3131
//! let mut rng = rand::thread_rng();
32-
//! let y: f64 = rng.gen(); // generates a float between 0 and 1
32+
//! let y: f64 = rng.random(); // generates a float between 0 and 1
3333
//!
3434
//! let mut nums: Vec<i32> = (1..100).collect();
3535
//! nums.shuffle(&mut rng);
@@ -147,7 +147,7 @@ use crate::distributions::{Distribution, Standard};
147147
/// let mut rng = rand::thread_rng();
148148
///
149149
/// for x in v.iter_mut() {
150-
/// *x = rng.gen();
150+
/// *x = rng.random();
151151
/// }
152152
/// ```
153153
///
@@ -158,7 +158,7 @@ use crate::distributions::{Distribution, Standard};
158158
#[inline]
159159
pub fn random<T>() -> T
160160
where Standard: Distribution<T> {
161-
thread_rng().gen()
161+
thread_rng().random()
162162
}
163163

164164
#[cfg(test)]

‎src/prelude.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@
1515
//! ```
1616
//! use rand::prelude::*;
1717
//! # let mut r = StdRng::from_rng(thread_rng()).unwrap();
18-
//! # let _: f32 = r.gen();
18+
//! # let _: f32 = r.random();
1919
//! ```
2020
2121
#[doc(no_inline)] pub use crate::distributions::Distribution;

0 commit comments

Comments
 (0)