def test_setops_preserve_object_dtype(self): idx = Index([1, 2, 3], dtype=object) result = idx.intersection(idx[1:]) expected = idx[1:] tm.assert_index_equal(result, expected) # if other is not monotonic increasing, intersection goes through # a different route result = idx.intersection(idx[1:][::-1]) tm.assert_index_equal(result, expected) result = idx._union(idx[1:], sort=None) expected = idx tm.assert_numpy_array_equal(result, expected.values) result = idx.union(idx[1:], sort=None) tm.assert_index_equal(result, expected) # if other is not monotonic increasing, _union goes through # a different route result = idx._union(idx[1:][::-1], sort=None) tm.assert_numpy_array_equal(result, expected.values) result = idx.union(idx[1:][::-1], sort=None) tm.assert_index_equal(result, expected)
def test_intersection(self): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index( np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) self.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) index = RangeIndex(5) # intersect of non-overlapping indices other = RangeIndex(5, 10, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) self.assert_index_equal(result, expected) other = RangeIndex(-1, -5, -1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) self.assert_index_equal(result, expected) # intersection of empty indices other = RangeIndex(0, 0, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) self.assert_index_equal(result, expected) result = other.intersection(index) self.assert_index_equal(result, expected) # intersection of non-overlapping values based on start value and gcd index = RangeIndex(1, 10, 2) other = RangeIndex(0, 10, 4) result = index.intersection(other) expected = RangeIndex(0, 0, 1) self.assert_index_equal(result, expected)
def test_intersection(self): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) index = RangeIndex(5) # intersect of non-overlapping indices other = RangeIndex(5, 10, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) other = RangeIndex(-1, -5, -1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) # intersection of empty indices other = RangeIndex(0, 0, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) result = other.intersection(index) tm.assert_index_equal(result, expected) # intersection of non-overlapping values based on start value and gcd index = RangeIndex(1, 10, 2) other = RangeIndex(0, 10, 4) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected)
def test_intersection(self): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index( np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) self.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other) expected = Index( np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected)
def remove_before_changepoint(data: pd.HDFStore, select_idx: pd.Index = None): changepoints = { 837: '2014-03-16', 700: '2014-01-03', 681: '2013-06-14', 986: '2013-05-22', 885: '2014-05-18', 589: '2013-05-27', 105: '2013-05-20', 663: '2013-10-06', 764: '2013-04-24', 364: '2013-05-31', 969: '2013-03-10', 803: '2014-01-07', 91: '2014-01-14' } # noinspection PyUnusedLocal for store, date in changepoints.items(): idx = data.select_as_coordinates( 'train', 'Store != store or Date > pd.Timestamp(date)') if select_idx is not None: select_idx = select_idx.intersection(idx) else: select_idx = idx return select_idx
def intersect(self, exog_genes : pd.Index, ) -> pd.Index: """Intersect genes of CountData object with external set Parameter: ---------- exog_genes : pd.Index set of genes which object's gene set should be intersected with Returns: ------- Pandas Index object with the intersection between the two sets """ inter = exog_genes.intersection(self.genes) inter = np.unique(inter) keep = np.array([ self.genes.get_loc(x) for x in inter]) self.genes = inter self.cnt = self.cnt[:,keep] return self.genes
def test_intersection(self): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) self.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) self.assert_index_equal(result, expected)
def test_intersection_duplicates(values): # GH#31326 a = Index(values) b = Index([3, 3]) result = a.intersection(b) expected = Index([3]) tm.assert_index_equal(result, expected)
def test_intersection_str_dates(self, sort): dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)] i1 = Index(dt_dates, dtype=object) i2 = Index(["aa"], dtype=object) result = i2.intersection(i1, sort=sort) assert len(result) == 0
def test_intersect_str_dates(self): dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)] i1 = Index(dt_dates, dtype=object) i2 = Index(['aa'], dtype=object) res = i2.intersection(i1) self.assertEqual(len(res), 0)
def test_intersect_str_dates(self): dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)] i1 = Index(dt_dates, dtype=object) i2 = Index(['aa'], dtype=object) res = i2.intersection(i1) self.assertEqual(len(res), 0)
def _intersection(left: pd.Index, right: pd.Index) -> pd.Index: if ( # noqa: WPS337 isinstance(left, pd.MultiIndex) and isinstance(right, pd.MultiIndex) and pd.__version__ < "1.1.0" # noqa: WPS609 ): # pragma: no cover return iterutils.mi_intersection(left, right) return left.intersection(right, sort=False)
def test_intersection_non_monotonic_non_unique(self, index2, expected_arr, sort): # non-monotonic non-unique index1 = Index(["A", "B", "A", "C"]) expected = Index(expected_arr, dtype="object") result = index1.intersection(index2, sort=sort) if sort is None: expected = expected.sort_values() tm.assert_index_equal(result, expected)
def append_new_entrants(self, existing_data: pd.Series, new_index: pd.Index, getter: Callable): intersection = existing_data.loc[new_index.intersection( existing_data.index)] new_entrants_index = new_index.difference( self.stratification_groups.index) new_entrants_stratifications = getter(new_entrants_index) return intersection.append(new_entrants_stratifications)
def test_intersect_str_dates(self): dt_dates = [datetime(2012, 2, 9), datetime(2012, 2, 22)] index1 = Index(dt_dates, dtype=object) index2 = Index(["aa"], dtype=object) result = index2.intersection(index1) expected = Index([], dtype=object) tm.assert_index_equal(result, expected)
def test_intersection(self): other = Index([1, 2, 3, 4, 5]) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected)
def _get_common_indices(index_1: pd.Index, index_2: pd.Index): """Get intersection of indices""" _intersection = index_1.intersection(index_2) _diff_to_1 = index_1.difference(_intersection) if len(_diff_to_1) > 0: logger.warning( "Sample with clinical features not in demographics: {}".format( ", ".join(_diff_to_1))) return _intersection, _diff_to_1
def test_intersection_name_preservation(self, index2, keeps_name, sort): index1 = Index([1, 2, 3, 4, 5], name="index") expected = Index([3, 4, 5]) result = index1.intersection(index2, sort) if keeps_name: expected.name = "index" assert result.name == expected.name tm.assert_index_equal(result, expected)
def test_intersection(self): other = Index([1, 2, 3, 4, 5]) result = self.index.intersection(other) expected = np.sort(np.intersect1d(self.index.values, other.values)) tm.assert_numpy_array_equal(result, expected) result = other.intersection(self.index) expected = np.sort( np.asarray(np.intersect1d(self.index.values, other.values))) tm.assert_numpy_array_equal(result, expected)
def _condition_logic(base_idx: pd.Index, sub_select_idx: pd.Index, state_idx: pd.Index, condition_idx: pd.Index, logic: str) -> pd.Index: if str(logic).upper() == 'ALL': return base_idx.intersection(condition_idx).sort_values() elif str(logic).upper() == 'ANY': return sub_select_idx.intersection(condition_idx).sort_values() elif str(logic).upper() == 'AND': return state_idx.intersection(condition_idx).sort_values() elif str(logic).upper() == 'NAND': return sub_select_idx.drop(state_idx.intersection(condition_idx)).sort_values() elif str(logic).upper() == 'OR': return state_idx.append(state_idx.union(condition_idx)).drop_duplicates().sort_values() elif str(logic).upper() == 'NOR': result = state_idx.append(state_idx.union(condition_idx)).drop_duplicates().sort_values() return sub_select_idx.drop(result) elif str(logic).upper() == 'NOT': return state_idx.difference(condition_idx) elif str(logic).upper() == 'XOR': return state_idx.union(condition_idx).difference(state_idx.intersection(condition_idx)) raise ValueError(f"The logic '{logic}' must be AND, NAND, OR, NOR, NOT, XOR ANY or ALL")
def test_intersection_monotonic(self, index2, keeps_name, sort): index1 = Index([5, 3, 2, 4, 1], name="index") expected = Index([5, 3, 4]) if keeps_name: expected.name = "index" result = index1.intersection(index2, sort=sort) if sort is None: expected = expected.sort_values() tm.assert_index_equal(result, expected)
def test_intersection_uint64_outside_int64_range(self, index_large): other = Index([2 ** 63, 2 ** 63 + 5, 2 ** 63 + 10, 2 ** 63 + 15, 2 ** 63 + 20]) result = index_large.intersection(other) expected = Index(np.sort(np.intersect1d(index_large.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(index_large) expected = Index( np.sort(np.asarray(np.intersect1d(index_large.values, other.values))) ) tm.assert_index_equal(result, expected)
def test_intersection(self): index = self.create_index() other = Index([1, 2, 3, 4, 5]) result = index.intersection(other) expected = Index(np.sort(np.intersect1d(index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(index) expected = Index( np.sort(np.asarray(np.intersect1d(index.values, other.values)))) tm.assert_index_equal(result, expected)
def test_intersection(self): other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20]) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected)
def test_intersection(self): other = Index([2**63, 2**63 + 5, 2**63 + 10, 2**63 + 15, 2**63 + 20]) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected)
def test_intersection_duplicates(self, sort): # GH#38196 idx1 = Index( [ pd.Timestamp("2019-12-13"), pd.Timestamp("2019-12-12"), pd.Timestamp("2019-12-12"), ] ) result = idx1.intersection(idx1, sort=sort) expected = Index([pd.Timestamp("2019-12-13"), pd.Timestamp("2019-12-12")]) tm.assert_index_equal(result, expected)
def test_union_dtypes(left, right, expected, names): left = pandas_dtype(left) right = pandas_dtype(right) a = Index([], dtype=left, name=names[0]) b = Index([], dtype=right, name=names[1]) result = a.union(b) assert result.dtype == expected assert result.name == names[2] # Testing name retention # TODO: pin down desired dtype; do we want it to be commutative? result = a.intersection(b) assert result.name == names[2]
def get_controller_index(net, ctrl_type=None, parameters=None, idx=[]): """ Returns indices of searched controllers. Parameters can specify the search query. INPUT: **net** (pandapowerNet) - The pandapower network OPTINAL: **controller_type** (controller object or string name of controller object) **parameters** (None, dict) - Dict of parameter names, which are in the controller object or net.controller DataFrame **idx** ([], list) - list of indices in net.controller to be searched for. If list is empty all indices are considered. OUTPUT: **idx** (list) - index / indices of controllers in net.controller which are in idx and matches given ctrl_type or parameters """ # logger.debug(ctrl_type, parameters, idx) idx = idx if len(idx) else net.controller.index if ctrl_type is not None: if isinstance(ctrl_type, str): idx = get_controller_index_by_typename(net, ctrl_type, idx) else: idx = get_controller_index_by_type(net, ctrl_type, idx) if isinstance(parameters, dict): df_keys = [k for k in parameters.keys() if k in net.controller.columns] attributes_keys = list(set(parameters.keys()) - set(df_keys)) attributes_dict = {k: parameters[k] for k in attributes_keys} # query of parameters in net.controller dataframe idx = Index(idx, dtype=np.int64) for df_key in df_keys: idx = idx.intersection(net.controller.index[net.controller[df_key] == parameters[df_key]]) # query of parameters in controller object attributes idx = [i for i in idx if _controller_attributes_query( net.controller.object.loc[i], attributes_dict)] return idx
def test_intersection(self, sort): # intersect with Int64Index index = RangeIndex(start=0, stop=20, step=2) other = Index(np.arange(1, 6)) result = index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(index, sort=sort) expected = Index( np.sort(np.asarray(np.intersect1d(index.values, other.values))) ) tm.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(index.values, other.values))) tm.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(index.values, other.values))) tm.assert_index_equal(result, expected) # reversed (GH 17296) result = other.intersection(index, sort=sort) tm.assert_index_equal(result, expected) # GH 17296: intersect two decreasing RangeIndexes first = RangeIndex(10, -2, -2) other = RangeIndex(5, -4, -1) expected = first.astype(int).intersection(other.astype(int), sort=sort) result = first.intersection(other, sort=sort).astype(int) tm.assert_index_equal(result, expected) # reversed result = other.intersection(first, sort=sort).astype(int) tm.assert_index_equal(result, expected) index = RangeIndex(5, name="foo") # intersect of non-overlapping indices other = RangeIndex(5, 10, 1, name="foo") result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1, name="foo") tm.assert_index_equal(result, expected) other = RangeIndex(-1, -5, -1) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) # intersection of empty indices other = RangeIndex(0, 0, 1) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) result = other.intersection(index, sort=sort) tm.assert_index_equal(result, expected)
def test_intersection(self): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) # reversed (GH 17296) result = other.intersection(self.index) tm.assert_index_equal(result, expected) # GH 17296: intersect two decreasing RangeIndexes first = RangeIndex(10, -2, -2) other = RangeIndex(5, -4, -1) expected = first.astype(int).intersection(other.astype(int)) result = first.intersection(other).astype(int) tm.assert_index_equal(result, expected) # reversed result = other.intersection(first).astype(int) tm.assert_index_equal(result, expected) index = RangeIndex(5) # intersect of non-overlapping indices other = RangeIndex(5, 10, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) other = RangeIndex(-1, -5, -1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) # intersection of empty indices other = RangeIndex(0, 0, 1) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) result = other.intersection(index) tm.assert_index_equal(result, expected) # intersection of non-overlapping values based on start value and gcd index = RangeIndex(1, 10, 2) other = RangeIndex(0, 10, 4) result = index.intersection(other) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected)
def test_intersection_equal_sort_true(self): # TODO decide on True behaviour idx = Index(["c", "a", "b"]) sorted_ = Index(["a", "b", "c"]) tm.assert_index_equal(idx.intersection(idx, sort=True), sorted_)
def test_intersection(self, sort): # intersect with Int64Index other = Index(np.arange(1, 6)) result = self.index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) result = other.intersection(self.index, sort=sort) expected = Index(np.sort(np.asarray(np.intersect1d(self.index.values, other.values)))) tm.assert_index_equal(result, expected) # intersect with increasing RangeIndex other = RangeIndex(1, 6) result = self.index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) # intersect with decreasing RangeIndex other = RangeIndex(5, 0, -1) result = self.index.intersection(other, sort=sort) expected = Index(np.sort(np.intersect1d(self.index.values, other.values))) tm.assert_index_equal(result, expected) # reversed (GH 17296) result = other.intersection(self.index, sort=sort) tm.assert_index_equal(result, expected) # GH 17296: intersect two decreasing RangeIndexes first = RangeIndex(10, -2, -2) other = RangeIndex(5, -4, -1) expected = first.astype(int).intersection(other.astype(int), sort=sort) result = first.intersection(other, sort=sort).astype(int) tm.assert_index_equal(result, expected) # reversed result = other.intersection(first, sort=sort).astype(int) tm.assert_index_equal(result, expected) index = RangeIndex(5) # intersect of non-overlapping indices other = RangeIndex(5, 10, 1) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) other = RangeIndex(-1, -5, -1) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) # intersection of empty indices other = RangeIndex(0, 0, 1) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected) result = other.intersection(index, sort=sort) tm.assert_index_equal(result, expected) # intersection of non-overlapping values based on start value and gcd index = RangeIndex(1, 10, 2) other = RangeIndex(0, 10, 4) result = index.intersection(other, sort=sort) expected = RangeIndex(0, 0, 1) tm.assert_index_equal(result, expected)
def test_intersection_equal_sort(self): idx = Index(["c", "a", "b"]) tm.assert_index_equal(idx.intersection(idx, sort=False), idx) tm.assert_index_equal(idx.intersection(idx, sort=None), idx)