 MutableSet - Maple Programming Help

# Online Help

###### All Products    Maple    MapleSim

Home : Support : Online Help : Programming : Operations : Sets and lists : MutableSet

MutableSet

an object-based mutable set

Description

 • The MutableSet appliable object provides an efficient means to construct, manipulate, and query set objects.
 • Unlike a standard Maple set, adding an element to a MutableSet object does not allocate a new container.  As such, it can be efficiently used in loops to build up a set an element at a time.

Construction

 • The MutableSet command returns a new MutableSet object.
 If called with a single argument that is either a Maple set or a MutableSet object, the returned object contains the elements in the argument.
 Otherwise, the returned object contains each distinct argument as an element.

Modification

 • The following commands modify the content of a MutableSet object. The ms argument denotes a MutableSet object.
 clear(ms) : clear ms
 delete(ms,value) : delete value from ms
 insert(ms,value) : insert value into ms

Set Operation

 The following set commands combine MutableSet objects. Those prefixed with an ampersand (&) operate inplace on the first argument. These commands can be invoked as functions or inline operators. The ms1 and ms2 arguments denote MutableSet objects.
 ms1 intersect ms2, or $\mathrm{ms1}\cap \mathrm{ms2}$, or intersect(ms1,ms2,...) : return a new MutableSet object that is the intersection of the given mutable sets
 ms1 &intersect ms2 or &intersect(ms1,ms2,...) : remove elements of ms1 that are not elements of ms2, etc., updating ms1
 ms1 minus ms2, or $\mathrm{ms1}\setminus \mathrm{ms2}$, or minus(ms1,ms2) : return a new MutableSet object that contains the set difference of ms1 and ms2
 ms1 &minus ms2 or &minus(ms1,ms2) : remove elements of ms2 from ms1, updating ms1
 ms1 union ms2, or $\mathrm{ms1}\cup \mathrm{ms2}$, or union(ms1,ms2,...) : return a new MutableSet object that is the union of the given mutable sets
 ms1 &union ms2 or &union(ms1,ms2,...) : combine the members of ms2, etc., with ms1, updating ms1

Inspection

 The following commands inspect the content of a MutableSet object. The ms, ms1, and ms2 arguments denote MutableSet objects.
 ms = other or =(ms,other): when evaluated in a boolean context, return true if ms and other are both MutableSet objects with identical content, false otherwise
 empty(ms) : return true if ms is empty; false otherwise
 has(ms,expr) : return true if any member of ms contains expr; false otherwise
 hastype(ms,typ) : return true if any member of ms contains an expression of the specified type; false otherwise
 in(value,ms), or value in ms, or $\mathrm{value}\in \mathrm{ms}$ : return true if value is a member of ms; false otherwise
 indets(ms,typ) : return a Maple set of all indeterminates in ms; if the optional typ parameter is specified, then return the expressions of type typ.
 lowerbound(ms) : return the lower index bound (always 1)
 max(ms) : return the maximum element of ms. Behaves like max on sets.
 member(value,ms) : return true if  value is a member of ms; false otherwise.  The three argument form of member is not supported.
 min(ms) : return the minimum element of ms.  Behaves like min on sets.
 numelems(ms) : return the number of elements in ms
 numboccur(ms,expr) : count the number of occurrences of expr in ms, either as an element or within elements.
 subset(ms1,ms2), or ms1 subset ms2, or $\mathrm{ms1}\subseteq \mathrm{ms2}$ : return true if ms1 is a subset of ms2; false otherwise
 upperbound(ms) : return the upper index (same as the output of numelems)

map and subs

 The map and subs commands operate on a MutableSet object; see their help pages for the complete syntax. By default they create a new MutableSet object, but if called with the inplace index option, they update the MutableSet object. The ms argument denotes a MutableSet object.
 map(fcn,ms) : apply a procedure, fcn, to each element of ms
 subs(eqns,ms) : substitute subexpressions in the content of ms

Conversion

 The convert command can be used to convert a MutableSet object to and from other Maple structures.
 convert(ms,typ) : convert a MutableSet to the specified type
 convert(expr,MutableSet) : convert expr to a MutableSet object; expr must be a list, set, or rtable

Indexing

 Integer indices can be used to extract or reassign a single element of a MutableSet. Reassigning an element may change its index.
 Range indices are not supported.

Iteration

 The MutableSet object exports a ModuleIterator command; that allows a MutableSet object to be used in loops and iterations (seq, add, etc.).

Examples

Construction

 Create a MutableSet with three elements.
 > M1 := MutableSet(a,b,c);
 ${\mathrm{M1}}{≔}{\mathrm{MutableSet}}{}\left({a}{,}{b}{,}{c}\right)$ (1)
 Copy $\mathrm{M1}$.
 > M2 := MutableSet(M1);
 ${\mathrm{M2}}{≔}{\mathrm{MutableSet}}{}\left({a}{,}{b}{,}{c}\right)$ (2)
 Create a MutableSet from a Maple set.
 > M3 := MutableSet({b,c,d});
 ${\mathrm{M3}}{≔}{\mathrm{MutableSet}}{}\left({b}{,}{c}{,}{d}\right)$ (3)

