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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::{collections::HashMap, rc::Rc};

use crate::{
    argument::Argument,
    derivation_rules::helpers::is_one,
    expressions::{product::product_of, sum::sum_of, Exponent, Integer},
    Expression,
};

use super::DerivationRule;

pub struct ProductExponents {}

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

        let mut new_factors = HashMap::<Expression, Vec<Expression>>::new();
        let mut order = Vec::<Expression>::new();

        for factor in product.factors() {
            match factor {
                Expression::Exponent(ref e) => {
                    new_factors.entry(e.base()).or_default().push(e.power());
                    if !order.contains(&e.base()) {
                        order.push(e.base());
                    }
                }
                _ => {
                    new_factors
                        .entry(factor.clone())
                        .or_default()
                        .push(Integer::of(1));
                    if !order.contains(factor) {
                        order.push(factor.clone());
                    }
                }
            }
        }

        let factors = order
            .into_iter()
            .map(|base| {
                let powers = &new_factors[&base];
                if powers.len() == 1 {
                    let only = powers.first().unwrap();
                    if is_one(only) {
                        base
                    } else {
                        Exponent::of(base.clone(), (*only).clone())
                    }
                } else {
                    Exponent::of(base, sum_of(powers))
                }
            })
            .collect::<Vec<_>>();

        let result = product_of(&factors);

        if result == input {
            return vec![];
        }

        vec![(
            product_of(&factors),
            Argument::new(String::from("Add exponents"), vec![input], self.name()),
        )]
    }

    fn name(&self) -> String {
        String::from("ProductExponents")
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        convenience_expressions::{i, v},
        derivation_rules::helpers::expect_result,
    };

    use super::*;

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

        expect_result(
            &rule,
            product_of(&[v("a"), v("x"), v("x"), Exponent::of(v("y"), i(2))]),
            product_of(&[
                v("a"),
                Exponent::of(v("x"), sum_of(&[i(1), i(1)])),
                Exponent::of(v("y"), i(2)),
            ]),
        )
    }
}