def test_datetime_difference(self):
"""
Test `datetime64 - datetime64`.
"""
sub = self.jit(sub_usecase)
def check(a, b, expected=None):
with self.silence_numpy_warnings():
self.assertPreciseEqual(sub(a, b), a - b, (a, b))
self.assertPreciseEqual(sub(b, a), b - a, (a, b))
# Did we get it right?
self.assertPreciseEqual(a - b, expected)
check(DT('2014'), DT('2017'), TD(-3, 'Y'))
check(DT('2014-02'), DT('2017-01'), TD(-35, 'M'))
check(DT('2014-02-28'), DT('2015-03-01'), TD(-366, 'D'))
# NaTs
if not numpy_support.strict_ufunc_typing:
check(DT('NaT'), DT('2000'), TD('NaT', 'Y'))
check(DT('NaT', 'M'), DT('2000'), TD('NaT', 'M'))
check(DT('NaT', 'M'), DT('2000-01-01'), TD('NaT', 'D'))
check(DT('NaT'), DT('NaT'), TD('NaT'))
# Test many more values
with self.silence_numpy_warnings():
dts = self.datetime_samples()
for a, b in itertools.product(dts, dts):
if (numpy_support.strict_ufunc_typing
and not npdatetime.same_kind(value_unit(a),
value_unit(b))):
continue
self.assertPreciseEqual(sub(a, b), a - b, (a, b))
def test_datetime_difference(self):
"""
Test `datetime64 - datetime64`.
"""
sub = self.jit(sub_usecase)
def check(a, b, expected=None):
with self.silence_numpy_warnings():
self.assertPreciseEqual(sub(a, b), a - b, (a, b))
self.assertPreciseEqual(sub(b, a), b - a, (a, b))
# Did we get it right?
self.assertPreciseEqual(a - b, expected)
check(DT('2014'), DT('2017'), TD(-3, 'Y'))
check(DT('2014-02'), DT('2017-01'), TD(-35, 'M'))
check(DT('2014-02-28'), DT('2015-03-01'), TD(-366, 'D'))
# NaTs
if not numpy_support.strict_ufunc_typing:
check(DT('NaT'), DT('2000'), TD('NaT', 'Y'))
check(DT('NaT', 'M'), DT('2000'), TD('NaT', 'M'))
check(DT('NaT', 'M'), DT('2000-01-01'), TD('NaT', 'D'))
check(DT('NaT'), DT('NaT'), TD('NaT'))
# Test many more values
with self.silence_numpy_warnings():
dts = self.datetime_samples()
for a, b in itertools.product(dts, dts):
if (numpy_support.strict_ufunc_typing
and not npdatetime.same_kind(value_unit(a),
value_unit(b))):
continue
self.assertPreciseEqual(sub(a, b), a - b, (a, b))
def test_comparisons(self):
# Test all datetime comparisons all at once
eq = self.jit(eq_usecase)
ne = self.jit(ne_usecase)
lt = self.jit(lt_usecase)
le = self.jit(le_usecase)
gt = self.jit(gt_usecase)
ge = self.jit(ge_usecase)
def check_eq(a, b, expected):
with self.silence_numpy_warnings():
self.assertPreciseEqual(eq(a, b), expected, (a, b, expected))
self.assertPreciseEqual(eq(b, a), expected, (a, b, expected))
self.assertPreciseEqual(ne(a, b), not expected,
(a, b, expected))
self.assertPreciseEqual(ne(b, a), not expected,
(a, b, expected))
if expected:
# If equal, then equal-ordered comparisons are true
self.assertTrue(le(a, b), (a, b))
self.assertTrue(ge(a, b), (a, b))
self.assertTrue(le(b, a), (a, b))
self.assertTrue(ge(b, a), (a, b))
# and strictly ordered comparisons are false
self.assertFalse(lt(a, b), (a, b))
self.assertFalse(gt(a, b), (a, b))
self.assertFalse(lt(b, a), (a, b))
self.assertFalse(gt(b, a), (a, b))
# Did we get it right?
self.assertPreciseEqual(a == b, expected)
def check_lt(a, b, expected):
with self.silence_numpy_warnings():
self.assertPreciseEqual(lt(a, b), expected, (a, b, expected))
self.assertPreciseEqual(gt(b, a), expected, (a, b, expected))
self.assertPreciseEqual(ge(a, b), not expected,
(a, b, expected))
self.assertPreciseEqual(le(b, a), not expected,
(a, b, expected))
if expected:
# If true, then values are not equal
check_eq(a, b, False)
# Did we get it right?
self.assertPreciseEqual(a < b, expected)
check_eq(DT('2014'), DT('2017'), False)
check_eq(DT('2014'), DT('2014-01'), True)
check_eq(DT('2014'), DT('2014-01-01'), True)
check_eq(DT('2014'), DT('2014-01-01', 'W'), True)
check_eq(DT('2014-01'), DT('2014-01-01', 'W'), True)
# Yes, it's not transitive
check_eq(DT('2014-01-01'), DT('2014-01-01', 'W'), False)
check_eq(DT('2014-01-02'), DT('2014-01-06', 'W'), True)
# with times
check_eq(DT('2014-01-01T00:01:00Z', 's'), DT('2014-01-01T00:01Z', 'm'),
True)
check_eq(DT('2014-01-01T00:01:01Z', 's'), DT('2014-01-01T00:01Z', 'm'),
False)
# NaTs
if not numpy_support.strict_ufunc_typing:
check_lt(DT('NaT'), DT('2017'), True)
check_lt(DT('NaT', 'Y'), DT('2017'), True)
if not numpy_support.strict_ufunc_typing:
check_lt(DT('NaT', 'ms'), DT('2017'), True)
check_eq(DT('NaT'), DT('NaT'), True)
if not numpy_support.strict_ufunc_typing:
check_eq(DT('NaT', 'Y'), DT('NaT'), True)
check_eq(DT('NaT', 'ms'), DT('NaT', 'M'), True)
# Check comparison between various units
dts = self.datetime_samples()
for a in dts:
# Take a number of smaller units
a_unit = a.dtype.str.split('[')[1][:-1]
i = all_units.index(a_unit)
units = all_units[i:i + 6]
for unit in units:
# Force conversion
b = a.astype('M8[%s]' % unit)
if (numpy_support.strict_ufunc_typing
and not npdatetime.same_kind(value_unit(a),
value_unit(b))):
continue
check_eq(a, b, True)
check_lt(a, b + np.timedelta64(1, unit), True)
check_lt(b - np.timedelta64(1, unit), a, True)
def test_comparisons(self):
# Test all datetime comparisons all at once
eq = self.jit(eq_usecase)
ne = self.jit(ne_usecase)
lt = self.jit(lt_usecase)
le = self.jit(le_usecase)
gt = self.jit(gt_usecase)
ge = self.jit(ge_usecase)
def check_eq(a, b, expected):
with self.silence_numpy_warnings():
self.assertPreciseEqual(eq(a, b), expected, (a, b, expected))
self.assertPreciseEqual(eq(b, a), expected, (a, b, expected))
self.assertPreciseEqual(ne(a, b), not expected, (a, b, expected))
self.assertPreciseEqual(ne(b, a), not expected, (a, b, expected))
if expected:
# If equal, then equal-ordered comparisons are true
self.assertTrue(le(a, b), (a, b))
self.assertTrue(ge(a, b), (a, b))
self.assertTrue(le(b, a), (a, b))
self.assertTrue(ge(b, a), (a, b))
# and strictly ordered comparisons are false
self.assertFalse(lt(a, b), (a, b))
self.assertFalse(gt(a, b), (a, b))
self.assertFalse(lt(b, a), (a, b))
self.assertFalse(gt(b, a), (a, b))
# Did we get it right?
self.assertPreciseEqual(a == b, expected)
def check_lt(a, b, expected):
with self.silence_numpy_warnings():
self.assertPreciseEqual(lt(a, b), expected, (a, b, expected))
self.assertPreciseEqual(gt(b, a), expected, (a, b, expected))
self.assertPreciseEqual(ge(a, b), not expected, (a, b, expected))
self.assertPreciseEqual(le(b, a), not expected, (a, b, expected))
if expected:
# If true, then values are not equal
check_eq(a, b, False)
# Did we get it right?
self.assertPreciseEqual(a < b, expected)
check_eq(DT('2014'), DT('2017'), False)
check_eq(DT('2014'), DT('2014-01'), True)
check_eq(DT('2014'), DT('2014-01-01'), True)
check_eq(DT('2014'), DT('2014-01-01', 'W'), True)
check_eq(DT('2014-01'), DT('2014-01-01', 'W'), True)
# Yes, it's not transitive
check_eq(DT('2014-01-01'), DT('2014-01-01', 'W'), False)
check_eq(DT('2014-01-02'), DT('2014-01-06', 'W'), True)
# with times
check_eq(DT('2014-01-01T00:01:00Z', 's'),
DT('2014-01-01T00:01Z', 'm'), True)
check_eq(DT('2014-01-01T00:01:01Z', 's'),
DT('2014-01-01T00:01Z', 'm'), False)
# NaTs
if not numpy_support.strict_ufunc_typing:
check_lt(DT('NaT'), DT('2017'), True)
check_lt(DT('NaT', 'Y'), DT('2017'), True)
if not numpy_support.strict_ufunc_typing:
check_lt(DT('NaT', 'ms'), DT('2017'), True)
check_eq(DT('NaT'), DT('NaT'), True)
if not numpy_support.strict_ufunc_typing:
check_eq(DT('NaT', 'Y'), DT('NaT'), True)
check_eq(DT('NaT', 'ms'), DT('NaT', 'M'), True)
# Check comparison between various units
dts = self.datetime_samples()
for a in dts:
# Take a number of smaller units
a_unit = a.dtype.str.split('[')[1][:-1]
i = all_units.index(a_unit)
units = all_units[i:i+6]
for unit in units:
# Force conversion
b = a.astype('M8[%s]' % unit)
if (numpy_support.strict_ufunc_typing
and not npdatetime.same_kind(value_unit(a),
value_unit(b))):
continue
check_eq(a, b, True)
check_lt(a, b + np.timedelta64(1, unit), True)
check_lt(b - np.timedelta64(1, unit), a, True)
def test_comparisons(self):
# Test all datetime comparisons all at once
eq = self.jit(eq_usecase)
ne = self.jit(ne_usecase)
lt = self.jit(lt_usecase)
le = self.jit(le_usecase)
gt = self.jit(gt_usecase)
ge = self.jit(ge_usecase)
def check_eq(a, b, expected):
expected_val = expected
not_expected_val = not expected
if numpy_version >= (1, 16):
# since np 1.16 all NaT comparisons bar != are False, including
# NaT==NaT
if np.isnat(a) or np.isnat(b):
expected_val = False
not_expected_val = True
self.assertFalse(le(a, b), (a, b))
self.assertFalse(ge(a, b), (a, b))
self.assertFalse(le(b, a), (a, b))
self.assertFalse(ge(b, a), (a, b))
self.assertFalse(lt(a, b), (a, b))
self.assertFalse(gt(a, b), (a, b))
self.assertFalse(lt(b, a), (a, b))
self.assertFalse(gt(b, a), (a, b))
with self.silence_numpy_warnings():
self.assertPreciseEqual(eq(a, b), expected_val,
(a, b, expected))
self.assertPreciseEqual(eq(b, a), expected_val,
(a, b, expected))
self.assertPreciseEqual(ne(a, b), not_expected_val,
(a, b, expected))
self.assertPreciseEqual(ne(b, a), not_expected_val,
(a, b, expected))
if expected_val:
# If equal, then equal-ordered comparisons are true
self.assertTrue(le(a, b), (a, b))
self.assertTrue(ge(a, b), (a, b))
self.assertTrue(le(b, a), (a, b))
self.assertTrue(ge(b, a), (a, b))
# and strictly ordered comparisons are false
self.assertFalse(lt(a, b), (a, b))
self.assertFalse(gt(a, b), (a, b))
self.assertFalse(lt(b, a), (a, b))
self.assertFalse(gt(b, a), (a, b))
# Did we get it right?
self.assertPreciseEqual(a == b, expected_val)
def check_lt(a, b, expected):
expected_val = expected
not_expected_val = not expected
if numpy_version >= (1, 16):
# since np 1.16 all NaT magnitude comparisons including equality
# are False (as NaT == NaT is now False)
if np.isnat(a) or np.isnat(b):
expected_val = False
not_expected_val = False
with self.silence_numpy_warnings():
lt = self.jit(lt_usecase)
self.assertPreciseEqual(lt(a, b), expected_val,
(a, b, expected))
self.assertPreciseEqual(gt(b, a), expected_val,
(a, b, expected))
self.assertPreciseEqual(ge(a, b), not_expected_val,
(a, b, expected))
self.assertPreciseEqual(le(b, a), not_expected_val,
(a, b, expected))
if expected_val:
# If true, then values are not equal
check_eq(a, b, False)
# Did we get it right?
self.assertPreciseEqual(a < b, expected_val)
check_eq(DT('2014'), DT('2017'), False)
check_eq(DT('2014'), DT('2014-01'), True)
check_eq(DT('2014'), DT('2014-01-01'), True)
check_eq(DT('2014'), DT('2014-01-01', 'W'), True)
check_eq(DT('2014-01'), DT('2014-01-01', 'W'), True)
# Yes, it's not transitive
check_eq(DT('2014-01-01'), DT('2014-01-01', 'W'), False)
check_eq(DT('2014-01-02'), DT('2014-01-06', 'W'), True)
# with times
check_eq(DT('2014-01-01T00:01:00Z', 's'), DT('2014-01-01T00:01Z', 'm'),
True)
check_eq(DT('2014-01-01T00:01:01Z', 's'), DT('2014-01-01T00:01Z', 'm'),
False)
# NaTs
check_lt(DT('NaT', 'Y'), DT('2017'), True)
check_eq(DT('NaT'), DT('NaT'), True)
# Check comparison between various units
dts = self.datetime_samples()
for a in dts:
# Take a number of smaller units
a_unit = a.dtype.str.split('[')[1][:-1]
i = all_units.index(a_unit)
units = all_units[i:i + 6]
for unit in units:
# Force conversion
b = a.astype('M8[%s]' % unit)
if (not npdatetime.same_kind(value_unit(a), value_unit(b))):
continue
check_eq(a, b, True)
check_lt(a, b + np.timedelta64(1, unit), True)
check_lt(b - np.timedelta64(1, unit), a, True)
