Syntax
Dom::Multiset(<s1, s2, …
>)
Description
Dom::Multiset
is the domain of multisets,
i.e., sets with possibly multiple identical elements.
A multiset is represented by a set of lists of the form [s, m],
where s is
an element of the multiset and m its
multiplicity.
Multisets can be returned by the system solver solve
. For example,
the input solve(x^3  4*x^2 + 5*x  2, x, Multiple)
gives
all roots of the polynomial x^{3} 
4 x^{2} + 5 x 
2 in form of the multiset {[1, 2], [2,
1]}
.
The standard set operations such as union, intersection and
subtraction of sets have been extended to deal with multisets.
These operations can handle different types of sets, such as
sets of type DOM_SET
and
multisets. One may, for example, compute the union of the multiset {[a,
2], [b, 1]}
and the set {c}
, which results
in the multiset {[a, 2], [b, 1], [c, 1]}
.
The elements of the multiset are sorted at the time where the
multiset is created. The system function sort
is used in order to guarantee that
exactly one representation exists for a multiset, independent of the
sequence in which the arguments appear.
Dom::Multiset(s1, s2, ...)
creates the multiset
consisting of the elements s1, s2, ...
Multiple identical elements in s1, s2
, ...
are collected. For example, the call Dom::Multiset(a, b,
a, c)
creates a multiset with the elements a, b,
c
. The element a
has multiplicity two,
the other two elements b
and c
both
have multiplicity one.
Examples
Example 1
The multiset {a, a, b} consists
of the two different elements a and b,
where a has
multiplicity two and b has
multiplicity one:
We create another multiset:
Standard set operations such as disjoint union, intersection
or subtraction are implemented for multisets and can be performed
using the standard set operators of MuPAD^{®}:
Example 2
Some system functions were overloaded for multisets, such as expand
, normal
or split
.
If we apply expand
to a multiset, for example,
we get an expression sequence of all elements of the multiset (appearing
in correspondence to their multiplicity):
If you want to convert a multiset into an ordinary set of the
domain type DOM_SET
,
use coerce
:
Note: The system function coerce
uses the
methods "convert"
and "convert_to"
of
the domain Dom::Multiset
.
Compare the last result with the return value of the function expr
, when it is applied
for multisets:
The result is a set of the domain type DOM_SET
,
consisting of lists of the domain type DOM_LIST
with two entries,
an element of the multiset and the corresponding multiplicity of that
element.
Parameters
s1, s2, …

Objects of any type

