Guess(F, S, EXPRR, retract, coerce)ΒΆ

mantepse.spad line 1292 [edit on github]

This package implements guessing of sequences. Packages for the most common cases are provided as GuessInteger, GuessPolynomial, etc.

algDepHP: (List List F, List GuessOption) -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S)

algDepHP(list, options) returns a specification for Hermite-Pade approximation looking for algebraic dependencies

diffHP: List GuessOption -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S)

diffHP options returns a specification for Hermite-Pade approximation with the differential operator

diffHP: Symbol -> List GuessOption -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S) if F has RetractableTo Symbol and S has RetractableTo Symbol

diffHP options returns a specification for Hermite-Pade approximation with the $q$-dilation operator

guess: (List F, List GuessOption) -> List EXPRR

guess(l, options) applies recursively guessRat to the successive differences and quotients of the list. The given options are used.

guess: (List F, List((List F, List GuessOption) -> List EXPRR), List Symbol) -> List EXPRR

guess(l, guessers, ops) applies recursively the given guessers to the successive differences if ops contains the symbol guessSum and quotients if ops contains the symbol guessProduct to the list. Default options as described in GuessOptionFunctions0 are used.

guess: (List F, List((List F, List GuessOption) -> List EXPRR), List Symbol, List GuessOption) -> List EXPRR

guess(l, guessers, ops) applies recursively the given guessers to the successive differences if ops contains the symbol guessSum and quotients if ops contains the symbol guessProduct to the list. The given options are used.

guess: List F -> List EXPRR

guess l applies recursively guessRat to the successive differences and quotients of the list. Default options as described in GuessOptionFunctions0 are used.

guessADE: (List F, List GuessOption) -> List EXPRR

guessADE(l, options) tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by l, using the given options.

guessADE: List F -> List EXPRR

guessADE l tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by l, using the default options described in GuessOptionFunctions0.

guessADE: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessADE q returns a guesser that tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by l, using the given options.

guessAlg: (List F, List GuessOption) -> List EXPRR

guessAlg(l, options) tries to find an algebraic equation for a generating function whose first Taylor coefficients are given by l, using the given options. It is equivalent to guessADE(l, options) with maxDerivative == 0.

guessAlg: List F -> List EXPRR

guessAlg l tries to find an algebraic equation for a generating function whose first Taylor coefficients are given by l, using the default options described in GuessOptionFunctions0. It is equivalent to guessADE(l, maxDerivative == 0).

guessAlgDep: (List List F, List GuessOption) -> List EXPRR

guessAlgDep ll tries to find an algebraic dependence between several power series whose first Taylor coefficients are given by members of ll, using the given options.

guessAlgDep: List List F -> List EXPRR

guessAlgDep ll tries to find an algebraic dependence between several power series whose first Taylor coefficients are given by members of ll, using the default options described in GuessOptionFunctions0.

guessBinRat: (List F, List GuessOption) -> List EXPRR

guessBinRat(l, options) tries to find a function of the form n+->binomial(a+b n, n) r(n), where r(n) is a rational function, that fits l.

guessBinRat: List F -> List EXPRR

guessBinRat(l, options) tries to find a function of the form n+->binomial(a+b n, n) r(n), where r(n) is a rational function, that fits l.

guessBinRat: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessBinRat q returns a guesser that tries to find a function of the form n+->qbinomial(a+b n, n) r(n), where r(q^n) is a q-rational function, that fits l.

guessExpRat: (List F, List GuessOption) -> List EXPRR

guessExpRat(l, options) tries to find a function of the form n+->(a+b n)^n r(n), where r(n) is a rational function, that fits l.

guessExpRat: List F -> List EXPRR

guessExpRat l tries to find a function of the form n+->(a+b n)^n r(n), where r(n) is a rational function, that fits l.

guessExpRat: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessExpRat q returns a guesser that tries to find a function of the form n+->(a+b q^n)^n r(q^n), where r(q^n) is a q-rational function, that fits l.

guessFE: (List F, List GuessOption) -> List EXPRR

guessFE(l, options) tries to find an algebraic substitution equation for a generating function whose first Taylor coefficients are given by l, using the given options.

guessFE: List F -> List EXPRR

guessFE l tries to find an algebraic substitution equation for a generating function whose first Taylor coefficients are given by l, using the default options described in GuessOptionFunctions0.

