403WebShell

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/simplify/__pycache__/
Upload File :
[ Back ]
Current File : /usr/lib/python3/dist-packages/sympy/simplify/__pycache__/cse_main.cpython-310.pyc
o

�8Vazv�@sdZddlmZmZmZmZmZmZddlm	Z	ddl
mZmZddl
mZddlmZddlmZddlmZmZmZmZd	d
lmZejejfedfgZdd
�Zdd�Zdd�Zdd�Z dd�Z!Gdd�d�Z"Gdd�d�Z#dd�Z$d'dd�Z%d(d d!�Z&		"d)d#d$�Z'd%d&�Z(dS)*z3 Tools for doing common subexpression elimination.
�)�Basic�Mul�Add�Pow�sympify�Symbol)�iterable)�Tuple�
OrderedSet)�factor_terms)�_coeff_isneg)�S)�numbered_symbols�sift�topological_sort�ordered�)�cse_optsNcsrt���g}t��D]\}\}}t��D]\}\}}||jvr&|�||f�qq
�fdd�ttt���|f�D�S)a(Sort replacements ``r`` so (k1, v1) appears before (k2, v2)
    if k2 is in v1's free symbols. This orders items in the
    way that cse returns its results (hence, in order to use the
    replacements in a substitution option it would make sense
    to reverse the order).

    Examples
    ========

    >>> from sympy.simplify.cse_main import reps_toposort
    >>> from sympy.abc import x, y
    >>> from sympy import Eq
    >>> for l, r in reps_toposort([(x, y + 1), (y, 2)]):
    ...     print(Eq(l, r))
    ...
    Eq(y, 2)
    Eq(x, y + 1)

    c�g|]}�|�qS�r��.0�i��rr�9/usr/lib/python3/dist-packages/sympy/simplify/cse_main.py�
<listcomp>=�z!reps_toposort.<locals>.<listcomp>)r�	enumerate�free_symbols�appendr�range�len)r�E�c1�k1�v1�c2�k2�v2rrr�
reps_toposort#s
��"r*cCs8t|dd��}|dd�|dD�}|d}t|�|gS)a�Move expressions that are in the form (symbol, expr) out of the
    expressions and sort them into the replacements using the reps_toposort.

    Examples
    ========

    >>> from sympy.simplify.cse_main import cse_separate
    >>> from sympy.abc import x, y, z
    >>> from sympy import cos, exp, cse, Eq, symbols
    >>> x0, x1 = symbols('x:2')
    >>> eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1))
    >>> cse([eq, Eq(x, z + 1), z - 2], postprocess=cse_separate) in [
    ... [[(x0, y + 1), (x, z + 1), (x1, x + 1)],
    ...  [x1 + exp(x1/x0) + cos(x0), z - 2]],
    ... [[(x1, y + 1), (x, z + 1), (x0, x + 1)],
    ...  [x0 + exp(x0/x1) + cos(x1), z - 2]]]
    ...
    True
    cSs|jo|jjS�N)�is_Equality�lhs�	is_Symbol)�wrrr�<lambda>Tszcse_separate.<locals>.<lambda>cS�g|]}|j�qSr)�args)rr/rrrrU�z cse_separate.<locals>.<listcomp>TF)rr*)r�e�drrr�cse_separate@sr6csD|s|�fSddlm}t|�\��|dt���}t|��t���t���t�����fdd�tt���D��tt����fdd�d��\��t�����7�g}t��d	}|dkr����}�|j	@}|ru|�
