
    sg                      z    d dl mZmZmZ d dlmZmZ d dlmZ d dl	m
Z
 d dlmZ d dlmZ d dlmZ  G d d	e      Zy
)    )Soodiff)FunctionArgumentIndexError)	fuzzy_not)Eq)im)	Piecewise)	Heavisidec                   P    e Zd ZdZdZd
dZed        Zd Zd Z	ddZ
dd	Ze	Ze	Zy)SingularityFunctionaU	  
    Singularity functions are a class of discontinuous functions.

    Explanation
    ===========

    Singularity functions take a variable, an offset, and an exponent as
    arguments. These functions are represented using Macaulay brackets as:

    SingularityFunction(x, a, n) := <x - a>^n

    The singularity function will automatically evaluate to
    ``Derivative(DiracDelta(x - a), x, -n - 1)`` if ``n < 0``
    and ``(x - a)**n*Heaviside(x - a, 1)`` if ``n >= 0``.

    Examples
    ========

    >>> from sympy import SingularityFunction, diff, Piecewise, DiracDelta, Heaviside, Symbol
    >>> from sympy.abc import x, a, n
    >>> SingularityFunction(x, a, n)
    SingularityFunction(x, a, n)
    >>> y = Symbol('y', positive=True)
    >>> n = Symbol('n', nonnegative=True)
    >>> SingularityFunction(y, -10, n)
    (y + 10)**n
    >>> y = Symbol('y', negative=True)
    >>> SingularityFunction(y, 10, n)
    0
    >>> SingularityFunction(x, 4, -1).subs(x, 4)
    oo
    >>> SingularityFunction(x, 10, -2).subs(x, 10)
    oo
    >>> SingularityFunction(4, 1, 5)
    243
    >>> diff(SingularityFunction(x, 1, 5) + SingularityFunction(x, 1, 4), x)
    4*SingularityFunction(x, 1, 3) + 5*SingularityFunction(x, 1, 4)
    >>> diff(SingularityFunction(x, 4, 0), x, 2)
    SingularityFunction(x, 4, -2)
    >>> SingularityFunction(x, 4, 5).rewrite(Piecewise)
    Piecewise(((x - 4)**5, x >= 4), (0, True))
    >>> expr = SingularityFunction(x, a, n)
    >>> y = Symbol('y', positive=True)
    >>> n = Symbol('n', nonnegative=True)
    >>> expr.subs({x: y, a: -10, n: n})
    (y + 10)**n

    The methods ``rewrite(DiracDelta)``, ``rewrite(Heaviside)``, and
    ``rewrite('HeavisideDiracDelta')`` returns the same output. One can use any
    of these methods according to their choice.

    >>> expr = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
    >>> expr.rewrite(Heaviside)
    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
    >>> expr.rewrite(DiracDelta)
    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
    >>> expr.rewrite('HeavisideDiracDelta')
    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)

    See Also
    ========

    DiracDelta, Heaviside

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Singularity_function

    Tc                 (   |dk(  r| j                   \  }}}|t        j                  t        j                  t        d      t        d      fv r| j	                  |||dz
        S |j
                  r|| j	                  |||dz
        z  S yt        | |      )aK  
        Returns the first derivative of a DiracDelta Function.

        Explanation
        ===========

        The difference between ``diff()`` and ``fdiff()`` is: ``diff()`` is the
        user-level function and ``fdiff()`` is an object method. ``fdiff()`` is
        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.

           N)argsr   ZeroNegativeOnefuncis_positiver   )selfargindexxans        `/var/www/html/venv/lib/python3.12/site-packages/sympy/functions/special/singularity_functions.pyfdiffzSingularityFunction.fdiffX   s      q=iiGAq!QVVQ]]AbE1R599yyAqs++1a1---  %T844    c                    |}|}|}||z
  }t        t        |      j                        rt        d      t        t        |      j                        rt        d      |t        j
                  u s|t        j
                  u rt        j
                  S |dz   j                  rt        d      |j                  rt        j                  S |j                  r0|j                  rt        j                  |z  S |j                  r||z  S |t        j                  dddfv r;|j                  s|j                  rt        j                  S |j                  rt        S yy)	aP  
        Returns a simplified form or a value of Singularity Function depending
        on the argument passed by the object.

        Explanation
        ===========

        The ``eval()`` method is automatically called when the
        ``SingularityFunction`` 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 SingularityFunction, Symbol, nan
        >>> from sympy.abc import x, a, n
        >>> SingularityFunction(x, a, n)
        SingularityFunction(x, a, n)
        >>> SingularityFunction(5, 3, 2)
        4
        >>> SingularityFunction(x, a, nan)
        nan
        >>> SingularityFunction(x, 3, 0).subs(x, 3)
        1
        >>> SingularityFunction(4, 1, 5)
        243
        >>> x = Symbol('x', positive = True)
        >>> a = Symbol('a', negative = True)
        >>> n = Symbol('n', nonnegative = True)
        >>> SingularityFunction(x, a, n)
        (-a + x)**n
        >>> x = Symbol('x', negative = True)
        >>> a = Symbol('a', positive = True)
        >>> SingularityFunction(x, a, n)
        0

        z8Singularity Functions are defined only for Real Numbers.z>Singularity Functions are not defined for imaginary exponents.   zASingularity Functions are not defined for exponents less than -4.r   r   N)r   r
   is_zero
ValueErrorr   NaNis_negativeis_extended_negativer   is_nonnegativeis_extended_nonnegativer   is_extended_positiver   )clsvariableoffsetexponentr   r   r   shifts           r   evalzSingularityFunction.evalq   s   V QRY&&'WXXRU]]#]^^AEE>Q!%%Z55LE`aa%%66M}}vvqy ,,axB++  E$>$>vv}}	  ,r   c                    | j                   \  }}}|t        j                  t        d      t        d      t        d      fv rt        t        t        ||z
  d      fd      S |j                  rt        ||z
  |z  ||z
  dk\  fd      S y)zV
        Converts a Singularity Function expression into its Piecewise form.

        r   r   r"   r   )r   TN)r   r   r   r   r   r	   r(   r   r   kwargsr   r   r   s         r   _eval_rewrite_as_Piecewisez.SingularityFunction._eval_rewrite_as_Piecewise   s    
 ))1a"quae44b"QUA,/;;q1uqj!a%1*5yAA r   c                    | j                   \  }}}|dk(  r1t        t        ||z
        |j                  j	                         d      S |dk(  r1t        t        ||z
        |j                  j	                         d      S |dk(  r1t        t        ||z
        |j                  j	                         d      S |dk(  r1t        t        ||z
        |j                  j	                         d      S |j
                  r||z
  |z  t        ||z
  d      z  S y	)
z_
        Rewrites a Singularity Function expression using Heavisides and DiracDeltas.

        r"   r!   r      r      r   N)r   r   r   free_symbolspopr(   r2   s         r   _eval_rewrite_as_Heavisidez.SingularityFunction._eval_rewrite_as_Heaviside   s    
 ))1a7	!a%(!..*<*<*>BB7	!a%(!..*<*<*>BB7	!a%(!..*<*<*>BB7	!a%(!..*<*<*>BBEA:iAq111 r   Nc                 2   | j                   \  }}}||z
  j                  |d      }|dk  rt        j                  S |j                  r1|j                  r%|dk(  rt        j                  S t        j
                  S |j                  r||z  S t        j                  S )Nr   r8   )r   subsr   r   r#   Oner   )r   r   logxcdirzr   r   r/   s           r   _eval_as_leading_termz)SingularityFunction._eval_as_leading_term   sv    ))1aQQ"q566MYY5==!RZ1662QUU2!8Ovvr   c                 ^   | j                   \  }}}||z
  j                  |d      }|dk  rt        j                  S |j                  r1|j                  r%|dk(  rt        j                  S t        j
                  S |j                  r||z
  |z  j                  ||||      S t        j                  S )Nr   r8   )r?   r@   )r   r=   r   r   r#   r>   r   _eval_nseries)r   r   r   r?   r@   rA   r   r/   s           r   rD   z!SingularityFunction._eval_nseries   s    ))1aQQ"q566MYY5==!RZ1662QUU2UQJ--aD-IIvvr   )r   )Nr   )__name__
__module____qualname____doc__is_realr   classmethodr0   r4   r;   rB   rD   _eval_rewrite_as_DiracDelta$_eval_rewrite_as_HeavisideDiracDelta r   r   r   r      sO    EN G52 B BH
B2$		 #=+E(r   r   N)
sympy.corer   r   r   sympy.core.functionr   r   sympy.core.logicr   sympy.core.relationalr	   $sympy.functions.elementary.complexesr
   $sympy.functions.elementary.piecewiser   'sympy.functions.special.delta_functionsr   r   rM   r   r   <module>rU      s-    " " < & $ 3 : =]F( ]Fr   