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

from PartialOrder

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

from PartialOrder

=: (%, %) -> Boolean

from BasicType

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

from PartialOrder

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

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
coerce: Stream R -> %

`coerce(x)` creation of elements

complete: % -> %

from LazyStreamAggregate R

concat!: (%, %) -> % if % has shallowlyMutable
concat!: (%, R) -> % if % has shallowlyMutable
concat!: List % -> % if % has shallowlyMutable
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
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: % -> %
cycleLength: % -> NonNegativeInteger
cycleSplit!: % -> % if % has shallowlyMutable
cycleTail: % -> %
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
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
elt: (%, rest) -> %
elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

elt: (%, value) -> R

from RecursiveAggregate R

empty?: % -> Boolean

from Aggregate

empty: () -> %

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 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
last: (%, NonNegativeInteger) -> %
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

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
qsetrest!: (%, %) -> % if % has shallowlyMutable
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: % -> %
rest: (%, NonNegativeInteger) -> %
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
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
setelt!: (%, Integer, R) -> R if % has shallowlyMutable

from EltableAggregate(Integer, R)

setelt!: (%, last, R) -> R if % has shallowlyMutable
setelt!: (%, rest, %) -> % if % has shallowlyMutable
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
setlast!: (%, R) -> R if % has shallowlyMutable
setrest!: (%, %) -> % if % has shallowlyMutable
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
stream: % -> Stream R

`stream(x)` returns stream of entries

subtractIfCan: (%, %) -> Union(%, failed)
swap!: (%, Integer, Integer) -> Void if % has shallowlyMutable

from IndexedAggregate(Integer, R)

tail: % -> %
third: % -> R
trim: (%, R) -> % if % has finiteAggregate

from LinearAggregate R

value: % -> R

from RecursiveAggregate R

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

BasicType

BiModule(R, R)

CancellationAbelianMonoid

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

Eltable(Integer, R)

Evalable R if R has Evalable R

Hashable if % has finiteAggregate and R has Hashable

InnerEvalable(R, R) if R has Evalable R

OrderedSet if % has finiteAggregate and R has OrderedSet

PartialOrder if % has finiteAggregate and R has OrderedSet

SetCategory