Documentation

# `contains`

Test if an entry exists in a container

MuPAD® notebooks will be removed in a future release. 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.

## Syntax

```contains(`s`, `object`)
contains(`l`, `object`, <`i`>)
contains(`t`, `object`)
```

## Description

`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`.

See Example 4 and Example 5.

`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.

## Examples

### Example 1

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

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

### Example 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)`

### Example 3

`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)`

### Example 4

`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)`

### Example 5

`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)`

### Example 6

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 does not match. [array] ```

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

`contains(a, (4, 4))`
```Error: Invalid argument. [array] ```

### Example 7

`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")`

### Example 8

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)`

## Parameters

 `s` A set `l` A list `t` An array of type `DOM_ARRAY`, a table, or a domain `object` An arbitrary MuPAD object `i` An integer

## Return Values

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`