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,
    convenience_expressions::sum_of_iter,
    expressions::{product::product_of, Expression, Fraction},
};

use super::DerivationRule;

/// Accepts sums with at least one fraction term and at least one non-fraction term.
/// For each fraction term, converts all non-fraction terms to fractions with
/// the same base.
///
/// Doesn't convert integrals.
pub struct MakeCommonDenominators {}

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

        let denominators = sum
            .terms()
            .iter()
            .filter(|term| matches!(term, Expression::Fraction(_)))
            .map(|frac| {
                let Expression::Fraction(f) = frac else {
                    panic!()
                };
                f.denominator()
            })
            .filter(|den| {
                let Expression::Integer(i) = den else {
                    return true;
                };
                i.value() != 1
            });

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

        for denominator in denominators {
            equivalents.push(sum_of_iter(&mut sum.terms().iter().map(
                |term| match term {
                    Expression::Fraction(_) => term.clone(),
                    Expression::Integral(_) => term.clone(),
                    x => Fraction::of(
                        product_of(&[x.clone(), denominator.clone()]),
                        denominator.clone(),
                    ),
                },
            )))
        }

        equivalents
            .into_iter()
            .filter(|exp| exp != &input)
            .map(|exp| {
                (
                    exp,
                    Argument::new(
                        String::from("Make common denominators"),
                        vec![input.clone()],
                        self.name(),
                    ),
                )
            })
            .collect()
    }
    fn name(&self) -> String {
        String::from("MakeCommonDenominators")
    }
}

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

    use super::*;

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

        let start = sum_of(&[v("x"), Fraction::of(v("y"), v("z"))]);
        let result = rule.apply(start).first().unwrap().0.clone();

        assert_eq!(
            result,
            sum_of(&[
                Fraction::of(product_of(&[v("x"), v("z")]), v("z")),
                Fraction::of(v("y"), v("z"))
            ])
        );

        expect_no_result(
            &rule,
            sum_of(&[Integral::of(v("x"), v("x")), Fraction::of(v("a"), v("b"))]),
        );
    }
    #[test]
    fn no_trivial_derivations() {
        let rule = MakeCommonDenominators {};

        expect_result(
            &rule,
            sum_of(&[Fraction::of(i(1), i(2)), i(1)]),
            sum_of(&[
                Fraction::of(i(1), i(2)),
                Fraction::of(product_of(&[i(1), i(2)]), i(2)),
            ]),
        );
    }
    #[test]
    fn no_den_one() {
        let rule = MakeCommonDenominators {};

        expect_no_result(&rule, sum_of(&[v("x"), Fraction::of(v("x"), i(1))]));
    }
}