# SequenceCategory RΒΆ

A category for infinite sequences over a commutative ring. It is a stream with arithmetics.

- 0: %
- from AbelianMonoid
- #: % -> NonNegativeInteger if % has finiteAggregate
- from Aggregate
- *: (%, R) -> %
- from RightModule R
- *: (Integer, %) -> %
- from AbelianGroup
- *: (NonNegativeInteger, %) -> %
- from AbelianMonoid
- *: (PositiveInteger, %) -> %
- from AbelianSemiGroup
- *: (R, %) -> %
- from LeftModule R
- +: (%, %) -> %
- from AbelianSemiGroup
- -: % -> %
- from AbelianGroup
- -: (%, %) -> %
- from AbelianGroup
- <: (%, %) -> Boolean if R has OrderedSet and % has finiteAggregate
- from PartialOrder
- <=: (%, %) -> Boolean if R has OrderedSet and % has finiteAggregate
- from PartialOrder
- =: (%, %) -> Boolean
- from BasicType
- >: (%, %) -> Boolean if R has OrderedSet and % has finiteAggregate
- from PartialOrder
- >=: (%, %) -> Boolean if R has OrderedSet and % has finiteAggregate
- from PartialOrder
- ~=: (%, %) -> Boolean
- from BasicType
- any?: (R -> Boolean, %) -> Boolean if % has finiteAggregate
- from HomogeneousAggregate R

- apply: (%, Partition) -> R
`elt(mm, pi)`

returns the product of the entries indexed by the integer partition`pi`

(as in partitionend moments)- child?: (%, %) -> Boolean
- from RecursiveAggregate R
- children: % -> List %
- from RecursiveAggregate R
- coerce: % -> OutputForm
- from CoercibleTo OutputForm

- coerce: Stream R -> %
`coerce(x)`

creation of elements- complete: % -> %
- from LazyStreamAggregate R
- concat!: (%, %) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- concat!: (%, R) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- concat: (%, %) -> %
- from LinearAggregate R
- concat: (%, R) -> %
- from LinearAggregate R
- concat: (R, %) -> %
- from LinearAggregate R
- concat: List % -> %
- from LinearAggregate R

- cons: (R, %) -> %
`cons(r, s)`

prepends`r`

to the stream`s`

- construct: List R -> %
- from Collection R
- convert: % -> InputForm if R has ConvertibleTo InputForm
- from ConvertibleTo InputForm
- copy: % -> %
- from Aggregate
- copyInto!: (%, %, Integer) -> % if % has shallowlyMutable and % has finiteAggregate
- from LinearAggregate R
- count: (R -> Boolean, %) -> NonNegativeInteger if % has finiteAggregate
- from HomogeneousAggregate R
- count: (R, %) -> NonNegativeInteger if % has finiteAggregate
- from HomogeneousAggregate R
- cycleEntry: % -> %
- from UnaryRecursiveAggregate R
- cycleLength: % -> NonNegativeInteger
- from UnaryRecursiveAggregate R
- cycleSplit!: % -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- cycleTail: % -> %
- from UnaryRecursiveAggregate R
- cyclic?: % -> Boolean
- from RecursiveAggregate R
- delete: (%, Integer) -> %
- from LinearAggregate R
- delete: (%, UniversalSegment Integer) -> %
- from LinearAggregate R

- dilate: (R, %) -> %
`dilate(a, x)`

returns the sequence $a^n`x_n`

$ (starting at $`n=1`

$)- distance: (%, %) -> Integer
- from RecursiveAggregate R
- elt: (%, first) -> R
- from UnaryRecursiveAggregate R

- elt: (%, Integer) -> R
`elt(mm, n)`

returns the`n`

