Formal Power Series

Methods for computing and manipulating Formal Power Series.

class sympy.series.formal.FormalPowerSeries(*args)[source]

Represents Formal Power Series of a function.

No computation is performed. This class should only to be used to represent a series. No checks are performed.

For computing a series use fps().

See also

sympy.series.formal.fps

coeff_bell(n)[source]

self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind. Note that n should be a integer.

The second kind of Bell polynomials (are sometimes called “partial” Bell polynomials or incomplete Bell polynomials) are defined as

\[B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} \left(\frac{x_1}{1!} \right)^{j_1} \left(\frac{x_2}{2!} \right)^{j_2} \dotsb \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}.\]

  • bell(n, k, (x1, x2, ...)) gives Bell polynomials of the second kind, \(B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})\).

See also

sympy.functions.combinatorial.numbers.bell

compose(other, x=None, n=6)[source]

Returns the truncated terms of the formal power series of the composed function, up to specified \(n\).

If \(f\) and \(g\) are two formal power series of two different functions, then the coefficient sequence ak of the composed formal power series \(fp\) will be as follows.

\[\sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})\]
Parameters

n : Number, optional

Specifies the order of the term up to which the polynomial should be truncated.

Examples

>>> from sympy import fps, sin, exp
>>> from sympy.abc import x
>>> f1 = fps(exp(x))
>>> f2 = fps(sin(x))

>>> f1.compose(f2, x).truncate()
1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)

>>> f1.compose(f2, x).truncate(8)
1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8)

See also

sympy.functions.combinatorial.numbers.bell, sympy.series.formal.FormalPowerSeriesCompose

References

R644

Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.

property infinite

Returns an infinite representation of the series

integrate(x=None, **kwargs)[source]

Integrate Formal Power Series.

Examples

>>> from sympy import fps, sin, integrate
>>> from sympy.abc import x
>>> f = fps(sin(x))
>>> f.integrate(x).truncate()
-1 + x**2/2 - x**4/24 + O(x**6)
>>> integrate(f, (x, 0, 1))
1 - cos(1)
inverse(x=None, n=6)[source]

Returns the truncated terms of the inverse of the formal power series, up to specified \(n\).

If \(f\) and \(g\) are two formal power series of two different functions, then the coefficient sequence ak of the composed formal power series \(fp\) will be as follows.

\[\sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})\]
Parameters

n : Number, optional

Specifies the order of the term up to which the polynomial should be truncated.

Examples

>>> from sympy import fps, exp, cos
>>> from sympy.abc import x
>>> f1 = fps(exp(x))
>>> f2 = fps(cos(x))

>>> f1.inverse(x).truncate()
1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6)

>>> f2.inverse(x).truncate(8)
1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)

See also

sympy.functions.combinatorial.numbers.bell, sympy.series.formal.FormalPowerSeriesInverse

References

R645

Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.

polynomial(n=6)[source]

Truncated series as polynomial.

Returns series expansion of f upto order O(x**n) as a polynomial(without O term).

product(other, x=None, n=6)[source]

Multiplies two Formal Power Series, using discrete convolution and return the truncated terms upto specified order.

Parameters

n : Number, optional

Specifies the order of the term up to which the polynomial should be truncated.

Examples

>>> from sympy import fps, sin, exp
>>> from sympy.abc import x
>>> f1 = fps(sin(x))
>>> f2 = fps(exp(x))

>>> f1.product(f2, x).truncate(4)
x + x**2 + x**3/3 + O(x**4)

See also

sympy.discrete.convolutions, sympy.series.formal.FormalPowerSeriesProduct

truncate(n=6)[source]

Truncated series.

Returns truncated series expansion of f upto order O(x**n).

If n is None, returns an infinite iterator.

sympy.series.formal.fps(f, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)[source]

Generates Formal Power Series of f.

Returns the formal series expansion of f around x = x0 with respect to x in the form of a FormalPowerSeries object.

Formal Power Series is represented using an explicit formula computed using different algorithms.

See compute_fps() for the more details regarding the computation of formula.

Parameters

x : Symbol, optional

If x is None and f is univariate, the univariate symbols will be supplied, otherwise an error will be raised.

x0 : number, optional

Point to perform series expansion about. Default is 0.

dir : {1, -1, ‘+’, ‘-‘}, optional

If dir is 1 or ‘+’ the series is calculated from the right and for -1 or ‘-‘ the series is calculated from the left. For smooth functions this flag will not alter the results. Default is 1.

hyper : {True, False}, optional

Set hyper to False to skip the hypergeometric algorithm. By default it is set to False.

order : int, optional

Order of the derivative of f, Default is 4.

rational : {True, False}, optional

Set rational to False to skip rational algorithm. By default it is set to True.

full : {True, False}, optional

Set full to True to increase the range of rational algorithm. See rational_algorithm() for details. By default it is set to False.

Examples

>>> from sympy import fps, ln, atan, sin
>>> from sympy.abc import x, n

Rational Functions

