Ë
    7^(hA-  ã            	       ó&  — d 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
mZ ddlmZmZ ddlmZmZmZ dd	lmZmZ dd
lmZmZmZmZ 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l)m*Z* ddl+m,Z,  G d„ d«      Z- G d„ de-«      Z.d„ Z/ e.d„ d„ «      Z0 edd„ g¬«      Z1 edd„ g¬«      Z2 ed«      Z3 ed «      Z4 ed!d"„ g¬«      Z5 e. ee4«      e4z   ee4«      «      Z6 e. ee5e4z  «      e4z  e5 ee5e4z  «      z  «      Z7e6e7fZ8 e.e3 ee4«      z   ed#«      z  e3 ee4«      z  d$„ ¬%«      Z9 e. ed#«       ee4«      z   ee4«      «      Z: e.d&„ d'„ «      Z; G d(„ d)e.«      Z< e<e
e«      Z= e<ee%«      Z> e<e e&«      Z? e.d*„ d+„ «      Z@d,„ d-œd.„ZAd/„ ZBd0„ ZC e.eBeC«      ZD e. e e
e3«       e
e4«      z   «       e"e3e4«      «      ZE e. e e d#e3«       e d#e4«      z   «       e#e3e4«       ed#«      z  «      ZFe=e@e0e9e:fZGeGeEeFfz   e8z   ZHe>e?fZIy1)2aø  
Classes and functions useful for rewriting expressions for optimized code
generation. Some languages (or standards thereof), e.g. C99, offer specialized
math functions for better performance and/or precision.

Using the ``optimize`` function in this module, together with a collection of
rules (represented as instances of ``Optimization``), one can rewrite the
expressions for this purpose::

    >>> from sympy import Symbol, exp, log
    >>> from sympy.codegen.rewriting import optimize, optims_c99
    >>> x = Symbol('x')
    >>> optimize(3*exp(2*x) - 3, optims_c99)
    3*expm1(2*x)
    >>> optimize(exp(2*x) - 1 - exp(-33), optims_c99)
    expm1(2*x) - exp(-33)
    >>> optimize(log(3*x + 3), optims_c99)
    log1p(x) + log(3)
    >>> optimize(log(2*x + 3), optims_c99)
    log(2*x + 3)

The ``optims_c99`` imported above is tuple containing the following instances
(which may be imported from ``sympy.codegen.rewriting``):

- ``expm1_opt``
- ``log1p_opt``
- ``exp2_opt``
- ``log2_opt``
- ``log2const_opt``


é    )Ú
expand_log)ÚS)ÚWild)Úsign)ÚexpÚlog)ÚMaxÚMin)ÚcosÚsinÚsinc)ÚQÚask)Úlog1pÚlog2Úexp2Úexpm1)ÚMatrixSolve)ÚUnevaluatedExpr)ÚPow)Ú	logaddexpÚ
logaddexp2)Úcosm1Úpowm1)ÚMul)ÚMatrixSymbol)Úsiftc                   ó   — e Zd ZdZdd„Zd„ Zy)ÚOptimizationzí Abstract base class for rewriting optimization.

    Subclasses should implement ``__call__`` taking an expression
    as argument.

    Parameters
    ==========
    cost_function : callable returning number
    priority : number

    Nc                 ó    — || _         || _        y ©N)Úcost_functionÚpriority)Úselfr"   r#   s      úU/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/codegen/rewriting.pyÚ__init__zOptimization.__init__@   s   € Ø*ˆÔØˆ�ó    c                 ó0   — t        || j                  ¬«      S )N)Úkey)Úminr"   )r$   Úargss     r%   ÚcheapestzOptimization.cheapestD   s   € Ü�4˜T×/Ñ/Ô0Ð0r'   )Né   )Ú__name__Ú
