1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
use crate::Decimal;
use rand::{
distributions::{
uniform::{SampleBorrow, SampleUniform, UniformInt, UniformSampler},
Distribution, Standard,
},
Rng,
};
impl Distribution<Decimal> for Standard {
fn sample<R>(&self, rng: &mut R) -> Decimal
where
R: Rng + ?Sized,
{
Decimal::from_parts(
rng.next_u32(),
rng.next_u32(),
rng.next_u32(),
rng.gen(),
rng.next_u32(),
)
}
}
impl SampleUniform for Decimal {
type Sampler = DecimalSampler;
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DecimalSampler {
mantissa_sampler: UniformInt<i128>,
scale: u32,
}
impl UniformSampler for DecimalSampler {
type X = Decimal;
/// Creates a new sampler that will yield random decimal objects between `low` and `high`.
///
/// The sampler will always provide decimals at the same scale as the inputs; if the inputs
/// have different scales, the higher scale is used.
///
/// # Example
///
/// ```
/// # use rand::Rng;
/// # use rust_decimal_macros::dec;
/// let mut rng = rand::rngs::OsRng;
/// let random = rng.gen_range(dec!(1.00)..dec!(2.00));
/// assert!(random >= dec!(1.00));
/// assert!(random < dec!(2.00));
/// assert_eq!(random.scale(), 2);
/// ```
#[inline]
fn new<B1, B2>(low: B1, high: B2) -> Self
where
B1: SampleBorrow<Self::X> + Sized,
B2: SampleBorrow<Self::X> + Sized,
{
let (low, high) = sync_scales(*low.borrow(), *high.borrow());
let high = Decimal::from_i128_with_scale(high.mantissa() - 1, high.scale());
UniformSampler::new_inclusive(low, high)
}
/// Creates a new sampler that will yield random decimal objects between `low` and `high`.
///
/// The sampler will always provide decimals at the same scale as the inputs; if the inputs
/// have different scales, the higher scale is used.
///
/// # Example
///
/// ```
/// # use rand::Rng;
/// # use rust_decimal_macros::dec;
/// let mut rng = rand::rngs::OsRng;
/// let random = rng.gen_range(dec!(1.00)..=dec!(2.00));
/// assert!(random >= dec!(1.00));
/// assert!(random <= dec!(2.00));
/// assert_eq!(random.scale(), 2);
/// ```
#[inline]
fn new_inclusive<B1, B2>(low: B1, high: B2) -> Self
where
B1: SampleBorrow<Self::X> + Sized,
B2: SampleBorrow<Self::X> + Sized,
{
let (low, high) = sync_scales(*low.borrow(), *high.borrow());
// Return our sampler, which contains an underlying i128 sampler so we
// outsource the actual randomness implementation.
Self {
mantissa_sampler: UniformInt::new_inclusive(low.mantissa(), high.mantissa()),
scale: low.scale(),
}
}
#[inline]
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Self::X {
let mantissa = self.mantissa_sampler.sample(rng);
Decimal::from_i128_with_scale(mantissa, self.scale)
}
}
/// Return equivalent Decimal objects with the same scale as one another.
#[inline]
fn sync_scales(mut a: Decimal, mut b: Decimal) -> (Decimal, Decimal) {
if a.scale() == b.scale() {
return (a, b);
}
// Set scales to match one another, because we are relying on mantissas'
// being comparable in order outsource the actual sampling implementation.
a.rescale(a.scale().max(b.scale()));
b.rescale(a.scale().max(b.scale()));
// Edge case: If the values have _wildly_ different scales, the values may not have rescaled far enough to match one another.
//
// In this case, we accept some precision loss because the randomization approach we are using assumes that the scales will necessarily match.
if a.scale() != b.scale() {
a.rescale(a.scale().min(b.scale()));
b.rescale(a.scale().min(b.scale()));
}
(a, b)
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use super::*;
macro_rules! dec {
($e:expr) => {
Decimal::from_str_exact(stringify!($e)).unwrap()
};
}
#[test]
fn has_random_decimal_instances() {
let mut rng = rand::rngs::OsRng;
let random: [Decimal; 32] = rng.gen();
assert!(random.windows(2).any(|slice| { slice[0] != slice[1] }));
}
#[test]
fn generates_within_range() {
let mut rng = rand::rngs::OsRng;
for _ in 0..128 {
let random = rng.gen_range(dec!(1.00)..dec!(1.05));
assert!(random < dec!(1.05));
assert!(random >= dec!(1.00));
}
}
#[test]
fn generates_within_inclusive_range() {
let mut rng = rand::rngs::OsRng;
let mut values: HashSet<Decimal> = HashSet::new();
for _ in 0..256 {
let random = rng.gen_range(dec!(1.00)..=dec!(1.01));
// The scale is 2, so 1.00 and 1.01 are the only two valid choices.
assert!(random == dec!(1.00) || random == dec!(1.01));
values.insert(random);
}
// Somewhat flaky, will fail 1 out of every 2^255 times this is run.
// Probably acceptable in the real world.
assert_eq!(values.len(), 2);
}
#[test]
fn test_edge_case_scales_match() {
let (low, high) = sync_scales(dec!(1.000_000_000_000_000_000_01), dec!(100_000_000_000_000_000_001));
assert_eq!(low.scale(), high.scale());
}
}