Entries
"isFinite"  is TRUE because Dom::Multiset represents
finite sets. 
"inhomog_intersect"  a table of the form T = Proc(multiset, setoftypeT) .
This entry is used internally by the implementation, and thus should
not be touched. 
"inhomog_union"  a table of the form T = Proc(multiset, setoftypeT) .
This entry is used internally by the implementation, and thus should
not be touched. 
Methods
expand all
Mathematical Methods
normal
— Normalization of multisets
normal(set
)
This method overloads the function normal
for
multisets, i.e., one may use it in the form normal(set)
.
powerset
— Power set of a multiset
powerset(set
)
The power set of set
is returned as a set of multisets.
random
— Random multiset generation
random()
The number of elements created, including their multiplicities,
is restricted to 20.
Access Methods
_index
— Multiset indexing
_index(set
, i
)
See the method "op"
.
This method overloads the function _index
for multisets, i.e., one may use
it in the form set[i]
, or in functional notation: _index(set,
i)
.
contains
— Check on existence of set elements
contains(set
, s
)
This method overloads the function contains
for multisets, i.e., one may
use it in the form contains(set, s)
.
equal
— Test on equality of multisets
equal(set1
, set2
)
The system function _equal
is
used for the test.
expand
— Expand a multiset to a sequence of its elements
expand(set
)
This method overloads the function expand
for multisets, i.e., one may use
it in the form expand(set)
.
getElement
— Extract one element from a multiset
getElement(set
)
Note that the elements of the multiset are sorted with the use
of the system function sort
,
and thus the order of a multiset depends on the sorting criteria specified
by this function.
This method overloads the function solvelib::getElement
, i.e., one may use
it in the form solvelib::getElement(set)
.
has
— Check on existence of (sub)expressions
has(set
, expr
)
To check whether expr
is contained as an
element of set
and not as a subexpression of the
elements of set
, the function contains
must be used.
This method overloads the function has
for multisets, i.e., one may use
it in the form has(set, expr)
.
map
— Apply a function to multiset elements
map(set
, func
,
<expr, …
>)
It overloads the function map
for multisets,
i.e., one may use it in the form map(set, func, ...)
.
multiplicity
— Multiplicity of an element
multiplicity(set
, s
)
Elements which are not contained in set
have
multiplicity zero.
card
— Number of elements in a multiset
card(set
)
This method overloads the function card
.
nops
— Number of different elements in a multiset
nops(set
)
This method overloads the function nops
for multisets, i.e., one may use
it in the form nops(set)
.
op
— Element of a multiset
op(set
)
op(set
, i
)
Returns the ith
element s of
the multiset set
and its multiplicity m in
form of the list [s, m].
See also the method "_index"
.
Note that the elements of the multiset are sorted with the use
of the system function sort
,
and thus the order of a multiset depends on the sorting criteria specified
by this function.
This method overloads the function op
for multisets, i.e., one may use it
in the form op(s, i)
.
select
— Selecting of multiset elements
select(set
, func
,
<expr, …
>)
This method overloads the function select
for multisets, i.e., one may use
it in the form select(set, func, ...)
. See select
for details.
split
— Splitting a multiset
split(set
, func
,
<expr, …
>)
This method overloads the function split
for multisets, i.e., one may use
it in the form split(set, func, ...)
. See split
for details.
subs
— Substitution of elements in multisets
subs(set, …
)
This method overloads the function subs
for
multisets, i.e., one may use it in the form subs(set, ...)
.
Conversion Methods
convert
— Conversion into a multiset
convert(x
)
FAIL
is returned if the conversion fails.
Currently only sets of type DOM_SET
can be converted into multisets.
convert_to
— Multiset conversion
convert_to(set
, T
)
FAIL
is returned if the conversion fails.
Currently T
may either be DOM_SET
to convert the
multiset set
into a set (loosing the multiplicities
and the order of the elements of set
), or DOM_EXPR
or "_exprseq"
to
convert set
into an expression sequence (see the
method "expand"
for details).
See also the method "expr"
.
expr
— Multiset conversion into an object of a kernel domain
expr(set
)
This method overloads the function expr
for multisets, i.e., one may use
it in the form expr(set)
.
sort
— Sorting of multisets
sort(set
)
This method overloads the function sort
for multisets, i.e., one may use
it in the form sort(set)
.
Technical Methods
bin_intersect
— Intersection of two multisets
bin_intersect(set1
, set2
)
This method is called from routines defined in the category Cat::Set
, which implements
among others the overloading of the function intersect
for multisets. One may intersect
two multisets directly by set1 intersect set2
,
or in functional notation by _intersect(set1, set2)
.
bin_minus
— Subtraction of two multisets
bin_minus(set1
, set2
)
This method is called from routines defined in the category Cat::Set
, which implements
among others the overloading of the function minus
for multisets.
One may subtract two multisets directly by set1 minus set2
,
or in functional notation by _minus(set1, set2)
.
homog_union
— Union of multisets
homog_union(set, …
)
This method is called from routines defined in the category Cat::Set
, which implements
among others the overloading of the function union
for multisets. One may compute
the union of two multisets directly by set1 union set2
,
or in functional notation by _union(set1, set2)
.
nested_union
— Union of nested sets
nested_union(setofsets
)
This method is called from routines defined in the category Cat::Set
, which implements
among others the overloading of the function union
for multisets and sets. One may
compute the union of multisets and sets directly by set1
union set2
, or in functional notation by _union(set1,
set2)
.