__module__Ú__qualname__Ú__doc__r&   r,   © r'   r%   r   r   4   s   „ ñ
óó1r'   r   c                   ó(   ‡ — e Zd ZdZˆ fd„Zd„ Zˆ xZS )ÚReplaceOptimaÕ   Rewriting optimization calling replace on expressions.

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

    The instance can be used as a function on expressions for which
    it will apply the ``replace`` method (see
    :meth:`sympy.core.basic.Basic.replace`).

    Parameters
    ==========

    query :
        First argument passed to replace.
    value :
        Second argument passed to replace.

    Examples
    ========

    >>> from sympy import Symbol
    >>> from sympy.codegen.rewriting import ReplaceOptim
    >>> from sympy.codegen.cfunctions import exp2
    >>> x = Symbol('x')
    >>> exp2_opt = ReplaceOptim(lambda p: p.is_Pow and p.base == 2,
    ...     lambda p: exp2(p.exp))
    >>> exp2_opt(2**x)
    exp2(x)

    c                 ó@   •— t        ‰| �  di |¤Ž || _        || _        y )Nr2   )Úsuperr&   ÚqueryÚvalue)r$   r7   r8   ÚkwargsÚ	__class__s       €r%   r&   zReplaceOptim.__init__h   s!   ø€ Ü‰ÑÑ"˜6Ò"ØˆŒ
Øˆ�
r'   c                 óN   — |j                  | j                  | j                  «      S r!   )Úreplacer7   r8   )r$   Úexprs     r%   Ú__call__zReplaceOptim.__call__m   s   € Ø�|‰|˜DŸJ™J¨¯
©
Ó3Ð3r'   )r.   r/   r0   r1   r&   r>   Ú__classcell__©r:   s   @r%   r4   r4   H   s   ø„ ñô>ö
4r'   r4   c                 ó€   — t        |d„ d¬«      D ]+  } || «      }|j                  €|} Œ|j                  | |«      } Œ- | S )aë   Apply optimizations to an expression.

    Parameters
    ==========

    expr : expression
    optimizations : iterable of ``Optimization`` instances
        The optimizations will be sorted with respect to ``priority`` (highest first).

    Examples
    ========

    >>> from sympy import log, Symbol
    >>> from sympy.codegen.rewriting import optims_c99, optimize
    >>> x = Symbol('x')
    >>> optimize(log(x+3)/log(2) + log(x**2 + 1), optims_c99)
    log1p(x**2) + log2(x + 3)

    c                 ó   — | j                   S r!   )r#   )Úopts    r%   ú<lambda>zoptimize.<locals>.<lambda>†   s
   € °s·|±|€ r'   T)r)   Úreverse)Úsortedr"   r,   )r=   ÚoptimizationsÚoptimÚnew_exprs       r%   ÚoptimizerJ   q   sN   € ô* ˜Ñ+CÈTÔRò 2ˆÙ˜“;ˆØ×ÑÐ&Ø‰Dà—>‘> $¨Ó1‰Dð2ð €Kr'   c                 ó<   — | j                   xr | j                  dk(  S )Né   )Úis_PowÚbase©Úps    r%   rD   rD   �   s   € ˆa�h‰hÒ&˜1Ÿ6™6 Q™;€ r'   c                 ó,   — t        | j                  «      S r!   )r   r   rO   s    r%   rD   rD   ‘   s   € Œd�1—5‘5‹k€ r'   Údc                 ó   — | j                   S r!   )Úis_Dummy©Úxs    r%   rD   rD   •   s
   €  Q§Z¡Z€ r'   )Ú
