SparseTable(Key, Ent, dent)

table.spad line 169 [edit on github]

• Key : SetCategory
• Ent : BasicType
• dent : Ent

A sparse table has a default entry, which is returned if no other value has been explicitly stored for a key.

= : (%, %) -> Boolean if Ent has SetCategory or % has finiteAggregate or Record(key : Key, entry : Ent) has SetCategory

from BasicType

coerce : % -> OutputForm if Record(key : Key, entry : Ent) has CoercibleTo(OutputForm) or Ent has CoercibleTo(OutputForm)

from CoercibleTo(OutputForm)

construct : List(Record(key : Key, entry : Ent)) -> %

from Collection(Record(key : Key, entry : Ent))

convert : % -> InputForm if Record(key : Key, entry : Ent) has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

copy : % -> %

from Aggregate

count : (Record(key : Key, entry : Ent), %) -> NonNegativeInteger if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from HomogeneousAggregate(Record(key : Key, entry : Ent))

dictionary : () -> %

from DictionaryOperations(Record(key : Key, entry : Ent))

dictionary : List(Record(key : Key, entry : Ent)) -> %

from DictionaryOperations(Record(key : Key, entry : Ent))

elt : (%, Key) -> Ent

from Eltable(Key, Ent)

elt : (%, Key, Ent) -> Ent

from EltableAggregate(Key, Ent)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(Ent)

from IndexedAggregate(Key, Ent)

eq? : (%, %) -> Boolean

from Aggregate

eval : (%, Ent, Ent) -> % if Ent has Evalable(Ent) and Ent has SetCategory

from InnerEvalable(Ent, Ent)

eval : (%, Equation(Ent)) -> % if Ent has Evalable(Ent) and Ent has SetCategory

from Evalable(Ent)

eval : (%, Equation(Record(key : Key, entry : Ent))) -> % if Record(key : Key, entry : Ent) has Evalable(Record(key : Key, entry : Ent)) and Record(key : Key, entry : Ent) has SetCategory

from Evalable(Record(key : Key, entry : Ent))

eval : (%, List(Ent), List(Ent)) -> % if Ent has Evalable(Ent) and Ent has SetCategory

from InnerEvalable(Ent, Ent)

eval : (%, List(Equation(Ent))) -> % if Ent has Evalable(Ent) and Ent has SetCategory

from Evalable(Ent)

eval : (%, List(Equation(Record(key : Key, entry : Ent)))) -> % if Record(key : Key, entry : Ent) has Evalable(Record(key : Key, entry : Ent)) and Record(key : Key, entry : Ent) has SetCategory

from Evalable(Record(key : Key, entry : Ent))

eval : (%, List(Record(key : Key, entry : Ent)), List(Record(key : Key, entry : Ent))) -> % if Record(key : Key, entry : Ent) has Evalable(Record(key : Key, entry : Ent)) and Record(key : Key, entry : Ent) has SetCategory

from InnerEvalable(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent))

eval : (%, Record(key : Key, entry : Ent), Record(key : Key, entry : Ent)) -> % if Record(key : Key, entry : Ent) has Evalable(Record(key : Key, entry : Ent)) and Record(key : Key, entry : Ent) has SetCategory

from InnerEvalable(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent))

extract! : % -> Record(key : Key, entry : Ent)

from BagAggregate(Record(key : Key, entry : Ent))

fill! : (%, Ent) -> %

from IndexedAggregate(Key, Ent)

find : (Mapping(Boolean, Record(key : Key, entry : Ent)), %) -> Union(Record(key : Key, entry : Ent), "failed")

from Collection(Record(key : Key, entry : Ent))

first : % -> Ent if Key has OrderedSet

from IndexedAggregate(Key, Ent)

index? : (Key, %) -> Boolean

from IndexedAggregate(Key, Ent)

indices : % -> List(Key)

from IndexedAggregate(Key, Ent)

insert! : (Record(key : Key, entry : Ent), %) -> %

from BagAggregate(Record(key : Key, entry : Ent))

inspect : % -> Record(key : Key, entry : Ent)

from BagAggregate(Record(key : Key, entry : Ent))

key? : (Key, %) -> Boolean

from KeyedDictionary(Key, Ent)

keys : % -> List(Key)

from KeyedDictionary(Key, Ent)

