# Vector RΒΆ

- R: Type

This type represents vector like objects with varying lengths and indexed by a finite segment of integers starting at 1.

- #: % -> NonNegativeInteger
- from Aggregate
- *: (%, R) -> % if R has SemiGroup
- from VectorCategory R
- *: (Integer, %) -> % if R has AbelianGroup
- from VectorCategory R
- *: (R, %) -> % if R has SemiGroup
- from VectorCategory R
- +: (%, %) -> % if R has AbelianSemiGroup
- from VectorCategory R
- -: % -> % if R has AbelianGroup
- from VectorCategory R
- -: (%, %) -> % if R has AbelianGroup
- from VectorCategory R
- <: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- <=: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- =: (%, %) -> Boolean if R has BasicType
- from BasicType
- >: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- >=: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- ~=: (%, %) -> Boolean if R has BasicType
- from BasicType
- any?: (R -> Boolean, %) -> Boolean
- from HomogeneousAggregate R
- coerce: % -> OutputForm if R has CoercibleTo OutputForm
- from CoercibleTo OutputForm
- concat: (%, %) -> %
- from LinearAggregate R
- concat: (%, R) -> %
- from LinearAggregate R
- concat: (R, %) -> %
- from LinearAggregate R
- concat: List % -> %
- from LinearAggregate R
- construct: List R -> %
- from Collection R
- convert: % -> InputForm if R has ConvertibleTo InputForm
- from ConvertibleTo InputForm
- copy: % -> %
- from Aggregate
- copyInto!: (%, %, Integer) -> %
- from LinearAggregate R
- count: (R -> Boolean, %) -> NonNegativeInteger
- from HomogeneousAggregate R
- count: (R, %) -> NonNegativeInteger if R has BasicType
- from HomogeneousAggregate R
- cross: (%, %) -> % if R has Ring
- from VectorCategory R
- delete: (%, Integer) -> %
- from LinearAggregate R
- delete: (%, UniversalSegment Integer) -> %
- from LinearAggregate R
- dot: (%, %) -> R if R has SemiRng and R has AbelianMonoid
- from VectorCategory R
- elt: (%, Integer) -> R
- from Eltable(Integer, R)
- elt: (%, Integer, R) -> R
- from EltableAggregate(Integer, R)
- elt: (%, UniversalSegment Integer) -> %
- from Eltable(UniversalSegment Integer, %)
- empty: () -> %
- from Aggregate
- empty?: % -> Boolean
- from Aggregate
- entries: % -> List R
- from IndexedAggregate(Integer, R)
- entry?: (R, %) -> Boolean if R has BasicType
- from IndexedAggregate(Integer, R)
- eq?: (%, %) -> Boolean
- from Aggregate
- eval: (%, Equation R) -> % if R has SetCategory and R has Evalable R
- from Evalable R
- eval: (%, List Equation R) -> % if R has SetCategory and R has Evalable R
- from Evalable R
- eval: (%, List R, List R) -> % if R has SetCategory and R has Evalable R
- from InnerEvalable(R, R)
- eval: (%, R, R) -> % if R has SetCategory and R has Evalable R
- from InnerEvalable(R, R)
- every?: (R -> Boolean, %) -> Boolean
- from HomogeneousAggregate R
- fill!: (%, R) -> %
- from IndexedAggregate(Integer, R)
- find: (R -> Boolean, %) -> Union(R, failed)
- from Collection R
- first: % -> R
- from IndexedAggregate(Integer, R)
- first: (%, NonNegativeInteger) -> %
- from LinearAggregate R
- hash: % -> SingleInteger if R has SetCategory
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState if R has SetCategory
- from SetCategory
- index?: (Integer, %) -> Boolean
- from IndexedAggregate(Integer, R)
- indices: % -> List Integer
- from IndexedAggregate(Integer, R)
- insert: (%, %, Integer) -> %
- from LinearAggregate R
- insert: (R, %, Integer) -> %
- from LinearAggregate R
- latex: % -> String if R has SetCategory
- from SetCategory
- leftTrim: (%, R) -> % if R has BasicType
- from LinearAggregate R
- length: % -> R if R has RadicalCategory and R has Ring
- from VectorCategory R
- less?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- map!: (R -> R, %) -> %
- from HomogeneousAggregate R
- map: ((R, R) -> R, %, %) -> %
- from LinearAggregate R
- map: (R -> R, %) -> %
- from HomogeneousAggregate R
- max: (%, %) -> % if R has OrderedSet
- from OrderedSet
- maxIndex: % -> Integer
- from IndexedAggregate(Integer, R)
- member?: (R, %) -> Boolean if R has BasicType
- from HomogeneousAggregate R
- members: % -> List R
- from HomogeneousAggregate R
- merge: (%, %) -> % if R has OrderedSet
- from LinearAggregate R
- merge: ((R, R) -> Boolean, %, %) -> %
- from LinearAggregate R
- min: (%, %) -> % if R has OrderedSet
- from OrderedSet
- minIndex: % -> Integer
- from IndexedAggregate(Integer, R)
- more?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- new: (NonNegativeInteger, R) -> %
- from LinearAggregate R
- outerProduct: (%, %) -> Matrix R if R has Ring
- from VectorCategory R
- parts: % -> List R
- from HomogeneousAggregate R
- position: (R -> Boolean, %) -> Integer
- from LinearAggregate R
- position: (R, %) -> Integer if R has BasicType
- from LinearAggregate R
- position: (R, %, Integer) -> Integer if R has BasicType
- from LinearAggregate R
- qelt: (%, Integer) -> R
- from EltableAggregate(Integer, R)
- qsetelt!: (%, Integer, R) -> R
- from EltableAggregate(Integer, R)
- reduce: ((R, R) -> R, %) -> R
- from Collection R
- reduce: ((R, R) -> R, %, R) -> R
- from Collection R
- reduce: ((R, R) -> R, %, R, R) -> R if R has BasicType
- from Collection R
- remove: (R -> Boolean, %) -> %
- from Collection R
- remove: (R, %) -> % if R has BasicType
- from Collection R
- removeDuplicates: % -> % if R has BasicType
- from Collection R
- reverse!: % -> %
- from LinearAggregate R
- reverse: % -> %
- from LinearAggregate R
- rightTrim: (%, R) -> % if R has BasicType
- from LinearAggregate R
- sample: %
- from Aggregate
- select: (R -> Boolean, %) -> %
- from Collection R
- setelt!: (%, Integer, R) -> R
- from EltableAggregate(Integer, R)
- setelt!: (%, UniversalSegment Integer, R) -> R
- from LinearAggregate R
- size?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- smaller?: (%, %) -> Boolean if R has Comparable
- from Comparable
- sort!: % -> % if R has OrderedSet
- from LinearAggregate R
- sort!: ((R, R) -> Boolean, %) -> %
- from LinearAggregate R
- sort: % -> % if R has OrderedSet
- from LinearAggregate R
- sort: ((R, R) -> Boolean, %) -> %
- from LinearAggregate R
- sorted?: % -> Boolean if R has OrderedSet
- from LinearAggregate R
- sorted?: ((R, R) -> Boolean, %) -> Boolean
- from LinearAggregate R
- swap!: (%, Integer, Integer) -> Void
- from IndexedAggregate(Integer, R)
- trim: (%, R) -> % if R has BasicType
- from LinearAggregate R

- vector: List R -> %
`vector(l)`

converts the list`l`

to a vector.- zero: NonNegativeInteger -> % if R has AbelianMonoid
- from VectorCategory R
- zero?: % -> Boolean if R has AbelianMonoid
- from VectorCategory R

CoercibleTo OutputForm if R has CoercibleTo OutputForm

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Eltable(UniversalSegment Integer, %)

Evalable R if R has SetCategory and R has Evalable R

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

OneDimensionalArrayAggregate R

OrderedSet if R has OrderedSet

PartialOrder if R has OrderedSet

SetCategory if R has SetCategory