d
d�t|td�D��|t|�kr�|����|f�n	|��||f��|8�|d	8}|dks\|�
�||fS)a�
    Return tuples giving ``(a, b)`` where ``a`` is a symbol and ``b`` is
    either an expression or None. The value of None is used when a
    symbol is no longer needed for subsequent expressions.

    Use of such output can reduce the memory footprint of lambdified
    expressions that contain large, repeated subexpressions.

    Examples
    ========

    >>> from sympy import cse
    >>> from sympy.simplify.cse_main import cse_release_variables
    >>> from sympy.abc import x, y
    >>> eqs = [(x + y - 1)**2, x, x + y, (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)]
    >>> defs, rvs = cse_release_variables(*cse(eqs))
    >>> for i in defs:
    ...   print(i)
    ...
    (x0, x + y)
    (x1, (x0 - 1)**2)
    (x2, 2*x + 1)
    (_3, x0/x2 + x1)
    (_4, x2**x0)
    (x2, None)
    (_0, x1)
    (x1, None)
    (_2, x0)
    (x0, None)
    (_1, x)
    >>> print(rvs)
    (_0, _1, _2, _3, _4)
    r)�symbolsz_:%dcsg|]
}�|�|f�qSrrr)r4�symsrrr�sz)cse_release_variables.<locals>.<listcomp>cs$t��fdd�|dj�@D��S)Ncsg|]}���|����qSr)�index�	count_opsr)�p�srrr�s�z;cse_release_variables.<locals>.<lambda>.<locals>.<listcomp>r)�sumr)�x)�in_user;r<rrr0�s
�z'cse_release_variables.<locals>.<lambda>��keyrcSsg|]}|df�qSr+r)rr<rrrr�r)�sympyr7�zipr"�list�setr!�sorted�popr�extend�strr �reverse)rr4r7�esyms�rvr�_p�cr)r4r?r;r<r8r�cse_release_variablesZs<"�
�rOcCs"|D]\}}|dur||�}q|S)a} Preprocess an expression to optimize for common subexpression
    elimination.

    Parameters
    ==========

    expr : sympy expression
        The target expression to optimize.
    optimizations : list of (callable, callable) pairs
        The (preprocessor, postprocessor) pairs.

    Returns
    =======

    expr : sympy expression
        The transformed expression.
    Nr��expr�
optimizations�pre�postrrr�preprocess_for_cse�s
�rUcCs&t|�D]\}}|dur||�}q|S)a)Postprocess an expression after common subexpression elimination to
    return the expression to canonical SymPy form.

    Parameters
    ==========

    expr : sympy expression
        The target expression to transform.
    optimizations : list of (callable, callable) pairs, optional
        The (preprocessor, postprocessor) pairs.  The postprocessors will be
        applied in reversed order to undo the effects of the preprocessors
        correctly.

    Returns
    =======

    expr : sympy expression
        The transformed expression.
    N)�reversedrPrrr�postprocess_for_cse�s
�rWc@sLeZdZdZdd�Zdd�Zdd�Zdd	�Zddd�Zddd�Z	dd�Z
d
S)�FuncArgTrackerz}
    A class which manages a mapping from functions to arguments and an inverse
    mapping from arguments to functions.
    cCspi|_g|_g|_g|_t|�D]%\}}t�}|jD]}|�|�}|�|�|j|�|�q|j�	|�qdSr+)
�
value_numbers�value_number_to_value�arg_to_funcset�func_to_argsetrr
r2�get_or_add_value_number�addr )�self�funcs�func_i�func�func_argset�func_arg�
arg_numberrrr�__init__�s


�zFuncArgTracker.__init__cs�fdd�t|�D�S)zh
        Return the list of arguments in sorted order according to their value
        numbers.
        c�g|]}�j|�qSr)rZ)r�argn�r_rrr��z:FuncArgTracker.get_args_in_value_order.<locals>.<listcomp>)rF)r_�argsetrrir�get_args_in_value_order�sz&FuncArgTracker.get_args_in_value_ordercCs>t|j�}|j�||�}||kr|j�|�|j�t��|S)zA
        Return the value number for the given argument.
        )r"rY�
setdefaultrZr r[r
)r_�value�nvalues�value_numberrrrr]�s
z&FuncArgTracker.get_or_add_value_numbercCs$|j|D]
}|j|�|�qdS)zS
        Remove the function func_i from the argument to function mapping.
        N)r\r[�remove)r_ra�argrrr�stop_arg_trackings�z FuncArgTracker.stop_arg_trackingrcs�ddlm}|dd��}|s|S�fdd�|D�}t|td�}|D]}||ur(q!|D]}||kr8||d7<q*q!t||gtd�\}	}
