# OneDimensionalArrayAggregate SΒΆ

- S: Type

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.

- #: % -> 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 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 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
- 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, %) -> %
- 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 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
- 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 Collection S
- remove: (S, %) -> % if S has BasicType
- from Collection S
- removeDuplicates: % -> % if S has BasicType
- from Collection S
- reverse!: % -> %
- from LinearAggregate S
- reverse: % -> %
- from LinearAggregate S
- rightTrim: (%, S) -> % if S has BasicType
- from LinearAggregate S
- sample: %
- from Aggregate
- select: (S -> Boolean, %) -> %
- from Collection S
- setelt!: (%, Integer, S) -> S
- from EltableAggregate(Integer, S)
- setelt!: (%, UniversalSegment Integer, S) -> S
- from LinearAggregate S
- 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

CoercibleTo OutputForm if S has CoercibleTo OutputForm

Comparable if S has Comparable

ConvertibleTo InputForm if S has ConvertibleTo InputForm

Eltable(UniversalSegment Integer, %)

Evalable S if S has Evalable S and S has SetCategory

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

OrderedSet if S has OrderedSet

PartialOrder if S has OrderedSet

SetCategory if S has SetCategory