ListMultiDictionary(S)

lmdict.spad line 1 [edit on github]

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
any? : (Mapping(Boolean, S), %) -> 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, %) -> NonNegativeInteger
from HomogeneousAggregate(S)
count : (Mapping(Boolean, 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 : (%, S, S) -> % if S has Evalable(S)
from InnerEvalable(S, S)
eval : (%, 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 : (%, List(Equation(S))) -> % if S has Evalable(S)
from Evalable(S)
every? : (Mapping(Boolean, S), %) -> Boolean
from HomogeneousAggregate(S)
extract! : % -> S
from BagAggregate(S)
find : (Mapping(Boolean, S), %) -> Union(S, "failed")
from Collection(S)
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 : (Mapping(S, S), %) -> %
from HomogeneousAggregate(S)
map! : (Mapping(S, S), %) -> %
from HomogeneousAggregate(S)
max : % -> S if S has OrderedSet
from HomogeneousAggregate(S)
max : (Mapping(Boolean, S, S), %) -> S
from HomogeneousAggregate(S)
member? : (S, %) -> Boolean
from HomogeneousAggregate(S)
members : % -> List(S)
from HomogeneousAggregate(S)
min : % -> S if S has OrderedSet
from HomogeneousAggregate(S)
more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
parts : % -> List(S)
from HomogeneousAggregate(S)
reduce : (Mapping(S, S, S), %) -> S
from Collection(S)
reduce : (Mapping(S, S, S), %, S) -> S
from Collection(S)
reduce : (Mapping(S, S, S), %, S, S) -> S
from Collection(S)
remove : (S, %) -> %
from Collection(S)
remove : (Mapping(Boolean, S), %) -> %
from Collection(S)
remove! : (S, %) -> %
from DictionaryOperations(S)
remove! : (Mapping(Boolean, S), %) -> %
from DictionaryOperations(S)
removeDuplicates : % -> %
from Collection(S)
removeDuplicates! : % -> %
from MultiDictionary(S)
sample : () -> %
from Aggregate
select : (Mapping(Boolean, S), %) -> %
from Collection(S)
select! : (Mapping(Boolean, S), %) -> %
from DictionaryOperations(S)
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
substitute : (S, S, %) -> %

substitute(x, y, d) replace x's with y's in dictionary d.

~= : (%, %) -> Boolean
from BasicType

CoercibleTo(OutputForm)

BagAggregate(S)

BasicType

shallowlyMutable

DictionaryOperations(S)

Collection(S)

SetCategory

MultiDictionary(S)

HomogeneousAggregate(S)

finiteAggregate

Aggregate

ConvertibleTo(InputForm)

InnerEvalable(S, S)

Evalable(S)