[CLN] Dispatch (some) Frame ops to Series, avoiding _data.eval

pandas/core/frame.py

@@ -70,7 +70,8 @@
                                   check_bool_indexer)
 from pandas.core.internals import (BlockManager,
                                    create_block_manager_from_arrays,
-                                   create_block_manager_from_blocks)
+                                   create_block_manager_from_blocks,
+                                   try_cast_result)
 from pandas.core.series import Series
 from pandas.core.arrays import Categorical, ExtensionArray
 import pandas.core.algorithms as algorithms
@@ -4921,21 +4922,64 @@ def _arith_op(left, right):
                                  copy=False)
 
     def _combine_match_index(self, other, func, level=None):
+        assert isinstance(other, Series)
         left, right = self.align(other, join='outer', axis=0, level=level,
                                  copy=False)
-        new_data = func(left.values.T, right.values).T
-        return self._constructor(new_data,
-                                 index=left.index, columns=self.columns,
-                                 copy=False)
+        assert left.index.equals(right.index)
+
+        if left._is_mixed_type or right._is_mixed_type:
+            if self.columns.is_unique:
+                new_data = {col: func(left[col], right)
+                            for col in left.columns}
+                result = self._constructor(new_data,
+                                           index=left.index,
+                                           columns=left.columns,
+                                           copy=False)
+                return result
+            else:
+                new_data = [func(left.iloc[:, idx], right)
+                            for idx in range(len(left.columns))]
+                result = self._constructor(new_data,
+                                           index=left.index,
+                                           copy=False)
+                result.columns = left.columns
+                return result
+
+        else:
+            # easy case, operate directly on values
+            result = func(left.values.T, right.values).T
+            return self._constructor(result,
+                                     index=left.index, columns=self.columns,
+                                     copy=False)
 
     def _combine_match_columns(self, other, func, level=None, try_cast=True):
+        # TODO: `func` passed here is wrapped in core.ops; if we are
+        # dispatching to Series implementation, should we pass unwrapped?
+        assert isinstance(other, Series)
         left, right = self.align(other, join='outer', axis=1, level=level,
                                  copy=False)
+        assert left.columns.equals(right.index), (left.columns, right.index)
 