>>> fps(ln(1 + x)).truncate()
x - x**2/2 + x**3/3 - x**4/4 + x**5/5 + O(x**6)

>>> fps(atan(x), full=True).truncate()
x - x**3/3 + x**5/5 + O(x**6)

Symbolic Functions

>>> fps(x**n*sin(x**2), x).truncate(8)
-x**(n + 6)/6 + x**(n + 2) + O(x**(n + 8))

See also

sympy.series.formal.FormalPowerSeries, sympy.series.formal.compute_fps

sympy.series.formal.compute_fps(f, x, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)[source]

Computes the formula for Formal Power Series of a function.

Tries to compute the formula by applying the following techniques (in order):

  • rational_algorithm

  • Hypergeometric algorithm

Parameters

x : Symbol

x0 : number, optional

Point to perform series expansion about. Default is 0.

dir : {1, -1, ‘+’, ‘-‘}, optional

If dir is 1 or ‘+’ the series is calculated from the right and for -1 or ‘-‘ the series is calculated from the left. For smooth functions this flag will not alter the results. Default is 1.

hyper : {True, False}, optional

Set hyper to False to skip the hypergeometric algorithm. By default it is set to False.

order : int, optional

Order of the derivative of f, Default is 4.

rational : {True, False}, optional

Set rational to False to skip rational algorithm. By default it is set to True.

full : {True, False}, optional

Set full to True to increase the range of rational algorithm. See rational_algorithm() for details. By default it is set to False.

Returns

ak : sequence

Sequence of coefficients.

xk : sequence

Sequence of powers of x.

ind : Expr

Independent terms.

mul : Pow

Common terms.

See also

sympy.series.formal.rational_algorithm, sympy.series.formal.hyper_algorithm

class sympy.series.formal.FormalPowerSeriesCompose(*args)[source]

Represents the composed formal power series of two functions.

No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic.

There are two differences between a FormalPowerSeries object and a FormalPowerSeriesCompose object. The first argument contains the outer function and the inner function involved in the omposition. Also, the coefficient sequence contains the generic sequence which is to be multiplied by a custom bell_seq finite sequence. The finite terms will then be added up to get the final terms.

See also

sympy.series.formal.FormalPowerSeries, sympy.series.formal.FiniteFormalPowerSeries

class sympy.series.formal.FormalPowerSeriesInverse(*args)[source]

Represents the Inverse of a formal power series.

No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic.

There is a single difference between a FormalPowerSeries object and a FormalPowerSeriesInverse object. The coefficient sequence contains the generic sequence which is to be multiplied by a custom bell_seq finite sequence. The finite terms will then be added up to get the final terms.

See also

sympy.series.formal.FormalPowerSeries, sympy.series.formal.FiniteFormalPowerSeries

class sympy.series.formal.FormalPowerSeriesProduct(*args)[source]

Represents the product of two formal power series of two functions.

No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic.

There are two differences between a FormalPowerSeries object and a FormalPowerSeriesProduct object. The first argument contains the two functions involved in the product. Also, the coefficient sequence contains both the coefficient sequence of the formal power series of the involved functions.

See also

sympy.series.formal.FormalPowerSeries, sympy.series.formal.FiniteFormalPowerSeries

class sympy.series.formal.FiniteFormalPowerSeries(*args)[source]

Base Class for Product, Compose and Inverse classes

Rational Algorithm

sympy.series.formal.rational_independent(terms, x)[source]

Returns a list of all the rationally independent terms.

Examples

>>> from sympy import sin, cos
>>> from sympy.series.formal import rational_independent
>>> from sympy.abc import x

>>> rational_independent([cos(x), sin(x)], x)
[cos(x), sin(x)]
>>> rational_independent([x**2, sin(x), x*sin(x), x**3], x)
[x**3 + x**2, x*sin(x) + sin(x)]
sympy.series.formal.rational_algorithm(f, x, k, order=4, full=False)[source]

Rational algorithm for computing formula of coefficients of Formal Power Series of a function.

Applicable when f(x) or some derivative of f(x) is a rational function in x.

rational_algorithm() uses apart() function for partial fraction decomposition. apart() by default uses ‘undetermined coefficients method’. By setting full=True, ‘Bronstein’s algorithm’ can be used instead.

Looks for derivative of a function up to 4’th order (by default). This can be overridden using order option.

Returns

formula : Expr

ind : Expr

Independent terms.

order : int

Examples

>>> from sympy import log, atan
>>> from sympy.series.formal import rational_algorithm as ra
>>> from sympy.abc import x, k

>>> ra(1 / (1 - x), x, k)
(1, 0, 0)
>>> ra(log(1 + x), x, k)
(-(-1)**(-k)/k, 0, 1)

>>> ra(atan(x), x, k, full=True)
((-I*(-I)**(-k)/2 + I*I**(-k)/2)/k, 0, 1)

Notes

By setting full=True, range of admissible functions to be solved using rational_algorithm can be increased. This option should be used carefully as it can significantly slow down the computation as doit is performed on the RootSum object returned by the apart() function. Use full=False whenever possible.

