>>> from symbolic_equation import Eq
>>> from sympy import symbols
>>> x, y = symbols('x y')
>>> eq1 = Eq(2*x - y - 1, tag='I')
>>> eq1
2*x - y - 1 = 0    ('I')

>>> eq2 = Eq(x + y - 5, tag='II')
>>> eq2
x + y - 5 = 0    ('II')

>>> eq_y = (
...     (eq1 - 2 * eq2).tag("I - 2 II")
...     .transform(lambda eq: eq - 9)
...     .transform(lambda eq: eq / (-3)).tag('y')
... )
>>> eq_y
9 - 3*y = 0     ('I - 2 II')
   -3*y = -9
      y = 3     ('y')

>>> eq_x = (
...     eq1.apply_to_lhs('subs', eq_y.as_dict).reset().tag(r'y in I')
...     .transform(lambda eq: eq / 2)
...     .transform(lambda eq: eq + 2).tag('x')
... )
>>> eq_x
2*x - 4 = 0    ('y in I')
  x - 2 = 0
      x = 2    ('x')

class Eq(builtins.object)
 |  symbolic_equation.Eq(lhs, rhs=None, tag=None, eq_sym_str=None, eq_sym_tex=None, _prev_lhs=None, _prev_rhs=None, _prev_tags=None)
 |
 |  Symbolic equation.
 |
 |  This class keeps track of the :attr:`lhs` and :attr:`rhs` of an equation
 |  across arbitrary manipulations.
 |
 |  Args:
 |      lhs: the left-hand-side of the equation
 |      rhs: the right-hand-side of the equation. If None, defaults to zero.
 |      tag: a tag (equation number) to be shown when printing
 |           the equation
 |      eq_sym_str: If given, a value that overrides the `eq_sym_str` class
 |          attribute for this particular instance.
 |      eq_sym_tex: If given, a value that overrides the `eq_sym_tex` class
 |          attribute for this particular instance.
 |
 |  Class Attributes:
 |      latex_renderer: If not None, a callable that must return a LaTeX
 |          representation (:class:`str`) of `lhs` and `rhs`. When overriding
 |          this, wrap the function with `staticmethod`.
 |      eq_sym_str: default representation of the "equal" when rendering the
 |          equation as a str
 |      eq_sym_tex: default representation of the "equal" when rendering the
 |          equation in latex
 |
 |  Methods defined here:
 |
 |  __add__(self, other)
 |      Add another equation, or a constant.
 |
 |  __eq__(self, other)
 |      Compare to another equation, or a constant.
 |
 |      This does not take into account any mathematical knowledge, it merely
 |      checks if the :attr:`lhs` and :attr:`rhs` are exactly equal. If
 |      comparing against a constant, the :attr:`rhs` must be exactly equal to
 |      that constant.
 |
 |  __init__(self, lhs, rhs=None, tag=None, eq_sym_str=None, eq_sym_tex=None, _prev_lhs=None, _prev_rhs=None, _prev_tags=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __mul__(self, other)
 |
 |  __radd__ = __add__(self, other)
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __rmul__(self, other)
 |
 |  __rsub__(self, other)
 |
 |  __str__(self)
 |      Return str(self).
 |
 |  __sub__(self, other)
 |
 |  __truediv__(self, other)
 |
 |  amend(self, previous_lines=1)
 |      Amend the previous lhs and rhs with the current ones.
 |
 |      If `previous_lines` is greater than 1, overwrite the corresponding
 |      number of previous lines.
 |
 |      This can be chained to e.g. an :meth:`apply` call to group multiple
 |      steps so that they don't show up a separate lines in the output.
 |
 |  apply(self, func_or_mtd, *args, **kwargs)
 |      Apply `func_or_mtd` to both sides of the equation.
 |
 |      Returns a new equation where the left-hand-side and right-hand side
 |      are replaced by the application of `func_or_mtd`, depending on its
 |      type.
 |
 |      * If `func_or_mtd` is a string, it must be the name of a method `mtd`,
 |        and equation is modified as
 |
 |        ::
 |
 |            lhs=lhs.mtd(*args, **kwargs)
 |            rhs=rhs.mtd(*args, **kwargs)
 |
 |      * If `func_or_mtd` is a callable `func`, the equation is modified as
 |
 |        ::
 |
 |            lhs=func(lhs, *args, **kwargs)
 |            rhs=func(rhs, *args, **kwargs)
 |
 |  apply_to_lhs(self, func_or_mtd, *args, **kwargs)
 |      Apply `func_or_mtd` to the :attr:`lhs` of the equation only.
 |
 |      Like :meth:`apply`, but modifying only the left-hand-side.
 |
 |  apply_to_rhs(self, func_or_mtd, *args, **kwargs)
 |      Apply `func_or_mtd` to the :attr:`rhs` of the equation only.
 |
 |      Like :meth:`apply`, but modifying only the right-hand-side.
 |
 |  copy(self)
 |      Return a copy of the equation, including its history.
 |
 |  reset(self)
 |      Discard the equation history.
 |
 |  tag(self, tag)
 |      Set the tag for the last line in the equation.
 |
 |  transform(self, func, *args, **kwargs)
 |      Apply `func` to the entire equation.
 |
 |      The lhs and the rhs of the equation is replaced with the lhs and rhs of
 |      the equation returned by ``func(self, *args, **kwargs)``.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)
 |
 |  as_dict
 |      Mapping of the lhs to the rhs.
 |
 |      This allows to plug an equation into another expression.
 |
 |  lhs
 |      The left-hand-side of the equation.
 |
 |  rhs
 |      The right-hand-side of the equation.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __hash__ = None
 |
 |  eq_sym_str = '='
 |
 |  eq_sym_tex = '='
 |
 |  latex_renderer = None