computorv1 1.0.11

An educational computor project solving polynomial equations.
Documentation 
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

use crate::aux::Polynomial;
use crate::solver::Roots;

// Degree 0 Polynomial:
// a0 = 0
// Solution:
// - If a0 == 0: all x ∈ ℝ are solutions
// - If a0 != 0: no solution

pub fn degree_0(poly: Polynomial) -> Result<Roots, String> {
    let val: f64 = poly.terms.get(&0).copied().unwrap_or(0.0);

    if val == 0.0 {
        Ok(Roots::with_real(vec![]))
    } else {
        Err("No solution.".to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::parse_equation;
    use std::collections::BTreeMap;
    mod degree_0 {
        use super::*;
        #[test]
        fn test_all_real_numbers_are_solutions() {
            // 5 X^0 - 5 X^0 = 0
            let mut terms: BTreeMap<u32, f64> = BTreeMap::new();
            terms.insert(0, 0.0);
            let poly: Polynomial = Polynomial {
                terms,
                variable: "X".to_string(),
            };
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));
        }

        #[test]
        fn test_no_solution() {
            // 5 X^0 = 0
            let mut terms: BTreeMap<u32, f64> = BTreeMap::new();
            terms.insert(0, 5.0);
            let poly: Polynomial = Polynomial {
                terms,
                variable: "X".to_string(),
            };
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Err("No solution.".to_string()));
        }

        #[test]
        fn test_missing_constant_term() {
            // 0 = 0
            let terms: BTreeMap<u32, f64> = BTreeMap::new(); // No terms
            let poly: Polynomial = Polynomial {
                terms,
                variable: "X".to_string(),
            };
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));
        }

        #[test]
        fn test_all_real_numbers_are_solutions_with_parse() {
            // 0 = 0
            let equation: &str = "0 * X^0 = 0 * X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));
        }

        #[test]
        fn test_no_solution_with_parse() {
            // 5 = 0
            let equation: &str = "5 * X^0 = 0 * X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Err("No solution.".to_string()));

            // -1 = 0
            let equation: &str = "5X^0  -  5 = 1X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Err("No solution.".to_string()));

            // -1 = 0 (X^0 == 1 X^0)
            let equation: &str = "5X^0  -  5 = X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Err("No solution.".to_string()));
        }

        #[test]
        fn test_valid_solution_with_parse() {
            let equation: &str = "5 * X^0  -  5 = 0 * X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));

            let equation: &str = "5X^0  -  5 = 0X^0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));
        }

        #[test]
        fn test_missing_constant_term_with_parse() {
            let equation: &str = "0 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Result<Roots, String> = degree_0(poly);
            assert_eq!(result, Ok(Roots::with_real(vec![])));
        }
    }
}