# Sequence RΒΆ

distro.spad line 41 [edit on github]

A domain for infinite sequences over a commutative ring. It is implemented as stream with arithmetics.

- 0: %
from AbelianMonoid

- *: (%, 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

- apply: (%, Partition) -> R
from SequenceCategory R

- child?: (%, %) -> Boolean
from RecursiveAggregate R

- children: % -> List %
from RecursiveAggregate R

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Stream R -> %
from SequenceCategory R

- complete: % -> %
from LazyStreamAggregate R

- concat: (%, %) -> %
from LinearAggregate R

- concat: (%, R) -> %
from LinearAggregate R

- concat: (R, %) -> %
from LinearAggregate R

- concat: List % -> %
from LinearAggregate R

- cons: (R, %) -> %
from SequenceCategory R

- 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

- cycleEntry: % -> %
from UnaryRecursiveAggregate R

- cycleLength: % -> NonNegativeInteger
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, %) -> %
from SequenceCategory R

- distance: (%, %) -> Integer
from RecursiveAggregate R

- elt: (%, first) -> R
from UnaryRecursiveAggregate R

- elt: (%, Integer) -> R
from SequenceCategory R

- 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)

- 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)

- explicitEntries?: % -> Boolean
from LazyStreamAggregate R

- explicitlyEmpty?: % -> Boolean
from LazyStreamAggregate R

- explicitlyFinite?: % -> Boolean
from StreamAggregate R

- extend: (%, Integer) -> %
from LazyStreamAggregate R

- find: (R -> Boolean, %) -> Union(R, failed)
from Collection R

- first: % -> R
from IndexedAggregate(Integer, R)

- first: (%, NonNegativeInteger) -> %
from SequenceCategory R

- firstn: (%, NonNegativeInteger) -> List R
from SequenceCategory R

- 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

- less?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- 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

- maxIndex: % -> Integer
from IndexedAggregate(Integer, R)

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

- possiblyInfinite?: % -> Boolean
from StreamAggregate R

- qelt: (%, Integer) -> R
from EltableAggregate(Integer, R)

- remove: (R -> Boolean, %) -> %
from LazyStreamAggregate R

- rest: % -> %
from UnaryRecursiveAggregate R

- rest: (%, NonNegativeInteger) -> %
from UnaryRecursiveAggregate R

- reverse!: % -> % if % has shallowlyMutable and % 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) -> %
from SequenceCategory R

- sequence: Stream R -> %
from SequenceCategory R

- size?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- smaller?: (%, %) -> Boolean if R has Comparable and % has finiteAggregate or % has finiteAggregate and R has OrderedSet
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

- sorted?: % -> Boolean if % has finiteAggregate and R has OrderedSet
from LinearAggregate R

- stream: % -> Stream R
from SequenceCategory R

- subtractIfCan: (%, %) -> Union(%, failed)

- tail: % -> %
from UnaryRecursiveAggregate R

- third: % -> R
from UnaryRecursiveAggregate R

- value: % -> R
from RecursiveAggregate R

- zero?: % -> Boolean
from AbelianMonoid

BiModule(R, R)

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

PartialOrder if % has finiteAggregate and R has OrderedSet