pcg_random/

rand.rs

use rand_core::{RngCore, SeedableRng};

use crate::{
	Pcg,
	lcg::{Integer, Lcg, Parameters},
	output::Output
};

macro_rules! impl_rng_core {
	() => {
		impl_rng_core!(u8);
		impl_rng_core!(u16);
		impl_rng_core!(u32);
		impl_rng_core!(u64);
		impl_rng_core!(u128);
		impl_rng_core!(usize);
	};

	(u8) => {
		impl_rng_core!(u8 impl<L> for Lcg<L, u8> where L: Copy + Into<Parameters<u8>>);

		impl_rng_core! { u8
			impl<L, P, S> for Pcg<L, P, S, u8>
			where
				L: Copy + Into<Parameters<S>>,
				P: Output<S, u8>,
				S: Integer
		}
	};

	(u16) => {
		impl_rng_core!(u16 impl<L> for Lcg<L, u16> where L: Copy + Into<Parameters<u16>>);

		impl_rng_core! { u16
			impl<L, P, S> for Pcg<L, P, S, u16>
			where
				L: Copy + Into<Parameters<S>>,
				P: Output<S, u16>,
				S: Integer
		}
	};

	(u32) => {
		impl_rng_core!(u32 impl<L> for Lcg<L, u32> where L: Copy + Into<Parameters<u32>>);

		impl_rng_core! { u32
			impl<L, P, S> for Pcg<L, P, S, u32>
			where
				L: Copy + Into<Parameters<S>>,
				P: Output<S, u32>,
				S: Integer
		}
	};

	(u64) => {
		impl_rng_core!(u64 impl<L> for Lcg<L, u64> where L: Copy + Into<Parameters<u64>>);

		impl_rng_core! { u64
			impl<L, P, S> for Pcg<L, P, S, u64>
			where
				L: Copy + Into<Parameters<S>>,
				P: Output<S, u64>,
				S: Integer
		}
	};

	(u128) => {
		impl_rng_core!(u128 impl<L> for Lcg<L, u128> where L: Copy + Into<Parameters<u128>>);

		impl_rng_core! { u128
			impl<L, P, S> for Pcg<L, P, S, u128>
			where
				L: Copy + Into<Parameters<S>>,
				P: Output<S, u128>,
				S: Integer
		}
	};

	(usize) => {
		impl_rng_core!(usize impl<L> for Lcg<L, usize> where L: Copy + Into<Parameters<usize>>);
	};

	(u8 impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		impl<$($t),+> RngCore for $name<$($t2),+>
		where
			$($tt)*
		{
			fn next_u32(&mut self) -> u32 {
				u32::from_le_bytes([
					self.generate(),
					self.generate(),
					self.generate(),
					self.generate()
				])
			}

			fn next_u64(&mut self) -> u64 {
				u64::from(self.next_u32()) | (u64::from(self.next_u32()) << 32)
			}

			fn fill_bytes(&mut self, dst: &mut [u8]) {
				dst.iter_mut().for_each(|dst| *dst = self.generate());
			}
		}
	};

	(u16 impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		#[allow(trivial_numeric_casts)]
		impl<$($t),+> RngCore for $name<$($t2),+>
		where
			$($tt)*
		{
			fn next_u32(&mut self) -> u32 {
				u32::from(self.generate() as u16) | (u32::from(self.generate() as u16) << 16)
			}

			fn next_u64(&mut self) -> u64 {
				u64::from(self.next_u32()) | (u64::from(self.next_u32()) << 32)
			}

			fn fill_bytes(&mut self, dst: &mut [u8]) {
				fill_u16(|| self.generate() as u16, dst);
			}
		}
	};

	(u32 impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		#[allow(trivial_numeric_casts)]
		impl<$($t),+> RngCore for $name<$($t2),+>
		where
			$($tt)*
		{
			fn next_u32(&mut self) -> u32 {
				self.generate() as u32
			}

			fn next_u64(&mut self) -> u64 {
				u64::from(self.next_u32()) | (u64::from(self.next_u32()) << 32)
			}

			fn fill_bytes(&mut self, dst: &mut [u8]) {
				fill_u32(|| self.generate() as u32, dst);
			}
		}
	};

	(u64 impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		#[allow(trivial_numeric_casts)]
		impl<$($t),+> RngCore for $name<$($t2),+>
		where
			$($tt)*
		{
			fn next_u32(&mut self) -> u32 {
				self.next_u64() as u32
			}

			fn next_u64(&mut self) -> u64 {
				self.generate() as u64
			}

			fn fill_bytes(&mut self, dst: &mut [u8]) {
				fill_u64(|| self.generate() as u64, dst);
			}
		}
	};

	(u128 impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		impl<$($t),+> RngCore for $name<$($t2),+>
		where
			$($tt)*
		{
			fn next_u32(&mut self) -> u32 {
				self.next_u64() as u32
			}

			fn next_u64(&mut self) -> u64 {
				self.generate() as u64
			}

			fn fill_bytes(&mut self, dst: &mut [u8]) {
				fill_u128(|| self.generate(), dst);
			}
		}
	};

	(usize impl<$($t:ident),+> for $name:ident<$($t2:ident),+> where $($tt:tt)*) => {
		#[cfg(target_pointer_width = "16")]
		impl_rng_core!(u16 impl<$($t),+> for $name<$($t2),+> where $($tt)*);

		#[cfg(target_pointer_width = "32")]
		impl_rng_core!(u32 impl<$($t),+> for $name<$($t2),+> where $($tt)*);

		#[cfg(target_pointer_width = "64")]
		impl_rng_core!(u64 impl<$($t),+> for $name<$($t2),+> where $($tt)*);
	};
}

