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

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

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

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

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

empty?: % -> Boolean

from Aggregate

empty: () -> %

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

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

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

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)

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

PartialOrder if % has finiteAggregate and R has OrderedSet

RecursiveAggregate R

RightModule R

SequenceCategory R

SetCategory

StreamAggregate R

UnaryRecursiveAggregate R