ratamath 0.1.0

A simple math training TUI game built with Ratatui( not final version)
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

use anyhow::bail;
use rand::seq::{IndexedMutRandom, IndexedRandom, SliceRandom};
use rand::{RngExt, rng};

#[derive(Debug, Clone)]
pub enum TypeProblem {
    Addition,
    Subtraction,
    Multiplication,
    Division,
}
#[derive(Debug)]
pub struct Domain {
    pub from: f32,
    pub to: f32,
    pub digits_after_num: Option<u32>,
}
impl Default for Domain {
    fn default() -> Self {
        Self {
            from: 0.0,
            to: 100.0,
            digits_after_num: None,
        }
    }
}
#[derive(Debug)]
pub struct GameParams {
    pub amount: u32,
    pub from: f32,
    pub to: f32,
    pub digits_after_num: u32,
    pub type_problems: Vec<TypeProblem>,
}
impl Default for GameParams {
    fn default() -> Self {
        Self {
            amount: 10,
            from: 0.0,
            to: 50.0,
            digits_after_num: 2,
            type_problems: vec![TypeProblem::Multiplication, TypeProblem::Addition],
        }
    }
}

#[derive(Default, Debug)]
pub struct Example {
    pub problem: String,
    pub answer: f32,
}
pub fn generate_problem(types: &Vec<TypeProblem>, domain: &GameParams) -> Example {
    let mut rng = rand::rng();
    let abs = 10u32.pow(domain.digits_after_num) as f32;
    let epsilon = 10.0_f32.powi(-((domain.digits_after_num + 1) as i32));

    let (operator, num1, num2, answer) = loop {
        let type_ = if let Some(t) = types.choose(&mut rng) {
            t.clone()
        } else {
            TypeProblem::Addition
        };

        let n1 = rng.random_range(domain.from as u32..domain.to as u32) as f32;
        let n2 = rng.random_range(domain.from as u32..domain.to as u32) as f32;

        match type_ {
            TypeProblem::Addition => break ('+', n1, n2, n1 + n2),
            TypeProblem::Subtraction => break ('-', n1, n2, n1 - n2),
            TypeProblem::Multiplication => break ('*', n1, n2, n1 * n2),
            TypeProblem::Division => {
                if n2 == 0.0 {
                    continue;
                }

                let ans = n1 / n2;
                let rounded = (ans * abs).round() / abs;

                if (ans - rounded).abs() < epsilon {
                    break ('/', n1, n2, ans);
                }
            }
        }
    };
    Example {
        problem: format!("{} {} {} = ", num1, operator, num2),
        answer,
    }
}