CLN: Move arithmetic methods into core/generic.py

Adds two classmethods to `NDFrame` that allow
easy, correct binding of all the arithmetic operators.

Only add if method not already in class' __dict__

Method binding is Py2/3 compatible

Handles both flex and special (`__*__`) methods

Frame: Refactor frame flex methods to generic

Series: refactor rich comparisons to generic

Panel: Refactor panel arithmetic methods into generic

Note that SparsePanel explicitly opts out
because it works differently and falls back
to using underlying operations + _fill_zeros.

Add subtract and multiply methods to match Panel

Add note with question on r* flex methods

Add call signature for flex_*_method to docstring

Change flexmethod to be accelerated

Add basic speedups to panel

Simplify naming and use special method check to handle the different
names (this does end up causing certain more descriptive names (i.e.,
"true division") to be lost, but overall I think it's a big improvement
and makes everything much more simple).

Also sets `default_axis` to be exactly the same as how it was before the
refactoring. (Frame flex methods use the default of 'columns', special
arithmetic methods use `default_axis=None` and all comp methods use
default axis of 'columns')

Author: jtratner

pandas/core/frame.py

@@ -835,68 +835,6 @@ def __contains__(self, key):
         """True if DataFrame has this column"""
         return key in self.columns
 
-    #----------------------------------------------------------------------
-    # Arithmetic methods
-
-    add = _arith_method(operator.add, 'add', '+')
-    mul = _arith_method(operator.mul, 'multiply', '*')
-    sub = _arith_method(operator.sub, 'subtract', '-')
-    if not py3compat.PY3:
-        div = divide = _arith_method(operator.div, 'divide', '/',
-                truediv=False, fill_zeros=np.inf, default_axis=None)
-    else:
-        div = divide = _arith_method(operator.truediv, 'divide', '/',
-                truediv=True, fill_zeros=np.inf, default_axis=None)
-    truediv = _arith_method(operator.truediv, 'true division', '/',
-            truediv=True, fill_zeros=np.inf, default_axis=None)
-    floordiv = _arith_method(operator.floordiv, 'floor division', '//',
-                                 default_axis=None, fill_zeros=np.inf)
-    mod = _arith_method(operator.mod, 'mod', default_axis=None, fill_zeros=np.nan)
-    pow = _arith_method(operator.pow, 'pow', '**')
-
-    radd = _arith_method(_radd_compat, 'radd')
-    rmul = _arith_method(operator.mul, 'rmultiply')
-    rsub = _arith_method(lambda x, y: y - x, 'rsubtract')
-    rdiv = _arith_method(lambda x, y: y / x, 'rdivide')
-    rpow = _arith_method(lambda x, y: y ** x, 'rpow')
-
-    __add__ = _arith_method(operator.add, '__add__', '+', default_axis=None)
-    __sub__ = _arith_method(operator.sub, '__sub__', '-', default_axis=None)
-    __mul__ = _arith_method(operator.mul, '__mul__', '*', default_axis=None)
-    __truediv__ = _arith_method(operator.truediv, '__truediv__', '/',
-                                default_axis=None, fill_zeros=np.inf, truediv=True)
-    __floordiv__ = _arith_method(operator.floordiv, '__floordiv__', '//',
-                                 default_axis=None, fill_zeros=np.inf)
-    __pow__ = _arith_method(operator.pow, '__pow__', '**', default_axis=None)
-
-    # Causes a floating point exception in the tests when numexpr enabled, so for now no speedup
-    # __mod__ = _arith_method(operator.mod, '__mod__', '%', default_axis=None, fill_zeros=np.nan)
-    __mod__ = _arith_method(operator.mod, '__mod__',
-                            default_axis=None, fill_zeros=np.nan)
-
-    __radd__ = _arith_method(_radd_compat, '__radd__', default_axis=None)
-    __rmul__ = _arith_method(operator.mul, '__rmul__', default_axis=None)
-    __rsub__ = _arith_method(lambda x, y: y - x, '__rsub__', default_axis=None)
-    __rtruediv__ = _arith_method(lambda x, y: y / x, '__rtruediv__',
-                                 default_axis=None, fill_zeros=np.inf)
-    __rfloordiv__ = _arith_method(lambda x, y: y // x, '__rfloordiv__',
-                                  default_axis=None, fill_zeros=np.inf)
-    __rpow__ = _arith_method(lambda x, y: y ** x, '__rpow__',
-                             default_axis=None)
-    __rmod__ = _arith_method(operator.mod, '__rmod__', default_axis=None, fill_zeros=np.nan)
-
-    # boolean operators
-    __and__ = _arith_method(operator.and_, '__and__', '&')
-    __or__ = _arith_method(operator.or_, '__or__', '|')
-    __xor__ = _arith_method(operator.xor, '__xor__')
-
-    # Python 2 division methods
-    if not py3compat.PY3:
-        __div__ = _arith_method(operator.div, '__div__', '/',
-                                default_axis=None, fill_zeros=np.inf, truediv=False)
-        __rdiv__ = _arith_method(lambda x, y: y / x, '__rdiv__',
-                                 default_axis=None, fill_zeros=np.inf)
-
     def __neg__(self):
         arr = operator.neg(self.values)
         return self._wrap_array(arr, self.axes, copy=False)
