# Source code for mars.tensor.base.in1d

```# Copyright 1999-2021 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import Union

import numpy as np

from ...typing import TileableType
from .. import asarray

[docs]def in1d(
ar1: Union[TileableType, np.ndarray],
ar2: Union[TileableType, np.ndarray, list],
assume_unique: bool = False,
invert: bool = False,
):
"""
Test whether each element of a 1-D tensor is also present in a second tensor.

Returns a boolean tensor the same length as `ar1` that is True
where an element of `ar1` is in `ar2` and False otherwise.

We recommend using :func:`isin` instead of `in1d` for new code.

Parameters
----------
ar1 : (M,) Tensor
Input tensor.
ar2 : array_like
The values against which to test each value of `ar1`.
assume_unique : bool, optional
If True, the input tensors are both assumed to be unique, which
can speed up the calculation.  Default is False.
invert : bool, optional
If True, the values in the returned tensor are inverted (that is,
False where an element of `ar1` is in `ar2` and True otherwise).
Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
to (but is faster than) ``np.invert(in1d(a, b))``.

Returns
-------
in1d : (M,) Tensor, bool
The values `ar1[in1d]` are in `ar2`.

--------
isin                  : Version of this function that preserves the
shape of ar1.
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.

Notes
-----
`in1d` can be considered as an element-wise function version of the
python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
equivalent to ``mt.array([item in b for item in a])``.
However, this idea fails if `ar2` is a set, or similar (non-sequence)
container:  As ``ar2`` is converted to a tensor, in those cases
``asarray(ar2)`` is an object tensor rather than the expected tensor of
contained values.

Examples
--------
>>> import mars.tensor as mt
>>> test = mt.array([0, 1, 2, 5, 0])
>>> states = [0, 2]
>>> mask = mt.in1d(test, states)
array([ True, False,  True, False,  True])