OneDimensionalArrayAggregate SΒΆ

aggcat.spad line 1847

One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically, these aggregates are finite linear aggregates with the shallowlyMutable property, that is, any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however FlexibleArray for a data structure which is a cross between a list and an array). Iteration over, and access to, elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result.

<: (%, %) -> 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
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
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
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)
find: (S -> Boolean, %) -> Union(S, failed)
from Collection S
first: % -> S
from IndexedAggregate(Integer, 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 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) -> 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
merge: (%, %) -> % if S has OrderedSet
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
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)
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
rightTrim: (%, S) -> % if S has BasicType
from LinearAggregate S
sample: %
from Aggregate
size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
smaller?: (%, %) -> Boolean if S has Comparable
from Comparable
sort!: % -> % if S has OrderedSet
from LinearAggregate S
sort: % -> % if S has OrderedSet
from LinearAggregate S
sorted?: % -> Boolean if S has OrderedSet
from LinearAggregate 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

finiteAggregate

FiniteLinearAggregate S

HomogeneousAggregate S

IndexedAggregate(Integer, S)

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

LinearAggregate S

OrderedSet if S has OrderedSet

PartialOrder if S has OrderedSet

SetCategory if S has SetCategory

shallowlyMutable