propertiesÚuc                 ó:   — | j                    xr | j                   S r!   )Ú	is_numberÚis_AddrU   s    r%   rD   rD   –   s   € ¨¯© _Ò%E¸Q¿X¹X¸€ r'   ÚvÚwÚnc                 ó   — | j                   S r!   ©rZ   rU   s    r%   rD   rD   ™   s
   €  Q§[¡[€ r'   rL   c                 ó&   — | j                  d„ «      S )Nc                 ó²   — | j                   xr | j                  j                  xs2 t        | t        t
        f«      xr | j                  d   j                   S ©Nr   )rM   r   Úis_negativeÚ
isinstancer   r   r+   rZ   ©Úes    r%   rD   z<lambda>.<locals>.<lambda>¤   sG   € Ø	�‰Ò&�Q—U‘U×&Ñ&ò 	DÜ�qœ3¤˜+Ó&ÒB¨q¯v©v°a©y×/BÑ/BÐ+Bð r'   )Úcount)r=   s    r%   rD   rD   £   s   € ÐSW×S]ÑS]ñEóT€ r'   ©r"   c                 óü   — t        | t        «      xrk | j                  d   j                  xrP t	        | j                  d   j                  «      dk(  xr) t        d„ | j                  d   j                  D «       «      S )Nr   rL   c              3   ó<   K  — | ]  }t        |t        «      –— Œ y ­wr!   )re   r   )Ú.0Úts     r%   ú	<genexpr>z<lambda>.<locals>.<genexpr>°   s   è ø€ ÒB¨a”z !¤S×)ÑBùs   ‚)re   r   r+   r[   ÚlenÚall©Úls    r%   rD   rD   ­   sh   € Œz˜!œSÓ!ò CØ—6‘6˜!‘9×#Ñ#òCä�q—v‘v˜a‘y—~‘~Ó&¨!Ñ+òCô ÑB°1·6±6¸!±9·>±>ÔBÓBð r'   c                 ó$  — t        | j                  d   j                  D �cg c]  }|j                  d   ‘Œ c}Ž t        t        t	        | j                  d   j                  D �cg c]  }|j                  d   ‘Œ c}Ž «      «      z   S c c}w c c}w rc   )r	   r+   r   r   r
   )rr   rg   s     r%   rD   rD   ±   sj   € Ü §¡¨¡§¡Ö0˜Aˆa�f‰f�Q‹iÒ0Ð1ÜŒc”#¨1¯6©6°!©9¯>©>Ö: a˜Ÿ™˜q›	Ò:Ð;Ó<Ó=ñ	>ð ùÚ0ùÚ:s   ¡BÁ$Bc                   ó:   ‡ — e Zd ZdZdˆ fd„	Zd„ Zd„ Zˆ fd„Zˆ xZS )ÚFuncMinusOneOptimaí  Specialization of ReplaceOptim for functions evaluating "f(x) - 1".

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

    Numerical functions which go toward one as x go toward zero is often best
    implemented by a dedicated function in order to avoid catastrophic
    cancellation. One such example is ``expm1(x)`` in the C standard library
    which evaluates ``exp(x) - 1``. Such functions preserves many more
    significant digits when its argument is much smaller than one, compared
    to subtracting one afterwards.

    Parameters
    ==========

    func :
        The function which is subtracted by one.
    func_m_1 :
        The specialized function evaluating ``func(x) - 1``.
    opportunistic : bool
        When ``True``, apply the transformation as long as the magnitude of the
        remaining number terms decreases. When ``False``, only apply the
        transformation if it completely eliminates the number term.

    Examples
    ========

    >>> from sympy import symbols, exp
    >>> from sympy.codegen.rewriting import FuncMinusOneOptim
    >>> from sympy.codegen.cfunctions import expm1
    >>> x, y = symbols('x y')
    >>> expm1_opt = FuncMinusOneOptim(exp, expm1)
    >>> expm1_opt(exp(x) + 2*exp(5*y) - 3)
    expm1(x) + 2*expm1(5*y)


    c                 óz   •‡‡— dŠt         ‰| �  d„ | j                  ˆˆfd„¬«       || _        ‰| _        || _        y )Né
   c                 ó   — | j                   S r!   )r[   rf   s    r%   rD   z,FuncMinusOneOptim.__init__.<locals>.<lambda>á   s
   €  1§8¡8€ r'   c                 óN   •— | j                  «       ‰| j                  ‰«      z  z
  S r!   )Ú	count_opsrh   )r=   Úfunc_m_1Úweights    €€r%   rD   z,FuncMinusOneOptim.__init__.<locals>.<lambda>â   s"   ø€ °D·N±NÓ4DÀvÈdÏjÉjÐYaÓNbÑGbÑ4b€ r'   ri   )r6   r&   Úreplace_in_AddÚfuncr{   Úopportunistic)r$   r~   r{   r   r|   r:   s     ` @€r%   r&   zFuncMinusOneOptim.__init__ß   s?   ú€ ØˆÜ‰ÑÑ+¨T×-@Ñ-@Ü'bð 	ô 	dàˆŒ	Ø ˆŒØ*ˆÕr'   c                 ó„   ‡ — t        |j                  d„ d¬«      \  }}t        |«      }t        |ˆ fd„d¬«      \  }}|||fS )Nc                 ó   — | j                   S r!   r`   ©Úargs    r%   rD   z4FuncMinusOneOptim._group_Add_terms.<locals>.<lambda>è   s
   € °c·m±m€ r'   T©Úbinaryc                 ó:   •— | j                  ‰j                  «      S r!   )Úhasr~   ©rƒ   r$   s    €r%   rD   z4FuncMinusOneOptim._group_Add_terms.<locals>.<lambda>ê   s   ø€ ¸3¿7¹7À4Ç9Á9Ó;M€ r'   )r   r+   Úsum)r$   ÚaddÚnumbersÚnon_numÚnumsumÚterms_with_funcÚothers   `      r%   Ú_group_Add_termsz"FuncMinusOneOptim._group_Add_termsç   sF   ø€ Ü §¡Ñ*CÈDÔQÑˆ�Ü�W“ˆÜ!% gÓ/MÐVZÔ![Ñˆ˜Ø�¨Ð-Ð-r'   c                 ó¼  ‡ — ‰ j                  |«      \  }}}|dk(  r|S g g }}|D �]  }|j                  rHt        |j                  ˆ fd„d¬«      \  }}	t	        |«      dk(  rt	        |	«      dk(  r|d   |	d   }	}n1d}	n.|j
                  ‰ j
                  k(  r|t        j                  }	}nd}	|	�‡|	j                  r{t        |	«      t        |«       k(  rc‰ j                  rt        |	|z   «      t        |«      k  }
n|	|z   dk(  }
|
r2||	z  }|j                  |	 ‰ j                  j                  Ž z  «       �Œ|j                  |«       �Œ"  |j
                  |g|¢|¢|¢­Ž S )z1 passed as second argument to Basic.replace(...) r   c                 ó6   •— | j                   ‰j                   k(  S r!   )r~   rˆ   s    €r%   rD   z2FuncMinusOneOptim.replace_in_Add.<locals>.<lambda>õ   s   ø€ ¸s¿x¹xÈ4Ï9É9Ñ?T€ r'   Tr„   r-   N)r�   Úis_Mulr   r+   ro   r~   r   ÚOnerZ   r   r   ÚabsÚappendr{   )r$   rg   r�   rŽ   Úother_non_num_termsÚsubstitutedÚ	untouchedÚ	with_funcr~   ÚcoeffÚdo_substitutes   `          r%   r}   z FuncMinusOneOptim.replace_in_Addí   sZ  ø€ à7;×7LÑ7LÈQÓ7OÑ4ˆ�Ð!4Ø�QŠ;ØˆHØ!# R�YˆØ(ó 	(ˆIØ×ÒÜ" 9§>¡>Ó3TÐ]aÔb‘��eÜ�t“9 ’>¤c¨%£j°A¢oØ"& q¡'¨5°©8˜%‘Dà ‘EØ—‘ 4§9¡9Ò,Ø'¬¯©�e‘à�àÐ  U§_¢_¼¸e»ÌÈfËÈÒ9UØ×%Ò%Ü$'¨¨f©Ó$5¼¸F»Ñ$C‘Mà$)¨&¡L°AÑ$5�Má Ø˜e‘O�FØ×&Ñ& u¨]¨T¯]©]¸D¿I¹IÐ-FÑ'FÔGÙØ×Ñ˜YÖ'ð-	(ð0 ˆq�v‰v�fÐM˜{ÐM¨YÐMÐ9LÒMÐMr'   c                 ó€   •— t         ‰| �  |«      }t         ‰| �  |j                  «       «      }| j                  ||«      S r!   )r6   r>   Úfactorr,   )r$   r=   Úalt1Úalt2r:   s       €r%   r>   zFuncMinusOneOptim.__call__  s8   ø€ Ü‰wÑ Ó%ˆÜ‰wÑ §¡£Ó.ˆØ�}‰}˜T 4Ó(Ð(r'   )T)	r.   r/   r0   r1   r&   r�   r}   r>   r?   r@   s   @r%   ru   ru   ¸   s$   ø„ ñ$õL+ò.òN÷@)ð )r'   ru   c                 ó"   — t        | t        «      S r!   )re   r   rf   s    r%   rD   rD     s   € Œj˜œCÓ € r'   c                 óœ   — t        | j                  t        d„ «      «      j                  t        t        dz   «      t	        t        «      «      S )Nc                 ó4   — t        | j                  «       «      S r!   )r   rž   r‚   s    r%   rD   z<lambda>.<locals>.<lambda>  s   € œ˜SŸZ™Z›\Ó*€ r'   r-   )r   r<   r   Ú_ur   rq   s    r%   rD   rD     s7   € Œj˜Ÿ™ÜÑ*óó ç�wŒs”2�a‘4‹yœ%¤›)Ó$ð r'   c                 ó   — | j                   S r!   )Ú	is_symbol)Úbs    r%   rD   rD     s
   € ÀÇÁ€ r'   )Úbase_reqc                ó(   ‡ ‡— t        ˆˆ fd„d„ «      S )a   Creates an instance of :class:`ReplaceOptim` for expanding ``Pow``.

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

    The requirements for expansions are that the base needs to be a symbol
    and the exponent needs to be an Integer (and be less than or equal to
    ``limit``).

    Parameters
    ==========

    limit : int
         The highest power which is expanded into multiplication.
    base_req : function returning bool
         Requirement on base for expansion to happen, default is to return
         the ``is_symbol`` attribute of the base.

    Examples
    ========

    >>> from sympy import Symbol, sin
    >>> from sympy.codegen.rewriting import create_expand_pow_optimization
    >>> x = Symbol('x')
    >>> expand_opt = create_expand_pow_optimization(3)
    >>> expand_opt(x**5 + x**3)
    x**5 + x*x*x
    >>> expand_opt(x**5 + x**3 + sin(x)**3)
    x**5 + sin(x)**3 + x*x*x
    >>> opt2 = create_expand_pow_optimization(3, base_req=lambda b: not b.is_Function)
    >>> opt2((x+1)**2 + sin(x)**2)
    sin(x)**2 + (x + 1)*(x + 1)

    c                 ó¨   •— | j                   xrD  ‰| j                  «      xr0 | j                  j                  xr t	        | j                  «      ‰k  S r!   )rM   rN   r   Ú