-        new_data = left._data.eval(func=func, other=right,
-                                   axes=[left.columns, self.index],
-                                   try_cast=try_cast)
-        return self._constructor(new_data)
+        new_data = [func(left.iloc[:, n], right.iloc[n])
+                    for n in range(len(left.columns))]
+
+        if try_cast:
+            new_data = [try_cast_result(left.iloc[:, n], new_data[n])
+                        for n in range(len(left.columns))]
+
+        if left.columns.is_unique:
+            new_data = {left.columns[n]: new_data[n]
+                        for n in range(len(left.columns))}
+            result = self._constructor(new_data,
+                                       index=left.index, columns=left.columns,
+                                       copy=False)
+            return result
+
+        else:
+            new_data = {i: new_data[i] for i in range(len(new_data))}
+            result = self._constructor(new_data, index=left.index, copy=False)
+            result.columns = left.columns
+            return result
 
     def _combine_const(self, other, func, errors='raise', try_cast=True):
         new_data = self._data.eval(func=func, other=other,

pandas/core/internals/__init__.py

@@ -86,6 +86,55 @@
 from pandas.compat import range, map, zip, u
 
 
+def try_cast_result(left, result, dtype=None):
+    """
+    Try to cast the result to the original dtype for `left`; we may have
+    roundtripped thru object in the mean-time.
+
+    Parameters
+    ----------
+    left : array-like
+    result : array-like
+    dtype : np.dtype, pd.dtype, or None (default None)
+
+    Returns
+    -------
+    maybe_casted : same type as `result`
+    """
+    if dtype is None:
+        dtype = left.dtype
+
+    if (is_integer_dtype(left) or is_bool_dtype(left) or
+            is_datetime64_dtype(left) or is_datetime64tz_dtype(left)):
+        pass
+    elif is_object_dtype(left) and lib.infer_dtype(left) == 'boolean':
+        # disguised is_bool_dtype
+        pass
+    elif is_float_dtype(left) and result.dtype == left.dtype:
+
+        # protect against a bool/object showing up here
+        if isinstance(dtype, compat.string_types) and dtype == 'infer':
+            return result
+        if not isinstance(dtype, type):
+            dtype = dtype.type
+        if issubclass(dtype, (np.bool_, np.object_)):
+            if issubclass(dtype, np.bool_):
+                if isna(result).all():
+                    return result.astype(np.bool_)
+                else:
+                    result = result.astype(np.object_)
+                    result[result == 1] = True
+                    result[result == 0] = False
+                    return result
+            else:
+                return result.astype(np.object_)
+
+        return result
+
+    # may need to change the dtype here
+    return maybe_downcast_to_dtype(result, dtype)
+
+
 class Block(PandasObject):
     """
     Canonical n-dimensional unit of homogeneous dtype contained in a pandas
@@ -711,34 +760,7 @@ def _try_cast_result(self, result, dtype=None):
         """ try to cast the result to our original type, we may have
         roundtripped thru object in the mean-time
         """
-        if dtype is None:
-            dtype = self.dtype
-
-        if self.is_integer or self.is_bool or self.is_datetime:
-            pass
-        elif self.is_float and result.dtype == self.dtype:
-
-            # protect against a bool/object showing up here
-            if isinstance(dtype, compat.string_types) and dtype == 'infer':
-                return result
-            if not isinstance(dtype, type):
-                dtype = dtype.type
-            if issubclass(dtype, (np.bool_, np.object_)):
-                if issubclass(dtype, np.bool_):
-                    if isna(result).all():
-                        return result.astype(np.bool_)
-                    else:
-                        result = result.astype(np.object_)
-                        result[result == 1] = True
-                        result[result == 0] = False
-                        return result
-                else:
-                    return result.astype(np.object_)
-
-            return result
-
-        # may need to change the dtype here
-        return maybe_downcast_to_dtype(result, dtype)
+        return try_cast_result(self, result, dtype)
 
     def _try_coerce_args(self, values, other):
         """ provide coercion to our input arguments """

pandas/core/sparse/frame.py

@@ -585,27 +585,22 @@ def _combine_match_index(self, other, func, level=None):
         if level is not None:
             raise NotImplementedError("'level' argument is not supported")
 
-        new_index = self.index.union(other.index)
-        this = self
-        if self.index is not new_index:
-            this = self.reindex(new_index)
-
-        if other.index is not new_index:
-            other = other.reindex(new_index)
+        this, other = self.align(other, join='outer', axis=0,
+                                 level=level, copy=False)
 
+        new_data = {}
         for col, series in compat.iteritems(this):
             new_data[col] = func(series.values, other.values)
 
         # fill_value is a function of our operator
-        fill_value = None
         if isna(other.fill_value) or isna(self.default_fill_value):
             fill_value = np.nan
         else:
             fill_value = func(np.float64(self.default_fill_value),
                               np.float64(other.fill_value))
 
         return self._constructor(
-            new_data, index=new_index, columns=self.columns,
+            new_data, index=this.index, columns=this.columns,
             default_fill_value=fill_value).__finalize__(self)
 
     def _combine_match_columns(self, other, func, level=None, try_cast=True):
@@ -617,19 +612,16 @@ def _combine_match_columns(self, other, func, level=None, try_cast=True):
         if level is not None:
             raise NotImplementedError("'level' argument is not supported")
 
-        new_data = {}
-
-        union = intersection = self.columns
-
-        if not union.equals(other.index):
-            union = other.index.union(self.columns)
-            intersection = other.index.intersection(self.columns)
+        left, right = self.align(other, join='outer', axis=1,
+                                 level=level, copy=False)
 
-        for col in intersection:
+        new_data = {}
+        for col in other.index.intersection(self.columns):
             new_data[col] = func(self[col], float(other[col]))
+            # TODO: Why are we casting other[col] to float?
 
         return self._constructor(
-            new_data, index=self.index, columns=union,
+            new_data, index=left.index, columns=left.columns,
             default_fill_value=self.default_fill_value).__finalize__(self)
 
     def _combine_const(self, other, func, errors='raise', try_cast=True):

pandas/tests/frame/test_axis_select_reindex.py

@@ -738,7 +738,7 @@ def test_align_int_fill_bug(self):
 
         result = df1 - df1.mean()
         expected = df2 - df2.mean()
-        assert_frame_equal(result, expected)
+        assert_frame_equal(result.astype('f8'), expected)
 
     def test_align_multiindex(self):
         # GH 10665

pandas/tests/reshape/test_pivot.py

@@ -1565,8 +1565,9 @@ def test_crosstab_normalize(self):
                               full_normal)
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='index'),
                               row_normal)
-        tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='columns'),
-                              col_normal)
+        tm.assert_frame_equal(
+            pd.crosstab(df.a, df.b, normalize='columns').astype('f8'),
+            col_normal)
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=1),
                               pd.crosstab(df.a, df.b, normalize='columns'))
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=0),
@@ -1599,7 +1600,8 @@ def test_crosstab_normalize(self):
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='index',
                                           margins=True), row_normal_margins)
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize='columns',
-                                          margins=True), col_normal_margins)
+                                          margins=True).astype('f8'),
+                              col_normal_margins)
         tm.assert_frame_equal(pd.crosstab(df.a, df.b, normalize=True,
                                           margins=True), all_normal_margins)
 

pandas/tests/series/test_operators.py

@@ -1547,8 +1547,11 @@ def tester(a, b):
         # this is an alignment issue; these are equivalent
         # https://github.com/pandas-dev/pandas/issues/5284
 
-        pytest.raises(ValueError, lambda: d.__and__(s, axis='columns'))
-        pytest.raises(ValueError, tester, s, d)
+        with pytest.raises(TypeError):
+            d.__and__(s, axis='columns')
+
+        with pytest.raises(TypeError):
+            tester(s, d)
 
         # this is wrong as its not a boolean result
         # result = d.__and__(s,axis='index')