Documentation |
Test if an entry exists in a container
This functionality does not run in MATLAB.
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 overloadcontains 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)