See also

sympy.polys.partfrac.apart

References

R646

Formal Power Series - Dominik Gruntz, Wolfram Koepf

R647

Power Series in Computer Algebra - Wolfram Koepf

Hypergeometric Algorithm

sympy.series.formal.simpleDE(f, x, g, order=4)[source]

Generates simple DE.

DE is of the form

\[f^k(x) + \sum\limits_{j=0}^{k-1} A_j f^j(x) = 0\]

where \(A_j\) should be rational function in x.

Generates DE’s upto order 4 (default). DE’s can also have free parameters.

By increasing order, higher order DE’s can be found.

Yields a tuple of (DE, order).

sympy.series.formal.exp_re(DE, r, k)[source]

Converts a DE with constant coefficients (explike) into a RE.

Performs the substitution:

\[f^j(x) \to r(k + j)\]

Normalises the terms so that lowest order of a term is always r(k).

Examples

>>> from sympy import Function, Derivative
>>> from sympy.series.formal import exp_re
>>> from sympy.abc import x, k
>>> f, r = Function('f'), Function('r')

>>> exp_re(-f(x) + Derivative(f(x)), r, k)
-r(k) + r(k + 1)
>>> exp_re(Derivative(f(x), x) + Derivative(f(x), (x, 2)), r, k)
r(k) + r(k + 1)

See also

sympy.series.formal.hyper_re

sympy.series.formal.hyper_re(DE, r, k)[source]

Converts a DE into a RE.

Performs the substitution:

\[x^l f^j(x) \to (k + 1 - l)_j . a_{k + j - l}\]

Normalises the terms so that lowest order of a term is always r(k).

Examples

>>> from sympy import Function, Derivative
>>> from sympy.series.formal import hyper_re
>>> from sympy.abc import x, k
>>> f, r = Function('f'), Function('r')

>>> hyper_re(-f(x) + Derivative(f(x)), r, k)
(k + 1)*r(k + 1) - r(k)
>>> hyper_re(-x*f(x) + Derivative(f(x), (x, 2)), r, k)
(k + 2)*(k + 3)*r(k + 3) - r(k)

See also

sympy.series.formal.exp_re

sympy.series.formal.rsolve_hypergeometric(f, x, P, Q, k, m)[source]

Solves RE of hypergeometric type.

Attempts to solve RE of the form

Q(k)*a(k + m) - P(k)*a(k)

Transformations that preserve Hypergeometric type:

  1. x**n*f(x): b(k + m) = R(k - n)*b(k)

  2. f(A*x): b(k + m) = A**m*R(k)*b(k)

  3. f(x**n): b(k + n*m) = R(k/n)*b(k)

  4. f(x**(1/m)): b(k + 1) = R(k*m)*b(k)

  5. f’(x): b(k + m) = ((k + m + 1)/(k + 1))*R(k + 1)*b(k)

Some of these transformations have been used to solve the RE.

Returns

formula : Expr

ind : Expr

Independent terms.

order : int

Examples

>>> from sympy import exp, ln, S
>>> from sympy.series.formal import rsolve_hypergeometric as rh
>>> from sympy.abc import x, k

>>> rh(exp(x), x, -S.One, (k + 1), k, 1)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1)

>>> rh(ln(1 + x), x, k**2, k*(k + 1), k, 1)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2)

References

R648

Formal Power Series - Dominik Gruntz, Wolfram Koepf

R649

Power Series in Computer Algebra - Wolfram Koepf

sympy.series.formal.solve_de(f, x, DE, order, g, k)[source]

Solves the DE.

Tries to solve DE by either converting into a RE containing two terms or converting into a DE having constant coefficients.

Returns

formula : Expr

ind : Expr

Independent terms.

order : int

Examples

>>> from sympy import Derivative as D, Function
>>> from sympy import exp, ln
>>> from sympy.series.formal import solve_de
>>> from sympy.abc import x, k
>>> f = Function('f')

>>> solve_de(exp(x), x, D(f(x), x) - f(x), 1, f, k)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1)

>>> solve_de(ln(1 + x), x, (x + 1)*D(f(x), x, 2) + D(f(x)), 2, f, k)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2)
sympy.series.formal.hyper_algorithm(f, x, k, order=4)[source]

Hypergeometric algorithm for computing Formal Power Series.

Steps:

  • Generates DE

  • Convert the DE into RE

  • Solves the RE

Examples

>>> from sympy import exp, ln
>>> from sympy.series.formal import hyper_algorithm

>>> from sympy.abc import x, k

>>> hyper_algorithm(exp(x), x, k)
(Piecewise((1/factorial(k), Eq(Mod(k, 1), 0)), (0, True)), 1, 1)

>>> hyper_algorithm(ln(1 + x), x, k)
(Piecewise(((-1)**(k - 1)*factorial(k - 1)/RisingFactorial(2, k - 1),
 Eq(Mod(k, 1), 0)), (0, True)), x, 2)

See also

sympy.series.formal.simpleDE, sympy.series.formal.solve_de