Fix Index __mul__-like ops with timedelta scalars

doc/source/whatsnew/v0.23.0.txt

@@ -427,6 +427,7 @@ Timezones
 - Bug in comparing :class:`DatetimeIndex`, which failed to raise ``TypeError`` when attempting to compare timezone-aware and timezone-naive datetimelike objects (:issue:`18162`)
 - Bug in localization of a naive, datetime string in a ``Series`` constructor with a ``datetime64[ns, tz]`` dtype (:issue:`174151`)
 - :func:`Timestamp.replace` will now handle Daylight Savings transitions gracefully (:issue:`18319`)
+-
 - Bug in tz-aware :class:`DatetimeIndex` where addition/subtraction with a :class:`TimedeltaIndex` or array with ``dtype='timedelta64[ns]'`` was incorrect (:issue:`17558`)
 - Bug in :func:`DatetimeIndex.insert` where inserting ``NaT`` into a timezone-aware index incorrectly raised (:issue:`16357`)
 
@@ -446,6 +447,9 @@ Numeric
 - Bug in :class:`Index` multiplication and division methods where operating with a ``Series`` would return an ``Index`` object instead of a ``Series`` object (:issue:`19042`)
 - Bug in the :class:`DataFrame` constructor in which data containing very large positive or very large negative numbers was causing ``OverflowError`` (:issue:`18584`)
 - Bug in :class:`Index` constructor with ``dtype='uint64'`` where int-like floats were not coerced to :class:`UInt64Index` (:issue:`18400`)
+- Bug in :class:`Index` multiplication and division methods where operating with a ``Series`` would return an ``Index`` object instead of a ``Series`` object (:issue:`19042`)
+- Multiplication of :class:`TimedeltaIndex` by ``TimedeltaIndex`` will now raise ``TypeError`` instead of raising ``ValueError`` in cases of length mis-match (:issue`19333`)
+- Multiplication and division of numeric-dtyped :class:`Index` objects with timedelta-like scalars returns ``TimedeltaIndex`` instead of raising ``TypeError`` (:issue:`19333`)
 
 -
 

pandas/core/indexes/base.py

@@ -5,7 +5,7 @@
 import numpy as np
 from pandas._libs import (lib, index as libindex, tslib as libts,
                           algos as libalgos, join as libjoin,
-                          Timestamp)
+                          Timestamp, Timedelta)
 from pandas._libs.lib import is_datetime_array
 
 from pandas.compat import range, u, set_function_name
@@ -16,7 +16,7 @@
 from pandas.core.dtypes.generic import (
     ABCSeries, ABCDataFrame,
     ABCMultiIndex,
-    ABCPeriodIndex,
+    ABCPeriodIndex, ABCTimedeltaIndex,
     ABCDateOffset)
 from pandas.core.dtypes.missing import isna, array_equivalent
 from pandas.core.dtypes.common import (
@@ -3864,7 +3864,21 @@ def dropna(self, how='any'):
         return self._shallow_copy()
 
     def _evaluate_with_timedelta_like(self, other, op, opstr, reversed=False):
-        raise TypeError("can only perform ops with timedelta like values")
+        # Timedelta knows how to operate with np.array, so dispatch to that
+        # operation and then wrap the results
+        other = Timedelta(other)
+        values = self.values
+        if reversed:
+            values, other = other, values
+
+        with np.errstate(all='ignore'):
+            result = op(values, other)
+
+        attrs = self._get_attributes_dict()
+        attrs = self._maybe_update_attributes(attrs)
+        if op == divmod:
+            return Index(result[0], **attrs), Index(result[1], **attrs)
+        return Index(result, **attrs)
 
     def _evaluate_with_datetime_like(self, other, op, opstr):
         raise TypeError("can only perform ops with datetime like values")
@@ -4024,6 +4038,9 @@ def _make_evaluate_binop(op, opstr, reversed=False, constructor=Index):
             def _evaluate_numeric_binop(self, other):
                 if isinstance(other, (ABCSeries, ABCDataFrame)):
                     return NotImplemented
+                elif isinstance(other, ABCTimedeltaIndex):
+                    # Defer to subclass implementation
+                    return NotImplemented
 
                 other = self._validate_for_numeric_binop(other, op, opstr)
 

pandas/core/indexes/range.py

@@ -8,7 +8,7 @@
     is_integer,
     is_scalar,
     is_int64_dtype)
