# SequenceCategory RΒΆ

distro.spad line 2 [edit on github]

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 % has finiteAggregate and R has OrderedSet
from PartialOrder

- <: (%, %) -> Boolean if % has finiteAggregate and R has OrderedSet
from PartialOrder

- >=: (%, %) -> Boolean if % has finiteAggregate and R has OrderedSet
from PartialOrder

- >: (%, %) -> Boolean if % has finiteAggregate and R has OrderedSet
from PartialOrder

- 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!: List % -> % 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

- 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

- entries: % -> List R
from IndexedAggregate(Integer, R)

- entry?: (R, %) -> Boolean if % has finiteAggregate
from IndexedAggregate(Integer, R)

- 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 if % has finiteAggregate and R has Hashable
from Hashable

- hashUpdate!: (HashState, %) -> HashState if % has finiteAggregate and 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

- 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: % -> R if % has finiteAggregate and R has OrderedSet
from HomogeneousAggregate R

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

- max: ((R, R) -> Boolean, %) -> R if % has finiteAggregate
from HomogeneousAggregate R

- 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 % has finiteAggregate and R has OrderedSet
from LinearAggregate R

- merge: ((R, R) -> Boolean, %, %) -> % if % has finiteAggregate
from LinearAggregate R

- min: % -> R if % has finiteAggregate and R has OrderedSet
from HomogeneousAggregate R

- min: (%, %) -> % if % has finiteAggregate and R has OrderedSet
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

- 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 % has finiteAggregate and R has OrderedSet or R has Comparable and % has finiteAggregate
from Comparable

- sort!: % -> % if % has shallowlyMutable and % has finiteAggregate and R has OrderedSet
from LinearAggregate R

- sort!: ((R, R) -> Boolean, %) -> % if % has shallowlyMutable and % has finiteAggregate
from LinearAggregate R

- sort: % -> % if % has finiteAggregate and R has OrderedSet
from LinearAggregate R

- sort: ((R, R) -> Boolean, %) -> % if % has finiteAggregate
from LinearAggregate R

- sorted?: % -> Boolean if % has finiteAggregate and R has OrderedSet
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)

- 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 % has finiteAggregate and R has OrderedSet

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Eltable(UniversalSegment Integer, %)

Evalable R if R has Evalable R

Hashable if % has finiteAggregate and R has Hashable

InnerEvalable(R, R) if R has Evalable R

Module R

OrderedSet if % has finiteAggregate and R has OrderedSet

PartialOrder if % has finiteAggregate and R has OrderedSet