Python rulestestcase.tree函数代码示例

    def test_match_quotient_rule(self):
        root = tree('d/dx x ^ 2 / x')
        self.assertEqualPos(match_quotient_rule(root),
                [P(root, quotient_rule)])

        root = tree('d/dx x ^ 2 / 2')
        self.assertEqualPos(match_quotient_rule(root), [])

    def test_add_quadrants(self):
        s, c = root = tree('sin(t) ^ 2 + cos(t) ^ 2')
        self.assertEqual(add_quadrants(root, (Scope(root), s, c)), 1)

        root, expect = tree('cos(t) ^ 2 + a + sin(t) ^ 2, a + 1')
        (c, a), s = root
        self.assertEqual(add_quadrants(root, (Scope(root), s, c)), expect)

    def test_match_sort_monomial_constant(self):
        x, l2 = root = tree('x * 2')
        self.assertEqualPos(match_sort_monomial(root),
                [P(root, swap_factors, (Scope(root), x, l2))])

        root = tree('2x')
        self.assertEqualPos(match_sort_monomial(root), [])

    def test_match_sort_polynome(self):
        x, x2 = root = tree('x + x ^ 2')
        self.assertEqualPos(match_sort_polynome(root),
                [P(root, swap_factors, (Scope(root), x, x2))])

        root = tree('x + 2')
        self.assertEqualPos(match_sort_polynome(root), [])

    def test_match_sort_monomial_variables(self):
        y, x = root = tree('yx')
        self.assertEqualPos(match_sort_monomial(root),
                [P(root, swap_factors, (Scope(root), y, x))])

        root = tree('xy')
        self.assertEqualPos(match_sort_monomial(root), [])

    def test_negated_factor(self):
        a, b = root = tree('a * -b')
        self.assertEqual(negated_factor(root, (Scope(root), b)), -(a * +b))

        (a, b), c = root = tree('a * (-b) * -c')
        self.assertEqual(negated_factor(root, (Scope(root), b)), -(a * +b * c))
        self.assertEqual(negated_factor(root, (Scope(root), c)), -(a * b * +c))

    def test_extract_nominator_term(self):
        root, expect = tree('(2a) / 3, 2 / 3 * a')
        l2, a = root[0]
        self.assertEqual(extract_nominator_term(root, (l2, a)), expect)

        root, expect, l1 = tree('a / 3, 1 / 3 * a, 1')
        self.assertEqual(extract_nominator_term(root, (l1, root[0])), expect)

    def test_match_factor_out_abs_term_exponent(self):
        root = tree('|a ^ 2|')
        self.assertEqualPos(match_factor_out_abs_term(root),
                [P(root, factor_out_abs_exponent)])

        root = tree('|a ^ b|')
        self.assertEqualPos(match_factor_out_abs_term(root), [])

    def test_match_expand(self):
        a, bc, d = tree('a,b + c,d')
        b, c = bc

        root = a * bc
        self.assertEqualPos(match_expand(root),
                [P(root, expand_single, (Scope(root), a, bc))])

        root = bc * a
        self.assertEqualPos(match_expand(root),
                [P(root, expand_single, (Scope(root), bc, a))])

        root = a * bc * d
        self.assertEqualPos(match_expand(root),
                [P(root, expand_single, (Scope(root), a, bc)),
                 P(root, expand_single, (Scope(root), bc, d))])

        ab, cd = root = (a + b) * (c + d)
        self.assertEqualPos(match_expand(root),
                [P(root, expand_double, (Scope(root), ab, cd))])

        (ab, cd), e = root = tree('(a + b)(c + d)e')
        self.assertEqualPos(match_expand(root),
                [P(root, expand_double, (Scope(root), ab, cd)),
                 P(root, expand_single, (Scope(root), cd, e)),
                 P(root, expand_single, (Scope(root), ab, e))])

    def test_match_factor_out_abs_term_numeric(self):
        root = tree('|2|')
        self.assertEqualPos(match_factor_out_abs_term(root),
                [P(root, absolute_numeric)])

        root = tree('|a|')
        self.assertEqualPos(match_factor_out_abs_term(root), [])

    def test_match_remove_division_negation(self):
        root = tree('-(-a + b) / c')
        self.assertEqualPos(match_remove_division_negation(root),
                [P(root, remove_division_negation, (True, root[0]))])

        root = tree('-a / (-b + c)')
        self.assertEqualPos(match_remove_division_negation(root),
                [P(root, remove_division_negation, (False, root[1]))])

    def test_match_division_in_denominator(self):
        a, ((b, c), d) = root = tree('a / (b / c + d)')
        self.assertEqualPos(match_division_in_denominator(root),
                [P(root, multiply_with_term, (c,))])

        a, ((d, (b, c)), e) = root = tree('a / (d + b / c + e)')
        self.assertEqualPos(match_division_in_denominator(root),
                [P(root, multiply_with_term, (c,))])

    def test_match_exponent_to_root(self):
        root = tree('a ^ (1 / 2)')
        self.assertEqualPos(match_exponent_to_root(root),
                [P(root, exponent_to_root)])

        root = tree('a ^ (n / 2)')
        self.assertEqualPos(match_exponent_to_root(root),
                [P(root, exponent_to_root)])

    def test_match_goniometric_chain_rule(self):
        root, x2 = tree('d/dx sin(x ^ 2), x ^ 2')
        self.assertEqualPos(match_goniometric(root),
                [P(root, chain_rule, (x2, sinus, ()))])

        root = tree('d/dx cos(x ^ 2)')
        self.assertEqualPos(match_goniometric(root),
                [P(root, chain_rule, (x2, cosinus, ()))])

    def test_match_one_derivative(self):
        root = tree('d/dx x')
        self.assertEqualPos(match_one_derivative(root),
                [P(root, one_derivative)])

        root = tree('d/dx x')
        self.assertEqualPos(match_one_derivative(root),
                [P(root, one_derivative)])