is_Integerr•   )rg   r¨   Úlimits    €€r%   rD   z0create_expand_pow_optimization.<locals>.<lambda>B  s;   ø€ �!—(‘(Ò\™x¨¯©Ó/Ò\°A·E±E×4DÑ4DÒ\ÌÈQÏUÉUËÐW\ÑI\€ r'   c                 óÚ   — | j                   dkD  r-t        t        | j                  g| j                   ­z  ddiŽ«      S dt        t        | j                  g| j                    z  ddiŽ«      z  S )Nr   ÚevaluateFr-   )r   r   r   rN   rO   s    r%   rD   z0create_expand_pow_optimization.<locals>.<lambda>C  s`   € ØHIÏÉÐPQÊ	ŒOœC 1§6¡6 (¨A¯E©E¨6¡/ÐC¸UÑCÓDð àŒoœc Q§V¡V H¨a¯e©e¨V¡OÐE¸uÑEÓFÑFð r'   )r4   )r¬   r¨   s   ``r%   Úcreate_expand_pow_optimizationr¯     s   ù€ ôF Ü\ñ	
óð r'   c                 ó@  — | j                   r’t        | j                  «      dk(  rz| j                  \  }}|j                  r_|j                  d   dk(  rM|j
                  }t        |t        «      r1t        t        t        j                  |j
                  «      «      «      S y)NrL   r-   F)Ú	is_MatMulro   r+   Ú
