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

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

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

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 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?: % -> 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

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

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

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

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

BasicType

BiModule(R, R)

CancellationAbelianMonoid

CoercibleTo OutputForm

Collection R

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

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Eltable(Integer, R)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, R)

Evalable R if R has Evalable R

Hashable if % has finiteAggregate and R has Hashable

HomogeneousAggregate R

IndexedAggregate(Integer, R)

InnerEvalable(R, R) if R has Evalable R

LazyStreamAggregate R

LeftModule R

LinearAggregate R

Module R

OrderedSet if % has finiteAggregate and R has OrderedSet

PartialOrder if % has finiteAggregate and R has OrderedSet

RecursiveAggregate R

RightModule R

SetCategory

StreamAggregate R

UnaryRecursiveAggregate R