impl_rng_core!();

macro_rules! impl_fill {
	($name:ident, $ty:ty) => {
		fn $name<F>(mut generate: F, dst: &mut [u8])
		where
			F: FnMut() -> $ty
		{
			let mut dst = dst.chunks_exact_mut(size_of::<$ty>());

			for dst in &mut dst {
				let dst: &mut [u8; size_of::<$ty>()] = dst.try_into().unwrap();
				*dst = generate().to_le_bytes();
			}

			let rem = dst.into_remainder();

			if !rem.is_empty() {
				rem.copy_from_slice(&generate().to_le_bytes()[..rem.len()]);
			}
		}
	};
}

impl_fill!(fill_u16, u16);
impl_fill!(fill_u32, u32);
impl_fill!(fill_u64, u64);
impl_fill!(fill_u128, u128);

impl<L, S> SeedableRng for Lcg<L, S>
where
	L: Copy + Default + Into<Parameters<S>>,
	S: Integer
{
	type Seed = S::Bytes;

	fn from_seed(seed: Self::Seed) -> Self {
		Self::new(S::from_bytes(seed))
	}

	fn seed_from_u64(state: u64) -> Self {
		Self::new(seed_from_u64(state))
	}
}

impl<L, P, S, O> SeedableRng for Pcg<L, P, S, O>
where
	L: Copy + Default + Into<Parameters<S>>,
	P: Output<S, O>,
	S: Integer
{
	type Seed = S::Bytes;

	fn from_seed(seed: Self::Seed) -> Self {
		Self::new(S::from_bytes(seed))
	}

	fn seed_from_u64(state: u64) -> Self {
		Self::new(seed_from_u64(state))
	}
}

fn seed_from_u64<S>(seed: u64) -> S
where
	S: Integer
{
	let [mut y, mut x] = [0x6a09e667f3bcc908 ^ seed, 0xbb67ae8584caa73b];

	let mut generate = || {
		for _ in 0..8 {
			x = x.rotate_right(16).wrapping_add(y);
			y = y.rotate_left(7) ^ x;
		}

		y
	};

	let _ = generate();

	let mut bytes = S::Bytes::default();
	fill_u64(generate, bytes.as_mut());
	S::from_bytes(bytes)
}