th element of a sequence.- elt: (%, Integer, R) -> R
- from EltableAggregate(Integer, R)
- elt: (%, last) -> R
- from UnaryRecursiveAggregate R
- elt: (%, rest) -> %
- from UnaryRecursiveAggregate R
- elt: (%, UniversalSegment Integer) -> %
- from Eltable(UniversalSegment Integer, %)
- elt: (%, value) -> R
- from RecursiveAggregate R
- empty: () -> %
- from Aggregate
- empty?: % -> Boolean
- from Aggregate
- entries: % -> List R
- from IndexedAggregate(Integer, R)
- entry?: (R, %) -> Boolean if % has finiteAggregate
- from IndexedAggregate(Integer, R)
- eq?: (%, %) -> Boolean
- from Aggregate
- eval: (%, Equation R) -> % if R has Evalable R
- from Evalable R
- eval: (%, List Equation R) -> % if R has Evalable R
- from Evalable R
- eval: (%, List R, List R) -> % if R has Evalable R
- from InnerEvalable(R, R)
- eval: (%, R, R) -> % if R has Evalable R
- from InnerEvalable(R, R)
- every?: (R -> Boolean, %) -> Boolean if % has finiteAggregate
- from HomogeneousAggregate R
- explicitEntries?: % -> Boolean
- from LazyStreamAggregate R
- explicitlyEmpty?: % -> Boolean
- from LazyStreamAggregate R
- explicitlyFinite?: % -> Boolean
- from StreamAggregate R
- extend: (%, Integer) -> %
- from LazyStreamAggregate R
- fill!: (%, R) -> % if % has shallowlyMutable
- from IndexedAggregate(Integer, R)
- find: (R -> Boolean, %) -> Union(R, failed)
- from Collection R
- first: % -> R
- from IndexedAggregate(Integer, R)

- first: (%, NonNegativeInteger) -> %
`first(x, n)`

returns the sequence of the first`n`

entries

- firstn: (%, NonNegativeInteger) -> List R
`firstn(x, n)`

returns a list of the first`n`

entries- frst: % -> R
- from LazyStreamAggregate R
- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- 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
- last: % -> R
- from UnaryRecursiveAggregate R
- last: (%, NonNegativeInteger) -> %
- from UnaryRecursiveAggregate R
- latex: % -> String
- from SetCategory
- lazy?: % -> Boolean
- from LazyStreamAggregate R
- lazyEvaluate: % -> %
- from LazyStreamAggregate R
- leaf?: % -> Boolean
- from RecursiveAggregate R
- leaves: % -> List R
- from RecursiveAggregate R
- leftTrim: (%, R) -> % if % has finiteAggregate
- from LinearAggregate R
- less?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- map!: (R -> R, %) -> % if % has shallowlyMutable
- from HomogeneousAggregate R
- map: ((R, R) -> R, %, %) -> %
- from LinearAggregate R
- map: (R -> R, %) -> %
- from HomogeneousAggregate R
- max: (%, %) -> % if R has OrderedSet and % has finiteAggregate
- from OrderedSet
- maxIndex: % -> Integer
- from IndexedAggregate(Integer, R)
- member?: (R, %) -> Boolean if % has finiteAggregate
- from HomogeneousAggregate R
- members: % -> List R if % has finiteAggregate
- from HomogeneousAggregate R
- merge: (%, %) -> % if R has OrderedSet and % has finiteAggregate
- from LinearAggregate R
- merge: ((R, R) -> Boolean, %, %) -> % if % has finiteAggregate
- from LinearAggregate R
- min: (%, %) -> % if R has OrderedSet and % has finiteAggregate
- from OrderedSet
- minIndex: % -> Integer
- from IndexedAggregate(Integer, R)
- more?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- new: (NonNegativeInteger, R) -> %
- from LinearAggregate R
- node?: (%, %) -> Boolean
- from RecursiveAggregate R
- nodes: % -> List %
- from RecursiveAggregate R
- numberOfComputedEntries: % -> NonNegativeInteger
- from LazyStreamAggregate R
- opposite?: (%, %) -> Boolean
- from AbelianMonoid
- parts: % -> List R if % has finiteAggregate
- from HomogeneousAggregate R
- position: (R -> Boolean, %) -> Integer if % has finiteAggregate
- from LinearAggregate R
- position: (R, %) -> Integer if % has finiteAggregate
- from LinearAggregate R
- position: (R, %, Integer) -> Integer if % has finiteAggregate
- from LinearAggregate R
- possiblyInfinite?: % -> Boolean
- from StreamAggregate R
- qelt: (%, Integer) -> R
- from EltableAggregate(Integer, R)
- qsetelt!: (%, Integer, R) -> R if % has shallowlyMutable
- from EltableAggregate(Integer, R)
- qsetfirst!: (%, R) -> R if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- qsetrest!: (%, %) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- reduce: ((R, R) -> R, %) -> R if % has finiteAggregate
- from Collection R
- reduce: ((R, R) -> R, %, R) -> R if % has finiteAggregate
- from Collection R
- reduce: ((R, R) -> R, %, R, R) -> R if % has finiteAggregate
- from Collection R
- remove: (R -> Boolean, %) -> %
- from LazyStreamAggregate R
- remove: (R, %) -> % if % has finiteAggregate
- from Collection R
- removeDuplicates: % -> % if % has finiteAggregate
- from Collection R
- rest: % -> %
- from UnaryRecursiveAggregate R
- rest: (%, NonNegativeInteger) -> %
- from UnaryRecursiveAggregate R
- reverse!: % -> % if % has shallowlyMutable and % has finiteAggregate
- from LinearAggregate R
- reverse: % -> % if % has finiteAggregate
- from LinearAggregate R
- rightTrim: (%, R) -> % if % has finiteAggregate
- from LinearAggregate R
- rst: % -> %
- from LazyStreamAggregate R
- sample: %
- from AbelianMonoid
- second: % -> R
- from UnaryRecursiveAggregate R
- select: (R -> Boolean, %) -> %
- from LazyStreamAggregate R