@@ -905,21 +843,6 @@ def __invert__(self):
         arr = operator.inv(self.values)
         return self._wrap_array(arr, self.axes, copy=False)
 
-    # Comparison methods
-    __eq__ = _comp_method(operator.eq, '__eq__', '==')
-    __ne__ = _comp_method(operator.ne, '__ne__', '!=')
-    __lt__ = _comp_method(operator.lt, '__lt__', '<' )
-    __gt__ = _comp_method(operator.gt, '__gt__', '>' )
-    __le__ = _comp_method(operator.le, '__le__', '<=')
-    __ge__ = _comp_method(operator.ge, '__ge__', '>=')
-
-    eq = _flex_comp_method(operator.eq, 'eq', '==')
-    ne = _flex_comp_method(operator.ne, 'ne', '!=')
-    lt = _flex_comp_method(operator.lt, 'lt', '<')
-    gt = _flex_comp_method(operator.gt, 'gt', '>')
-    le = _flex_comp_method(operator.le, 'le', '<=')
-    ge = _flex_comp_method(operator.ge, 'ge', '>=')
-
     def dot(self, other):
         """
         Matrix multiplication with DataFrame or Series objects
@@ -6030,7 +5953,8 @@ def boxplot(self, column=None, by=None, ax=None, fontsize=None,
     return ax
 DataFrame.boxplot = boxplot
 
-
+DataFrame._add_flex_arithmetic_methods(_arith_method, radd_func=_radd_compat, flex_comp_method=_flex_comp_method)
+DataFrame._add_special_arithmetic_methods(_arith_method, radd_func=_radd_compat, comp_method=_comp_method, bool_method=_arith_method)
 if __name__ == '__main__':
     import nose
     nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],

pandas/core/generic.py

@@ -1,13 +1,16 @@
 # pylint: disable=W0231,E1101
+import operator
 
 import numpy as np
+from pandas.core.common import bind_method
 
 from pandas.core.index import MultiIndex
 import pandas.core.indexing as indexing
 from pandas.core.indexing import _maybe_convert_indices
 from pandas.tseries.index import DatetimeIndex
 import pandas.core.common as com
 import pandas.lib as lib
+from pandas.util import py3compat
 
 
 class PandasError(Exception):
@@ -35,6 +38,76 @@ def __hash__(self):
         raise TypeError('{0!r} objects are mutable, thus they cannot be'
                               ' hashed'.format(self.__class__.__name__))
 
+    #----------------------------------------------------------------------
+    # Arithmetic!
+    @classmethod
+    def _add_special_arithmetic_methods(cls, arith_method=None, radd_func=None, comp_method=None, bool_method=None,
+                                        use_numexpr=True):
+        """
+        Adds the full suite of special arithmetic methods (``__add__``, ``__sub__``, etc.) to the class.
+
+        Parameters
+        ----------
+        flex_arith_method : factory for flex arithmetic methods, with op string:
+            f(op, name, str_rep, default_axis=None, fill_zeros=None, **eval_kwargs)
+        radd_func :  Possible replacement for ``lambda x, y: y + x`` for compatibility
+        flex_comp_method : optional, factory for rich comparison - signature: f(op, name, str_rep)
+        use_numexpr : whether to accelerate with numexpr, defaults to True
+        """
+        radd_func = radd_func or operator.add
+        # in frame, special methods have default_axis = None, comp methods use 'columns'
+        new_methods = create_methods(arith_method, radd_func, comp_method, bool_method, use_numexpr, default_axis=None,
+                                     special=True)
+
+        # inplace operators (I feel like these should get passed an `inplace=True`
+        # or just be removed
+        new_methods.update(dict(
+            __iadd__=new_methods["__add__"],
+            __isub__=new_methods["__sub__"],
+            __imul__=new_methods["__mul__"],
+            __itruediv__=new_methods["__truediv__"],
+            __ipow__=new_methods["__pow__"]
+        ))
+        if not py3compat.PY3:
+            new_methods["__idiv__"] = new_methods["__div__"]
+        for name, method in new_methods.items():
+            if name not in cls.__dict__:
+                bind_method(cls, name, method)
+            # DELETEME SOON!
+            else:
+                print("Not overwriting existing func %r" % name)
+
+    @classmethod
+    def _add_flex_arithmetic_methods(cls, flex_arith_method, radd_func=None, flex_comp_method=None,
+                                     flex_bool_method=None, use_numexpr=True):
+        """
+        Adds the full suite of flex arithmetic methods (``pow``, ``mul``, ``add``) to the class.
+
+        Parameters
+        ----------
+        flex_arith_method : factory for flex arithmetic methods, with op string:
+            f(op, name, str_rep, default_axis=None, fill_zeros=None, **eval_kwargs)
+        radd_func :  Possible replacement for ``lambda x, y: y + x`` for compatibility
+        flex_comp_method : optional, factory for rich comparison - signature: f(op, name, str_rep)
+        use_numexpr : whether to accelerate with numexpr, defaults to True
+        """
+        radd_func = radd_func or operator.add
+        # in frame, default axis is 'columns', doesn't matter for series and panel
+        new_methods = create_methods(
+            flex_arith_method, radd_func, flex_comp_method, flex_bool_method,
+            use_numexpr, default_axis='columns', special=False)
+        new_methods.update(dict(
+            multiply=new_methods['mul'],
+            subtract=new_methods['sub'],
+            divide=new_methods['div']
+        ))
+
+        for name, method in new_methods.items():
+            if name not in cls.__dict__:
+                bind_method(cls, name, method)
+            # DELETEME SOON!
+            else:
+                print("Not overwriting existing func %r" % name)
 
     #----------------------------------------------------------------------
     # Axis name business
@@ -1158,3 +1231,78 @@ def truncate(self, before=None, after=None, copy=True):
         result = result.copy()
 
     return result
+
+
+
+
+def create_methods(arith_method, radd_func, comp_method, bool_method, use_numexpr, special=False, default_axis='columns'):
+    # NOTE: Only frame cares about default_axis, specifically: special methods have default axis None,
+    # whereas flex methods have default axis 'columns'
+    # if we're not using numexpr, then don't pass a str_rep
+    if use_numexpr:
+        op = lambda x: x
+    else:
+        op = lambda x: None
+    if special:
+        def names(x):
+            if x[-1] == "_":
+                return "__%s_" % x
+            else:
+                return "__%s__" % x
+    else:
+        names = lambda x: x
+    radd_func = radd_func or operator.add
+    # Inframe, all special methods have default_axis=None, flex methods have default_axis set to the default (columns)
+    new_methods = dict(
+        add=arith_method(operator.add, names('add'), op('+'), default_axis=default_axis),
+        radd=arith_method(radd_func, names('radd'), op('+'), default_axis=default_axis),
+        sub=arith_method(operator.sub, names('sub'), op('-'), default_axis=default_axis),
+        mul=arith_method(operator.mul, names('mul'), op('*'), default_axis=default_axis),
+        truediv=arith_method(operator.truediv, names('truediv'), op('/'),
+                             truediv=True, fill_zeros=np.inf, default_axis=default_axis),
+        floordiv=arith_method(operator.floordiv, names('floordiv'), op('//'),
+                              default_axis=default_axis, fill_zeros=np.inf),
+        # Causes a floating point exception in the tests when numexpr
+        # enabled, so for now no speedup
+        mod=arith_method(operator.mod, names('mod'), default_axis=default_axis,
+                         fill_zeros=np.nan),
+        pow=arith_method(operator.pow, names('pow'), op('**'), default_axis=default_axis),
+        # not entirely sure why this is necessary, but previously was included
+        # so it's here to maintain compatibility
+        rmul=arith_method(operator.mul, names('rmul'), default_axis=default_axis),
+        rsub=arith_method(lambda x, y: y - x, names('rsub'), default_axis=default_axis),
+        rtruediv=arith_method(lambda x, y: operator.truediv(y, x), names('rtruediv'), op('/'),
+                              truediv=True, fill_zeros=np.inf, default_axis=default_axis),
+        rfloordiv=arith_method(lambda x, y: operator.floordiv(y, x), names('rfloordiv'), op('//'),
+                               default_axis=default_axis, fill_zeros=np.inf),
+        rpow=arith_method(lambda x, y: y ** x, names('rpow'), default_axis=default_axis),
+        rmod=arith_method(lambda x, y: y % x, names('rmod'), default_axis=default_axis),
+    )
+    if not py3compat.PY3:
+        new_methods["div"] = arith_method(operator.div, names('div'), op('/'),
+                                          truediv=False, fill_zeros=np.inf, default_axis=default_axis)
+        new_methods["rdiv"] = arith_method(lambda x, y: operator.div(y, x), names('rdiv'), op('/'),
+                                           truediv=False, fill_zeros=np.inf, default_axis=default_axis)
+    else:
+        new_methods["div"] = arith_method(operator.truediv, names('div'), op('/'),
+                                          truediv=True, fill_zeros=np.inf, default_axis=default_axis)
+        # Comp methods never had a default axis set
+    if comp_method:
+        new_methods.update(dict(
+            eq=comp_method(operator.eq, names('eq'), op('==')),
+            ne=comp_method(operator.ne, names('ne'), op('!=')),
+            lt=comp_method(operator.lt, names('lt'), op('<')),
+            gt=comp_method(operator.gt, names('gt'), op('>')),
+            le=comp_method(operator.le, names('le'), op('<=')),
+            ge=comp_method(operator.ge, names('ge'), op('>=')),
+        ))
+    if bool_method:
+        new_methods.update(dict(
+        and_=bool_method(operator.and_, names('and_ [&]'), op('&')),
+        or_=bool_method(operator.or_, names('or_ [|]'), op('|')),
+        # For some reason ``^`` wasn't used in original.
+        xor=bool_method(operator.xor, names('xor [^]'))
+        ))
+
+    new_methods = dict((names(k), v) for k, v in new_methods.items())
+    return new_methods

pandas/core/panel.py

@@ -117,7 +117,7 @@ def f(self, other):
     return f
 
 
-def _comp_method(func, name):
+def _comp_method(func, name, str_rep=None):
 
     def na_op(x, y):
         try:
@@ -227,26 +227,6 @@ def _construct_axes_dict_for_slice(self, axes=None, **kwargs):
         d.update(kwargs)
         return d
 
-    __add__ = _arith_method(operator.add, '__add__', '+')
-    __sub__ = _arith_method(operator.sub, '__sub__', '-')
-    __truediv__ = _arith_method(operator.truediv, '__truediv__', '/', truediv=True, fill_zeros=np.inf)
-    __floordiv__ = _arith_method(operator.floordiv, '__floordiv__', '//',
-                                 fill_zeros=np.inf)
-    __floordiv__ = _arith_method(operator.floordiv, '__floordiv__')
-    __mul__ = _arith_method(operator.mul, '__mul__', '*')
-    __pow__ = _arith_method(operator.pow, '__pow__', '**')
-
-    __radd__ = _arith_method(operator.add, '__radd__')
-    __rmul__ = _arith_method(operator.mul, '__rmul__')
-    __rsub__ = _arith_method(lambda x, y: y - x, '__rsub__')
-    __rtruediv__ = _arith_method(lambda x, y: y / x, '__rtruediv__')
-    __rfloordiv__ = _arith_method(lambda x, y: y // x, '__rfloordiv__')
-    __rpow__ = _arith_method(lambda x, y: y ** x, '__rpow__')
-
-    if not py3compat.PY3:
-        __div__ = _arith_method(operator.div, '__div__', '/', truediv=False)
-        __rdiv__ = _arith_method(lambda x, y: y / x, '__rdiv__')
-
     def __init__(self, data=None, items=None, major_axis=None, minor_axis=None,
                  copy=False, dtype=None):
         self._init_data(
@@ -464,21 +444,6 @@ def __neg__(self):
     def __invert__(self):
         return -1 * self
 
-    # Comparison methods
-    __eq__ = _comp_method(operator.eq, '__eq__')
-    __ne__ = _comp_method(operator.ne, '__ne__')
-    __lt__ = _comp_method(operator.lt, '__lt__')
-    __gt__ = _comp_method(operator.gt, '__gt__')
-    __le__ = _comp_method(operator.le, '__le__')
-    __ge__ = _comp_method(operator.ge, '__ge__')
-
-    eq = _comp_method(operator.eq, 'eq')
-    ne = _comp_method(operator.ne, 'ne')
-    gt = _comp_method(operator.gt, 'gt')
-    lt = _comp_method(operator.lt, 'lt')
-    ge = _comp_method(operator.ge, 'ge')
-    le = _comp_method(operator.le, 'le')
-
     #----------------------------------------------------------------------
     # Magic methods
 
@@ -1627,7 +1592,7 @@ def _extract_axis(self, data, axis=0, intersect=False):
         return _ensure_index(index)
 
     @classmethod
-    def _add_aggregate_operations(cls):
+    def _add_aggregate_operations(cls, use_numexpr=True):
         """ add the operations to the cls; evaluate the doc strings again """
 
         # doc strings substitors
@@ -1644,27 +1609,26 @@ def _add_aggregate_operations(cls):
 -------
 """ + cls.__name__ + "\n"
 
