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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::rc::Rc;

use crate::{
    argument::Argument,
    expressions::{product::product_of_iter, sum::sum_of, Expression},
};

use super::DerivationRule;

/**
* Distributes multiplication over addition.
*
* a(b+c) = ab + ac
*
*/
pub struct DistributiveProperty {}

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

        // Get all the factors which are themselves sums
        let sum_factors = product
            .factors()
            .iter()
            .filter(|factor| matches!(factor, Expression::Sum(_)));

        let mut equivalents: Vec<Expression> = vec![];

        // For each factor which is a sum, distribute each subset of
        // the other factors in the product over it, adding each
        // as a result.

        for sum in sum_factors {
            let terms = match sum {
                Expression::Sum(s) => s.terms(),
                _ => panic!(),
            };
            // For each subset of the other factors
            let other_factors: Vec<&Expression> =
                product.factors().iter().filter(|f| *f != sum).collect();

            // Powerset of the other factors, excluding empty set
            let base: u32 = 2;
            for s in 1..base.pow(other_factors.len() as u32) {
                let (to_distribute, others) = {
                    let mut subset: Vec<&Expression> = vec![];
                    let mut complement: Vec<&Expression> = vec![];
                    (0..other_factors.len()).for_each(|i| {
                        if s & (1 << i) != 0 {
                            subset.push(other_factors[i]);
                        } else {
                            complement.push(other_factors[i]);
                        }
                    });
                    (subset, complement)
                };

                let new_terms = terms
                    .iter()
                    .map(|term| {
                        product_of_iter(
                            &mut [term]
                                .iter()
                                .map(|e| (*e).clone())
                                .chain(to_distribute.iter().map(|e| (*e).clone())),
                        )
                    })
                    .collect::<Vec<Expression>>();

                let new_factors = &mut new_terms
                    .iter()
                    .chain(others)
                    .cloned()
                    .collect::<Vec<Expression>>();

                let equivalent = sum_of(new_factors);

                equivalents.push(equivalent);
            }
        }

        equivalents
            .iter()
            .map(|eq| {
                (
                    eq.clone(),
                    Argument::new(
                        String::from("Divide fractions"),
                        vec![input.clone()],
                        self.name(),
                    ),
                )
            })
            .collect()
    }

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

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        convenience_expressions::v, derivation_rules::DerivationRule,
        expressions::product::product_of,
    };

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

        // (a+b)c
        let start = product_of(&[sum_of(&[v("a"), v("b")]), v("c")]);
        let result = rule.apply(start).first().unwrap().0.clone();

        // ac + bc
        let expected = sum_of(&[product_of(&[v("a"), v("c")]), product_of(&[v("b"), v("c")])]);
        assert_eq!(result, expected);
    }
}