QEtaComputation(C, F, AB, R)

qetasamba.spad line 788 [edit on github]

QEtaComputation implements a variant of the algorithm Samba from an article of Ralf Hemmecke: “Dancing Samba with Ramanujan Partition Congruences” (Journal of Symbolic Computation). doi:10.1016/j.jsc.2017.02.001 http://www.risc.jku.at/publications/download/risc_5338/DancingSambaRamanujan.pdf In this variant, the critical elements are the basis elements that became reducible and products of basis elements. Products are kept as pairs and will only be evaluated when the critical element is considered. The pairs are only computed (and considered as critical elements) when there are no reducible basis elements left to consider.

addBasisElementPairs!: (F, List F, %) -> Void

addBasisElementPairs!(u, basis, x) adds all pairs (u, b) for each element in the given list.

addGapPair!: (F, F, F, XHashTable(Integer, List Record(f1: F, f2: F))) -> XHashTable(Integer, List Record(f1: F, f2: F))

addGapPair!(t, f1, f2, p) adds the pair (t^j, f1) to p where the j>0 is chosen in such a way that qetaGrade(t^j*f1) = qetaGrade(f2). It is assumed that the input is such that j is an integer. If j=0 then nothing is added.

addGapPairs!: % -> Void

addGapPairs!(x) adds gap-pair for every pair in the current basis that differ in qetaGrade by a multiple of qetaGrade(t) where t = multiplier(algebraBasis x).

addPair!: (F, F, XHashTable(Integer, List Record(f1: F, f2: F))) -> XHashTable(Integer, List Record(f1: F, f2: F))

addPair!(f1, f2, p) adds the pair (f1,f2) to the list corresponding to p.qetaGrade(f1*f2).

algebraBasis: % -> AB

from QEtaComputationCategory(F, AB)

basis: % -> List F

basis x returns basis(algebraBasis x).

coerce: % -> OutputForm

from CoercibleTo OutputForm

computePairs!: % -> Void

computePairs!(x) discards all previously computed pairs and then computes all the n*(n+1)/2 (commutative) pairs of the current elements of the basis and additionally adds all the gap-pairs where n is the number of basis elements.

criticalElements?: % -> Boolean

from QEtaComputationCategory(F, AB)

extractNext!: % -> F

from QEtaComputationCategory(F, AB)

initialize: List F -> %

from QEtaComputationCategory(F, AB)

noTrace: % -> Void

from QEtaComputationCategory(F, AB)

oneStep!: % -> %

from QEtaComputationCategory(F, AB)

oneStepComputation!: (%, % -> F) -> %

from QEtaComputationCategory(F, AB)

oneTracedStep!: (% -> Void, (F, AB) -> Void, F -> Void, F -> Void) -> % -> %

from QEtaComputationCategory(F, AB)

oneTracedStepComputation!: (% -> Void, (F, AB) -> Void, F -> Void, F -> Void) -> (%, % -> F) -> %

from QEtaComputationCategory(F, AB)

oneVerboseStep!: (NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger) -> % -> %

oneVerboseStep!(ny, n0, nl, nr) is equivalent with oneTracedStep!(trace ny, traceEnter(n0)$R, traceLoop(nl)$R, traceReturn(nr)$R).

postProcess!: % -> %

from QEtaComputationCategory(F, AB)

trace: NonNegativeInteger -> % -> Void

from QEtaComputationCategory(F, AB)

update!: (F, %) -> %

update!(u, x) adds a new basis element and updates the critical elements accordingly. Note that older basis elements might become critical elements in this process.

CoercibleTo OutputForm

QEtaComputationCategory(F, AB)