-        def _panel_arith_method(op, name):
+        def _panel_arith_method(op, name, str_rep = None, default_axis=None, fill_zeros=None, **eval_kwargs):
+            def na_op(x, y):
+                try:
+                    result = expressions.evaluate(op, str_rep, x, y, raise_on_error=True, **eval_kwargs)
+                except TypeError:
+                    result = op(x, y)
+
+                # handles discrepancy between numpy and numexpr on division/mod by 0
+                # though, given that these are generally (always?) non-scalars, I'm
+                # not sure whether it's worth it at the moment
+                result = com._fill_zeros(result,y,fill_zeros)
+                return result
             @Substitution(op)
             @Appender(_agg_doc)
             def f(self, other, axis=0):
-                return self._combine(other, op, axis=axis)
+                return self._combine(other, na_op, axis=axis)
             f.__name__ = name
             return f
-
-        cls.add = _panel_arith_method(operator.add, 'add')
-        cls.subtract = cls.sub = _panel_arith_method(operator.sub, 'subtract')
-        cls.multiply = cls.mul = _panel_arith_method(operator.mul, 'multiply')
-
-        try:
-            cls.divide = cls.div = _panel_arith_method(operator.div, 'divide')
-        except AttributeError:  # pragma: no cover
-            # Python 3
-            cls.divide = cls.div = _panel_arith_method(operator.truediv,
-                                                       'divide')
-        cls.truediv = _panel_arith_method(operator.truediv, 'true division')
-        cls.floordiv = _panel_arith_method(operator.floordiv, 'floor division')
-
+        # add `div`, `mul`, `pow`, etc..
+        cls._add_flex_arithmetic_methods(_panel_arith_method, use_numexpr=use_numexpr)
         _agg_doc = """
 Return %(desc)s over requested axis
 
@@ -1745,6 +1709,7 @@ def min(self, axis='major', skipna=True):
             return self._reduce(nanops.nanmin, axis=axis, skipna=skipna)
         cls.min = min
 
+Panel._add_special_arithmetic_methods(_arith_method, comp_method=_comp_method)
 Panel._add_aggregate_operations()
 
 WidePanel = Panel