More plumbing

Author: WeatherGod

pandas/core/indexes/base.py

@@ -3983,7 +3983,8 @@ def _join_multi(self, other, how, return_indexers=True):
 
     def _join_non_unique(self, other, how='left', return_indexers=False):
         from pandas.core.reshape.merge import _get_join_indexers
-
+        tolerance = self._choose_tolerance([other])
+        # FIXME: intolerant
         left_idx, right_idx = _get_join_indexers([self._ndarray_values],
                                                  [other._ndarray_values],
                                                  how=how,
@@ -3996,7 +3997,7 @@ def _join_non_unique(self, other, how='left', return_indexers=False):
         mask = left_idx == -1
         np.putmask(join_index, mask, other._ndarray_values.take(right_idx))
 
-        join_index = self._wrap_joined_index(join_index, other)
+        join_index = self._wrap_joined_index(join_index, other, tolerance)
 
         if return_indexers:
             return join_index, left_idx, right_idx
@@ -4133,9 +4134,12 @@ def _get_leaf_sorter(labels):
         else:
             return join_index
 
-    def _join_monotonic(self, other, how='left', return_indexers=False):
-        if self.equals(other):
+    def _join_monotonic(self, other, how='left', return_indexers=False,
+                        tolerance=None):
+        tolerance = self._choose_tolerance([other], tolerance=tolerance)
+        if self.equals(other, tolerance=tolerance):
             ret_index = other if how == 'right' else self
+            # FIXME: intolerant, need to set the used tolerance
             if return_indexers:
                 return ret_index, None, None
             else:
@@ -4145,6 +4149,7 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
         ov = other._ndarray_values
 
         if self.is_unique and other.is_unique:
+            # FIXME: intolerant
             # We can perform much better than the general case
             if how == 'left':
                 join_index = self
@@ -4156,11 +4161,14 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
                 ridx = None
             elif how == 'inner':
                 join_index, lidx, ridx = self._inner_indexer(sv, ov)
-                join_index = self._wrap_joined_index(join_index, other)
+                join_index = self._wrap_joined_index(join_index, other,
+                                                     tolerance)
             elif how == 'outer':
                 join_index, lidx, ridx = self._outer_indexer(sv, ov)
-                join_index = self._wrap_joined_index(join_index, other)
+                join_index = self._wrap_joined_index(join_index, other,
+                                                     tolerance)
         else:
+            # FIXME: intolerant
             if how == 'left':
                 join_index, lidx, ridx = self._left_indexer(sv, ov)
             elif how == 'right':
@@ -4169,7 +4177,7 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
                 join_index, lidx, ridx = self._inner_indexer(sv, ov)
             elif how == 'outer':
                 join_index, lidx, ridx = self._outer_indexer(sv, ov)
-            join_index = self._wrap_joined_index(join_index, other)
+            join_index = self._wrap_joined_index(join_index, other, tolerance)
 
         if return_indexers:
             lidx = None if lidx is None else ensure_platform_int(lidx)
@@ -4178,9 +4186,9 @@ def _join_monotonic(self, other, how='left', return_indexers=False):
         else:
             return join_index
 
-    def _wrap_joined_index(self, joined, other):
+    def _wrap_joined_index(self, joined, other, tolerance):
         name = self.name if self.name == other.name else None
-        return Index(joined, name=name)
+        return Index(joined, name=name, tolerance=tolerance)
 
     def _get_string_slice(self, key, use_lhs=True, use_rhs=True):
         # this is for partial string indexing,

pandas/core/indexes/interval.py

@@ -650,7 +650,7 @@ def get_loc(self, key, method=None, tolerance=None):
         >>> overlapping_index.get_loc(1.5)
         array([0, 1], dtype=int64)
         """
-        # FIXME: mostly intolerant
+        # FIXME: intolerant
         self._check_method(method)
 
         original_key = key
@@ -660,7 +660,7 @@ def get_loc(self, key, method=None, tolerance=None):
             if isinstance(key, Interval):
                 left = self._maybe_cast_slice_bound(key.left, 'left', None)
                 right = self._maybe_cast_slice_bound(key.right, 'right', None)
-                key = Interval(left, right, key.closed, tolerance=tolerance)
+                key = Interval(left, right, key.closed)
             else:
                 key = self._maybe_cast_slice_bound(key, 'left', None)
 

pandas/core/indexes/multi.py

@@ -2892,9 +2892,9 @@ def _bounds(self):
 
         return self.__bounds
 
-    def _wrap_joined_index(self, joined, other):
+    def _wrap_joined_index(self, joined, other, tolerance):
         names = self.names if self.names == other.names else None
-        return MultiIndex.from_tuples(joined, names=names)
+        return MultiIndex.from_tuples(joined, names=names, tolerance=tolerance)
 
     @Appender(Index.isin.__doc__)
     def isin(self, values, level=None):

pandas/core/indexes/numeric.py

@@ -186,9 +186,9 @@ def _convert_scalar_indexer(self, key, kind=None):
         return (super(Int64Index, self)
                 ._convert_scalar_indexer(key, kind=kind))
 
-    def _wrap_joined_index(self, joined, other):
+    def _wrap_joined_index(self, joined, other, tolerance):
         name = self.name if self.name == other.name else None
-        return Int64Index(joined, name=name)
+        return Int64Index(joined, name=name, tolerance=tolerance)
 
     @classmethod
     def _assert_safe_casting(cls, data, subarr):
@@ -263,9 +263,9 @@ def _convert_index_indexer(self, keyarr):
             return keyarr.astype(np.uint64)
         return keyarr
 
-    def _wrap_joined_index(self, joined, other):
+    def _wrap_joined_index(self, joined, other, tolerance):
         name = self.name if self.name == other.name else None
-        return UInt64Index(joined, name=name)
+        return UInt64Index(joined, name=name, tolerance=tolerance)
 
     @classmethod
     def _assert_safe_casting(cls, data, subarr):

pandas/core/indexes/range.py

@@ -330,7 +330,7 @@ def equals(self, other, tolerance=None):
 
         return super(RangeIndex, self).equals(other, tolerance=tolerance)
 
-    def intersection(self, other):
+    def intersection(self, other, tolerance=None):
         """
         Form the intersection of two Index objects. Sortedness of the result is
         not guaranteed
@@ -343,22 +343,25 @@ def intersection(self, other):
         -------
         intersection : Index
         """
-        # FIXME: intolerant
         if not isinstance(other, RangeIndex):
-            return super(RangeIndex, self).intersection(other)
+            return super(RangeIndex, self).intersection(other,
+                                                        tolerance=tolerance)
 
+        tolerance = self._choose_tolerance([other], tolerance=tolerance)
         if not len(self) or not len(other):
-            return RangeIndex._simple_new(None)
+            return RangeIndex._simple_new(None, tolerance=tolerance)
 
         first = self[::-1] if self._step < 0 else self
         second = other[::-1] if other._step < 0 else other
 
+        # FIXME: intolerant
+
         # check whether intervals intersect
         # deals with in- and decreasing ranges
         int_low = max(first._start, second._start)
         int_high = min(first._stop, second._stop)
         if int_high <= int_low:
-            return RangeIndex._simple_new(None)
+            return RangeIndex._simple_new(None, tolerance=tolerance)
 
         # Method hint: linear Diophantine equation
         # solve intersection problem
@@ -368,14 +371,15 @@ def intersection(self, other):
 
         # check whether element sets intersect
         if (first._start - second._start) % gcd:
-            return RangeIndex._simple_new(None)
+            return RangeIndex._simple_new(None, tolerance=tolerance)
 
         # calculate parameters for the RangeIndex describing the
         # intersection disregarding the lower bounds
         tmp_start = first._start + (second._start - first._start) * \
             first._step // gcd * s
         new_step = first._step * second._step // gcd
-        new_index = RangeIndex(tmp_start, int_high, new_step, fastpath=True)
+        new_index = RangeIndex(tmp_start, int_high, new_step, fastpath=True,
+                               tolerance=tolerance)
 
         # adjust index to limiting interval
         new_index._start = new_index._min_fitting_element(int_low)
@@ -423,7 +427,6 @@ def union(self, other, tolerance=None):
         -------
         union : Index
         """
-        # FIXME: intolerant
         self._assert_can_do_setop(other)
         tolerance = self._choose_tolerance([other], tolerance=tolerance)
         if len(other) == 0 or self.equals(other, tolerance=tolerance):