Skip to main content

hyprstream_bench/gen/
unitconv.rs

1//! Unit conversion (km↔mi, kg↔lb, °C↔°F). Truth is computed with pinned
2//! conversion constants and rounded to integers so outcomes are exact.
3
4use hyprstream_decision::Entry;
5
6use crate::family::{Family, Stratum};
7use crate::gen::stream;
8use crate::item::Item;
9
10const FAMILY: Family = Family::UnitConv;
11
12struct Conversion {
13    text: String,
14    answer: i64,
15    unit: &'static str,
16}
17
18fn conversion(seed: u64) -> Conversion {
19    let mut rng = stream(seed);
20    match rng.below(3) {
21        0 => {
22            let km = rng.range(1, 500);
23            Conversion {
24                text: format!("A route is {km} km long."),
25                answer: (km as f64 * 0.621_371).round() as i64,
26                unit: "mi",
27            }
28        }
29        1 => {
30            let kg = rng.range(1, 300);
31            Conversion {
32                text: format!("A crate weighs {kg} kg."),
33                answer: (kg as f64 * 2.204_62).round() as i64,
34                unit: "lb",
35            }
36        }
37        _ => {
38            let celsius = rng.range(-40, 45);
39            Conversion {
40                text: format!("The sensor reads {celsius} °C."),
41                answer: (celsius as f64 * 9.0 / 5.0 + 32.0).round() as i64,
42                unit: "°F",
43            }
44        }
45    }
46}
47
48pub fn noul(seed: u64, stratum: Stratum) -> Item {
49    let mut rng = stream(seed ^ 0xA0);
50    let conv = conversion(seed);
51    let (claim, truth) = match stratum {
52        Stratum::NearMiss => {
53            let slip = conv.answer + [1, -1, 2][rng.below(3) as usize];
54            if rng.below(2) == 0 {
55                (slip, false)
56            } else {
57                (conv.answer, true)
58            }
59        }
60        _ => {
61            let offset = rng.range(-4, 4);
62            (conv.answer + offset, offset == 0)
63        }
64    };
65    Item::noul(
66        FAMILY,
67        stratum,
68        seed,
69        Entry::Str(conv.text),
70        format!(
71            "Is that {claim} {} (rounded to the nearest integer)?",
72            conv.unit
73        ),
74        truth,
75    )
76}
77
78pub fn choice(seed: u64, stratum: Stratum) -> Item {
79    let mut rng = stream(seed ^ 0xC0);
80    let conv = conversion(seed);
81    let spread: Vec<i64> = match stratum {
82        // Close distractors: ±1 and ±2 — answers within rounding distance.
83        Stratum::NearMiss => vec![1, -1, 2],
84        _ => vec![rng.range(3, 8), -rng.range(3, 8), rng.range(9, 20)],
85    };
86    let mut values: Vec<i64> = spread.iter().map(|d| conv.answer + d).collect();
87    values.retain(|v| *v != conv.answer);
88    values.dedup();
89    let correct = rng.below(values.len() as u64 + 1) as usize;
90    values.insert(correct, conv.answer);
91    Item::choice(
92        FAMILY,
93        stratum,
94        seed,
95        Entry::Str(conv.text),
96        format!(
97            "What is the converted value in {} (rounded to the nearest integer)?",
98            conv.unit
99        ),
100        values
101            .iter()
102            .map(|v| format!("{v} {}", conv.unit))
103            .collect(),
104        correct,
105    )
106}
107
108pub fn score(seed: u64, stratum: Stratum) -> Item {
109    let conv = conversion(seed);
110    Item::score(
111        FAMILY,
112        stratum,
113        seed,
114        Entry::Str(conv.text),
115        format!(
116            "How large is the converted value in {}? Levels: 0 = negative, 1 = 0–99, 2 = 100–499, 3 = 500 or more.",
117            conv.unit
118        ),
119        4,
120        match conv.answer {
121            v if v < 0 => 0,
122            v if v < 100 => 1,
123            v if v < 500 => 2,
124            _ => 3,
125        },
126    )
127}