def test_arith_flex_frame_mixed(self, op, int_frame, mixed_int_frame, mixed_float_frame): f = getattr(operator, op) # vs mix int result = getattr(mixed_int_frame, op)(2 + mixed_int_frame) expected = f(mixed_int_frame, 2 + mixed_int_frame) # no overflow in the uint dtype = None if op in ["__sub__"]: dtype = dict(B="uint64", C=None) elif op in ["__add__", "__mul__"]: dtype = dict(C=None) tm.assert_frame_equal(result, expected) _check_mixed_int(result, dtype=dtype) # vs mix float result = getattr(mixed_float_frame, op)(2 * mixed_float_frame) expected = f(mixed_float_frame, 2 * mixed_float_frame) tm.assert_frame_equal(result, expected) _check_mixed_float(result, dtype=dict(C=None)) # vs plain int result = getattr(int_frame, op)(2 * int_frame) expected = f(int_frame, 2 * int_frame) tm.assert_frame_equal(result, expected)
def test_arith_flex_frame_mixed(self, op, int_frame, mixed_int_frame, mixed_float_frame): f = getattr(operator, op) # vs mix int result = getattr(mixed_int_frame, op)(2 + mixed_int_frame) expected = f(mixed_int_frame, 2 + mixed_int_frame) # no overflow in the uint dtype = None if op in ['__sub__']: dtype = dict(B='uint64', C=None) elif op in ['__add__', '__mul__']: dtype = dict(C=None) tm.assert_frame_equal(result, expected) _check_mixed_int(result, dtype=dtype) # vs mix float result = getattr(mixed_float_frame, op)(2 * mixed_float_frame) expected = f(mixed_float_frame, 2 * mixed_float_frame) tm.assert_frame_equal(result, expected) _check_mixed_float(result, dtype=dict(C=None)) # vs plain int result = getattr(int_frame, op)(2 * int_frame) expected = f(int_frame, 2 * int_frame) tm.assert_frame_equal(result, expected)
def test_arith_flex_frame(self): ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod'] if not compat.PY3: aliases = {} else: aliases = {'div': 'truediv'} for op in ops: try: alias = aliases.get(op, op) f = getattr(operator, alias) result = getattr(self.frame, op)(2 * self.frame) exp = f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)(2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) # rops r_f = lambda x, y: f(y, x) result = getattr(self.frame, 'r' + op)(2 * self.frame) exp = r_f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)(2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) result = getattr(self.intframe, op)(2 * self.intframe) exp = f(self.intframe, 2 * self.intframe) assert_frame_equal(result, exp) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) except: printing.pprint_thing("Failing operation %r" % op) raise # ndim >= 3 ndim_5 = np.ones(self.frame.shape + (3, 4, 5)) msg = "Unable to coerce to Series/DataFrame" with tm.assert_raises_regex(ValueError, msg): f(self.frame, ndim_5) with tm.assert_raises_regex(ValueError, msg): getattr(self.frame, op)(ndim_5) # res_add = self.frame.add(self.frame) # res_sub = self.frame.sub(self.frame) # res_mul = self.frame.mul(self.frame) # res_div = self.frame.div(2 * self.frame) # assert_frame_equal(res_add, self.frame + self.frame) # assert_frame_equal(res_sub, self.frame - self.frame) # assert_frame_equal(res_mul, self.frame * self.frame) # assert_frame_equal(res_div, self.frame / (2 * self.frame)) const_add = self.frame.add(1) assert_frame_equal(const_add, self.frame + 1) # corner cases result = self.frame.add(self.frame[:0]) assert_frame_equal(result, self.frame * np.nan) result = self.frame[:0].add(self.frame) assert_frame_equal(result, self.frame * np.nan) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): self.frame.add(self.frame.iloc[0], fill_value=3) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): self.frame.add(self.frame.iloc[0], axis='index', fill_value=3)
def test_arith_flex_frame(self): ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod'] if not compat.PY3: aliases = {} else: aliases = {'div': 'truediv'} for op in ops: try: alias = aliases.get(op, op) f = getattr(operator, alias) result = getattr(self.frame, op)(2 * self.frame) exp = f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)(2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) # rops r_f = lambda x, y: f(y, x) result = getattr(self.frame, 'r' + op)(2 * self.frame) exp = r_f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)( 2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) result = getattr(self.intframe, op)(2 * self.intframe) exp = f(self.intframe, 2 * self.intframe) assert_frame_equal(result, exp) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(self.mixed_int, op)( 2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) except: printing.pprint_thing("Failing operation %r" % op) raise # ndim >= 3 ndim_5 = np.ones(self.frame.shape + (3, 4, 5)) msg = "Unable to coerce to Series/DataFrame" with assertRaisesRegexp(ValueError, msg): f(self.frame, ndim_5) with assertRaisesRegexp(ValueError, msg): getattr(self.frame, op)(ndim_5) # res_add = self.frame.add(self.frame) # res_sub = self.frame.sub(self.frame) # res_mul = self.frame.mul(self.frame) # res_div = self.frame.div(2 * self.frame) # assert_frame_equal(res_add, self.frame + self.frame) # assert_frame_equal(res_sub, self.frame - self.frame) # assert_frame_equal(res_mul, self.frame * self.frame) # assert_frame_equal(res_div, self.frame / (2 * self.frame)) const_add = self.frame.add(1) assert_frame_equal(const_add, self.frame + 1) # corner cases result = self.frame.add(self.frame[:0]) assert_frame_equal(result, self.frame * np.nan) result = self.frame[:0].add(self.frame) assert_frame_equal(result, self.frame * np.nan) with assertRaisesRegexp(NotImplementedError, 'fill_value'): self.frame.add(self.frame.iloc[0], fill_value=3) with assertRaisesRegexp(NotImplementedError, 'fill_value'): self.frame.add(self.frame.iloc[0], axis='index', fill_value=3)
def test_arith_flex_frame(self): ops = ["add", "sub", "mul", "div", "truediv", "pow", "floordiv", "mod"] if not compat.PY3: aliases = {} else: aliases = {"div": "truediv"} for op in ops: try: alias = aliases.get(op, op) f = getattr(operator, alias) result = getattr(self.frame, op)(2 * self.frame) exp = f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)(2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) # vs mix int if op in ["add", "sub", "mul"]: result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # overflow in the uint dtype = None if op in ["sub"]: dtype = dict(B="object", C=None) elif op in ["add", "mul"]: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) # rops r_f = lambda x, y: f(y, x) result = getattr(self.frame, "r" + op)(2 * self.frame) exp = r_f(self.frame, 2 * self.frame) assert_frame_equal(result, exp) # vs mix float result = getattr(self.mixed_float, op)(2 * self.mixed_float) exp = f(self.mixed_float, 2 * self.mixed_float) assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) result = getattr(self.intframe, op)(2 * self.intframe) exp = f(self.intframe, 2 * self.intframe) assert_frame_equal(result, exp) # vs mix int if op in ["add", "sub", "mul"]: result = getattr(self.mixed_int, op)(2 + self.mixed_int) exp = f(self.mixed_int, 2 + self.mixed_int) # overflow in the uint dtype = None if op in ["sub"]: dtype = dict(B="object", C=None) elif op in ["add", "mul"]: dtype = dict(C=None) assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) except: printing.pprint_thing("Failing operation %r" % op) raise # ndim >= 3 ndim_5 = np.ones(self.frame.shape + (3, 4, 5)) with assertRaisesRegexp(ValueError, "shape"): f(self.frame, ndim_5) with assertRaisesRegexp(ValueError, "shape"): getattr(self.frame, op)(ndim_5) # res_add = self.frame.add(self.frame) # res_sub = self.frame.sub(self.frame) # res_mul = self.frame.mul(self.frame) # res_div = self.frame.div(2 * self.frame) # assert_frame_equal(res_add, self.frame + self.frame) # assert_frame_equal(res_sub, self.frame - self.frame) # assert_frame_equal(res_mul, self.frame * self.frame) # assert_frame_equal(res_div, self.frame / (2 * self.frame)) const_add = self.frame.add(1) assert_frame_equal(const_add, self.frame + 1) # corner cases result = self.frame.add(self.frame[:0]) assert_frame_equal(result, self.frame * np.nan) result = self.frame[:0].add(self.frame) assert_frame_equal(result, self.frame * np.nan) with assertRaisesRegexp(NotImplementedError, "fill_value"): self.frame.add(self.frame.iloc[0], fill_value=3) with assertRaisesRegexp(NotImplementedError, "fill_value"): self.frame.add(self.frame.iloc[0], axis="index", fill_value=3)
def test_arith_flex_frame(self): seriesd = tm.getSeriesData() frame = pd.DataFrame(seriesd).copy() mixed_float = pd.DataFrame({ 'A': frame['A'].copy().astype('float32'), 'B': frame['B'].copy().astype('float32'), 'C': frame['C'].copy().astype('float16'), 'D': frame['D'].copy().astype('float64') }) intframe = pd.DataFrame({k: v.astype(int) for k, v in seriesd.items()}) mixed_int = pd.DataFrame({ 'A': intframe['A'].copy().astype('int32'), 'B': np.ones(len(intframe), dtype='uint64'), 'C': intframe['C'].copy().astype('uint8'), 'D': intframe['D'].copy().astype('int64') }) # force these all to int64 to avoid platform testing issues intframe = pd.DataFrame({c: s for c, s in intframe.items()}, dtype=np.int64) ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod'] if not PY3: aliases = {} else: aliases = {'div': 'truediv'} for op in ops: try: alias = aliases.get(op, op) f = getattr(operator, alias) result = getattr(frame, op)(2 * frame) exp = f(frame, 2 * frame) tm.assert_frame_equal(result, exp) # vs mix float result = getattr(mixed_float, op)(2 * mixed_float) exp = f(mixed_float, 2 * mixed_float) tm.assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(mixed_int, op)(2 + mixed_int) exp = f(mixed_int, 2 + mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) tm.assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) # rops r_f = lambda x, y: f(y, x) result = getattr(frame, 'r' + op)(2 * frame) exp = r_f(frame, 2 * frame) tm.assert_frame_equal(result, exp) # vs mix float result = getattr(mixed_float, op)(2 * mixed_float) exp = f(mixed_float, 2 * mixed_float) tm.assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) result = getattr(intframe, op)(2 * intframe) exp = f(intframe, 2 * intframe) tm.assert_frame_equal(result, exp) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(mixed_int, op)(2 + mixed_int) exp = f(mixed_int, 2 + mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) tm.assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) except: printing.pprint_thing("Failing operation %r" % op) raise # ndim >= 3 ndim_5 = np.ones(frame.shape + (3, 4, 5)) msg = "Unable to coerce to Series/DataFrame" with tm.assert_raises_regex(ValueError, msg): f(frame, ndim_5) with tm.assert_raises_regex(ValueError, msg): getattr(frame, op)(ndim_5) # res_add = frame.add(frame) # res_sub = frame.sub(frame) # res_mul = frame.mul(frame) # res_div = frame.div(2 * frame) # tm.assert_frame_equal(res_add, frame + frame) # tm.assert_frame_equal(res_sub, frame - frame) # tm.assert_frame_equal(res_mul, frame * frame) # tm.assert_frame_equal(res_div, frame / (2 * frame)) const_add = frame.add(1) tm.assert_frame_equal(const_add, frame + 1) # corner cases result = frame.add(frame[:0]) tm.assert_frame_equal(result, frame * np.nan) result = frame[:0].add(frame) tm.assert_frame_equal(result, frame * np.nan) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): frame.add(frame.iloc[0], fill_value=3) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): frame.add(frame.iloc[0], axis='index', fill_value=3)
def test_arith_flex_frame(self): seriesd = tm.getSeriesData() frame = pd.DataFrame(seriesd).copy() mixed_float = pd.DataFrame({'A': frame['A'].copy().astype('float32'), 'B': frame['B'].copy().astype('float32'), 'C': frame['C'].copy().astype('float16'), 'D': frame['D'].copy().astype('float64')}) intframe = pd.DataFrame({k: v.astype(int) for k, v in seriesd.items()}) mixed_int = pd.DataFrame({'A': intframe['A'].copy().astype('int32'), 'B': np.ones(len(intframe), dtype='uint64'), 'C': intframe['C'].copy().astype('uint8'), 'D': intframe['D'].copy().astype('int64')}) # force these all to int64 to avoid platform testing issues intframe = pd.DataFrame({c: s for c, s in intframe.items()}, dtype=np.int64) ops = ['add', 'sub', 'mul', 'div', 'truediv', 'pow', 'floordiv', 'mod'] if not PY3: aliases = {} else: aliases = {'div': 'truediv'} for op in ops: try: alias = aliases.get(op, op) f = getattr(operator, alias) result = getattr(frame, op)(2 * frame) exp = f(frame, 2 * frame) tm.assert_frame_equal(result, exp) # vs mix float result = getattr(mixed_float, op)(2 * mixed_float) exp = f(mixed_float, 2 * mixed_float) tm.assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(mixed_int, op)(2 + mixed_int) exp = f(mixed_int, 2 + mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) tm.assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) # rops r_f = lambda x, y: f(y, x) result = getattr(frame, 'r' + op)(2 * frame) exp = r_f(frame, 2 * frame) tm.assert_frame_equal(result, exp) # vs mix float result = getattr(mixed_float, op)(2 * mixed_float) exp = f(mixed_float, 2 * mixed_float) tm.assert_frame_equal(result, exp) _check_mixed_float(result, dtype=dict(C=None)) result = getattr(intframe, op)(2 * intframe) exp = f(intframe, 2 * intframe) tm.assert_frame_equal(result, exp) # vs mix int if op in ['add', 'sub', 'mul']: result = getattr(mixed_int, op)(2 + mixed_int) exp = f(mixed_int, 2 + mixed_int) # no overflow in the uint dtype = None if op in ['sub']: dtype = dict(B='uint64', C=None) elif op in ['add', 'mul']: dtype = dict(C=None) tm.assert_frame_equal(result, exp) _check_mixed_int(result, dtype=dtype) except: printing.pprint_thing("Failing operation %r" % op) raise # ndim >= 3 ndim_5 = np.ones(frame.shape + (3, 4, 5)) msg = "Unable to coerce to Series/DataFrame" with tm.assert_raises_regex(ValueError, msg): f(frame, ndim_5) with tm.assert_raises_regex(ValueError, msg): getattr(frame, op)(ndim_5) # res_add = frame.add(frame) # res_sub = frame.sub(frame) # res_mul = frame.mul(frame) # res_div = frame.div(2 * frame) # tm.assert_frame_equal(res_add, frame + frame) # tm.assert_frame_equal(res_sub, frame - frame) # tm.assert_frame_equal(res_mul, frame * frame) # tm.assert_frame_equal(res_div, frame / (2 * frame)) const_add = frame.add(1) tm.assert_frame_equal(const_add, frame + 1) # corner cases result = frame.add(frame[:0]) tm.assert_frame_equal(result, frame * np.nan) result = frame[:0].add(frame) tm.assert_frame_equal(result, frame * np.nan) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): frame.add(frame.iloc[0], fill_value=3) with tm.assert_raises_regex(NotImplementedError, 'fill_value'): frame.add(frame.iloc[0], axis='index', fill_value=3)