- sequence: (R -> R, R) -> %
`sequence(f, s0)`

generates a stream recursively by applying the function`f:`

`S`

`->`

`S`

to the last computed value.

- sequence: Stream R -> %
`sequence(x)`

turns the stream`x`

into a sequence- setchildren!: (%, List %) -> % if % has shallowlyMutable
- from RecursiveAggregate R
- setelt!: (%, first, R) -> R if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setelt!: (%, Integer, R) -> R if % has shallowlyMutable
- from EltableAggregate(Integer, R)
- setelt!: (%, last, R) -> R if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setelt!: (%, rest, %) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setelt!: (%, UniversalSegment Integer, R) -> R if % has shallowlyMutable
- from LinearAggregate R
- setelt!: (%, value, R) -> R if % has shallowlyMutable
- from RecursiveAggregate R
- setfirst!: (%, R) -> R if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setlast!: (%, R) -> R if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setrest!: (%, %) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R
- setvalue!: (%, R) -> R if % has shallowlyMutable
- from RecursiveAggregate R
- size?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- smaller?: (%, %) -> Boolean if R has Comparable and % has finiteAggregate or R has OrderedSet and % has finiteAggregate
- from Comparable
- sort!: % -> % if R has OrderedSet and % has shallowlyMutable and % has finiteAggregate
- from LinearAggregate R
- sort!: ((R, R) -> Boolean, %) -> % if % has shallowlyMutable and % has finiteAggregate
- from LinearAggregate R
- sort: % -> % if R has OrderedSet and % has finiteAggregate
- from LinearAggregate R
- sort: ((R, R) -> Boolean, %) -> % if % has finiteAggregate
- from LinearAggregate R
- sorted?: % -> Boolean if R has OrderedSet and % has finiteAggregate
- from LinearAggregate R
- sorted?: ((R, R) -> Boolean, %) -> Boolean if % has finiteAggregate
- from LinearAggregate R
- split!: (%, NonNegativeInteger) -> % if % has shallowlyMutable
- from UnaryRecursiveAggregate R

- stream: % -> Stream R
`stream(x)`

returns stream of entries- subtractIfCan: (%, %) -> Union(%, failed)
- from CancellationAbelianMonoid
- swap!: (%, Integer, Integer) -> Void if % has shallowlyMutable
- from IndexedAggregate(Integer, R)
- tail: % -> %
- from UnaryRecursiveAggregate R
- third: % -> R
- from UnaryRecursiveAggregate R
- trim: (%, R) -> % if % has finiteAggregate
- from LinearAggregate R
- value: % -> R
- from RecursiveAggregate R
- zero?: % -> Boolean
- from AbelianMonoid

BiModule(R, R)

Comparable if R has Comparable and % has finiteAggregate or R has OrderedSet and % has finiteAggregate

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Eltable(UniversalSegment Integer, %)

Evalable R if R has Evalable R

InnerEvalable(R, R) if R has Evalable R

Module R

OrderedSet if R has OrderedSet and % has finiteAggregate

PartialOrder if R has OrderedSet and % has finiteAggregate