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

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

// Degree 1 Polynomial (Linear):
// a1 * x + a0 = 0, where a1 != 0
// Solution:
// x = -a0 / a1

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

    if a == 0.0 {
        return degree_0(poly);
    }
    let sol: f64 = -b / a;
    Ok(Roots::with_real(vec![sol]))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::parse_equation;
    mod degree_1 {
        use super::*;

        #[test]
        fn test_not_degree_1() {
            let equation: &str = "0*X^0 + 0 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![]);
        }

        #[test]
        fn test_poly_0_is_0() {
            let equation: &str = "1*X^1 + 0 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![0.0]);
        }

        #[test]
        fn test_simple_positive_solution() {
            let equation: &str = "2 * X^1 + 4 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![-2.0]);

            let equation: &str = "1.0 * X = 42";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![42.0]);
        }

        #[test]
        fn test_simple_negative_solution() {
            let equation: &str = "-3 * X^1 + 6 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![2.0]);
        }

        #[test]
        fn test_zero_coefficient() {
            let equation: &str = "0 * X^1 + 5 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result:Result<Roots, String> = degree_1(poly);
            assert!(result.is_err(), "Expected an error for zero coefficient got {:?}", result);
        }

        #[test]
        fn test_zero_solution() {
            let equation: &str = "4 * X^1 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![0.0]);
        }

        #[test]
        fn test_fractional_solution() {
            let equation: &str = "3 * X^1 + 1.5 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![-0.5]);
        }

        #[test]
        fn test_reduced_to_degree_1() {
            let equation: &str = "5 + 4 * X + X^2= X^2";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![-1.25]);
        }
        #[test]
        fn test_no_solution_due_to_zero_coefficients() {
            let equation: &str = "0 * X^1 + 0 = 0";
            let poly: Polynomial = parse_equation(equation).expect("Failed to parse equation");
            let result: Roots = degree_1(poly).unwrap();
            assert_eq!(result.real, vec![]); // All real numbers are solutions
        }
    }
}