Modification

 Delete the b element from $\mathrm{M1}$ and insert a d element.
 > delete(M1,b);
 ${\mathrm{MutableSet}}{}\left({a}{,}{c}\right)$ (4)
 > insert(M1,d);
 ${\mathrm{MutableSet}}{}\left({a}{,}{c}{,}{d}\right)$ (5)
 Add $c$ to each element in $\mathrm{M2}$; do so inplace.
 > map[inplace](+, M2, c);
 ${\mathrm{MutableSet}}{}\left({a}{+}{c}{,}{b}{+}{c}{,}{2}{}{c}\right)$ (6)
 Replace all occurrences of $c$ inside $\mathrm{M2}$ with $d$; do so inplace.
 > subs[inplace](c = d, M2);
 ${\mathrm{MutableSet}}{}\left({2}{}{d}{,}{a}{+}{d}{,}{b}{+}{d}\right)$ (7)

Operation

 Create two MutableSet objects, then form their intersection.
 > M1 := MutableSet(a,b,c,d);
 ${\mathrm{M1}}{≔}{\mathrm{MutableSet}}{}\left({a}{,}{b}{,}{c}{,}{d}\right)$ (8)
 > M2 := MutableSet(c,d,e,f);
 ${\mathrm{M2}}{≔}{\mathrm{MutableSet}}{}\left({c}{,}{d}{,}{e}{,}{f}\right)$ (9)
 > M3 := M1 intersect M2;
 ${\mathrm{M3}}{≔}{\mathrm{MutableSet}}{}\left({c}{,}{d}\right)$ (10)
 Use the inplace form to update $\mathrm{M1}$ with the intersection of $\mathrm{M1}$ and $\mathrm{M2}$.
 > M1 &intersect M2:
 > M1;
 ${\mathrm{MutableSet}}{}\left({c}{,}{d}\right)$ (11)

Inspection

 Use member to determine whether a given element is a member of $\mathrm{M1}$.
 > M1 := MutableSet(a,b,c,4);
 ${\mathrm{M1}}{≔}{\mathrm{MutableSet}}{}\left({4}{,}{a}{,}{b}{,}{c}\right)$ (12)
 > member(b, M1);
 ${\mathrm{true}}$ (13)
 Use has to test for the occurrence of a subexpression in any of the members of the set.
 > has(M1, c);
 ${\mathrm{true}}$ (14)
 > indets(M1, numeric);
 $\left\{{4}\right\}$ (15)

Conversion

 Create a MutableSet object by converting a Vector.
 > M1 := convert(Vector(10,symbol=v),MutableSet);
 ${\mathrm{M1}}{≔}{\mathrm{MutableSet}}{}\left({{v}}_{{1}}{,}{{v}}_{{2}}{,}{{v}}_{{3}}{,}{{v}}_{{4}}{,}{{v}}_{{5}}{,}{{v}}_{{6}}{,}{{v}}_{{7}}{,}{{v}}_{{8}}{,}{{v}}_{{9}}{,}{{v}}_{{10}}\right)$ (16)
 Convert M1 to a standard set.
 > convert(M1,set);
 $\left\{{{v}}_{{1}}{,}{{v}}_{{2}}{,}{{v}}_{{3}}{,}{{v}}_{{4}}{,}{{v}}_{{5}}{,}{{v}}_{{6}}{,}{{v}}_{{7}}{,}{{v}}_{{8}}{,}{{v}}_{{9}}{,}{{v}}_{{10}}\right\}$ (17)

Indexing

 Use indexing to extract each element of a MutableSet.
 > M1 := MutableSet(a,b,c,d);
 ${\mathrm{M1}}{≔}{\mathrm{MutableSet}}{}\left({a}{,}{b}{,}{c}{,}{d}\right)$ (18)
 > seq(i=M1[i], i=1..numelems(M1));
 ${1}{=}{a}{,}{2}{=}{b}{,}{3}{=}{c}{,}{4}{=}{d}$ (19)
 Reassign the value of the second index. Note that in the updated MutableSet, the new value is assigned a different index.
 > M1 := 23:
 > seq(i=M1[i], i=1..numelems(M1));
 ${1}{=}{23}{,}{2}{=}{a}{,}{3}{=}{c}{,}{4}{=}{d}$ (20)

Iteration

 Iterate through each element in M1.
 > [seq(x, x in M1)];
 $\left[{23}{,}{a}{,}{c}{,}{d}\right]$ (21)
 Add the elements of M2.
 > add(x, x in M2);
 ${c}{+}{d}{+}{e}{+}{f}$ (22)
 > for x in M2 do print(x); end do;
 ${c}$
 ${d}$
 ${e}$
 ${f}$ (23)

Usage

 The MutableSet object provides an efficient way to construct a set an element at a time, in a loop.  Doing so with standard Maple sets is inefficient in that each addition creates a new set; as such the operation is $\mathrm{O}\left({n}^{2}\right)$ in time and memory, where $n$ is the number of elements. The following compares the memory and time required to create a set of ten thousand elements using standard sets and a MutableSet object.
 > MapleSets := proc(n :: posint)  local i, s;     s := {};     for i to n do         s := s union {i};     end do:     numelems(s); end proc: MutableSets := proc(n :: posint) local i, s;     s := MutableSet();     for i to n do         insert(s,-i);     end do;     numelems(s); end proc:
 > CodeTools:-Usage(MapleSets(10000));
 memory used=382.91MiB, alloc change=27.48MiB, cpu time=1.66s, real time=1.33s, gc time=745.11ms
 ${10000}$ (24)
 > CodeTools:-Usage(MutableSets(10000));
 memory used=1.38MiB, alloc change=0 bytes, cpu time=42.00ms, real time=42.00ms, gc time=0ns
 ${10000}$ (25)

Compatibility

 • The MutableSet object was introduced in Maple 2016.
 • For more information on Maple 2016 changes, see Updates in Maple 2016.

 See Also