rand/distr/
integer.rs

1// Copyright 2018 Developers of the Rand project.
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
6// option. This file may not be copied, modified, or distributed
7// except according to those terms.
8
9//! The implementations of the `StandardUniform` distribution for integer types.
10
11use crate::distr::{Distribution, StandardUniform};
12use crate::Rng;
13#[cfg(all(target_arch = "x86", feature = "simd_support"))]
14use core::arch::x86::__m512i;
15#[cfg(target_arch = "x86")]
16use core::arch::x86::{__m128i, __m256i};
17#[cfg(all(target_arch = "x86_64", feature = "simd_support"))]
18use core::arch::x86_64::__m512i;
19#[cfg(target_arch = "x86_64")]
20use core::arch::x86_64::{__m128i, __m256i};
21use core::num::{
22    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroU128, NonZeroU16,
23    NonZeroU32, NonZeroU64, NonZeroU8,
24};
25#[cfg(feature = "simd_support")]
26use core::simd::*;
27
28impl Distribution<u8> for StandardUniform {
29    #[inline]
30    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
31        rng.next_u32() as u8
32    }
33}
34
35impl Distribution<u16> for StandardUniform {
36    #[inline]
37    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
38        rng.next_u32() as u16
39    }
40}
41
42impl Distribution<u32> for StandardUniform {
43    #[inline]
44    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
45        rng.next_u32()
46    }
47}
48
49impl Distribution<u64> for StandardUniform {
50    #[inline]
51    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
52        rng.next_u64()
53    }
54}
55
56impl Distribution<u128> for StandardUniform {
57    #[inline]
58    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
59        // Use LE; we explicitly generate one value before the next.
60        let x = u128::from(rng.next_u64());
61        let y = u128::from(rng.next_u64());
62        (y << 64) | x
63    }
64}
65
66macro_rules! impl_int_from_uint {
67    ($ty:ty, $uty:ty) => {
68        impl Distribution<$ty> for StandardUniform {
69            #[inline]
70            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
71                rng.random::<$uty>() as $ty
72            }
73        }
74    };
75}
76
77impl_int_from_uint! { i8, u8 }
78impl_int_from_uint! { i16, u16 }
79impl_int_from_uint! { i32, u32 }
80impl_int_from_uint! { i64, u64 }
81impl_int_from_uint! { i128, u128 }
82
83macro_rules! impl_nzint {
84    ($ty:ty, $new:path) => {
85        impl Distribution<$ty> for StandardUniform {
86            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
87                loop {
88                    if let Some(nz) = $new(rng.random()) {
89                        break nz;
90                    }
91                }
92            }
93        }
94    };
95}
96
97impl_nzint!(NonZeroU8, NonZeroU8::new);
98impl_nzint!(NonZeroU16, NonZeroU16::new);
99impl_nzint!(NonZeroU32, NonZeroU32::new);
100impl_nzint!(NonZeroU64, NonZeroU64::new);
101impl_nzint!(NonZeroU128, NonZeroU128::new);
102
103impl_nzint!(NonZeroI8, NonZeroI8::new);
104impl_nzint!(NonZeroI16, NonZeroI16::new);
105impl_nzint!(NonZeroI32, NonZeroI32::new);
106impl_nzint!(NonZeroI64, NonZeroI64::new);
107impl_nzint!(NonZeroI128, NonZeroI128::new);
108
109#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
110macro_rules! x86_intrinsic_impl {
111    ($meta:meta, $($intrinsic:ident),+) => {$(
112        #[cfg($meta)]
113        impl Distribution<$intrinsic> for StandardUniform {
114            #[inline]
115            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $intrinsic {
116                // On proper hardware, this should compile to SIMD instructions
117                // Verified on x86 Haswell with __m128i, __m256i
118                let mut buf = [0_u8; core::mem::size_of::<$intrinsic>()];
119                rng.fill_bytes(&mut buf);
120                // x86 is little endian so no need for conversion
121                zerocopy::transmute!(buf)
122            }
123        }
124    )+};
125}
126
127#[cfg(feature = "simd_support")]
128macro_rules! simd_impl {
129    ($($ty:ty),+) => {$(
130        /// Requires nightly Rust and the [`simd_support`] feature
131        ///
132        /// [`simd_support`]: https://github.com/rust-random/rand#crate-features
133        #[cfg(feature = "simd_support")]
134        impl<const LANES: usize> Distribution<Simd<$ty, LANES>> for StandardUniform
135        where
136            LaneCount<LANES>: SupportedLaneCount,
137        {
138            #[inline]
139            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Simd<$ty, LANES> {
140                let mut vec = Simd::default();
141                rng.fill(vec.as_mut_array().as_mut_slice());
142                vec
143            }
144        }
145    )+};
146}
147
148#[cfg(feature = "simd_support")]
149simd_impl!(u8, i8, u16, i16, u32, i32, u64, i64);
150
151#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
152x86_intrinsic_impl!(
153    any(target_arch = "x86", target_arch = "x86_64"),
154    __m128i,
155    __m256i
156);
157#[cfg(all(
158    any(target_arch = "x86", target_arch = "x86_64"),
159    feature = "simd_support"
160))]
161x86_intrinsic_impl!(
162    all(
163        any(target_arch = "x86", target_arch = "x86_64"),
164        feature = "simd_support"
165    ),
166    __m512i
167);
168
169#[cfg(test)]
170mod tests {
171    use super::*;
172
173    #[test]
174    fn test_integers() {
175        let mut rng = crate::test::rng(806);
176
177        rng.sample::<i8, _>(StandardUniform);
178        rng.sample::<i16, _>(StandardUniform);
179        rng.sample::<i32, _>(StandardUniform);
180        rng.sample::<i64, _>(StandardUniform);
181        rng.sample::<i128, _>(StandardUniform);
182
183        rng.sample::<u8, _>(StandardUniform);
184        rng.sample::<u16, _>(StandardUniform);
185        rng.sample::<u32, _>(StandardUniform);
186        rng.sample::<u64, _>(StandardUniform);
187        rng.sample::<u128, _>(StandardUniform);
188    }
189
190    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
191    #[test]
192    fn x86_integers() {
193        let mut rng = crate::test::rng(807);
194
195        rng.sample::<__m128i, _>(StandardUniform);
196        rng.sample::<__m256i, _>(StandardUniform);
197        #[cfg(feature = "simd_support")]
198        rng.sample::<__m512i, _>(StandardUniform);
199    }
200
201    #[test]
202    fn value_stability() {
203        fn test_samples<T: Copy + core::fmt::Debug + PartialEq>(zero: T, expected: &[T])
204        where
205            StandardUniform: Distribution<T>,
206        {
207            let mut rng = crate::test::rng(807);
208            let mut buf = [zero; 3];
209            for x in &mut buf {
210                *x = rng.sample(StandardUniform);
211            }
212            assert_eq!(&buf, expected);
213        }
214
215        test_samples(0u8, &[9, 247, 111]);
216        test_samples(0u16, &[32265, 42999, 38255]);
217        test_samples(0u32, &[2220326409, 2575017975, 2018088303]);
218        test_samples(
219            0u64,
220            &[
221                11059617991457472009,
222                16096616328739788143,
223                1487364411147516184,
224            ],
225        );
226        test_samples(
227            0u128,
228            &[
229                296930161868957086625409848350820761097,
230                145644820879247630242265036535529306392,
231                111087889832015897993126088499035356354,
232            ],
233        );
234
235        test_samples(0i8, &[9, -9, 111]);
236        // Skip further i* types: they are simple reinterpretation of u* samples
237
238        #[cfg(feature = "simd_support")]
239        {
240            // We only test a sub-set of types here and make assumptions about the rest.
241
242            test_samples(
243                u8x4::default(),
244                &[
245                    u8x4::from([9, 126, 87, 132]),
246                    u8x4::from([247, 167, 123, 153]),
247                    u8x4::from([111, 149, 73, 120]),
248                ],
249            );
250            test_samples(
251                u8x8::default(),
252                &[
253                    u8x8::from([9, 126, 87, 132, 247, 167, 123, 153]),
254                    u8x8::from([111, 149, 73, 120, 68, 171, 98, 223]),
255                    u8x8::from([24, 121, 1, 50, 13, 46, 164, 20]),
256                ],
257            );
258
259            test_samples(
260                i64x8::default(),
261                &[
262                    i64x8::from([
263                        -7387126082252079607,
264                        -2350127744969763473,
265                        1487364411147516184,
266                        7895421560427121838,
267                        602190064936008898,
268                        6022086574635100741,
269                        -5080089175222015595,
270                        -4066367846667249123,
271                    ]),
272                    i64x8::from([
273                        9180885022207963908,
274                        3095981199532211089,
275                        6586075293021332726,
276                        419343203796414657,
277                        3186951873057035255,
278                        5287129228749947252,
279                        444726432079249540,
280                        -1587028029513790706,
281                    ]),
282                    i64x8::from([
283                        6075236523189346388,
284                        1351763722368165432,
285                        -6192309979959753740,
286                        -7697775502176768592,
287                        -4482022114172078123,
288                        7522501477800909500,
289                        -1837258847956201231,
290                        -586926753024886735,
291                    ]),
292                ],
293            );
294        }
295    }
296}
rand/distr/integer.rs

rand/distr/
integer.rs