guessHolo: (List F, List GuessOption) -> List EXPRR

guessHolo(l, options) tries to find an ordinary linear differential equation for a generating function whose first Taylor coefficients are given by l, using the given options. It is equivalent to guessADE(l, options) with maxPower == 1.

guessHolo: List F -> List EXPRR

guessHolo l tries to find an ordinary linear differential equation for a generating function whose first Taylor coefficients are given by l, using the default options described in GuessOptionFunctions0. It is equivalent to guessADE(l, maxPower == 1).

guessHolo: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessHolo q returns a guesser that tries to find a linear differential equation for a generating function whose first Taylor coefficients are given by l, using the given options.

guessPade: (List F, List GuessOption) -> List EXPRR

guessPade(l, options) tries to find a rational function whose first Taylor coefficients are given by l, using the given options. It is equivalent to guessADE(l, maxDerivative == 0, maxPower == 1, allDegrees == true).

guessPade: List F -> List EXPRR

guessPade(l, options) tries to find a rational function whose first Taylor coefficients are given by l, using the default options described in GuessOptionFunctions0. It is equivalent to guessADE(l, options) with maxDerivative == 0, maxPower == 1, allDegrees == true.

guessPRec: (List F, List GuessOption) -> List EXPRR

guessPRec(l, options) tries to find a linear recurrence with polynomial coefficients whose first values are given by l, using the given options. It is equivalent to guessRec(l, options) with maxPower == 1.

guessPRec: List F -> List EXPRR

guessPRec l tries to find a linear recurrence with polynomial coefficients whose first values are given by l, using the default options described in GuessOptionFunctions0. It is equivalent to guessRec(l, maxPower == 1).

guessPRec: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessPRec q returns a guesser that tries to find a linear q-recurrence with polynomial coefficients whose first values are given by l, using the given options. It is equivalent to guessRec(q) with maxPower == 1.

guessRat: (List F, List GuessOption) -> List EXPRR

guessRat(l, options) tries to find a rational function whose first values are given by l, using the given options. It is equivalent to guessRec(l, maxShift == 0, maxPower == 1, allDegrees == true).

guessRat: List F -> List EXPRR

guessRat l tries to find a rational function whose first values are given by l, using the default options described in GuessOptionFunctions0. It is equivalent to guessRec(l, maxShift == 0, maxPower == 1, allDegrees == true).

guessRat: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessRat q returns a guesser that tries to find a q-rational function whose first values are given by l, using the given options. It is equivalent to guessRec with (l, maxShift == 0, maxPower == 1, allDegrees == true).

guessRec: (List F, List GuessOption) -> List EXPRR

guessRec(l, options) tries to find an ordinary difference equation whose first values are given by l, using the given options.

guessRec: List F -> List EXPRR

guessRec l tries to find an ordinary difference equation whose first values are given by l, using the default options described in GuessOptionFunctions0.

guessRec: Symbol -> (List F, List GuessOption) -> List EXPRR if F has RetractableTo Symbol and S has RetractableTo Symbol

guessRec q returns a guesser that finds an ordinary q-difference equation whose first values are given by l, using the given options.

shiftHP: List GuessOption -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S)

shiftHP options returns a specification for Hermite-Pade approximation with the shift operator

shiftHP: Symbol -> List GuessOption -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S) if F has RetractableTo Symbol and S has RetractableTo Symbol

shiftHP options returns a specification for Hermite-Pade approximation with the $q$-shift operator, or, if maxMixedDegree > 0 for mixed shifts

substHP: List GuessOption -> Record(degreeStream: Stream NonNegativeInteger, guessStream: UnivariateFormalPowerSeries F -> Stream UnivariateFormalPowerSeries F, guessModGen: NonNegativeInteger -> (List U32Vector, Integer, Integer) -> Vector U32Vector, testGen: List PositiveInteger -> UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger) -> Vector UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger), exprStream: (EXPRR, Symbol) -> Stream EXPRR, kind: Symbol, qvar: Symbol, A: (NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial S) -> S, AF: (NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries SparseMultivariatePolynomial(F, NonNegativeInteger)) -> SparseMultivariatePolynomial(F, NonNegativeInteger), AX: (NonNegativeInteger, Symbol, EXPRR) -> EXPRR, C: NonNegativeInteger -> List S)

substHP options returns a specification for Hermite-Pade approximation with the substitution operator