DequeueAggregate SΒΆ

aggcat.spad line 333

A dequeue is a doubly ended stack, that is, a bag where first items inserted are the first items extracted, at either the front or the back end of the data structure.

=: (%, %) -> Boolean if S has BasicType
from BasicType
~=: (%, %) -> Boolean if S has BasicType
from BasicType
back: % -> S
from QueueAggregate S
bottom: % -> S
bottom(d) returns the element at the bottom (back) of the dequeue.
coerce: % -> OutputForm if S has CoercibleTo 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 if S has BasicType
from HomogeneousAggregate S
dequeue!: % -> S
from QueueAggregate S
empty: () -> %
from Aggregate
empty?: % -> Boolean
from Aggregate
enqueue!: (S, %) -> S
from QueueAggregate S
eq?: (%, %) -> Boolean
from Aggregate
eval: (%, Equation S) -> % if S has Evalable S and S has SetCategory
from Evalable S
eval: (%, List Equation S) -> % if S has Evalable S and S has SetCategory
from Evalable S
eval: (%, List S, List S) -> % if S has Evalable S and S has SetCategory
from InnerEvalable(S, S)
eval: (%, S, S) -> % if S has Evalable S and S has SetCategory
from InnerEvalable(S, S)
extract!: % -> S
from BagAggregate S
extractBottom!: % -> S
extractBottom!(d) destructively extracts the bottom (back) element from the dequeue d. Error: if d is empty.
extractTop!: % -> S
extractTop!(d) destructively extracts the top (front) element from the dequeue d. Error: if d is empty.
find: (S -> Boolean, %) -> Union(S, failed)
from Collection S
front: % -> S
from QueueAggregate S
hash: % -> SingleInteger if S has SetCategory
from SetCategory
hashUpdate!: (HashState, %) -> HashState if S has SetCategory
from SetCategory
insert!: (S, %) -> %
from BagAggregate S
insertBottom!: (S, %) -> S
insertBottom!(x, d) destructively inserts x into the dequeue d at the bottom (back) of the dequeue.
insertTop!: (S, %) -> S
insertTop!(x, d) destructively inserts x into the dequeue d, that is, at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue, and so on.
inspect: % -> S
from BagAggregate S
latex: % -> String if S has SetCategory
from SetCategory
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
map: (S -> S, %) -> %
from HomogeneousAggregate S
member?: (S, %) -> Boolean if S has BasicType
from HomogeneousAggregate S
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
pop!: % -> S
from StackAggregate S
push!: (S, %) -> S
from StackAggregate S
reduce: ((S, S) -> S, %, S, S) -> S if S has BasicType
from Collection S
remove: (S, %) -> % if S has BasicType
from Collection S
removeDuplicates: % -> % if S has BasicType
from Collection S
reverse!: % -> %
reverse!(d) destructively replaces d by its reverse dequeue, i.e. the top (front) element is now the bottom (back) element, and so on.
rotate!: % -> %
from QueueAggregate S
sample: %
from Aggregate
size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
top: % -> S
from StackAggregate S

Aggregate

BagAggregate S

BasicType if S has BasicType

CoercibleTo OutputForm if S has CoercibleTo OutputForm

Collection S

ConvertibleTo InputForm if S has ConvertibleTo InputForm

Evalable S if S has Evalable S and S has SetCategory

finiteAggregate

HomogeneousAggregate S

InnerEvalable(S, S) if S has Evalable S and S has SetCategory

QueueAggregate S

SetCategory if S has SetCategory

shallowlyMutable

StackAggregate S