-from pandas.core.dtypes.generic import ABCSeries
+from pandas.core.dtypes.generic import ABCSeries, ABCTimedeltaIndex
 
 from pandas import compat
 from pandas.compat import lrange, range, get_range_parameters
@@ -587,6 +587,9 @@ def _make_evaluate_binop(op, opstr, reversed=False, step=False):
             def _evaluate_numeric_binop(self, other):
                 if isinstance(other, ABCSeries):
                     return NotImplemented
+                elif isinstance(other, ABCTimedeltaIndex):
+                    # Defer to TimedeltaIndex implementation
+                    return NotImplemented
 
                 other = self._validate_for_numeric_binop(other, op, opstr)
                 attrs = self._get_attributes_dict()

pandas/tests/indexes/test_numeric.py

@@ -13,7 +13,7 @@
 import pandas.util.testing as tm
 
 import pandas as pd
-from pandas._libs.lib import Timestamp
+from pandas._libs.lib import Timestamp, Timedelta
 
 from pandas.tests.indexes.common import Base
 
@@ -26,6 +26,36 @@ def full_like(array, value):
     return ret
 
 
+class TestIndexArithmetic(object):
+    @pytest.mark.parametrize('index', [pd.Int64Index(range(1, 11)),
+                                       pd.UInt64Index(range(1, 11)),
+                                       pd.Float64Index(range(1, 11)),
+                                       pd.RangeIndex(1, 11)])
+    @pytest.mark.parametrize('scalar_td', [Timedelta(days=1),
+                                           Timedelta(days=1).to_timedelta64(),
+                                           Timedelta(days=1).to_pytimedelta()])
+    def test_index_mul_timedelta(self, scalar_td, index):
+        expected = pd.timedelta_range('1 days', '10 days')
+
+        result = index * scalar_td
+        tm.assert_index_equal(result, expected)
+        commute = scalar_td * index
+        tm.assert_index_equal(commute, expected)
+
+    @pytest.mark.parametrize('index', [pd.Int64Index(range(1, 3)),
+                                       pd.UInt64Index(range(1, 3)),
+                                       pd.Float64Index(range(1, 3)),
+                                       pd.RangeIndex(1, 3)])
+    @pytest.mark.parametrize('scalar_td', [Timedelta(days=1),
+                                           Timedelta(days=1).to_timedelta64(),
+                                           Timedelta(days=1).to_pytimedelta()])
+    def test_index_rdiv_timedelta(self, scalar_td, index):
+        expected = pd.TimedeltaIndex(['1 Day', '12 Hours'])
+
+        result = scalar_td / index
+        tm.assert_index_equal(result, expected)
+
+
 class Numeric(Base):
 
     def test_numeric_compat(self):

pandas/tests/indexes/timedeltas/test_arithmetic.py

@@ -297,7 +297,7 @@ def test_dti_mul_dti_raises(self):
 
     def test_dti_mul_too_short_raises(self):
         idx = self._holder(np.arange(5, dtype='int64'))
-        with pytest.raises(ValueError):
+        with pytest.raises(TypeError):
             idx * self._holder(np.arange(3))
         with pytest.raises(ValueError):
             idx * np.array([1, 2])
@@ -476,6 +476,20 @@ def test_ops_compat(self):
         # don't allow division by NaT (make could in the future)
         pytest.raises(TypeError, lambda: rng / pd.NaT)
 
+    @pytest.mark.parametrize('other', [np.arange(1, 11),
+                                       pd.Int64Index(range(1, 11)),
+                                       pd.UInt64Index(range(1, 11)),
+                                       pd.Float64Index(range(1, 11)),
+                                       pd.RangeIndex(1, 11)])
+    def test_tdi_rmul_arraylike(self, other):
+        tdi = TimedeltaIndex(['1 Day'] * 10)
+        expected = timedelta_range('1 days', '10 days')
+
+        result = other * tdi
+        tm.assert_index_equal(result, expected)
+        commute = tdi * other
+        tm.assert_index_equal(commute, expected)
+
     def test_subtraction_ops(self):
         # with datetimes/timedelta and tdi/dti
         tdi = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')