|	D]}||dkrOqF||
vr[||d7<qFd	d
�|��D�S)aReturn a dict whose keys are function numbers. The entries of the dict are
        the number of arguments said function has in common with
        ``argset``. Entries have at least 2 items in common.  All keys have
        value at least ``min_func_i``.
        r)�defaultdictcSsdS)Nrrrrrrr0sz:FuncArgTracker.get_common_arg_candidates.<locals>.<lambda>crgr)r[�rrrrirrrrjz<FuncArgTracker.get_common_arg_candidates.<locals>.<listcomp>r@rcSsi|]\}}|dkr||�qS)�r)r�k�vrrr�
<dictcomp>/sz<FuncArgTracker.get_common_arg_candidates.<locals>.<dictcomp>)�collectionsrt�maxr"rF�items)r_rk�
min_func_irt�	count_map�funcsets�largest_funcset�funcsetra�smaller_funcs_container�larger_funcs_containerrrir�get_common_arg_candidatess6�����z(FuncArgTracker.get_common_arg_candidatesNcCsPt|�}tdd�|jt|�D��}|dur||M}|D]	}||j|M}q|S)z�
        Return a set of functions each of which whose argument list contains
        ``argset``, optionally filtered only to contain functions in
        ``restrict_to_funcset``.
        css�|]}|VqdSr+r)r�firrr�	<genexpr>9s�
�z7FuncArgTracker.get_subset_candidates.<locals>.<genexpr>N)�iterr
r[�next)r_rk�restrict_to_funcset�iarg�indicesrrrrr�get_subset_candidates1s�z$FuncArgTracker.get_subset_candidatescCspt|�}|j|}||D]
}|j|�|�q
||D]
}|j|�|�q|j|��|j|�|�dS)z@
        Update a function with a new set of arguments.
        N)r
r\r[rqr^�clear�update)r_ra�
new_argset�new_args�old_args�deleted_arg�	added_argrrr�update_func_argsetDs
z!FuncArgTracker.update_func_argset)rr+)�__name__�
__module__�__qualname__�__doc__rfrlr]rsr�r�r�rrrrrX�s

)rXc@s4eZdZdd�Zdd�Zdd�Zedd��ZeZd	S)
�UnevaluatedcCs||_||_dSr+�rbr2)r_rbr2rrrrfVs
zUnevaluated.__init__cCs d�|jd�dd�|jD���S)NzUneval<{}>({})z, css�|]}t|�VqdSr+)rI�r�arrrr�\s�z&Unevaluated.__str__.<locals>.<genexpr>)�formatrb�joinr2rirrr�__str__Zs�zUnevaluated.__str__cCs|j|jddi�S)N�evaluateFr�rirrr�as_unevaluated_basic^sz Unevaluated.as_unevaluated_basiccCst�jdd�|jD��S)NcSr1r)rr�rrrrcr3z,Unevaluated.free_symbols.<locals>.<listcomp>)rE�unionr2rirrrraszUnevaluated.free_symbolsN)	r�r�r�rfr�r��propertyr�__repr__rrrrr�Ts
r�cs�t|dd�d�}t|�}t�}tt|��D]�}|j|j||dd��tt����fdd�d��}|r�|jdd�}|j|�	|j|�}t|�dkrKq1|j|�
|�}	|	rst||�|��}
|�
|
�}|�||	t|g�B�|�|�n|�
||�}|j|�
|�}|�||t|g�B�|�|�|�||�D]}
|j|
�
|�}|�|
|t|g�B�|�|
�q�|s3||vr�t||�|j|��|||<|�|�qd	S)
aw
    Recognize and extract common subexpressions of function arguments within a
    set of function calls. For instance, for the following function calls::

        x + z + y
        sin(x + y)

    this will extract a common subexpression of `x + y`::

        w = x + y
        w + z
        sin(w)

    The function we work with is assumed to be associative and commutative.

    Parameters
    ==========

    func_class: class
        The function class (e.g. Add, Mul)
    funcs: list of functions
        A list of function calls.
    opt_subs: dict
        A dictionary of substitutions which this function may update.
    cSs
