Added rule for subtracting addition terms from both sides of an equation.

src/rules/lineq.py

+from .utils import find_variable
+from ..node import Scope, OP_EQ, OP_ADD, OP_MUL, eq
+from ..possibilities import Possibility as P, MESSAGES
+from ..translate import _
+
+
+def match_subtract_addition_term(node):
+    """
+    x + a = b   ->  x + a - a = b - a
+    x = b + cx  ->  x + - cx = b + cx - cx
+    """
+    assert node.is_op(OP_EQ)
+
+    x = find_variable(node)
+    p = []
+    left, right = node
+
+    if left.is_op(OP_ADD):
+        scope = Scope(left)
+
+        for n in scope:
+            # Bring terms without x to the right
+            if not n.contains(x):
+                p.append(P(node, subtract_addition_term, (n,)))
+
+    if right.is_op(OP_ADD):
+        scope = Scope(right)
+
+        for n in scope:
+            # Bring terms with x to the left
+            if n.contains(x):
+                p.append(P(node, subtract_addition_term, (n,)))
+
+    return p
+
+
+def subtract_addition_term(root, args):
+    """
+    x + a = b   ->  x + a - a = b - a
+    x = b + cx  ->  x + - cx = b + cx - cx
+    """
+    left, right = root
+    term = args[0]
+
+    return eq(left - term, right - term)
+
+
+MESSAGES[subtract_addition_term] = \
+        _('Subtract {1} from both sides of the equation.')

tests/test_rules_lineq.py

+from src.rules.lineq import match_subtract_addition_term, \
+        subtract_addition_term
+from src.node import Scope
+from src.possibilities import Possibility as P
+from tests.rulestestcase import RulesTestCase, tree
+
+
+class TestRulesLineq(RulesTestCase):
+
+    def test_match_subtract_addition_term(self):
+        root, a = tree('x + a = b, a')
+        self.assertEqualPos(match_subtract_addition_term(root),
+                [P(root, subtract_addition_term, (a,))])
+
+        root, cx = tree('x = b + cx, cx')
+        self.assertEqualPos(match_subtract_addition_term(root),
+                [P(root, subtract_addition_term, (cx,))])
+
+    def test_subtract_addition_term(self):
+        root, a, expect = tree('x + a = b, a, x + a - a = b - a')
+        self.assertEqual(subtract_addition_term(root, (a,)), expect)