ListMultiDictionary SΒΆ

lmdict.spad line 1

The ListMultiDictionary domain implements a dictionary with duplicates allowed. The representation is a list with duplicates represented explicitly. Hence most operations will be relatively inefficient when the number of entries in the dictionary becomes large. If the objects in the dictionary belong to an ordered set, the entries are maintained in ascending order.

#: % -> NonNegativeInteger
from Aggregate
=: (%, %) -> Boolean
from BasicType
~=: (%, %) -> Boolean
from BasicType
any?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S
coerce: % -> OutputForm
from CoercibleTo OutputForm
construct: List S -> %
from Collection S
convert: % -> InputForm if S has ConvertibleTo InputForm
from ConvertibleTo InputForm
copy: % -> %
from Aggregate
count: (S -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate S
count: (S, %) -> NonNegativeInteger
from HomogeneousAggregate S
dictionary: () -> %
from DictionaryOperations S
dictionary: List S -> %
from DictionaryOperations S
duplicates: % -> List Record(entry: S, count: NonNegativeInteger)
from MultiDictionary S
duplicates?: % -> Boolean
duplicates?(d) tests if dictionary d has duplicate entries.
empty: () -> %
from Aggregate
empty?: % -> Boolean
from Aggregate
eq?: (%, %) -> Boolean
from Aggregate
eval: (%, Equation S) -> % if S has Evalable S
from Evalable S
eval: (%, List Equation S) -> % if S has Evalable S
from Evalable S
eval: (%, List S, List S) -> % if S has Evalable S
from InnerEvalable(S, S)
eval: (%, S, S) -> % if S has Evalable S
from InnerEvalable(S, S)
every?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S
extract!: % -> S
from BagAggregate S
find: (S -> Boolean, %) -> Union(S, failed)
from Collection S
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
insert!: (S, %) -> %
from BagAggregate S
insert!: (S, %, NonNegativeInteger) -> %
from MultiDictionary S
inspect: % -> S
from BagAggregate S
latex: % -> String
from SetCategory
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
map!: (S -> S, %) -> %
from HomogeneousAggregate S
map: (S -> S, %) -> %
from HomogeneousAggregate S
member?: (S, %) -> Boolean
from HomogeneousAggregate S
members: % -> List S
from HomogeneousAggregate S
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
parts: % -> List S
from HomogeneousAggregate S
reduce: ((S, S) -> S, %) -> S
from Collection S
reduce: ((S, S) -> S, %, S) -> S
from Collection S
reduce: ((S, S) -> S, %, S, S) -> S
from Collection S
remove!: (S -> Boolean, %) -> %
from DictionaryOperations S
remove!: (S, %) -> %
from DictionaryOperations S
remove: (S -> Boolean, %) -> %
from Collection S
remove: (S, %) -> %
from Collection S
removeDuplicates!: % -> %
from MultiDictionary S
removeDuplicates: % -> %
from Collection S
sample: %
from Aggregate
select!: (S -> Boolean, %) -> %
from DictionaryOperations S
select: (S -> Boolean, %) -> %
from Collection S
size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
substitute: (S, S, %) -> %
substitute(x, y, d) replace x's with y's in dictionary d.

Aggregate

BagAggregate S

BasicType

CoercibleTo OutputForm

Collection S

ConvertibleTo InputForm if S has ConvertibleTo InputForm

DictionaryOperations S

Evalable S if S has Evalable S

finiteAggregate

HomogeneousAggregate S

InnerEvalable(S, S) if S has Evalable S

MultiDictionary S

SetCategory

shallowlyMutable