t|j�Sr+)r"r2)�frrrr0�s
z#match_common_args.<locals>.<lambda>r@r)r}cs�||fSr+r)rw��common_arg_candidates_countsrrr0�sF)�lastN)rFrXr
r!r"r�r\�keysrG�intersection�
differencer�rlr]r�r^r�rs)�
func_classr`�opt_subs�arg_tracker�changedr�common_arg_candidates�j�com_args�diff_i�com_func�com_func_number�diff_jrw�diff_krr�r�match_common_argshsV�
�
�
�


��+��r��	canonicalc	s�ddlm�m�m�t��t��t��t����������fdd��|D]
}t|tt	f�r2�|�q%t�}�D]7}|j
dd�\}}|ro|j|�}|rd|dkrU|j|�}n|j||j|�dd�}|�|<t|�dkro|�
|�q8tt���tt|���S)	a=Find optimization opportunities in Adds, Muls, Pows and negative
    coefficient Muls.

    Parameters
    ==========

    exprs : list of sympy expressions
        The expressions to optimize.
    order : string, 'none' or 'canonical'
        The order by which Mul and Add arguments are processed. For large
        expressions where speed is a concern, use the setting order='none'.

    Returns
    =======

    opt_subs : dictionary of expression substitutions
        The expression substitutions which can be useful to optimize CSE.

    Examples
    ========

    >>> from sympy.simplify.cse_main import opt_cse
    >>> from sympy.abc import x
    >>> opt_subs = opt_cse([x**-2])
    >>> k, v = list(opt_subs.keys())[0], list(opt_subs.values())[0]
    >>> print((k, v.as_unevaluated_basic()))
    (x**(-2), 1/(x**2))
    r)�MatAdd�MatMul�MatPowcst|ttf�s	dS|js|jrdSt|�rtt�|��dS|�vr$|S��|�tt�|j	��t
|�rL|}|jsLtttj
|f��|<��|�|}t|t�f�rZ��|�dSt|t�f�rh��|�dSt|t�f�r�|j|j}}t
|�r�ttt||�df��|<dSdSdS)N���)�
isinstancerr��is_Atom�is_OrderrrD�mapr^r2rrr
�NegativeOnerr�base�exp)rQ�neg_exprr�r��r�r�r��
_find_opts�adds�mulsr��seen_subexprrr��s6

�zopt_cse.<locals>._find_optsF)�csetr)r�)�sympy.matrices.expressionsr�r�r��dictr
rEr�rr��args_cncrbr"r^r�rr)	�exprs�orderr4�commutative_muls�mrN�nc�c_mul�new_objrr�r�opt_cse�s4$�

�r�rcs�ddlm�m�m�m�ddlm��	durt��	t��t��t�������	��fdd��|D]}t	|t
�r;�|�q0�fdd��D��g�t��
������	�
��
��fd	d
��g}|D]}t	|t
�rj�|�}n|}|�|�q^�|fS)a�Perform raw CSE on expression tree, taking opt_subs into account.

    Parameters
    ==========

    exprs : list of sympy expressions
        The expressions to reduce.
    symbols : infinite iterator yielding unique Symbols
        The symbols used to label the common subexpressions which are pulled
        out.
    opt_subs : dictionary of expression substitutions
        The expressions to be substituted before any CSE action is performed.
    order : string, 'none' or 'canonical'
        The order by which Mul and Add arguments are processed. For large
        expressions where speed is a concern, use the setting order='none'.
    ignore : iterable of Symbols
        Substitutions containing any Symbol from ``ignore`` will be ignored.
    r)�
MatrixExpr�MatrixSymbolr�r�)�RootOfNcs�t|ttf�s	dSt|��rdSt|t�r%|js|jr%|jr#��|�dSt|�r,|}n'|�vrC�D]	}||jvr;nq2��|�dS��|�|�vrP�|}|j	}t
t�|��dSr+)r�rr�r�r�r.r^rrr2rDr�)rQr2�ign)r��_find_repeated�excluded_symbols�ignorer�r��to_eliminaterrr�Hs,


�

z tree_cse.<locals>._find_repeatedc3s�|]	}|�vr|VqdSr+r)r�symbol)r�rrr�ps�ztree_cse.<locals>.<genexpr>csjt|ttf�s	|S|js|St|�r �fdd�|D�}|j|�S|�vr(�|S|}|�vr2�|}�dkrgt|t�f�rT|��\}}|dgkrK|}ntt	|��|}nt|t
�f�rctt	|j��}n|j}n|j}tt�|��}t|t�sz||kr�|j|�}n|}|�
vr�zt�	�}Wnt
y�td��wt|��r��|j|j|j�}|�|<��||f�|S|S)Ncsg|]}�|��qSrrru)�_rebuildrrr~rz.tree_cse.<locals>._rebuild.<locals>.<listcomp>�nonerz$Symbols iterator ran out of symbols.)r�rr�r2rrbrr�rDrrr�r��
StopIteration�
ValueError�name�rows�colsr )rQr��	orig_exprrNr�r2�new_expr�sym)r�r�r�r�r�r�r��replacements�subsr7r�rrr�vsP

�

�ztree_cse.<locals>._rebuild)r�r�r�r�r��sympy.polys.rootoftoolsr�r�rEr�rr )r�r7r�r�r�r4�
reduced_exprs�	reduced_er)r�r�r�r�r�r�r�r�r�r�r�r�r�r�r7r�r�tree_cse(s.!
� 9

r�Tcs6ddlm}m}m}	m}
m}|st||�|||d�St|tt	f�r%t
|�}t|t|f�r/|g}|}g}
|D]+}t|||	f�rH|
�t
|����q5t||
|f�r[|
�t
|������q5|
�|�q5|
}~
�durkg�n�dkrqt��fdd�|D�}|dur�ttd�}nt|�}t||�}t|||||�\}}|}t|�D]\}\}}t|��}||f||<q��fd	d�|D�}t|�D]P\}}t|||	f�r�||j|j||�||<t||	�r�||��||<q�t||
|f��r|
|j|ji�}||D]\}}|||<q�t||��r|��}|||<q�|du�r||fS|||�S)
a,
 Perform common subexpression elimination on an expression.

    Parameters
    ==========

    exprs : list of sympy expressions, or a single sympy expression
        The expressions to reduce.
    symbols : infinite iterator yielding unique Symbols
        The symbols used to label the common subexpressions which are pulled
        out. The ``numbered_symbols`` generator is useful. The default is a
        stream of symbols of the form "x0", "x1", etc. This must be an
        infinite iterator.
    optimizations : list of (callable, callable) pairs
        The (preprocessor, postprocessor) pairs of external optimization
        functions. Optionally 'basic' can be passed for a set of predefined
        basic optimizations. Such 'basic' optimizations were used by default
        in old implementation, however they can be really slow on larger
        expressions. Now, no pre or post optimizations are made by default.
    postprocess : a function which accepts the two return values of cse and
        returns the desired form of output from cse, e.g. if you want the
        replacements reversed the function might be the following lambda:
        lambda r, e: return reversed(r), e
    order : string, 'none' or 'canonical'
        The order by which Mul and Add arguments are processed. If set to
        'canonical', arguments will be canonically ordered. If set to 'none',
        ordering will be faster but dependent on expressions hashes, thus
        machine dependent and variable. For large expressions where speed is a
        concern, use the setting order='none'.
    ignore : iterable of Symbols
        Substitutions containing any Symbol from ``ignore`` will be ignored.
    list : bool, (default True)
        Returns expression in list or else with same type as input (when False).

    Returns
    =======

    replacements : list of (Symbol, expression) pairs
        All of the common subexpressions that were replaced. Subexpressions
        earlier in this list might show up in subexpressions later in this
        list.
    reduced_exprs : list of sympy expressions
        The reduced expressions with all of the replacements above.

    Examples
    ========

    >>> from sympy import cse, SparseMatrix
    >>> from sympy.abc import x, y, z, w
    >>> cse(((w + x + y + z)*(w + y + z))/(w + x)**3)
    ([(x0, y + z), (x1, w + x)], [(w + x0)*(x0 + x1)/x1**3])

    Note that currently, y + z will not get substituted if -y - z is used.

    >>> cse(((w + x + y + z)*(w - y - z))/(w + x)**3)
     ([(x0, w + x)], [(w - y - z)*(x0 + y + z)/x0**3])

    List of expressions with recursive substitutions:

    >>> m = SparseMatrix([x + y, x + y + z])
    >>> cse([(x+y)**2, x + y + z, y + z, x + z + y, m])
    ([(x0, x + y), (x1, x0 + z)], [x0**2, x1, y + z, x1, Matrix([
    [x0],
    [x1]])])

    Note: the type and mutability of input matrices is retained.

    >>> isinstance(_[1][-1], SparseMatrix)
    True

    The user may disallow substitutions containing certain symbols:

    >>> cse([y**2*(x + 1), 3*y**2*(x + 1)], ignore=(y,))
    ([(x0, x + 1)], [x0*y**2, 3*x0*y**2])

    The default return value for the reduced expression(s) is a list, even if there is only
    one expression. The `list` flag preserves the type of the input in the output:

    >>> cse(x)
    ([], [x])
    >>> cse(x, list=False)
    ([], x)
    r)�
MatrixBase�Matrix�ImmutableMatrix�SparseMatrix�ImmutableSparseMatrix)r7rR�postprocessr�r�N�basicc�g|]}t|���qSr)rU�rr4�rRrrr.rjzcse.<locals>.<listcomp>)�clscr�r)rWr�r�rrrCs�)�sympy.matricesr�r�r�r�r��_cse_homogeneousr��int�floatrrr r	�flat�todokr|�basic_optimizationsrrr�r�r�rrWr�r��as_immutable)r�r7rRr�r�r�rDr�r�r�r�r��copy�tempr4r�r�r�rr��subtreer�rwrxrr�r�cse�spT�
�

�
�
�

rcs�t�t�rddlm}t|��fi|��\}}|t|�fSt�tttf�r7t	�fi|��\}}|t
��|�fSt�t�r^t����}t	�fdd�|D�fi|��\}}tt
||��}||fSzt	�fi|��\}\}W||fSty{g�fYSw)aM
    Same as ``cse`` but the ``reduced_exprs`` are returned
    with the same type as ``exprs`` or a sympified version of the same.

    Parameters
    ==========

    exprs : an Expr, iterable of Expr or dictionary with Expr values
        the expressions in which repeated subexpressions will be identified
    kwargs : additional arguments for the ``cse`` function

    Returns
    =======

    replacements : list of (Symbol, expression) pairs
        All of the common subexpressions that were replaced. Subexpressions
        earlier in this list might show up in subexpressions later in this
        list.
    reduced_exprs : list of sympy expressions
        The reduced expressions with all of the replacements above.

    Examples
    ========

    >>> from sympy.simplify.cse_main import cse
    >>> from sympy import cos, Tuple, Matrix
    >>> from sympy.abc import x
    >>> output = lambda x: type(cse(x, list=False)[1])
    >>> output(1)
    <class 'sympy.core.numbers.One'>
    >>> output('cos(x)')
    <class 'str'>
    >>> output(cos(x))
    cos
    >>> output(Tuple(1, x))
    <class 'sympy.core.containers.Tuple'>
    >>> output(Matrix([[1,0], [0,1]]))
    <class 'sympy.matrices.dense.MutableDenseMatrix'>
    >>> output([1, x])
    <class 'list'>
    >>> output((1, x))
    <class 'tuple'>
    >>> output({1, x})
    <class 'set'>
    r)rcrrr)rrw�r�rrr�rz$_cse_homogeneous.<locals>.<listcomp>)r�rIrBrr��reprrD�tuplerEr�typer�r�rC�	TypeError)r��kwargsrr�r�r��valuesrrrr�Zs,
.�
�
"��r�)r�)Nr�r)NNNr�rT))r��
sympy.corerrrrrr�sympy.core.compatibilityr�sympy.core.containersr	r
�sympy.core.exprtoolsr�sympy.core.functionr�sympy.core.singletonr
�sympy.utilities.iterablesrrrr�r�sub_pre�sub_postrr*r6rOrUrWrXr�r�r�r�rr�rrrr�<module>s: 
�H
^
b
�"
Youez - 2016 - github.com/yon3zu
LinuXploit