B [3@sdZddlmZmZddlmZmZddlmZddl m Z ddl m Z ddl mZddlmZmZdd lmZdd lmZdd lmZmZmZdd lmZdd lmZddlmZddZ ddZ!ddZ"GdddeZ#dddZ$dS)zFourier Series)print_functiondivision)pioo)Expr)Add)sympify)S)DummySymbol) is_sequence)Tuple)sincossinc)Interval) SeriesBase) SeqFormulac Csddlm}|d|d|d}}td|t||}d||||||}||tjd}|td|||||||dtffS)z,Returns the cos sequence in a Fourier seriesr) integrate) sympy.integralsrrrsubsr Zerorr) funclimitsnrxLZcos_termZformulaa0r 3lib/python3.7/site-packages/sympy/series/fourier.pyfourier_cos_seqs r"cCsdddlm}|d|d|d}}td|t||}td|||||||dtfS)z,Returns the sin sequence in a Fourier seriesr)rrr)rrrrrr)rrrrrrZsin_termr r r!fourier_sin_seqs  r#cCsdd}d\}}}|dkr0||t t}}}t|trnt|dkrR|\}}}nt|dkrn||}|\}}t|tr|dks|dkrtdt|tj tj g}||ks||krtdt |||fS) a Limits should be of the form (x, start, stop). x should be a symbol. Both start and stop should be bounded. * If x is not given, x is determined from func. * If limits is None. Limit of the form (x, -pi, pi) is returned. Examples ======== >>> from sympy import pi >>> from sympy.series.fourier import _process_limits as pari >>> from sympy.abc import x >>> pari(x**2, (x, -2, 2)) (x, -2, 2) >>> pari(x**2, (-2, 2)) (x, -2, 2) >>> pari(x**2, None) (x, -pi, pi) cSsB|j}t|jdkr|St|jdkr2tdStd|dS)Nrrkz specify dummy variables for %s. If the function contains more than one free symbol, a dummy variable should be supplied explicitly e.g. FourierSeries(m*n**2, (n, -pi, pi))) free_symbolslenpopr ValueError)rZfreer r r!_find_x<sz _process_limits.._find_x)NNNNrzInvalid limits given: %sz.Both the start and end value should be bounded) rr r r& isinstancer r(strr ZNegativeInfinityZInfinityr)rrr)rstartstopZ unboundedr r r!_process_limits's       r/c@seZdZdZddZeddZeddZedd Zed d Z ed d Z eddZ eddZ eddZ eddZeddZddZd2ddZd3ddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1S)4 FourierSeriesaRepresents Fourier sine/cosine series. This class only represents a fourier series. No computation is performed. For how to compute Fourier series, see the :func:`fourier_series` docstring. See Also ======== sympy.series.fourier.fourier_series cGstt|}tj|f|S)N)maprr__new__)clsargsr r r!r2ks zFourierSeries.__new__cCs |jdS)Nr)r4)selfr r r!functionoszFourierSeries.functioncCs|jddS)Nrr)r4)r5r r r!rsszFourierSeries.xcCs|jdd|jddfS)Nrr)r4)r5r r r!periodwszFourierSeries.periodcCs|jddS)Nrr)r4)r5r r r!r{szFourierSeries.a0cCs|jddS)Nrr)r4)r5r r r!anszFourierSeries.ancCs|jddS)Nr)r4)r5r r r!bnszFourierSeries.bncCs tdtS)Nr)rr)r5r r r!intervalszFourierSeries.intervalcCs|jjS)N)r:inf)r5r r r!r-szFourierSeries.startcCs|jjS)N)r:Zsup)r5r r r!r.szFourierSeries.stopcCstS)N)r)r5r r r!lengthszFourierSeries.lengthcCs|j}||r|SdS)N)rZhas)r5oldnewrr r r! _eval_subss zFourierSeries._eval_subsr*cCsL|dkrt|Sg}x.|D]&}t||kr,P|tjk r||qWt|S)a Return the first n nonzero terms of the series. If n is None return an iterator. Parameters ========== n : int or None Amount of non-zero terms in approximation or None. Returns ======= Expr or iterator Approximation of function expanded into Fourier series. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x, (x, -pi, pi)) >>> s.truncate(4) 2*sin(x) - sin(2*x) + 2*sin(3*x)/3 - sin(4*x)/2 See Also ======== sympy.series.fourier.FourierSeries.sigma_approximation N)iterr&r rappendr)r5rtermstr r r!truncates   zFourierSeries.truncatecs&fddt|dD}t|S)a Return :math:`\sigma`-approximation of Fourier series with respect to order n. Sigma approximation adjusts a Fourier summation to eliminate the Gibbs phenomenon which would otherwise occur at discontinuities. A sigma-approximated summation for a Fourier series of a T-periodical function can be written as .. math:: s(\theta) = \frac{1}{2} a_0 + \sum _{k=1}^{m-1} \operatorname{sinc} \Bigl( \frac{k}{m} \Bigr) \cdot \left[ a_k \cos \Bigl( \frac{2\pi k}{T} \theta \Bigr) + b_k \sin \Bigl( \frac{2\pi k}{T} \theta \Bigr) \right], where :math:`a_0, a_k, b_k, k=1,\ldots,{m-1}` are standard Fourier series coefficients and :math:`\operatorname{sinc} \Bigl( \frac{k}{m} \Bigr)` is a Lanczos :math:`\sigma` factor (expressed in terms of normalized :math:`\operatorname{sinc}` function). Parameters ========== n : int Highest order of the terms taken into account in approximation. Returns ======= Expr Sigma approximation of function expanded into Fourier series. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x, (x, -pi, pi)) >>> s.sigma_approximation(4) 2*sin(x)*sinc(pi/4) - 2*sin(2*x)/pi + 2*sin(3*x)*sinc(3*pi/4)/3 See Also ======== sympy.series.fourier.FourierSeries.truncate Notes ===== The behaviour of :meth:`~sympy.series.fourier.FourierSeries.sigma_approximation` is different from :meth:`~sympy.series.fourier.FourierSeries.truncate` - it takes all nonzero terms of degree smaller than n, rather than first n nonzero ones. References ========== .. [1] https://en.wikipedia.org/wiki/Gibbs_phenomenon .. [2] https://en.wikipedia.org/wiki/Sigma_approximation cs.g|]&\}}|tjk rtt||qSr )r rrr).0irC)rr r! sz5FourierSeries.sigma_approximation..N) enumerater)r5rrBr )rr!sigma_approximations=z!FourierSeries.sigma_approximationcCs\t||j}}||jkr*td||f|j|}|j|}|||jd||j|j fS)aShift the function by a term independent of x. f(x) -> f(x) + s This is fast, if Fourier series of f(x) is already computed. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x**2, (x, -pi, pi)) >>> s.shift(1).truncate() -4*cos(x) + cos(2*x) + 1 + pi**2/3 z '%s' should be independent of %sr) rrr%r(rr6rr4r8r9)r5srrsfuncr r r!shifts    zFourierSeries.shiftcCs|t||j}}||jkr*td||f|j|||}|j|||}|j|||}|||j d|j ||fS)aShift x by a term independent of x. f(x) -> f(x + s) This is fast, if Fourier series of f(x) is already computed. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x**2, (x, -pi, pi)) >>> s.shiftx(1).truncate() -4*cos(x + 1) + cos(2*x + 2) + pi**2/3 z '%s' should be independent of %sr) rrr%r(r8rr9r6rr4r)r5rJrr8r9rKr r r!shiftx"s zFourierSeries.shiftxcCstt||j}}||jkr*td||f|j|}|j|}|j|}|jd|}| ||jd|||fS)aScale the function by a term independent of x. f(x) -> s * f(x) This is fast, if Fourier series of f(x) is already computed. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x**2, (x, -pi, pi)) >>> s.scale(2).truncate() -8*cos(x) + 2*cos(2*x) + 2*pi**2/3 z '%s' should be independent of %srr) rrr%r(r8Z coeff_mulr9rr4r)r5rJrr8r9rrKr r r!scale>s    zFourierSeries.scalecCs|t||j}}||jkr*td||f|j|||}|j|||}|j|||}|||j d|j ||fS)aScale x by a term independent of x. f(x) -> f(s*x) This is fast, if Fourier series of f(x) is already computed. Examples ======== >>> from sympy import fourier_series, pi >>> from sympy.abc import x >>> s = fourier_series(x**2, (x, -pi, pi)) >>> s.scalex(2).truncate() -4*cos(2*x) + cos(4*x) + pi**2/3 z '%s' should be independent of %sr) rrr%r(r8rr9r6rr4r)r5rJrr8r9rKr r r!scalex[s zFourierSeries.scalexcCs x|D]}|tjk r|SqWdS)N)r r)r5rrCr r r!_eval_as_leading_termws  z#FourierSeries._eval_as_leading_termcCs&|dkr|jS|j||j|S)Nr)rr8Zcoeffr9)r5Zptr r r! _eval_term|szFourierSeries._eval_termcCs |dS)N)rN)r5r r r!__neg__szFourierSeries.__neg__cCst|tr|j|jkrtd|j|j}}|j|j||}|j|jkrP|S|j|j}|j |j }|j |j }| ||j d|||fSt ||S)Nz(Both the series should have same periodsr)r+r0r7r(rr6rr%r8r9rrr4r)r5otherryr6r8r9rr r r!__add__s      zFourierSeries.__add__cCs || S)N)rV)r5rTr r r!__sub__szFourierSeries.__sub__N)r*)r*)__name__ __module__ __qualname____doc__r2propertyr6rr7rr8r9r:r-r.r<r?rDrIrLrMrNrOrPrQrSrVrWr r r r!r0]s0            * Ar0NcCst|}t||}|d}||jkr(|Std}||| }||krft|||\}}tddtf}nH|| krtj }tddtf}t |||}nt|||\}}t |||}t |||||fS)aComputes Fourier sine/cosine series expansion. Returns a :class:`FourierSeries` object. Examples ======== >>> from sympy import fourier_series, pi, cos >>> from sympy.abc import x >>> s = fourier_series(x**2, (x, -pi, pi)) >>> s.truncate(n=3) -4*cos(x) + cos(2*x) + pi**2/3 Shifting >>> s.shift(1).truncate() -4*cos(x) + cos(2*x) + 1 + pi**2/3 >>> s.shiftx(1).truncate() -4*cos(x + 1) + cos(2*x + 2) + pi**2/3 Scaling >>> s.scale(2).truncate() -8*cos(x) + 2*cos(2*x) + 2*pi**2/3 >>> s.scalex(2).truncate() -4*cos(2*x) + cos(4*x) + pi**2/3 Notes ===== Computing Fourier series can be slow due to the integration required in computing an, bn. It is faster to compute Fourier series of a function by using shifting and scaling on an already computed Fourier series rather than computing again. e.g. If the Fourier series of ``x**2`` is known the Fourier series of ``x**2 - 1`` can be found by shifting by ``-1``. See Also ======== sympy.series.fourier.FourierSeries References ========== .. [1] mathworld.wolfram.com/FourierSeries.html rrr) rr/r%r rr"rrr rr#r0)frrrZneg_frr8r9r r r!fourier_seriess"6    r^)N)%r[Z __future__rrZsympyrrZsympy.core.exprrZsympy.core.addrZsympy.core.sympifyrZsympy.core.singletonr Zsympy.core.symbolr r Zsympy.core.compatibilityr Zsympy.core.containersr Z(sympy.functions.elementary.trigonometricrrrZsympy.sets.setsrZsympy.series.series_classrZsympy.series.sequencesrr"r#r/r0r^r r r r!s(           6@