a
    ¬<bû  ã                   @   sd   d dl mZ d dlmZ d dlmZ d dlmZmZ ddl	m
Z
mZ d dlmZ dd	„ Zd
d„ ZdS )é    )ÚMul)ÚS)Údefault_sort_key)Ú
DiracDeltaÚ	Heavisideé   )ÚIntegralÚ	integrate)Úsolvec           	   	   C   s4  g }d}|   ¡ \}}t|td}| |¡ |D ]b}|jrdt|jtƒrd| | 	|j|j
d ¡¡ |j}|du r†t|tƒr†| |¡r†|}q.| |¡ q.|s(g }|D ]b}t|tƒrÄ| |jd|d¡ q |jrøt|jtƒrø| | 	|jjd|d|j
¡¡ q | |¡ q ||krt|Ž  ¡ }nd}d|fS |t|Ž fS )a¶  change_mul(node, x)

       Rearranges the operands of a product, bringing to front any simple
       DiracDelta expression.

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

       If no simple DiracDelta expression was found, then all the DiracDelta
       expressions are simplified (using DiracDelta.expand(diracdelta=True, wrt=x)).

       Return: (dirac, new node)
       Where:
         o dirac is either a simple DiracDelta expression or None (if no simple
           expression was found);
         o new node is either a simplified DiracDelta expressions or None (if it
           could not be simplified).

       Examples
       ========

       >>> from sympy import DiracDelta, cos
       >>> from sympy.integrals.deltafunctions import change_mul
       >>> from sympy.abc import x, y
       >>> change_mul(x*y*DiracDelta(x)*cos(x), x)
       (DiracDelta(x), x*y*cos(x))
       >>> change_mul(x*y*DiracDelta(x**2 - 1)*cos(x), x)
       (None, x*y*cos(x)*DiracDelta(x - 1)/2 + x*y*cos(x)*DiracDelta(x + 1)/2)
       >>> change_mul(x*y*DiracDelta(cos(x))*cos(x), x)
       (None, None)

       See Also
       ========

       sympy.functions.special.delta_functions.DiracDelta
       deltaintegrate
    N)Úkeyr   T©Z
diracdeltaZwrt)Zargs_cncÚsortedr   ÚextendÚis_PowÚ
isinstanceÚbaser   ÚappendÚfuncÚexpÚ	is_simpleÚexpandr   )	ÚnodeÚxÚnew_argsZdiracÚcZncZsorted_argsÚargZnnode© r   ún/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/sympy/integrals/deltafunctions.pyÚ
change_mul	   s2    '

"
r   c                 C   sì  |   t¡sdS | jtkr¢| jd|d}|| kr|  |¡ržt| jƒdksT| jd dkrbt| jd ƒS t| jd | jd d ƒ| jd  ¡  	¡  S nt
||ƒ}|S nF| js°| jrè|  ¡ }| |krät
||ƒ}|duràt|tƒsà|S nt| |ƒ\}}|s|rèt
||ƒ}|S nÚ|jd|d}|jr:t||ƒ\}}|| }t|jd |ƒd }t|jƒdkrbdn|jd }	d}
|	dkrâtj|	 | ||	¡ ||¡ }|jr²|	d8 }	|
d7 }
n,|
dkrÌ|t|| ƒ S |t||
d ƒ S qptjS dS )aß  
    deltaintegrate(f, x)

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

    The idea for integration is the following:

    - If we are dealing with a DiracDelta expression, i.e. DiracDelta(g(x)),
      we try to simplify it.

      If we could simplify it, then we integrate the resulting expression.
      We already know we can integrate a simplified expression, because only
      simple DiracDelta expressions are involved.

      If we couldn't simplify it, there are two cases:

      1) The expression is a simple expression: we return the integral,
         taking care if we are dealing with a Derivative or with a proper
         DiracDelta.

      2) The expression is not simple (i.e. DiracDelta(cos(x))): we can do
         nothing at all.

    - If the node is a multiplication node having a DiracDelta term:

      First we expand it.

      If the expansion did work, then we try to integrate the expansion.

      If not, we try to extract a simple DiracDelta term, then we have two
      cases:

      1) We have a simple DiracDelta term, so we return the integral.

      2) We didn't have a simple term, but we do have an expression with
         simplified DiracDelta terms, so we integrate this expression.

    Examples
    ========

        >>> from sympy.abc import x, y, z
        >>> from sympy.integrals.deltafunctions import deltaintegrate
        >>> from sympy import sin, cos, DiracDelta
        >>> deltaintegrate(x*sin(x)*cos(x)*DiracDelta(x - 1), x)
        sin(1)*cos(1)*Heaviside(x - 1)
        >>> deltaintegrate(y**2*DiracDelta(x - z)*DiracDelta(y - z), y)
        z**2*DiracDelta(x - z)*Heaviside(y - z)

    See Also
    ========

    sympy.functions.special.delta_functions.DiracDelta
    sympy.integrals.integrals.Integral
    NTr   r   r   )Zhasr   r   r   r   ÚlenÚargsr   Zas_polyZLCr	   Zis_Mulr   r   r   r   r
   r   ZNegativeOneÚdiffÚsubsÚis_zeroZZero)Úfr   ÚhÚfhÚgZ	deltatermZ	rest_multZrest_mult_2ZpointÚnÚmÚrr   r   r   ÚdeltaintegrateR   sR    8


ÿ





r+   N)Zsympy.core.mulr   Zsympy.core.singletonr   Zsympy.core.sortingr   Zsympy.functionsr   r   Z	integralsr   r	   Zsympy.solversr
   r   r+   r   r   r   r   Ú<module>   s   I