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

/*
# Easy Average Grade Calculator 

This tool is a easy average grade average calulcator written in Rust. It takes a list of graded to calculated the average and can be used as a library by other applications.

See a more complex [grade calulcator](https://www.thebestdegree.com/grade-calculator/) for weighted grade calculation for college or high school students and teachers. 

These tools are all implemented in Rust.

## Usage ##

The easy grade calulcator can either read the input grades from arguments or a text file as shown below:

```bash
grade-avg 3.5 2.5
```

Another way to use the tool would be to create a txt file as the input grades. Create a input file `grades.txt` with the contents:

```
1.5
3.5
2.5
```

The average for these grades can be calculcated as below:



```bash
cat ~/grades.txt | grade-avg
```
*/
use std::error::Error;
use std::fmt;
//let strict_grades: Vec<f32> = vec![1.0, 1.3, 1.7, 2.0, 2.3, 2.7, 3.0, 3.3, 3.7, 4.0, 4.3, 4.7, 5.0];

#[derive(Debug, Clone, Copy)]
pub struct Grade {
    val: usize,
}

impl fmt::Display for Grade {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let out_val = (self.val as f32) / 10.0;
        write!(f, "{:.1}", out_val)
    }
}

impl PartialEq for Grade {
    fn eq(&self, other: &Self) -> bool {
        self.val == other.val
    }
}

impl Grade {
    pub fn from(input: &str) -> Result<Grade, Box<dyn Error>> {
        let parsed_val = input.replace(",", ".").parse::<f32>()?;
        let val = (parsed_val * 10.0) as usize;
        if val >= 10 && val <= 50 {
            Ok(Grade { val })
        } else {
            Err(format!("{} is out of bounds! Must be between 1.0 and 5.0", input).into())
        }
    }

    pub fn verbal(&self) -> &str {
        if self.val >= 10 && self.val < 16 {
            "Grade A"
        } else if self.val >= 16 && self.val < 25 {
            "Grade B"
        } else if self.val >= 26 && self.val < 35 {
            "Grade C"
        } else if self.val >= 36 && self.val < 41 {
            "Grade D"
        } else if self.val >= 41 && self.val <= 50 {
            "Grade F"
        } else {
            unreachable!()
        }
    }
}

pub fn avg(grade_list: &[Grade]) -> Option<Grade> {
    if !grade_list.is_empty() {
        let acc: usize = grade_list.iter().map(|e| e.val).sum();
        let grade = (acc / grade_list.len()) as usize;
        Some(Grade { val: grade })
    } else {
        None
    }
}

pub fn avg_prec(grade_list: &[Grade]) -> Option<f64> {
    if !grade_list.is_empty() {
        let acc: usize = grade_list.iter().map(|grade| grade.val).sum();
        Some((acc as f64) / (10.0 * grade_list.len() as f64))
    } else {
        None
    }
}