FlexibleArray SΒΆ

array1.spad line 329

A FlexibleArray is the notion of an array intended to allow for growth at the end only. Hence the following efficient operations concat!(a, x) meaning append item x at the end of the array a delete!(a, n) meaning delete the last item from the array a Flexible arrays support the other operations inherited from ExtensibleLinearAggregate. However, these are not efficient. Flexible arrays combine the O(1) access time property of arrays with growing and shrinking at the end in O(1) (average) time. This is done by using an ordinary array which may have zero or more empty slots at the end. When the array becomes full it is copied into a new larger (50% larger) array. Conversely, when the array becomes less than 1/2 full, it is copied into a smaller array. Flexible arrays provide for an efficient implementation of many data structures in particular heaps, stacks and sets.

#: % -> NonNegativeInteger
from Aggregate
<: (%, %) -> Boolean if S has OrderedSet
from PartialOrder
<=: (%, %) -> Boolean if S has OrderedSet
from PartialOrder
=: (%, %) -> Boolean if S has BasicType
from BasicType
>: (%, %) -> Boolean if S has OrderedSet
from PartialOrder
>=: (%, %) -> Boolean if S has OrderedSet
from PartialOrder
~=: (%, %) -> Boolean if S has BasicType
from BasicType
any?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S
coerce: % -> OutputForm if S has CoercibleTo OutputForm
from CoercibleTo OutputForm
concat!: (%, %) -> %
from ExtensibleLinearAggregate S
concat!: (%, S) -> %
from ExtensibleLinearAggregate S
concat: (%, %) -> %
from LinearAggregate S
concat: (%, S) -> %
from LinearAggregate S
concat: (S, %) -> %
from LinearAggregate S
concat: List % -> %
from LinearAggregate S
construct: List S -> %
from Collection S
convert: % -> InputForm if S has ConvertibleTo InputForm
from ConvertibleTo InputForm
copy: % -> %
from Aggregate
copyInto!: (%, %, Integer) -> %
from LinearAggregate S
count: (S -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate S
count: (S, %) -> NonNegativeInteger if S has BasicType
from HomogeneousAggregate S
delete!: (%, Integer) -> %
from ExtensibleLinearAggregate S
delete!: (%, UniversalSegment Integer) -> %
from ExtensibleLinearAggregate S
delete: (%, Integer) -> %
from LinearAggregate S
delete: (%, UniversalSegment Integer) -> %
from LinearAggregate S
elt: (%, Integer) -> S
from Eltable(Integer, S)
elt: (%, Integer, S) -> S
from EltableAggregate(Integer, S)
elt: (%, UniversalSegment Integer) -> %
from Eltable(UniversalSegment Integer, %)
empty: () -> %
from Aggregate
empty?: % -> Boolean
from Aggregate
entries: % -> List S
from IndexedAggregate(Integer, S)
entry?: (S, %) -> Boolean if S has BasicType
from IndexedAggregate(Integer, 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)
every?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S
fill!: (%, S) -> %
from IndexedAggregate(Integer, S)
find: (S -> Boolean, %) -> Union(S, failed)
from Collection S
first: % -> S
from IndexedAggregate(Integer, S)
first: (%, NonNegativeInteger) -> %
from LinearAggregate S

flexibleArray: List S -> %

hash: % -> SingleInteger if S has SetCategory
from SetCategory
hashUpdate!: (HashState, %) -> HashState if S has SetCategory
from SetCategory
index?: (Integer, %) -> Boolean
from IndexedAggregate(Integer, S)
indices: % -> List Integer
from IndexedAggregate(Integer, S)
insert!: (%, %, Integer) -> %
from ExtensibleLinearAggregate S
insert!: (S, %, Integer) -> %
from ExtensibleLinearAggregate S
insert: (%, %, Integer) -> %
from LinearAggregate S
insert: (S, %, Integer) -> %
from LinearAggregate S
latex: % -> String if S has SetCategory
from SetCategory
leftTrim: (%, S) -> % if S has BasicType
from LinearAggregate S
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
map!: (S -> S, %) -> %
from HomogeneousAggregate S
map: ((S, S) -> S, %, %) -> %
from LinearAggregate S
map: (S -> S, %) -> %
from HomogeneousAggregate S
max: (%, %) -> % if S has OrderedSet
from OrderedSet
maxIndex: % -> Integer
from IndexedAggregate(Integer, S)
member?: (S, %) -> Boolean if S has BasicType
from HomogeneousAggregate S
members: % -> List S
from HomogeneousAggregate S
merge!: (%, %) -> % if S has OrderedSet
from ExtensibleLinearAggregate S
merge!: ((S, S) -> Boolean, %, %) -> %
from ExtensibleLinearAggregate S
merge: (%, %) -> % if S has OrderedSet
from LinearAggregate S
merge: ((S, S) -> Boolean, %, %) -> %
from LinearAggregate S
min: (%, %) -> % if S has OrderedSet
from OrderedSet
minIndex: % -> Integer
from IndexedAggregate(Integer, S)
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
new: (NonNegativeInteger, S) -> %
from LinearAggregate S
parts: % -> List S
from HomogeneousAggregate S

physicalLength!: (%, Integer) -> %

physicalLength: % -> NonNegativeInteger

position: (S -> Boolean, %) -> Integer
from LinearAggregate S
position: (S, %) -> Integer if S has BasicType
from LinearAggregate S
position: (S, %, Integer) -> Integer if S has BasicType
from LinearAggregate S
qelt: (%, Integer) -> S
from EltableAggregate(Integer, S)
qsetelt!: (%, Integer, S) -> S
from EltableAggregate(Integer, S)
reduce: ((S, S) -> S, %) -> S
from Collection S
reduce: ((S, S) -> S, %, S) -> S
from Collection S
reduce: ((S, S) -> S, %, S, S) -> S if S has BasicType
from Collection S
remove!: (S -> Boolean, %) -> %
from ExtensibleLinearAggregate S
remove!: (S, %) -> % if S has BasicType
from ExtensibleLinearAggregate S
remove: (S -> Boolean, %) -> %
from Collection S
remove: (S, %) -> % if S has BasicType
from Collection S
removeDuplicates!: % -> % if S has BasicType
from ExtensibleLinearAggregate S
removeDuplicates: % -> % if S has BasicType
from Collection S

removeRepeats!: % -> %

reverse!: % -> %
from LinearAggregate S
reverse: % -> %
from LinearAggregate S
rightTrim: (%, S) -> % if S has BasicType
from LinearAggregate S
sample: %
from Aggregate
select!: (S -> Boolean, %) -> %
from ExtensibleLinearAggregate S
select: (S -> Boolean, %) -> %
from Collection S
setelt!: (%, Integer, S) -> S
from EltableAggregate(Integer, S)
setelt!: (%, UniversalSegment Integer, S) -> S
from LinearAggregate S

shrinkable: Boolean -> Boolean

size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
smaller?: (%, %) -> Boolean if S has Comparable
from Comparable
sort!: % -> % if S has OrderedSet
from LinearAggregate S
sort!: ((S, S) -> Boolean, %) -> %
from LinearAggregate S
sort: % -> % if S has OrderedSet
from LinearAggregate S
sort: ((S, S) -> Boolean, %) -> %
from LinearAggregate S
sorted?: % -> Boolean if S has OrderedSet
from LinearAggregate S
sorted?: ((S, S) -> Boolean, %) -> Boolean
from LinearAggregate S
swap!: (%, Integer, Integer) -> Void
from IndexedAggregate(Integer, S)
trim: (%, S) -> % if S has BasicType
from LinearAggregate S

Aggregate

BasicType if S has BasicType

CoercibleTo OutputForm if S has CoercibleTo OutputForm

Collection S

Comparable if S has Comparable

ConvertibleTo InputForm if S has ConvertibleTo InputForm

Eltable(Integer, S)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, S)

Evalable S if S has Evalable S and S has SetCategory

ExtensibleLinearAggregate S

finiteAggregate

FiniteLinearAggregate S

HomogeneousAggregate S

IndexedAggregate(Integer, S)

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

LinearAggregate S

OneDimensionalArrayAggregate S

OrderedSet if S has OrderedSet

PartialOrder if S has OrderedSet

SetCategory if S has SetCategory

shallowlyMutable