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 : Mapping(Stream(UnivariateFormalPowerSeries(F)), UnivariateFormalPowerSeries(F)), guessModGen : Mapping(Mapping(Vector(U32Vector), List(U32Vector), Integer, Integer), NonNegativeInteger), testGen : Mapping(Mapping(Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F, NonNegativeInteger))), UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F, NonNegativeInteger))), List(PositiveInteger)), exprStream : Mapping(Stream(EXPRR), EXPRR, Symbol), kind : Symbol, qvar : Symbol, A : Mapping(S, NonNegativeInteger, NonNegativeInteger, SparseUnivariatePolynomial(S)), AF : Mapping(SparseMultivariatePolynomial(F, NonNegativeInteger), NonNegativeInteger, NonNegativeInteger, UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F, NonNegativeInteger))), AX : Mapping(EXPRR, NonNegativeInteger, Symbol, EXPRR), C : Mapping(List(S), NonNegativeInteger))

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

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

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

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

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

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.

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(Mapping(List(EXPRR), List(F), List(GuessOption))), 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(Mapping(List(EXPRR), List(F), List(GuessOption))), 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.

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 : (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 : Symbol -> Mapping(List(EXPRR), List(F), List(GuessOption)) 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(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).

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.

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.

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.

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 : (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 : Symbol -> Mapping(List(EXPRR), List(F), List(GuessOption)) 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(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 : (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 : Symbol -> Mapping(List(EXPRR), List(F), List(GuessOption)) 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(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.

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.

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 : (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 : Symbol -> Mapping(List(EXPRR), List(F), List(GuessOption)) 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.

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 : (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 : Symbol -> Mapping(List(EXPRR), List(F), List(GuessOption)) 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.

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.

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

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

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

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

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

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