403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.206
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3/dist-packages/sympy/integrals/__pycache__/deltafunctions.cpython-310.pyc
o

�8Va�@sHddlmZddlmZmZddlmZddlmZdd�Z	dd�Z
d	S)
�)�Mul)�
DiracDelta�	Heaviside)�default_sort_key)�Sc		Cs6g}d}|��\}}t|td�}|�|�|D]1}|jr2t|jt�r2|�|�	|j|j
d��|j}|durCt|t�rC|�|�rC|}q|�|�q|s�g}|D]1}t|t�ra|�|jd|d��qO|jr{t|jt�r{|�|�	|jjd|d�|j
��qO|�|�qO||kr�t
|���}d|fSd}d|fS|t
|�fS)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)�key�T��
diracdelta�wrt)�args_cnc�sortedr�extend�is_Pow�
isinstance�baser�append�func�exp�	is_simple�expandr)	�node�x�new_args�dirac�c�nc�sorted_args�arg�nnode�r �@/usr/lib/python3/dist-packages/sympy/integrals/deltafunctions.py�
change_muls4'

"�r"cCs�|�t�sdSddlm}m}ddlm}|jtkr^|jd|d�}||krW|�	|�rUt
|j�dks8|jddkr?t|jd�St|jd|jdd�|jd�
���SdS|||�}|S|jsd|jr�|��}||kr~|||�}|dur|t||�s||SdSt||�\}}	|s�|	r�||	|�}|SdS|jd|d�}|jr�t||�\}}
|	|
}	||jd|�d}t
|j�dkr�dn|jd}d}
|dkr�d||	�||��||�}|jr�|d8}|
d7}
n|
dkr�|t||�S|t||
d�S|dks�tjSdS)	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
    Nr)�Integral�	integrate)�solveTr	r���)�hasr�sympy.integralsr#r$�
sympy.solversr%rrr�len�argsr�as_poly�LC�is_Mulrrr"�diff�subs�is_zeror�Zero)�frr#r$r%�h�fh�g�	deltaterm�	rest_mult�rest_mult_2�point�n�m�rr r r!�deltaintegratePs^
8

�2
�
(�
 �
�r>N)�
sympy.corer�sympy.functionsrr�sympy.core.compatibilityr�sympy.core.singletonrr"r>r r r r!�<module>sI

Youez - 2016 - github.com/yon3zu
LinuXploit