is_InverseÚshaperƒ   re   r   Úboolr   r   Úfullrank©r=   ÚleftÚrightÚinv_args       r%   Ú_matinv_predicaterº   I  sn   € à‡~‚~œ#˜dŸi™i›.¨AÒ-Ø—i‘i‰ˆˆeØ�?Š?˜uŸ{™{¨1™~°Ò2Ø—h‘hˆGÜ˜'¤<Ô0ÜœC¤§
¡
¨4¯8©8Ó 4Ó5Ó6Ð6àr'   c                 óP   — | j                   \  }}|j                  }t        ||«      S r!   )r+   rƒ   r   r¶   s       r%   Ú_matinv_transformr¼   T  s%   € Ø—)‘)�K€Dˆ%Ø�h‰h€GÜ�w Ó&Ð&r'   N)Jr1   Úsympy.core.functionr   Úsympy.core.singletonr   Úsympy.core.symbolr   Ú$sympy.functions.elementary.complexesr   Ú&sympy.functions.elementary.exponentialr   r   Ú(sympy.functions.elementary.miscellaneousr	   r
   Ú(sympy.functions.elementary.trigonometricr   r   r   Úsympy.assumptionsr   r   Úsympy.codegen.cfunctionsr   r   r   r   Úsympy.codegen.matrix_nodesr   Úsympy.core.exprr   Úsympy.core.powerr   Úsympy.codegen.numpy_nodesr   r   Úsympy.codegen.scipy_nodesr   r   Úsympy.core.mulr   Ú"sympy.matrices.expressions.matexprr   Úsympy.utilities.iterablesr   r   r4   rJ   Úexp2_optÚ_dr¤   Ú_vÚ_wÚ_nÚ	sinc_opt1Ú	sinc_opt2Ú	sinc_optsÚlog2_optÚlog2const_optÚlogsumexp_2terms_optru   Ú	expm1_optÚ	cosm1_optÚ	powm1_optÚ	log1p_optr¯   rº   r¼   Ú
matinv_optÚlogaddexp_optÚlogaddexp2_optÚ
optims_c99Úoptims_numpyÚoptims_scipyr2   r'   r%   ú<module>rã      s_  ðñõ@ +Ý "Ý "Ý 5ß =ß ?ß EÑ Eß $ß =Ó =Ý 2Ý +Ý  ß ;ß 2Ý Ý ;Ý *÷1ñ 1ô(&4�<ô &4òRñ< Ù&Ùó€ñ 
ˆ#Ñ/Ð0Ô1€Ù	ˆ#ÑEÐFÔG€Ù	ˆ#ƒY€Ù	ˆ#ƒY€Ù	ˆ#Ñ0Ð1Ô2€áÙˆƒGˆB�J‘�R“ó€	ñ Ùˆˆ2‰ƒJˆr�M�2‘d˜2˜b™5“k‘>ó€	ð ˜	Ð"€	á˜™3˜r›7™
¡3 q£6Ñ)¨2©d°2«h©;ñ Gô €ñ ™S ›V¡D¨£H™_©c°"«gÓ6€á#ñDñó	Ð ôX)˜ô X)ñv ˜c 5Ó)€	Ù˜c 5Ó)€	Ù˜c 5Ó)€	áÙ ñ%ó€	ñ 7Lô (òV	ò'ñ Ð+Ð->Ó?€
ñ ™S¡ R£©¨R«¡Ó1±9¸RÀÓ3DÓE€Ù™c¡# a¨£*©S°°B«ZÑ"7Ó8¹*ÀRÈÓ:LÉSÐQRËVÑ:SÓT€ð ˜ H¨h¸ÐF€
à˜]¨NÐ<Ñ<¸yÑH€à˜9Ð%�r'   