DequeueAggregate(S)

aggcat.spad line 358 [edit on github]

• S : Type

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.

# : % -> NonNegativeInteger

from Aggregate

= : (%, %) -> Boolean if S has BasicType

from BasicType

any? : (Mapping(Boolean, S), %) -> Boolean

from HomogeneousAggregate(S)

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)

count : (Mapping(Boolean, S), %) -> NonNegativeInteger

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 : (%, S, S) -> % if S has Evalable(S) and S has SetCategory

from InnerEvalable(S, S)

eval : (%, 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 : (%, List(Equation(S))) -> % if S has Evalable(S) and S has SetCategory

from Evalable(S)

every? : (Mapping(Boolean, S), %) -> Boolean

from HomogeneousAggregate(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 : (Mapping(Boolean, S), %) -> Union(S, "failed")

from Collection(S)

front : % -> S

from QueueAggregate(S)

hash : % -> SingleInteger if S has Hashable

from Hashable

hashUpdate! : (HashState, %) -> HashState if S has Hashable

from Hashable

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 : (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 if S has BasicType

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)

pop! : % -> S

from StackAggregate(S)

push! : (S, %) -> S

from StackAggregate(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 if S has BasicType

from Collection(S)

remove : (S, %) -> % if S has BasicType

from Collection(S)

remove : (Mapping(Boolean, S), %) -> %

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

select : (Mapping(Boolean, S), %) -> %

from Collection(S)

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

top : % -> S

from StackAggregate(S)

~= : (%, %) -> Boolean if S has BasicType

from BasicType

CoercibleTo(OutputForm)

BagAggregate(S)

HomogeneousAggregate(S)

Collection(S)

QueueAggregate(S)

SetCategory

StackAggregate(S)

shallowlyMutable

Hashable

finiteAggregate

BasicType

Aggregate

Evalable(S)

ConvertibleTo(InputForm)

InnerEvalable(S, S)