ó ¡¼™\c@ sîddlmZmZddlmZmZmZddlmZddl m Z m Z ddl m Z ddlmZddlmZmZddlmZdd lmZdd lmZd e fd „ƒYZd e fd„ƒYZdS(iÿÿÿÿ(tprint_functiontdivision(tStsympifytdiff(t deprecated(tFunctiontArgumentIndexError(t fuzzy_not(tEq(timtsign(t Piecewise(tPolynomialError(t filldedentt DiracDeltacB sƒeZdZeZdd„Zedd„ƒZeddddd d ƒd „ƒZ d „Z d „Z d„Z d„Z d„ZRS(sD The DiracDelta function and its derivatives. DiracDelta is not an ordinary function. It can be rigorously defined either as a distribution or as a measure. DiracDelta only makes sense in definite integrals, and in particular, integrals of the form ``Integral(f(x)*DiracDelta(x - x0), (x, a, b))``, where it equals ``f(x0)`` if ``a <= x0 <= b`` and ``0`` otherwise. Formally, DiracDelta acts in some ways like a function that is ``0`` everywhere except at ``0``, but in many ways it also does not. It can often be useful to treat DiracDelta in formal ways, building up and manipulating expressions with delta functions (which may eventually be integrated), but care must be taken to not treat it as a real function. SymPy's ``oo`` is similar. It only truly makes sense formally in certain contexts (such as integration limits), but SymPy allows its use everywhere, and it tries to be consistent with operations on it (like ``1/oo``), but it is easy to get into trouble and get wrong results if ``oo`` is treated too much like a number. Similarly, if DiracDelta is treated too much like a function, it is easy to get wrong or nonsensical results. DiracDelta function has the following properties: 1) ``diff(Heaviside(x), x) = DiracDelta(x)`` 2) ``integrate(DiracDelta(x - a)*f(x),(x, -oo, oo)) = f(a)`` and ``integrate(DiracDelta(x - a)*f(x),(x, a - e, a + e)) = f(a)`` 3) ``DiracDelta(x) = 0`` for all ``x != 0`` 4) ``DiracDelta(g(x)) = Sum_i(DiracDelta(x - x_i)/abs(g'(x_i)))`` Where ``x_i``-s are the roots of ``g`` 5) ``DiracDelta(-x) = DiracDelta(x)`` Derivatives of ``k``-th order of DiracDelta have the following property: 6) ``DiracDelta(x, k) = 0``, for all ``x != 0`` 7) ``DiracDelta(-x, k) = -DiracDelta(x, k)`` for odd ``k`` 8) ``DiracDelta(-x, k) = DiracDelta(x, k)`` for even ``k`` Examples ======== >>> from sympy import DiracDelta, diff, pi, Piecewise >>> from sympy.abc import x, y >>> DiracDelta(x) DiracDelta(x) >>> DiracDelta(1) 0 >>> DiracDelta(-1) 0 >>> DiracDelta(pi) 0 >>> DiracDelta(x - 4).subs(x, 4) DiracDelta(0) >>> diff(DiracDelta(x)) DiracDelta(x, 1) >>> diff(DiracDelta(x - 1),x,2) DiracDelta(x - 1, 2) >>> diff(DiracDelta(x**2 - 1),x,2) 2*(2*x**2*DiracDelta(x**2 - 1, 2) + DiracDelta(x**2 - 1, 1)) >>> DiracDelta(3*x).is_simple(x) True >>> DiracDelta(x**2).is_simple(x) False >>> DiracDelta((x**2 - 1)*y).expand(diracdelta=True, wrt=x) DiracDelta(x - 1)/(2*Abs(y)) + DiracDelta(x + 1)/(2*Abs(y)) See Also ======== Heaviside simplify, is_simple sympy.functions.special.tensor_functions.KroneckerDelta References ========== .. [1] http://mathworld.wolfram.com/DeltaFunction.html icC se|dkrRd}t|jƒdkr7|jd}n|j|jd|dƒSt||ƒ‚dS(s© Returns the first derivative of a DiracDelta Function. The difference between ``diff()`` and ``fdiff()`` is:- ``diff()`` is the user-level function and ``fdiff()`` is an object method. ``fdiff()`` is just a convenience method available in the ``Function`` class. It returns the derivative of the function without considering the chain rule. ``diff(function, x)`` calls ``Function._eval_derivative`` which in turn calls ``fdiff()`` internally to compute the derivative of the function. Examples ======== >>> from sympy import DiracDelta, diff >>> from sympy.abc import x >>> DiracDelta(x).fdiff() DiracDelta(x, 1) >>> DiracDelta(x, 1).fdiff() DiracDelta(x, 2) >>> DiracDelta(x**2 - 1).fdiff() DiracDelta(x**2 - 1, 1) >>> diff(DiracDelta(x, 1)).fdiff() DiracDelta(x, 3) iiN(tlentargstfuncR(tselftargindextk((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pytfdifffs  icC s*t|ƒ}|j s|jr5td|fƒ‚nt|ƒ}|tjkrWtjS|jrgtjStt |ƒj ƒr­tt dt t |ƒƒt |ƒfƒƒ‚n|j ƒ\}}|r&|ddkr&|ddkrô|| |ƒ S|ddkr&|r|| |ƒS|| ƒSndS(se Returns a simplified form or a value of DiracDelta depending on the argument passed by the DiracDelta object. The ``eval()`` method is automatically called when the ``DiracDelta`` class is about to be instantiated and it returns either some simplified instance or the unevaluated instance depending on the argument passed. In other words, ``eval()`` method is not needed to be called explicitly, it is being called and evaluated once the object is called. Examples ======== >>> from sympy import DiracDelta, S, Subs >>> from sympy.abc import x >>> DiracDelta(x) DiracDelta(x) >>> DiracDelta(-x, 1) -DiracDelta(x, 1) >>> DiracDelta(1) 0 >>> DiracDelta(5, 1) 0 >>> DiracDelta(0) DiracDelta(0) >>> DiracDelta(-1) 0 >>> DiracDelta(S.NaN) nan >>> DiracDelta(x).eval(1) 0 >>> DiracDelta(x - 100).subs(x, 5) 0 >>> DiracDelta(x - 100).subs(x, 100) DiracDelta(0) sfError: the second argument of DiracDelta must be a non-negative integer, %s given instead.sg Function defined only for Real Values. Complex part: %s found in %s .iiÿÿÿÿiiN(Rt is_Integert is_negativet ValueErrorRtNaNt is_nonzerotZeroRR tis_zeroRtreprtargs_cnc(tclstargRtctnc((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pytevals&1   (t useinsteadsexpand(diracdelta=True, wrt=x)tissuei;2tdeprecated_since_versions1.1cC s|jdtd|ƒS(Nt diracdeltatwrt(texpandtTrue(Rtx((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pytsimplifyÕsc K s}ddlm}|jddƒ}|dkrm|j}t|ƒdkrX|jƒ}qmttdƒƒ‚n|j dj |ƒ s¬t|j ƒdkr°|j ddkr°|Syµ||j d|ƒ}d}t }t t |j d|ƒƒ}xf|jƒD]X\} } | jtk rO| dkrO||j|| ƒ|j|| ƒ7}qþt}PqþW|rd|SWntk rxnX|S(s=Compute a simplified representation of the function using property number 4. Pass wrt as a hint to expand the expression with respect to a particular variable. wrt is: - a variable with respect to which a DiracDelta expression will get expanded. Examples ======== >>> from sympy import DiracDelta >>> from sympy.abc import x, y >>> DiracDelta(x*y).expand(diracdelta=True, wrt=x) DiracDelta(x)/Abs(y) >>> DiracDelta(x*y).expand(diracdelta=True, wrt=y) DiracDelta(y)/Abs(x) >>> DiracDelta(x**2 + x - 2).expand(diracdelta=True, wrt=x) DiracDelta(x - 1)/3 + DiracDelta(x + 2)/3 See Also ======== is_simple, Diracdelta iÿÿÿÿ(trootsR)is» When there is more than 1 free symbol or variable in the expression, the 'wrt' keyword is required as a hint to expand when using the DiracDelta hint.iN(tsympy.polys.polyrootsR.tgettNonet free_symbolsRtpopt TypeErrorRRthasR+tabsRtitemstis_realtFalseRtsubsR ( RthintsR.R)tfreetargrootstresulttvalidtdargtrtm((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyt_eval_expand_diracdeltaÙs2  ?* cC s0|jdj|ƒ}|r,|jƒdkStS(sis_simple(self, x) Tells whether the argument(args[0]) of DiracDelta is a linear expression in x. x can be: - a symbol Examples ======== >>> from sympy import DiracDelta, cos >>> from sympy.abc import x, y >>> DiracDelta(x*y).is_simple(x) True >>> DiracDelta(x*y).is_simple(y) True >>> DiracDelta(x**2 + x - 2).is_simple(x) False >>> DiracDelta(cos(x)).is_simple(x) False See Also ======== simplify, Diracdelta ii(Rtas_polytdegreeR9(RR,tp((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyt is_simples!cO sBt|ƒdkr>ttdƒt|ddƒfdtfƒSdS(s‚Represents DiracDelta in a Piecewise form Examples ======== >>> from sympy import DiracDelta, Piecewise, Symbol, SingularityFunction >>> x = Symbol('x') >>> DiracDelta(x).rewrite(Piecewise) Piecewise((DiracDelta(0), Eq(x, 0)), (0, True)) >>> DiracDelta(x - 5).rewrite(Piecewise) Piecewise((DiracDelta(0), Eq(x - 5, 0)), (0, True)) >>> DiracDelta(x**2 - 5).rewrite(Piecewise) Piecewise((DiracDelta(0), Eq(x**2 - 5, 0)), (0, True)) >>> DiracDelta(x - 5, 4).rewrite(Piecewise) DiracDelta(x - 5, 4) iiN(RR RR R+(RRtkwargs((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyt_eval_rewrite_as_Piecewise@scO sddlm}ddlm}|tdƒkrB|dddƒS|tddƒkrg|dddƒS|j}t|ƒdkrë|jƒ}t|ƒdkrÁ||||d|ƒddƒS||||d|ƒd|d dƒStt dƒƒ‚dS( sb Returns the DiracDelta expression written in the form of Singularity Functions. iÿÿÿÿ(tsolve(tSingularityFunctioniiiþÿÿÿsr rewrite(SingularityFunction) doesn't support arguments with more that 1 variable.N( t sympy.solversRJtsympy.functionsRKRR2RR3R4R(RRRHRJRKR<R,((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyt$_eval_rewrite_as_SingularityFunctionYs  !*cC s)ddlj}|j|jdjƒƒS(Niÿÿÿÿi(tsage.alltallt dirac_deltaRt_sage_(Rtsage((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRRqs(t__name__t __module__t__doc__R+R8Rt classmethodR$RR-RCRGRIRNRR(((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRsO 'G$ A &  t HeavisidecB sheZdZeZdd„Zd d„Zed d„ƒZ d d„Z d d„Z d„Z d„Z RS( sHeaviside Piecewise function Heaviside function has the following properties [1]_: 1) ``diff(Heaviside(x),x) = DiracDelta(x)`` ``( 0, if x < 0`` 2) ``Heaviside(x) = < ( undefined if x==0 [1]`` ``( 1, if x > 0`` 3) ``Max(0,x).diff(x) = Heaviside(x)`` .. [1] Regarding to the value at 0, Mathematica defines ``H(0) = 1``, but Maple uses ``H(0) = undefined``. Different application areas may have specific conventions. For example, in control theory, it is common practice to assume ``H(0) == 0`` to match the Laplace transform of a DiracDelta distribution. To specify the value of Heaviside at x=0, a second argument can be given. Omit this 2nd argument or pass ``None`` to recover the default behavior. >>> from sympy import Heaviside, S >>> from sympy.abc import x >>> Heaviside(9) 1 >>> Heaviside(-9) 0 >>> Heaviside(0) Heaviside(0) >>> Heaviside(0, S.Half) 1/2 >>> (Heaviside(x) + 1).replace(Heaviside(x), Heaviside(x, 1)) Heaviside(x, 1) + 1 See Also ======== DiracDelta References ========== .. [2] http://mathworld.wolfram.com/HeavisideStepFunction.html .. [3] http://dlmf.nist.gov/1.16#iv icC s0|dkrt|jdƒSt||ƒ‚dS(s} Returns the first derivative of a Heaviside Function. Examples ======== >>> from sympy import Heaviside, diff >>> from sympy.abc import x >>> Heaviside(x).fdiff() DiracDelta(x) >>> Heaviside(x**2 - 1).fdiff() DiracDelta(x**2 - 1) >>> diff(Heaviside(x)).fdiff() DiracDelta(x, 1) iiN(RRR(RR((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyR«s cK sK|dkr(t||ƒj|||St||ƒj||||SdS(N(R1tsupert__new__(R R!tH0toptions((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRZÅs cC sŸt|ƒ}t|ƒ}|jr(tjS|jr8tjS|jrE|S|tjkr[tjStt |ƒjƒr›t dt t |ƒƒt |ƒfƒ‚ndS(s Returns a simplified form or a value of Heaviside depending on the argument passed by the Heaviside object. The ``eval()`` method is automatically called when the ``Heaviside`` class is about to be instantiated and it returns either some simplified instance or the unevaluated instance depending on the argument passed. In other words, ``eval()`` method is not needed to be called explicitly, it is being called and evaluated once the object is called. Examples ======== >>> from sympy import Heaviside, S >>> from sympy.abc import x >>> Heaviside(x) Heaviside(x) >>> Heaviside(19) 1 >>> Heaviside(0) Heaviside(0) >>> Heaviside(0, 1) 1 >>> Heaviside(-5) 0 >>> Heaviside(S.NaN) nan >>> Heaviside(x).eval(100) 1 >>> Heaviside(x - 100).subs(x, 5) 0 >>> Heaviside(x - 100).subs(x, 105) 1 sFFunction defined only for Real Values. Complex part: %s found in %s .N( RRRRt is_positivetOneRRRR RR(R R!R[((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyR$Ës.     cK sâ|dkrItd|dkftdƒt|dƒfd|dkfƒS|dkrztd|dkfd|dkfƒS|dkr«td|dkfd|dkfƒStd|dkf|t|dƒfd|dkfƒS(sRRepresents Heaviside in a Piecewise form Examples ======== >>> from sympy import Heaviside, Piecewise, Symbol, pprint >>> x = Symbol('x') >>> Heaviside(x).rewrite(Piecewise) Piecewise((0, x < 0), (Heaviside(0), Eq(x, 0)), (1, x > 0)) >>> Heaviside(x - 5).rewrite(Piecewise) Piecewise((0, x - 5 < 0), (Heaviside(0), Eq(x - 5, 0)), (1, x - 5 > 0)) >>> Heaviside(x**2 - 1).rewrite(Piecewise) Piecewise((0, x**2 - 1 < 0), (Heaviside(0), Eq(x**2 - 1, 0)), (1, x**2 - 1 > 0)) iiN(R1R RXR (RR!R[RH((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRIs = % %cK s=|jr9|dks$|tjkr9t|ƒddSndS(s¹Represents the Heaviside function in the form of sign function. The value of the second argument of Heaviside must specify Heaviside(0) = 1/2 for rewritting as sign to be strictly equivalent. For easier usage, we also allow this rewriting when Heaviside(0) is undefined. Examples ======== >>> from sympy import Heaviside, Symbol, sign >>> x = Symbol('x', real=True) >>> Heaviside(x).rewrite(sign) sign(x)/2 + 1/2 >>> Heaviside(x, 0).rewrite(sign) Heaviside(x, 0) >>> Heaviside(x - 2).rewrite(sign) sign(x - 2)/2 + 1/2 >>> Heaviside(x**2 - 2*x + 1).rewrite(sign) sign(x**2 - 2*x + 1)/2 + 1/2 >>> y = Symbol('y') >>> Heaviside(y).rewrite(sign) Heaviside(y) >>> Heaviside(y**2 - 2*y + 1).rewrite(sign) Heaviside(y**2 - 2*y + 1) See Also ======== sign iiN(R8R1RtHalfR (RR!R[RH((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyt_eval_rewrite_as_sign!s& cK sœddlm}ddlm}|tdƒkrB|dddƒS|j}t|ƒdkr†|jƒ}|||||ƒddƒStt dƒƒ‚dS(sa Returns the Heaviside expression written in the form of Singularity Functions. iÿÿÿÿ(RJ(RKiisr rewrite(SingularityFunction) doesn't support arguments with more that 1 variable.N( RLRJRMRKRXR2RR3R4R(RRRHRJRKR<R,((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRNKs  cC s)ddlj}|j|jdjƒƒS(Niÿÿÿÿi(RORPt heavisideRRR(RRS((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRRbsN(RTRURVR+R8RR1RZRWR$RIR`RNRR(((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pyRX{s,  :  * N(t __future__RRt sympy.coreRRRtsympy.core.decoratorsRtsympy.core.functionRRtsympy.core.logicRtsympy.core.relationalR t$sympy.functions.elementary.complexesR R t$sympy.functions.elementary.piecewiseR tsympy.polys.polyerrorsR tsympy.utilitiesRRRX(((sFlib/python2.7/site-packages/sympy/functions/special/delta_functions.pytsÿi