def in1d(self, test: Union[Strings, Categorical]) -> pdarray:
"""
Test whether each element of the Categorical object is
also present in the test Strings or Categorical object.
Returns a boolean array the same length as `self` that is True
where an element of `self` is in `test` and False otherwise.
Parameters
----------
test : Union[Strings,Categorical]
The values against which to test each value of 'self`.
Returns
-------
pdarray, bool
The values `self[in1d]` are in the `test` Strings or Categorical object.
Raises
------
TypeError
Raised if test is not a Strings or Categorical object
See Also
--------
unique, intersect1d, union1d
Notes
-----
`in1d` can be considered as an element-wise function version of the
python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is logically
equivalent to ``ak.array([item in b for item in a])``, but is much
faster and scales to arbitrarily large ``a``.
Examples
--------
>>> strings = ak.array(['String {}'.format(i) for i in range(0,5)])
>>> cat = ak.Categorical(strings)
>>> ak.in1d(cat,strings)
array([True, True, True, True, True])
>>> strings = ak.array(['String {}'.format(i) for i in range(5,9)])
>>> catTwo = ak.Categorical(strings)
>>> ak.in1d(cat,catTwo)
array([False, False, False, False, False])
"""
reset_cat = self if self.uses_all_categories else self.reset_categories(
)
if isinstance(test, Categorical):
reset_test = test if test.uses_all_categories else test.reset_categories(
)
categoriesisin = in1d(reset_cat.categories, reset_test.categories)
else:
categoriesisin = in1d(reset_cat.categories, test)
return categoriesisin[reset_cat.codes]
def in1d(self, test):
__doc__ = in1d.__doc__
categoriesisin = in1d(self.categories, test)
return categoriesisin[self.codes]
def _binop(self, other: Union[Categorical, str_scalars],
op: str_scalars) -> pdarray:
"""
Executes the requested binop on this Categorical instance and returns
the results within a pdarray object.
Parameters
----------
other : Union[Categorical,str_scalars]
the other object is a Categorical object or string scalar
op : str_scalars
name of the binary operation to be performed
Returns
-------
pdarray
encapsulating the results of the requested binop
Raises
- -----
ValueError
Raised if (1) the op is not in the self.BinOps set, or (2) if the
sizes of this and the other instance don't match
RuntimeError
Raised if a server-side error is thrown while executing the
binary operation
"""
if op not in self.BinOps:
raise NotImplementedError("Categorical: unsupported operator: {}".\
format(op))
if np.isscalar(other) and resolve_scalar_dtype(other) == "str":
idxresult = self.categories._binop(other, op)
return idxresult[self.codes]
if self.size != cast(Categorical, other).size:
raise ValueError("Categorical {}: size mismatch {} {}".\
format(op, self.size, cast(Categorical,other).size))
if isinstance(other, Categorical):
if (self.categories.size
== other.categories.size) and (self.categories
== other.categories).all():
# Because categories are identical, codes can be compared directly
return self.codes._binop(other.codes, op)
else:
# Remap both codes to the union of categories
union = unique(
concatenate((self.categories, other.categories),
ordered=False))
newinds = arange(union.size)
# Inds of self.categories in unioned categories
selfnewinds = newinds[in1d(union, self.categories)]
# Need a permutation and segments to broadcast new codes
if self.permutation is None or self.segments is None:
g = GroupBy(self.codes)
self.permutation = g.permutation
self.segments = g.segments
# Form new codes by broadcasting new indices for unioned categories
selfnewcodes = broadcast(self.segments, selfnewinds, self.size,
self.permutation)
# Repeat for other
othernewinds = newinds[in1d(union, other.categories)]
if other.permutation is None or other.segments is None:
g = GroupBy(other.codes)
other.permutation = g.permutation
other.segments = g.segments
othernewcodes = broadcast(other.segments, othernewinds,
other.size, other.permutation)
# selfnewcodes and othernewcodes now refer to same unioned categories
# and can be compared directly
return selfnewcodes._binop(othernewcodes, op)
else:
raise NotImplementedError(
("Operations between Categorical and " +
"non-Categorical not yet implemented. " +
"Consider converting operands to Categorical."))