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

use std::rc::Rc;

use crate::{
    argument::Argument,
    derivation_rules::helpers::is_one,
    expressions::{product::product_of, Fraction},
    Expression,
};

use super::{helpers::factors_in, DerivationRule};

/// (ab)/(ac) = (a/a)(b/c)
pub struct PullOutUnitFractions {}

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

        let mut numerator = factors_in(&frac.numerator());
        let mut denominator = factors_in(&frac.denominator());

        let mut common = Vec::<Expression>::new();

        let mut i = 0;
        'outer: while i < numerator.len() {
            let mut j = 0;
            while j < denominator.len() {
                if numerator[i] == denominator[j] {
                    let factor = numerator.remove(i);
                    if !is_one(&factor) {
                        common.push(factor);
                    }
                    denominator.remove(j);
                    continue 'outer;
                }
                j += 1;
            }
            i += 1;
        }

        if common.is_empty() || (numerator.is_empty() && denominator.is_empty()) {
            return vec![];
        }

        let new_rhs = if denominator.is_empty() {
            product_of(&numerator)
        } else {
            Fraction::of(product_of(&numerator), product_of(&denominator))
        };

        vec![(
            product_of(&[
                Fraction::of(product_of(&common), product_of(&common)),
                new_rhs,
            ]),
            Argument::new(
                String::from("Pull same out of top and bottom of fraction"),
                vec![input],
                self.name(),
            ),
        )]
    }

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

#[cfg(test)]
mod tests {
    use crate::{
        convenience_expressions::v,
        derivation_rules::helpers::{expect_no_result, expect_result},
        expressions::{product::product_of, Fraction},
    };

    use super::*;

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

        expect_result(
            &rule,
            Fraction::of(product_of(&[v("a"), v("b")]), product_of(&[v("a"), v("c")])),
            product_of(&[Fraction::of(v("a"), v("a")), Fraction::of(v("b"), v("c"))]),
        );

        expect_no_result(&rule, Fraction::of(v("a"), v("a")))
    }
}