# Vector RΒΆ

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
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
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 AbelianMonoid and R has SemiRng

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?: % -> Boolean

from Aggregate

empty: () -> %

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 Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if R has Hashable

from Hashable

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: % -> R if R has OrderedSet

from HomogeneousAggregate R

max: (%, %) -> % if R has OrderedSet

from OrderedSet

max: ((R, R) -> Boolean, %) -> R

from HomogeneousAggregate R

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: % -> R if R has OrderedSet

from HomogeneousAggregate 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?: % -> Boolean if R has AbelianMonoid

from VectorCategory R

zero: NonNegativeInteger -> % if R has AbelianMonoid

from VectorCategory R

Aggregate

BasicType if R has BasicType

Comparable if R has Comparable

Eltable(Integer, R)

Evalable R if R has SetCategory and R has Evalable R

finiteAggregate

Hashable if R has Hashable

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

OrderedSet if R has OrderedSet

PartialOrder if R has OrderedSet

SetCategory if R has SetCategory

shallowlyMutable