SequenceCategory RΒΆ

distro.spad line 36

A category for infinite sequences over a commutative ring. It is a 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 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
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: (%, %) -> %
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
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, %) -> %
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 nth 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)
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)
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) -> %
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
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
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)
merge: (%, %) -> % if R has OrderedSet and % 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
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) -> %
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
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
sorted?: % -> Boolean if R has OrderedSet and % has finiteAggregate
from LinearAggregate R
stream: % -> Stream R
stream(x) returns stream of entries
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
tail: % -> %
from UnaryRecursiveAggregate R
third: % -> R
from UnaryRecursiveAggregate R
value: % -> R
from RecursiveAggregate R
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

BasicType

BiModule(R, R)

CancellationAbelianMonoid

CoercibleTo OutputForm

Collection R

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

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Eltable(Integer, R)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, R)

Evalable R if R has Evalable R

HomogeneousAggregate R

IndexedAggregate(Integer, R)

InnerEvalable(R, R) if R has Evalable R

LazyStreamAggregate R

LeftModule R

LinearAggregate R

Module R

OrderedSet if R has OrderedSet and % has finiteAggregate

PartialOrder if R has OrderedSet and % has finiteAggregate

RecursiveAggregate R

RightModule R

SetCategory

StreamAggregate R

UnaryRecursiveAggregate R