ExtensibleLinearAggregate(S)

aggcat.spad line 2179 [edit on github]

• S : Type

An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists which are represented by linked structures so as to make insertion, deletion, and concatenation efficient. However, access to elements of these extensible aggregates is generally slow since access is made from the end. See FlexibleArray for an exception.

# : % -> NonNegativeInteger if % has finiteAggregate

from Aggregate

< : (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

<= : (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

= : (%, %) -> Boolean if S has SetCategory or S has Hashable and % has finiteAggregate or S has BasicType and % has finiteAggregate

from BasicType

> : (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

>= : (%, %) -> Boolean if S has OrderedSet and % has finiteAggregate

from PartialOrder

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

from HomogeneousAggregate(S)

coerce : % -> OutputForm if S has CoercibleTo(OutputForm)

from CoercibleTo(OutputForm)

concat : (%, %) -> %

from LinearAggregate(S)

concat : (%, S) -> %

from LinearAggregate(S)

concat : (S, %) -> %

from LinearAggregate(S)

concat : List(%) -> %

from LinearAggregate(S)

concat! : (%, %) -> %

concat!(u, v) destructively appends v to the end of u. v is unchanged

concat! : (%, S) -> %

concat!(u, x) destructively adds element x to the end of u.

construct : List(S) -> %

from Collection(S)

convert : % -> InputForm if S has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

copy : % -> %

from Aggregate

copyInto! : (%, %, Integer) -> % if % has finiteAggregate

from LinearAggregate(S)

count : (S, %) -> NonNegativeInteger if S has BasicType and % has finiteAggregate

from HomogeneousAggregate(S)

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

from HomogeneousAggregate(S)

delete : (%, Integer) -> %

from LinearAggregate(S)

delete : (%, UniversalSegment(Integer)) -> %

from LinearAggregate(S)

delete! : (%, Integer) -> %

delete!(u, i) destructively deletes the ith element of u.

delete! : (%, UniversalSegment(Integer)) -> %

delete!(u, i..j) destructively deletes elements u.i through u.j.

elt : (%, UniversalSegment(Integer)) -> %

from Eltable(UniversalSegment(Integer), %)

elt : (%, Integer) -> S

from Eltable(Integer, S)

elt : (%, Integer, S) -> S

from EltableAggregate(Integer, S)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(S)

from IndexedAggregate(Integer, S)

entry? : (S, %) -> Boolean if S has BasicType and % has finiteAggregate

from IndexedAggregate(Integer, 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 if % has finiteAggregate

from HomogeneousAggregate(S)

fill! : (%, S) -> %

from IndexedAggregate(Integer, S)

find : (Mapping(Boolean, S), %) -> Union(S, "failed")

from Collection(S)

first : (%, NonNegativeInteger) -> %

from LinearAggregate(S)

first : % -> S

from IndexedAggregate(Integer, S)

hash : % -> SingleInteger if S has Hashable and % has finiteAggregate

from Hashable

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

from Hashable

index? : (Integer, %) -> Boolean

from IndexedAggregate(Integer, S)

indices : % -> List(Integer)

from IndexedAggregate(Integer, S)

insert : (%, %, Integer) -> %

from LinearAggregate(S)

insert : (S, %, Integer) -> %

from LinearAggregate(S)

insert! : (%, %, Integer) -> %

insert!(v, u, i) destructively inserts aggregate v into u at position i.

insert! : (S, %, Integer) -> %

insert!(x, u, i) destructively inserts x into u at position i.

latex : % -> String if S has SetCategory

from SetCategory

leftTrim : (%, S) -> % if S has BasicType and % has finiteAggregate

from LinearAggregate(S)

less? : (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate(S)

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

from LinearAggregate(S)

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

from HomogeneousAggregate(S)

max : (%, %) -> % if S has OrderedSet and % has finiteAggregate

from OrderedSet

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

from HomogeneousAggregate(S)

max : (Mapping(Boolean, S, S), %) -> S if % has finiteAggregate

from HomogeneousAggregate(S)

maxIndex : % -> Integer

from IndexedAggregate(Integer, S)

member? : (S, %) -> Boolean if S has BasicType and % has finiteAggregate

from HomogeneousAggregate(S)

members : % -> List(S) if % has finiteAggregate

from HomogeneousAggregate(S)

merge : (%, %) -> % if S has OrderedSet and % has finiteAggregate

from LinearAggregate(S)

merge : (Mapping(Boolean, S, S), %, %) -> % if % has finiteAggregate

from LinearAggregate(S)

merge! : (%, %) -> % if S has OrderedSet

merge!(u, v) destructively merges u and v in ascending order.

merge! : (Mapping(Boolean, S, S), %, %) -> %

merge!(p, u, v) destructively merges u and v using predicate p.

min : (%, %) -> % if S has OrderedSet and % has finiteAggregate

from OrderedSet

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

from HomogeneousAggregate(S)

minIndex : % -> Integer

from IndexedAggregate(Integer, S)

more? : (%, NonNegativeInteger) -> Boolean

from Aggregate

new : (NonNegativeInteger, S) -> %

from LinearAggregate(S)

parts : % -> List(S) if % has finiteAggregate

from HomogeneousAggregate(S)

position : (S, %) -> Integer if S has BasicType and % has finiteAggregate

from LinearAggregate(S)

position : (S, %, Integer) -> Integer if S has BasicType and % has finiteAggregate

from LinearAggregate(S)

position : (Mapping(Boolean, S), %) -> Integer if % has finiteAggregate

from LinearAggregate(S)

qelt : (%, Integer) -> S

from EltableAggregate(Integer, S)

qsetelt! : (%, Integer, S) -> S

from EltableAggregate(Integer, S)

reduce : (Mapping(S, S, S), %) -> S if % has finiteAggregate

from Collection(S)

reduce : (Mapping(S, S, S), %, S) -> S if % has finiteAggregate

from Collection(S)

reduce : (Mapping(S, S, S), %, S, S) -> S if S has BasicType and % has finiteAggregate

from Collection(S)

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

from Collection(S)

remove : (Mapping(Boolean, S), %) -> % if % has finiteAggregate

from Collection(S)

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

remove!(x, u) destructively removes all values x from u.

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

remove!(p, u) destructively removes all elements x of u such that p(x) is true.

removeDuplicates : % -> % if S has BasicType and % has finiteAggregate

from Collection(S)

removeDuplicates! : % -> % if S has BasicType

removeDuplicates!(u) destructively removes duplicates from u.

reverse : % -> % if % has finiteAggregate

from LinearAggregate(S)

reverse! : % -> % if % has finiteAggregate

from LinearAggregate(S)

rightTrim : (%, S) -> % if S has BasicType and % has finiteAggregate

from LinearAggregate(S)

sample : () -> %

from Aggregate

select : (Mapping(Boolean, S), %) -> % if % has finiteAggregate

from Collection(S)

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

select!(p, u) destructively changes u by keeping only values x such that p(x).

setelt! : (%, Integer, S) -> S

from EltableAggregate(Integer, S)

setelt! : (%, UniversalSegment(Integer), S) -> S

from LinearAggregate(S)

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller? : (%, %) -> Boolean if % has finiteAggregate and S has Comparable or S has OrderedSet and % has finiteAggregate

from Comparable

sort : % -> % if S has OrderedSet and % has finiteAggregate

from LinearAggregate(S)

sort : (Mapping(Boolean, S, S), %) -> % if % has finiteAggregate

from LinearAggregate(S)

sort! : % -> % if S has OrderedSet and % has finiteAggregate

from LinearAggregate(S)

sort! : (Mapping(Boolean, S, S), %) -> % if % has finiteAggregate

from LinearAggregate(S)

sorted? : % -> Boolean if S has OrderedSet and % has finiteAggregate

from LinearAggregate(S)

sorted? : (Mapping(Boolean, S, S), %) -> Boolean if % has finiteAggregate

from LinearAggregate(S)

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

from IndexedAggregate(Integer, S)

trim : (%, S) -> % if S has BasicType and % has finiteAggregate

from LinearAggregate(S)

~= : (%, %) -> Boolean if S has SetCategory or S has Hashable and % has finiteAggregate or S has BasicType and % has finiteAggregate

from BasicType

Comparable

ConvertibleTo(InputForm)

shallowlyMutable

InnerEvalable(S, S)

Aggregate

BasicType

LinearAggregate(S)

IndexedAggregate(Integer, S)

OrderedSet

SetCategory

Evalable(S)

HomogeneousAggregate(S)

PartialOrder

CoercibleTo(OutputForm)

Collection(S)

Eltable(UniversalSegment(Integer), %)

EltableAggregate(Integer, S)

Hashable

Eltable(Integer, S)