ihateintegrals 0.1.2

A computer algebra library for solving integrals.
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

use super::DerivationRule;

use crate::argument::Argument;
use crate::expressions::sum::sum_of;
use crate::expressions::{Expression, Integer, Negation};
use std::rc::Rc;

/**
* Combine any integer terms in sums.
* a + 2 + 2 = a + 4
* 2 + (-2) = 0
*/
pub struct EvaluateSums {}

impl DerivationRule for EvaluateSums {
    fn apply(&self, input: Expression) -> Vec<(Expression, Rc<Argument>)> {
        let sum = match input {
            Expression::Sum(ref s) => s,
            _ => return vec![],
        };

        let mut integer_terms: Vec<i64> = Vec::new();
        let mut other_terms: Vec<Expression> = Vec::new();

        for term in sum.terms() {
            match term {
                Expression::Integer(i) => integer_terms.push(i.value() as i64),
                Expression::Negation(n) => {
                    if let Expression::Integer(i) = n.exp() {
                        integer_terms.push(-(i.value() as i64));
                    } else {
                        other_terms.push(term.clone());
                    }
                }
                _ => other_terms.push(term.clone()),
            }
        }

        if integer_terms.len() < 2 {
            return vec![];
        }

        let sum = integer_terms.iter().sum::<i64>();
        let new_int_term = if sum >= 0 {
            Integer::of(sum as u32)
        } else {
            Negation::of(Integer::of(-sum as u32))
        };
        other_terms.push(new_int_term);
        let result = sum_of(&other_terms);

        vec![(
            result,
            Argument::new(
                String::from("Evaluate addition"),
                vec![input.clone()],
                self.name(),
            ),
        )]
    }
    fn name(&self) -> String {
        String::from("EvaluateSums")
    }
}

#[cfg(test)]
mod tests {
    use crate::expressions::Negation;
    use crate::expressions::{sum::sum_of, Integer};

    use super::DerivationRule;
    use super::EvaluateSums;

    #[test]
    fn test_1() {
        let rule = EvaluateSums {};

        let start = sum_of(&[Integer::of(1), Integer::of(4)]);
        assert!(rule.apply(start).first().unwrap().0 == Integer::of(5));

        let start1 = sum_of(&[Negation::of(Integer::of(4)), Integer::of(1)]);
        let result1 = rule.apply(start1).first().unwrap().0.clone();
        assert_eq!(result1, Negation::of(Integer::of(3)));
    }
}