Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Test if an entry exists in a container

**MuPAD® notebooks are not recommended. Use MATLAB® live scripts instead.**

**MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.**

contains(`s`

,`object`

) contains(`l`

,`object`

, <`i`

>) contains(`t`

,`object`

)

`contains(s, object)`

tests if `object`

is
an element of the set `s`

.

`contains(l, object)`

returns the index of `object`

in
the list `l`

.

`contains(t, object)`

tests if the array, table,
or domain `t`

has an entry corresponding to the index `object`

.

`contains`

is a fast membership test for the MuPAD^{®} basic
container data types. For lists and sets, `contains`

searches
the elements for the given object. However, for arrays, tables, and domains, `contains`

searches
the indices.

`contains`

works syntactically, i.e., mathematically
equivalent objects are considered to be equal only if they are syntactically
identical. `contains`

does *not* represent
elementhood in the mathematical sense. See Example 2.

`contains`

does not descend recursively into
subexpressions; use `has`

to
achieve this. See Example 3.

`contains(s, object)`

returns `TRUE`

if `object`

is
an element of the set `s`

.
Otherwise, it returns `FALSE`

.

`contains(l, object)`

returns the position
of `object`

in the list `l`

as
a positive integer if `object`

is an entry of `l`

.
Otherwise, the return value is `0`

. If more than
one entry of `l`

is equal to `object`

,
then the index of the first occurrence is returned.

By passing a third argument `i`

to `contains`

,
you can specify a position in the list where the search is to start.
Then, entries with index less than `i`

are not taken
into account. If `i`

is out of range, then the return
value is `0`

.

`contains(t, object)`

returns `TRUE`

if
the array, table,
or domain `t`

has
an entry corresponding to the index `object`

. Otherwise,
it returns `FALSE`

.
Cf. Example 6.

`contains`

may be used to test if a set contains a given element:

contains({a, b, c}, a), contains({a, b, c}, 2)

`contains`

works syntactically, i.e., mathematically
equivalent objects are considered to be equal only if they are syntactically
identical. In this example `contains`

returns `FALSE`

since ```
y*(x
+ 1)
```

and `y*x + y`

are different representations
of the same mathematical expression:

contains({y*(x + 1)}, y*x + y)

Elementhood in the mathematical sense is represented by the
operator `in`

:

simplify(y*x + y in {y*(x+1)}, condition)

`contains`

does not descend recursively into
the operands of its first argument. In the following example, `c`

is
not an element of the set, and therefore `FALSE`

is returned:

contains({a, b, c + d}, c)

If you want to test whether a given expression is contained *somewhere
inside* a complex expression, please use `has`

:

has({a, b, c + d}, c)

`contains`

applied to a `list`

returns the position
of the specified object in the list:

contains([a, b, c], b)

If the list does not contain the object, `0`

is
returned:

contains([a, b, c], d)

`contains`

returns the position of the first
occurrence of the given object in the list if it occurs more than
once:

l := [a, b, a, b]: contains(l, b)

A starting position for the search may be given as optional third argument:

contains(l, b, 1), contains(l, b, 2), contains(l, b, 3), contains(l, b, 4)

If the third argument is out of range, then the return value
is `0`

:

contains(l, b, -1), contains(l, b, 0), contains(l, b, 5)

For tables, `contains`

returns `TRUE`

if
the second argument is a valid index in the table. The entries stored
in the table are not considered:

t := table(13 = value): contains(t, 13), contains(t, value)

Similarly, `contains`

tests if an `array`

has
a value for a given index. The array `a`

has a value
corresponding to the index `(1, 1)`

, but none for
the index `(1, 2)`

:

a := array(1..3, 1..2, (1, 1) = x, (2, 1) = PI): contains(a, (1, 1)), contains(a, (1, 2))

`contains`

is not intended for testing if an
array contains a given value:

contains(a, PI)

Error: Index dimension mismatch. [array]

Even if the dimensions match, the index must not be out of range:

contains(a, (4, 4))

Error: The argument is invalid. [array]

`contains`

may be used to test, whether a domain has the
specified `slot`

:

T := newDomain("T"): T::index := value: contains(T, index), contains(T, value)

There is no entry corresponding to the slot `index`

in `T`

.
Please keep in mind that the syntax `T::index`

is
equivalent to `slot(T, "index" )`

:

contains(T, "index")

Users can overload`contains`

for
their own domains.
For illustration, we create a new domain `T`

and
supply it with an `"contains"`

slot, which tests
is the set of entries of an element contains the given value `idx`

:

T := newDomain("T"): T::contains := (e, idx) -> contains({extop(e)}, idx):

If we now call `contains`

with an object of
domain type `T`

, the slot routine `T::contains`

is
invoked:

e := new(T, 1, 2): contains(e, 2), contains(e, 3)

For sets, arrays, tables, or domains, `contains`

returns
one of the Boolean values `TRUE`

or `FALSE`

. For lists, the
return value is a nonnegative integer.

` l`

, `s`

, ` t`

Was this topic helpful?