Sequence(R)

distro.spad line 41 [edit on github]

• R : CommutativeRing

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

* : (%, R) -> %

from RightModule(R)

* : (R, %) -> %

from LeftModule(R)

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

0 : () -> %

from AbelianMonoid

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

apply : (%, Partition) -> R

from SequenceCategory(R)

child? : (%, %) -> Boolean

from RecursiveAggregate(R)

children : % -> List(%)

from RecursiveAggregate(R)

coerce : Stream(R) -> %

from SequenceCategory(R)

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

complete : % -> %

from LazyStreamAggregate(R)

concat : (%, %) -> %

from UnaryRecursiveAggregate(R)

concat : (%, R) -> %

from LinearAggregate(R)

concat : (R, %) -> %

from UnaryRecursiveAggregate(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 finiteAggregate and % has shallowlyMutable

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 : (%, "rest") -> %

from UnaryRecursiveAggregate(R)

elt : (%, UniversalSegment(Integer)) -> %

from Eltable(UniversalSegment(Integer), %)

elt : (%, "first") -> R

from UnaryRecursiveAggregate(R)

elt : (%, "last") -> R

from UnaryRecursiveAggregate(R)

elt : (%, "value") -> R

from RecursiveAggregate(R)

elt : (%, Integer) -> R

from SequenceCategory(R)

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

from EltableAggregate(Integer, R)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(R)

from IndexedAggregate(Integer, R)

eq? : (%, %) -> Boolean

from Aggregate

eval : (%, R, R) -> % if R has Evalable(R)

from InnerEvalable(R, R)

eval : (%, 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 : (%, List(Equation(R))) -> % if R has Evalable(R)

from Evalable(R)

explicitEntries? : % -> Boolean

from LazyStreamAggregate(R)

explicitlyEmpty? : % -> Boolean

from LazyStreamAggregate(R)

explicitlyFinite? : % -> Boolean

from StreamAggregate(R)

extend : (%, Integer) -> %

from LazyStreamAggregate(R)

find : (Mapping(Boolean, R), %) -> Union(R, "failed")

from Collection(R)

first : (%, NonNegativeInteger) -> %

from SequenceCategory(R)

first : % -> R

from UnaryRecursiveAggregate(R)

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

from SequenceCategory(R)

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

from UnaryRecursiveAggregate(R)

last : % -> R

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 : (Mapping(R, R), %) -> %

from HomogeneousAggregate(R)

map : (Mapping(R, R, R), %, %) -> %

from LinearAggregate(R)

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

from OrderedSet

max : % -> R if % has finiteAggregate and R has OrderedSet

from HomogeneousAggregate(R)

maxIndex : % -> Integer

from IndexedAggregate(Integer, R)

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

from LinearAggregate(R)

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

from OrderedSet

min : % -> R if % has finiteAggregate and R has OrderedSet

from HomogeneousAggregate(R)

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 : (Mapping(Boolean, R), %) -> %

from LazyStreamAggregate(R)

rest : % -> %

from UnaryRecursiveAggregate(R)

rest : (%, NonNegativeInteger) -> %

from UnaryRecursiveAggregate(R)

reverse! : % -> % if % has finiteAggregate and % has shallowlyMutable

from LinearAggregate(R)

rst : % -> %

from LazyStreamAggregate(R)

sample : () -> %

from AbelianMonoid

second : % -> R

from UnaryRecursiveAggregate(R)

select : (Mapping(Boolean, R), %) -> %

from LazyStreamAggregate(R)

sequence : (Mapping(R, R), R) -> %

from SequenceCategory(R)

sequence : Stream(R) -> %

from SequenceCategory(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 finiteAggregate and R has OrderedSet

from LinearAggregate(R)

sort! : % -> % if % has finiteAggregate and R has OrderedSet and % has shallowlyMutable

from LinearAggregate(R)

sort! : (Mapping(Boolean, R, R), %) -> % if % has finiteAggregate and % has shallowlyMutable

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

~= : (%, %) -> Boolean

from BasicType

LeftModule(R)

Evalable(R)

ConvertibleTo(InputForm)

Collection(R)

BiModule(R, R)

OrderedSet

RightModule(R)

RecursiveAggregate(R)

LazyStreamAggregate(R)

EltableAggregate(Integer, R)

Module(R)

StreamAggregate(R)

PartialOrder

InnerEvalable(R, R)

Aggregate

Eltable(UniversalSegment(Integer), %)

CancellationAbelianMonoid

AbelianMonoid

UnaryRecursiveAggregate(R)

Comparable

Hashable

SequenceCategory(R)

HomogeneousAggregate(R)

CoercibleTo(OutputForm)

LinearAggregate(R)

BasicType

IndexedAggregate(Integer, R)

AbelianSemiGroup

SetCategory

Eltable(Integer, R)

AbelianGroup