latex : % -> String if Record(key : Key, entry : Ent) has SetCategory or Ent has SetCategory

from SetCategory

less? : (%, NonNegativeInteger) -> Boolean

from Aggregate

map : (Mapping(Ent, Ent), %) -> %

from HomogeneousAggregate(Ent)

map : (Mapping(Ent, Ent, Ent), %, %) -> %

from TableAggregate(Key, Ent)

map : (Mapping(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent)), %) -> %

from HomogeneousAggregate(Record(key : Key, entry : Ent))

map! : (Mapping(Ent, Ent), %) -> %

from HomogeneousAggregate(Ent)

map! : (Mapping(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent)), %) -> %

from HomogeneousAggregate(Record(key : Key, entry : Ent))

max : % -> Ent if % has finiteAggregate and Ent has OrderedSet

from HomogeneousAggregate(Ent)

max : % -> Record(key : Key, entry : Ent) if Record(key : Key, entry : Ent) has OrderedSet and % has finiteAggregate

from HomogeneousAggregate(Record(key : Key, entry : Ent))

maxIndex : % -> Key if Key has OrderedSet

from IndexedAggregate(Key, Ent)

member? : (Record(key : Key, entry : Ent), %) -> Boolean if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from HomogeneousAggregate(Record(key : Key, entry : Ent))

min : % -> Ent if % has finiteAggregate and Ent has OrderedSet

from HomogeneousAggregate(Ent)

min : % -> Record(key : Key, entry : Ent) if Record(key : Key, entry : Ent) has OrderedSet and % has finiteAggregate

from HomogeneousAggregate(Record(key : Key, entry : Ent))

minIndex : % -> Key if Key has OrderedSet

from IndexedAggregate(Key, Ent)

more? : (%, NonNegativeInteger) -> Boolean

from Aggregate

qelt : (%, Key) -> Ent

from EltableAggregate(Key, Ent)

qsetelt! : (%, Key, Ent) -> Ent

from EltableAggregate(Key, Ent)

reduce : (Mapping(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent), Record(key : Key, entry : Ent)), %, Record(key : Key, entry : Ent), Record(key : Key, entry : Ent)) -> Record(key : Key, entry : Ent) if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from Collection(Record(key : Key, entry : Ent))

remove : (Record(key : Key, entry : Ent), %) -> % if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from Collection(Record(key : Key, entry : Ent))

remove! : (Record(key : Key, entry : Ent), %) -> % if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from DictionaryOperations(Record(key : Key, entry : Ent))

remove! : (Key, %) -> Union(Ent, "failed")

from KeyedDictionary(Key, Ent)

removeDuplicates : % -> % if Record(key : Key, entry : Ent) has BasicType and % has finiteAggregate

from Collection(Record(key : Key, entry : Ent))

sample : () -> %

from Aggregate

search : (Key, %) -> Union(Ent, "failed")

from KeyedDictionary(Key, Ent)

setelt! : (%, Key, Ent) -> Ent

from TableAggregate(Key, Ent)

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

swap! : (%, Key, Key) -> Void

from IndexedAggregate(Key, Ent)

table : () -> %

from TableAggregate(Key, Ent)

table : List(Record(key : Key, entry : Ent)) -> %

from TableAggregate(Key, Ent)

~= : (%, %) -> Boolean if Ent has SetCategory or % has finiteAggregate or Record(key : Key, entry : Ent) has SetCategory

from BasicType

ConvertibleTo(InputForm)

BagAggregate(Record(key : Key, entry : Ent))

KeyedDictionary(Key, Ent)

Aggregate

HomogeneousAggregate(Record(key : Key, entry : Ent))

BasicType

Collection(Record(key : Key, entry : Ent))

IndexedAggregate(Key, Ent)

InnerEvalable(Record(key : Key, entry : Ent), Record(key : Key, entry : Ent))

HomogeneousAggregate(Ent)

Dictionary(Record(key : Key, entry : Ent))

DictionaryOperations(Record(key : Key, entry : Ent))

Evalable(Record(key : Key, entry : Ent))

Evalable(Ent)

SetCategory

EltableAggregate(Key, Ent)

CoercibleTo(OutputForm)

InnerEvalable(Ent, Ent)

TableAggregate(Key, Ent)

Eltable(Key, Ent)

shallowlyMutable