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

use crate::bools::random::{random_bools, RandomBools};
use crate::num::conversion::string::options::{FromSciStringOptions, SciSizeOptions, ToSciOptions};
use crate::num::random::geometric::{
    geometric_random_negative_signeds, geometric_random_unsigneds, GeometricRandomNaturalValues,
    GeometricRandomNegativeSigneds,
};
use crate::num::random::{random_unsigned_inclusive_range, RandomUnsignedInclusiveRange};
use crate::random::Seed;
use crate::rounding_modes::random::{random_rounding_modes, RandomRoundingModes};

/// Generates random [`SciSizeOptions`](super::SciSizeOptions)s.
///
/// This struct is created by [`random_sci_size_options`]; see its documentation for more.
pub struct RandomSciSizeOptions {
    bs: RandomBools,
    xs: GeometricRandomNaturalValues<u64>,
}

impl Iterator for RandomSciSizeOptions {
    type Item = SciSizeOptions;

    fn next(&mut self) -> Option<SciSizeOptions> {
        let x = self.xs.next().unwrap();
        Some(if self.bs.next().unwrap() {
            if x == 0 {
                SciSizeOptions::Complete
            } else {
                SciSizeOptions::Precision(x)
            }
        } else {
            SciSizeOptions::Scale(x)
        })
    }
}

/// Generates random [`SciSizeOptions`](super::SciSizeOptions)s.
///
/// The scales and precisions are chosen from a geometric distribution whose mean is the
/// ratio `m_size_numerator / m_size_denominator`.
///
/// # Panics
/// Panics if `m_size_numerator` or `m_size_denominator` are zero, or, if after being reduced to
/// lowest terms, their sum is greater than or equal to $2^{64}$.
///
/// The output length is infinite.
pub fn random_sci_size_options(
    seed: Seed,
    m_size_numerator: u64,
    m_size_denominator: u64,
) -> RandomSciSizeOptions {
    RandomSciSizeOptions {
        bs: random_bools(seed.fork("bs")),
        xs: geometric_random_unsigneds(seed.fork("xs"), m_size_numerator, m_size_denominator),
    }
}

/// Generates random [`ToSciOptions`](super::ToSciOptions)s.
///
/// This struct is created by [`random_to_sci_options`]; see its documentation for more.
pub struct RandomToSciOptions {
    us: RandomUnsignedInclusiveRange<u8>,
    rms: RandomRoundingModes,
    sos: RandomSciSizeOptions,
    is: GeometricRandomNegativeSigneds<i64>,
    bs: RandomBools,
}

impl Iterator for RandomToSciOptions {
    type Item = ToSciOptions;

    fn next(&mut self) -> Option<ToSciOptions> {
        Some(ToSciOptions {
            base: self.us.next().unwrap(),
            rounding_mode: self.rms.next().unwrap(),
            size_options: self.sos.next().unwrap(),
            neg_exp_threshold: self.is.next().unwrap(),
            lowercase: self.bs.next().unwrap(),
            e_lowercase: self.bs.next().unwrap(),
            force_exponent_plus_sign: self.bs.next().unwrap(),
            include_trailing_zeros: self.bs.next().unwrap(),
        })
    }
}

/// Generates random [`ToSciOptions`](super::ToSciOptions)s.
///
/// The scales, precisions, and the negative of the negative exponenet threshold are chosen from a
/// geometric distribution whose mean is the ratio `m_size_numerator / m_size_denominator`.
///
/// # Panics
/// Panics if `m_size_numerator` or `m_size_denominator` are zero, or, if after being reduced to
/// lowest terms, their sum is greater than or equal to $2^{64}$.
///
/// The output length is infinite.
pub fn random_to_sci_options(
    seed: Seed,
    m_size_numerator: u64,
    m_size_denominator: u64,
) -> RandomToSciOptions {
    RandomToSciOptions {
        us: random_unsigned_inclusive_range(seed.fork("us"), 2, 36),
        rms: random_rounding_modes(seed.fork("rms")),
        sos: random_sci_size_options(seed.fork("sos"), m_size_numerator, m_size_denominator),
        is: geometric_random_negative_signeds(
            seed.fork("is"),
            m_size_numerator,
            m_size_denominator,
        ),
        bs: random_bools(seed.fork("bs")),
    }
}

/// Generates random [`FromSciStringOptions`](super::FromSciStringOptions)s.
///
/// This struct is created by [`random_from_sci_string_options`]; see its documentation for more.
pub struct RandomFromSciStringOptions {
    us: RandomUnsignedInclusiveRange<u8>,
    rms: RandomRoundingModes,
}

impl Iterator for RandomFromSciStringOptions {
    type Item = FromSciStringOptions;

    fn next(&mut self) -> Option<FromSciStringOptions> {
        Some(FromSciStringOptions {
            base: self.us.next().unwrap(),
            rounding_mode: self.rms.next().unwrap(),
        })
    }
}

/// Generates random [`FromSciStringOptions`](super::FromSciStringOptions)s.
///
/// The output length is infinite.
pub fn random_from_sci_string_options(seed: Seed) -> RandomFromSciStringOptions {
    RandomFromSciStringOptions {
        us: random_unsigned_inclusive_range(seed.fork("us"), 2, 36),
        rms: random_rounding_modes(seed.fork("rms")),
    }
}