Ë
    7^(h‰ò  ã                  ó²  — U d Z ddlmZ ddlmZmZmZmZmZ ddl	Z	ddl
mZ ddlmZmZmZmZmZmZmZmZmZ ddlmZ ddl
mZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl
m9Z: dd	l;m<Z< dd
l=m>Z> ddl?m@Z@mAZA ddlBmBZB ddlCmDZD ddlEmFZF ddlGmHZH ddlImJZJ ddlKmLZL er^ddlMmNZN ddlOmPZP ddlQmRZR ddlSmTZT ddlUmVZV ddlWmXZX ddlYmZZZ ddl[m\Z\ ddl]m^Z^m_Z_ ddl`maZambZbmcZc ddldmeZemfZf ddlgmhZh ddlimjZjmkZkmlZlmmZmmnZn  e	jÞ                  d «      Zpe5Zqd!„ Z9 ere«      Zs ere «      Ztd"Zu G d#„ d$ev«      Zw	 exeyeyeyeyf   Zz	 eZ{e|e}ef   Z~dVd%„ZdWdXd&„Z€exe�ey   eyeyeyf   Z‚edYdZd'„«       ZƒedYd[d(„«       ZƒdY	 d\d)„ZƒdWd]d*„Z„d^d+„Z…d_d,„Z†d`d-„Z‡dad.„Zˆdbd/„Z‰dcd0„ZŠddd1„Z‹ded2„ZŒdfd3„Z�dW	 dgd4„ZŽdhd5„Z�did6„Z�djd7„Z‘dkd8„Z’dld9„Z“	 	 dmd:„Z”dnd;„Z•dod<„Z–dpd=„Z—dqd>„Z˜drd?„Z™dsd@„ZšdtdA„Z›dudB„Zœd_dC„Z�dvdD„ZždwdE„ZŸdxdF„Z dxdG„Z¡dydH„Z¢dzdI„Z£d{dJ„Z¤d|dK„Z¥d}dL„Z¦i a§dMe¨dN<   dO„ Z©d}dP„Zªd~dQ„Z« G dR„ dS«      Z¬ddT„Z­	 	 	 d€	 	 	 	 	 d�dU„Z®y)‚z^
Adaptive numerical evaluation of SymPy expressions, using mpmath
for mathematical functions.
é    )Úannotations)ÚCallableÚTYPE_CHECKINGÚAnyÚoverloadÚTypeN)	Úmake_mpcÚmake_mpfÚmpÚmpcÚmpfÚnsumÚquadtsÚquadoscÚworkprec)Úinf)!Úfrom_intÚfrom_man_expÚfrom_rationalÚfhalfÚfnanÚfinfÚfninfÚfnoneÚfoneÚfzeroÚmpf_absÚmpf_addÚmpf_atanÚ	mpf_atan2Úmpf_cmpÚmpf_cosÚmpf_eÚmpf_expÚmpf_logÚmpf_ltÚmpf_mulÚmpf_negÚmpf_piÚmpf_powÚmpf_pow_intÚ	mpf_shiftÚmpf_sinÚmpf_sqrtÚ	normalizeÚround_nearestÚto_intÚto_strÚmpf_tan)Úbitcount)ÚMPZ)Ú	_infs_nan)Údps_to_precÚprec_to_dpsé   )Úsympify)ÚS)Ú
SYMPY_INTS)Úis_sequence)Úlambdify)Úas_int)ÚExpr©ÚAdd©ÚMul©ÚPow)ÚSymbol©ÚIntegral©ÚSum©ÚProduct©ÚexpÚlog)ÚAbsÚreÚim©ÚceilingÚfloor)Úatan)ÚFloatÚRationalÚIntegerÚAlgebraicNumberÚNumberé
   c                ó<   — t        t        t        | «      «      «      S )z8Return smallest integer, b, such that |n|/2**b < 1.
    )Úmpmath_bitcountÚabsÚint)Úns    úN/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/core/evalf.pyr4   r4   2   s   € ô œ3œs 1›v›;Ó'Ð'ó    iM  c                  ó   — e Zd Zy)ÚPrecisionExhaustedN)Ú__name__Ú
__module__Ú__qualname__© rd   rc   rf   rf   A   s   „ Ørd   rf   c                ó:   — | r	| t         k(  rt        S | d   | d   z   S )a^  Fast approximation of log2(x) for an mpf value tuple x.

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

    Calculated as exponent + width of mantissa. This is an
    approximation for two reasons: 1) it gives the ceil(log2(abs(x)))
    value and 2) it is too high by 1 in the case that x is an exact
    power of 2. Although this is easy to remedy by testing to see if
    the odd mpf mantissa is 1 (indicating that one was dealing with
    an exact power of 2) that would decrease the speed and is not
    necessary as this is only being used as an approximation for the
    number of bits in x. The correct return value could be written as
    "x[2] + (x[3] if x[1] != 1 else 0)".
        Since mpf tuples always have an odd mantissa, no check is done
    to see if the mantissa is a multiple of 2 (in which case the
    result would be too large by 1).

    Examples
    ========

    >>> from sympy import log
    >>> from sympy.core.evalf import fastlog, bitcount
    >>> s, m, e = 0, 5, 1
    >>> bc = bitcount(m)
    >>> n = [1, -1][s]*m*2**e
    >>> n, (log(n)/log(2)).evalf(2), fastlog((s, m, e, bc))
    (10, 3.3, 4)
    é   é   )r   Ú	MINUS_INF)Úxs    rc   Úfastlogrp   r   s%   € ñ> �”U’
ÜÐØˆQ‰4�!�A‘$‰;Ðrd   c                óª   — | j                  «       \  }}|r*|j                  «       \  }}|t        j                  u r||fS y|r|t        j                  fS y)a  Return a and b if v matches a + I*b where b is not zero and
    a and b are Numbers, else None. If `or_real` is True then 0 will
    be returned for `b` if `v` is a real number.

    Examples
    ========

    >>> from sympy.core.evalf import pure_complex
    >>> from sympy import sqrt, I, S
    >>> a, b, surd = S(2), S(3), sqrt(2)
    >>> pure_complex(a)
    >>> pure_complex(a, or_real=True)
    (2, 0)
    >>> pure_complex(surd)
    >>> pure_complex(a + b*I)
    (2, 3)
    >>> pure_complex(I)
    (0, 1)
    N)Úas_coeff_AddÚas_coeff_Mulr;   ÚImaginaryUnitÚZero)ÚvÚor_realÚhÚtÚcÚis         rc   Úpure_complexr|   –   sW   € ð( �>‰>Ó�D€A€qÙØ�~‰~Ó‰ˆˆ1Ø”—‘ÑØ�a�4ˆKð ñ 
Ø”!—&‘&ˆyÐØrd   c                 ó   — y ©Nrj   ©ÚmagÚsigns     rc   Úscaled_zeror‚   ¹   ó   € àrd   c                 ó   — y r~   rj   r   s     rc   r‚   r‚   ¼   rƒ   rd   c                ó  — t        | t        «      r*t        | «      dk(  rt        | d¬«      r| d   d   f| dd z   S t        | t        «      r8|dvrt        d«      ‚t        t        | «      d	}}|dk(  rdnd}|gf|dd z   }||fS t        d
«      ‚)al  Return an mpf representing a power of two with magnitude ``mag``
    and -1 for precision. Or, if ``mag`` is a scaled_zero tuple, then just
    remove the sign from within the list that it was initially wrapped
    in.

    Examples
    ========

    >>> from sympy.core.evalf import scaled_zero
    >>> from sympy import Float
    >>> z, p = scaled_zero(100)
    >>> z, p
    (([0], 1, 100, 1), -1)
    >>> ok = scaled_zero(z)
    >>> ok
    (0, 1, 100, 1)
    >>> Float(ok)
    1.26765060022823e+30
    >>> Float(ok, p)
    0.e+30
    >>> ok, p = scaled_zero(100, -1)
    >>> Float(scaled_zero(ok), p)
    -0.e+30
    é   T©Úscaledr   r9   N)éÿÿÿÿr9   zsign must be +/-1r‰   z-scaled zero expects int or scaled_zero tuple.)Ú
isinstanceÚtupleÚlenÚiszeror<   Ú
ValueErrorr,   r   )r€   r�   ÚrvÚpÚss        rc   r‚   r‚   ¿   sŸ   € ô4 �#”uÔ¤# c£(¨a¢-´F¸3ÀtÕ4LØ�A‘�q‘	ˆ|˜c ! "˜gÑ%Ð%Ü	�CœÔ	$Ø�wÑÜÐ0Ó1Ð1Üœ$ Ó$ bˆAˆØ˜’‰A ˆØˆcˆV�b˜˜�f‰_ˆØ�1ˆuˆäÐHÓIÐIrd   c                óŠ   — |s|  xs | d    xr | d    S | xr+ t        | d   t        «      xr | d   | d   cxk(  xr dk(  S c S )Nr9   r‰   r   )rŠ   Úlist)r   rˆ   s     rc   r�   r�   æ   sV   € ÙØˆwÒ4˜c !™f˜*Ò4¨S°©W¨Ð4ØÒF”:˜c !™f¤dÓ+ÒF°°A±¸#¸b¹'Ö0FÀQÑ0FÐFÑ0FÐFrd   c                óÔ   — | t         j                  u rt        S | \  }}}}|s
|st        S |S |s|S t        |«      }t        |«      }t	        ||z
  ||z
  «      }|t	        ||«      z
  }| S )a  
    Returns relative accuracy of a complex number with given accuracies
    for the real and imaginary parts. The relative accuracy is defined
    in the complex norm sense as ||z|+|error|| / |z| where error
    is equal to (real absolute error) + (imag absolute error)*i.

    The full expression for the (logarithmic) error can be approximated
    easily by using the max norm to approximate the complex norm.

    In the worst case (re and im equal), this is wrong by a factor
    sqrt(2), or by log2(sqrt(2)) = 0.5 bit.
    )r;   ÚComplexInfinityÚINFrp   Úmax)	ÚresultrR   rS   Úre_accÚim_accÚre_sizeÚim_sizeÚabsolute_errorÚrelative_errors	            rc   Úcomplex_accuracyrŸ   ì   s~   € ð ”×"Ñ"Ñ"Üˆ
Ø#Ñ€BˆˆF�FÙÙÜˆJØˆÙØˆÜ�b‹k€GÜ�b‹k€GÜ˜ 6Ñ)¨7°VÑ+;Ó<€NØ#¤c¨'°7Ó&;Ñ;€NØˆ?Ðrd   c           	     ó‚  — t        | |dz   |«      }|t        j                  u r
t        d |d fS |\  }}}}|s||||f\  }}}}|rl| j                  r1t        t        t        | |dz   «      «      |dz   |«      \  }}	}
}	|d |
d fS d|v rt        j                  ||f|«      d |d fS t        | «      d |d fS |rt        |«      d |d fS y)Nrl   Úsubs©NNNN)
Úevalfr;   r•   r   Ú	is_numberr`   ÚNÚlibmpÚmpc_absr   )ÚexprÚprecÚoptionsr˜   rR   rS   r™   rš   Úabs_exprÚ_Úaccs              rc   Úget_absr®   	  sò   € Ü�4˜ ™ 7Ó+€FØ”×"Ñ"Ñ"Ü�T˜4 Ð%Ð%Ø#Ñ€BˆˆF�FÙØ!# V¨R°Ð!7ÑˆˆF�B˜Ù	Ø�>Š>Ü"'¬¬A¨d°D¸1±HÓ,=Ó(>Ø(,¨q©°'ó#;ÑˆH�a˜˜aà˜T 3¨Ð,Ð,à˜Ñ Ü—}‘} b¨" X¨tÓ4°d¸FÀDÐHÐHÜ�t“9˜d D¨$Ð.Ð.Ù	Ü�r‹{˜D &¨$Ð.Ð.à%rd   c                óÐ   — |}d}	 t        | ||«      }|t        j                  u r
t        d|dfS ||dd…   \  }}|r||k\  s	|d    |kD  r|d|dfS |t	        dd|z  «      z  }|dz  }Œb)z/no = 0 for real part, no = 1 for imaginary partr   r9   Nrl   é   )r£   r;   r•   r   r—   )	r¨   Únor©   rª   r   r{   ÚresÚvalueÚaccuracys	            rc   Úget_complex_partrµ     s•   € à€HØ	€AØ
Ü�D˜( GÓ,ˆØ”!×#Ñ#Ñ#Ü˜˜t TÐ)Ð)Ø˜b˜e !˜e™*‰ˆˆxá˜( dÒ*¨u°Q©x¨i¸$Ò.>Ø˜$ ¨$Ð.Ð.Ø”C˜˜A˜q™D“MÑ!ˆØ	ˆQ‰ˆð rd   c                ó6   — t        | j                  d   ||«      S ©Nr   )r®   Úargs©r¨   r©   rª   s      rc   Ú	evalf_absrº   /  s   € Ü�4—9‘9˜Q‘<  wÓ/Ð/rd   c                ó8   — t        | j                  d   d||«      S r·   ©rµ   r¸   r¹   s      rc   Úevalf_rer½   3  ó   € Ü˜DŸI™I a™L¨!¨T°7Ó;Ð;rd   c                ó8   — t        | j                  d   d||«      S ©Nr   r9   r¼   r¹   s      rc   Úevalf_imrÁ   7  r¾   rd   c                ó  — | t         k(  r|t         k(  rt        d«      ‚| t         k(  rd |d |fS |t         k(  r| d |d fS t        | «      }t        |«      }||kD  r|}|t        ||z
   d«      z   }n|}|t        ||z
   d«      z   }| |||fS )Nz&got complex zero with unknown accuracyr   )r   rŽ   rp   Úmin)rR   rS   r©   Úsize_reÚsize_imr™   rš   s          rc   Úfinalize_complexrÆ   ;  s¬   € Ø	ŒU‚{�rœU’{ÜÐAÓBÐBØ	ŒuŠØ�R˜˜tÐ#Ð#Ø	ŒuŠØ�4˜˜tÐ#Ð#ä�b‹k€GÜ�b‹k€GØ�ÒØˆØœ˜g¨Ñ/Ð0°!Ó4Ñ4‰àˆØœ˜g¨Ñ/Ð0°!Ó4Ñ4ˆØˆr�6˜6Ð!Ð!rd   c                óT  — | t         j                  u r| S | \  }}}}|r|t        vrt        |«      | dz   k  rd\  }}|r|t        vrt        |«      | dz   k  rd\  }}|rD|rBt        |«      t        |«      z
  }|dk  r||z
  | dz   k  rd\  }}|dk  r||z
  |dz
  k\  rd\  }}||||fS )z.
    Chop off tiny real or complex parts.
    r†   ©NNrl   )r;   r•   r6   rp   )r³   r©   rR   rS   r™   rš   Údeltas          rc   Ú
chop_partsrÊ   N  sÓ   € ð ”×!Ñ!Ñ!ØˆØ"Ñ€BˆˆF�Fá	ˆbœ	Ñ!¤w¨r£{°d°U¸Q±YÒ'>Ø‰
ˆˆFÙ	ˆbœ	Ñ!¤w¨r£{°d°U¸Q±YÒ'>Ø‰
ˆˆFá	‰bÜ˜“œg b›kÑ)ˆØ�AŠ:˜5 6™>¨d¨U°Q©YÒ6Ø#‰JˆB�Ø�AŠ:˜5 6™>¨T°A©XÒ5Ø#‰JˆB�Øˆr�6˜6Ð!Ð!rd   c                ó@   — t        |«      }||k  rt        d| z  «      ‚y )Nz‡Failed to distinguish the expression: 

%s

from zero. Try simplifying the input, using chop=True, or providing a higher maxn for evalf)rŸ   rf   )r¨   r˜   r©   Úas       rc   Úcheck_targetrÍ   d  s2   € Ü˜Ó €AØˆ4‚xÜ ð "&à)-ñ"/ó 0ð 	0ð rd   c                ó€  ‡‡‡— ddl m}m} d}t        | |‰«      }|t        j
                  u rt        d«      ‚|\  }}	}
}|r'|	r%t        t        |«      |
z
  t        |	«      |z
  «      }n&|rt        |«      |
z
  }n|	rt        |	«      |z
  }n|ryyd}|| k\  r||z   |z   Št        | ‰‰«      \  }}	}
}n|Šdˆˆˆfd„}d\  }}}}|�|t        k7  r | || d	¬
«      |«      \  }}|	�|	t        k7  r | || d	¬
«      |	«      \  }}|r8t        t        |xs t        «      «      t        t        |xs t        «      «      fS ||||fS )zŸ
    With no = 1, computes ceiling(expr)
    With no = -1, computes floor(expr)

    Note: this function either gives the exact result or signals failure.
    r   ©rR   rS   r°   z+Cannot get integer part of Complex Infinity©r   r   r¢   r]   c                óþ  •‡— ddl m} |\  }}}}|dk(  }t        t        |t        «      «      }|rjt        | |z
  d‰«      \  }}}	}
|rJ ‚t        |«       dz   }|‰kD  rt        | |‰«      \  }}}	}
|rJ ‚|}t        t        |t        «      «      }|\  }}}}|dk(  }|s¤‰j                  dd«      }|r6d„ Št        ˆfd	„|j                  «       D «       «      r| j                  |«      }  || | d¬
«      } t        | d‰«      \  }}}}	 t        | |d |d fd«       |t        ‰t        |xs t        t        «      ‰k(  z  «      z  }t!        |«      }|t"        fS # t        $ r  | j                  d«      st        ‚t        }Y Œew xY w)Nr9   rA   r   r]   rl   r¡   Fc                ó¾   — 	 t        | d¬«       y# t        $ rC 	 | j                  «       D �cg c]  }t        |d¬«      ‘Œ nc c}w c} Y y# t        $ r Y Y yw xY ww xY w)z)Check for integer or integer + I*integer.F)ÚstrictT)r?   rŽ   Úas_real_imag)ro   r{   s     rc   Úis_int_reimz8get_integer_part.<locals>.calc_part.<locals>.is_int_reim´  s\   € ð)Ü˜q¨Õ/Ø#øÜ%ò )ð)Ø>?¿n¹nÓ>NÖO¸œV A¨eÖ4ÑOùÕOÙ#'øÜ)ò )Ú#(ð)úð	)ús1   ‚ �	AšA¬AÁ 	AÁ	AÁAÁAÁAc              3  ó.   •K  — | ]  } ‰|«      –— Œ y ­wr~   rj   )Ú.0rv   rÕ   s     €rc   ú	<genexpr>z6get_integer_part.<locals>.calc_part.<locals>.<genexpr>À  s   øè ø€ Ò:¨!‘{ 1—~Ñ:ùs   ƒ©Úevaluaterm   )ÚaddrB   ra   r1   Úrndr£   rp   ÚgetÚallÚvaluesr¡   rÍ   rf   Úequalsr   r!   r   r–   )Úre_imÚnexprrB   r¬   ÚexponentÚis_intÚnintÚireÚiimÚire_accÚiim_accÚsizeÚnew_expr‘   ro   Úx_accrÕ   r±   rª   r©   s                   @€€€rc   Ú	calc_partz#get_integer_part.<locals>.calc_part—  s�  ù€ ÝØ!Ñˆˆ1ˆh˜Ø˜Q‘ˆÜ”6˜%¤Ó%Ó&ˆÙô */Ø˜‘˜b 'ó*+Ñ&ˆC��g˜wáˆN�7Ü˜C“L�= 1Ñ$ˆDØ�dŠ{Ü-2Ø˜4 ó.*Ñ*��S˜' 7á��wØ�Ü”v˜e¤SÓ)Ó*ˆDØ"ÑˆAˆq�'˜1Ø ‘\ˆFÙð —‘˜F EÓ*ˆAÙò
)ô Ó:¨q¯x©x«zÔ:Ô:Ø!ŸJ™J q›M�Eá˜ ˜u¨uÔ5ˆEÜ" 5¨"¨gÓ6‰NˆAˆq�%˜ðÜ˜U Q¨¨e°TÐ$:¸AÔ>ð
 ”C˜œG A¢J¬´Ó6¸"Ñ<Ñ=Ó>Ñ>ˆDÜ˜‹~ˆØ”SˆyÐøô &ò Ø—|‘| A”Ü,Ð,Ü’ðús   ÄE Å&E<Å;E<FrÙ   )rá   r@   râ   ÚMPF_TUP)Ú$sympy.functions.elementary.complexesrR   rS   r£   r;   r•   rŽ   r—   rp   r   ra   r1   )r¨   r±   rª   Úreturn_intsrR   rS   Úassumed_sizer˜   ræ   rç   rè   ré   ÚgapÚmarginrí   Úre_Úim_r™   rš   r©   s    ``                @rc   Úget_integer_partrö   l  sf  ú€ ÷ <à€LÜ�4˜ wÓ/€FØ”×"Ñ"Ñ"ÜÐFÓGÐGØ!'Ñ€Cˆˆg�wñ ‰sÜ”'˜#“, Ñ(¬'°#«,¸Ñ*@ÓA‰Ù	Ü�c‹l˜WÑ$‰Ù	Ü�c‹l˜WÑ$‰ñ Øà)à€Fà
ˆvˆg‚~Ø˜Ñ$ sÑ*ˆÜ%*Ø�$˜ó&!Ñ"ˆˆS�'™7ð ˆ÷
6ðp  6Ñ€Cˆˆf�fà
€˜3¤%š<Ù¡ 4°%Ô 8¸#Ó>‰ˆˆVØ
€˜3¤%š<Ù¡ 4°%Ô 8¸#Ó>‰ˆˆVáÜ”6˜#š,¤Ó'Ó(¬#¬f°S²\¼EÓ.BÓ*CÐCÐCØ��V˜VÐ#Ð#rd   c                ó6   — t        | j                  d   d|«      S rÀ   ©rö   r¸   r¹   s      rc   Úevalf_ceilingrù   Û  s   € Ü˜DŸI™I a™L¨!¨WÓ5Ð5rd   c                ó6   — t        | j                  d   d|«      S )Nr   r‰   rø   r¹   s      rc   Úevalf_floorrû   ß  s   € Ü˜DŸI™I a™L¨"¨gÓ6Ð6rd   c                ó"   — | j                   d |d fS r~   )Ú_mpf_r¹   s      rc   Úevalf_floatrþ   ã  s   € Ø�:‰:�t˜T 4Ð'Ð'rd   c                óL   — t        | j                  | j                  |«      d |d fS r~   )r   r�   Úqr¹   s      rc   Úevalf_rationalr  ç  s"   € Ü˜Ÿ™ §¡¨Ó.°°d¸DÐ@Ð@rd   c                ó6   — t        | j                  |«      d |d fS r~   )r   r�   r¹   s      rc   Úevalf_integerr  ë  s   € Ü�D—F‘F˜DÓ! 4¨¨tÐ3Ð3rd   c                ó&  — | D �cg c]  }t        |d   «      rŒ|‘Œ } }| syt        | «      dk(  r| d   S g }ddlm} | D ]H  } |j                  |d   d«      }|t
        j                  u s|j                  sŒ8|j                  |«       ŒJ |r#ddl	m
} t         ||Ž |dz   i «      }|d   |d   fS d|z  }	d\  }
}g }| D ]~  \  }}|\  }}}}|r| }|j                  ||z   |z
  «       ||z
  }||k\  r/||	kD  r!|
r|t        t        |
«      «      z
  |	kD  r|}
|}ŒY|
||z  z  }
Œb| }||z
  |	kD  r|
rŒp||}}
Œu|
|z  |z   }
|}Œ€ t        |«      }|
st        |«      S |
dk  rd}|
 }
nd}t        |
«      }||z   |z
  }t!        ||
|||t"        «      |f}|S c c}w )	a'  
    Helper for evalf_add. Adds a list of (mpfval, accuracy) terms.

    Returns
    =======

    - None, None if there are no non-zero terms;
    - terms[0] if there is only 1 term;
    - scaled_zero if the sum of the terms produces a zero by cancellation
      e.g. mpfs representing 1 and -1 would produce a scaled zero which need
      special handling since they are not actually zero and they are purposely
      malformed to ensure that they cannot be used in anything but accuracy
      calculations;
    - a tuple that is scaled to target_prec that corresponds to the
      sum of the terms.

    The returned mpf tuple will be normalized to target_prec; the input
    prec is used to define the working precision.

    XXX explain why this is needed and why one cannot just loop using mpf_add
    r   rÈ   r9   ©rX   rA   r†   rl   rÐ   )r�   rŒ   ÚnumbersrX   Ú_newr;   ÚNaNÚis_infiniteÚappendrÛ   rB   r£   r4   r`   r—   r‚   r/   rÜ   )Útermsr©   Útarget_precry   ÚspecialrX   ÚargrB   r�   Úworking_precÚsum_manÚsum_expÚabsolute_errro   r´   r�   ÚmanrO   ÚbcrÉ   r�   Úsum_signÚsum_bcÚsum_accuracyÚrs                            rc   Ú	add_termsr  õ  s  € ð0 Ö2�1¤V¨A¨a©D¥\ŠQÐ2€EÐ2ÙØÜ	ˆU‹�qŠØ�Q‰xˆð €GÝØò  ˆØˆe�j‰j˜˜1™˜qÓ!ˆØ”!—%‘%‰<˜3Ÿ?›?Ø�N‰N˜3Õð ñ ÝÜ‘3˜�= $¨¡(¨BÓ/ˆØ�!‰u�b˜‘eˆ|Ðà�T‘6€LØÑ€GˆWØ €Làò ‰ˆˆ8ØÑˆˆc�3˜ÙØ�$ˆCØ×Ñ˜B ™H xÑ/Ô0Ø�g‘ˆØ�'Š>ð ˜Ò%ÙØœ¤# g£,Ó/Ñ/°,Ò>Ø�Ø‘à˜C 5™LÑ)‘à�FˆEà�r‰z˜LÒ(ÚØ'*¨C˜W‘Gà" eÑ+¨sÑ2�Ø‘ð1ô2 ˜Ó&€NÙÜ˜>Ó*Ð*Ø�‚{ØˆØ�(‰àˆÜ�gÓ€FØ˜VÑ# nÑ4€LÜ�(˜G W¨f°kÜó	Øð	€Aà€Hùòw 3s
   …F™Fc           	     ó‚  — t        | «      }|r/|\  }}t        |||«      \  }}}}t        |||«      \  }	}}
}||	||
fS |j                  dt        «      }d}|}	 t	        |d|z  «      |d<   | j
                  D �cg c]  }t        ||dz   |«      ‘Œ }}|j                  t        j                  «      }|dk\  r
t        d |d fS t        |D �cg c]!  }t        |t        «      sŒ|d   sŒ|dd d…   ‘Œ# c}||«      \  }}t        |D �cg c]!  }t        |t        «      sŒ|d   sŒ|dd d…   ‘Œ# c}||«      \  }	}
|dk(  r@|t        t        t        fv s|	t        t        t        fv r
t        d |d fS t        j                  S t        ||	||
f«      }||k\  r!|j                  d«      rt!        d|d||
«       nH||z
  |d   kD  rn<|t#        dd|z  z   ||z
  «      z   }|dz  }|j                  d«      rt!        d	|«       �ŒŸ||d<   t%        |d
¬«      rt'        |«      }t%        |	d
¬«      rt'        |	«      }	||	||
fS c c}w c c}w c c}w )NÚmaxprecr   r9   rl   r]   ÚverbosezADD: wantedúaccurate bits, gotzADD: restarting with precTr‡   )r|   r£   rÝ   ÚDEFAULT_MAXPRECrÃ   r¸   Úcountr;   r•   r   r  rŠ   r‹   r   r   rŸ   Úprintr—   r�   r‚   )rv   r©   rª   r²   rx   rz   rR   r¬   r™   rS   rš   Ú
oldmaxprecr{   r  r  r  rb   rÌ   r­   s                      rc   Ú	evalf_addr"  K  sk  € Ü
�q‹/€CÙ
Ø‰ˆˆ1Ü   D¨'Ó2ÑˆˆAˆv�qÜ   D¨'Ó2ÑˆˆAˆv�qØ�2�v˜vÐ%Ð%à—‘˜Y¬Ó8€Jà	€AØ€KØ
Ü  ¨Q¨t©VÓ4ˆ�	Ñà;<¿6¹6ÖB°C”�s˜D 2™I wÕ/ÐBˆÐBØ�K‰Kœ×)Ñ)Ó*ˆØ�Š6Ü˜˜t TÐ)Ð)ÜØ#ÖE˜¤z°!´UÕ';ÀÀ!ÃˆQˆqˆt�!ˆt‹WÒEÀtÈ[óZ‰
ˆˆFäØ#ÖE˜¤z°!´UÕ';ÀÀ!ÃˆQˆqˆt�!ˆt‹WÒEÀtÈ[óZ‰
ˆˆFà�Š6Ø”dœE¤4Ð(Ñ(¨B´4¼ÄÐ2EÑ,EÜ˜T 4¨Ð-Ð-Ü×$Ñ$Ð$Ü  B¨°Ð7Ó8ˆØ�+ÒØ�{‰{˜9Ô%Ü�m [Ð2FÈÐPVÔWØà�{Ñ" g¨iÑ&8Ò8Øàœ#˜b 1 a¡4™i¨°sÑ):Ó;Ñ;ˆDØ�‰FˆAØ�{‰{˜9Ô%ÜÐ1°4Ô8ñ7 ð: $€GˆIÑÜˆb˜ÕÜ˜‹_ˆÜˆb˜ÕÜ˜‹_ˆØˆr�6˜6Ð!Ð!ùò? Cùò
 FùâEs*   Á8H2ÃH7ÃH7Ã$
H7ÄH<ÄH<Ä
H<c           
     ó  — t        | «      }|r|\  }}t        |||«      \  }}}}d |d |fS t        | j                  «      }d}	g }
ddlm} |D ]’  }t        |||«      }|t        j                  u r|
j                  |«       Œ4|d   €|d   €d}	ŒA |j                  |d   d«      }|t        j                  u rt        d |d fc S |j                  sŒ‚|
j                  |«       Œ” |
r%|	r
t        d |d fS ddlm} t         ||
Ž |dz   i «      S |	ry|}|t        |«      z   d	z   }t!        d«      ddfx}\  }}}t        |«      }d}|j                  t        j"                  «       g }t%        |«      D ]×  \  }}||k7  r%t        |«      r|d
   |z  j'                  «       |d
<   Œ0||k(  r|t        j"                  u rŒHt        |||«      \  }}}}|r|r|j                  ||||f«       Œt|r||c\  }}}}} n|r||c\  }}}}} |dz  }n y|d|z  z  }||z  }||z  }||z  }|d|z  kD  r||z  }||z  }||z  }|d|z  kD  rŒt)        || «      }ŒÙ |dz  dz	  }!|s.t+        |!||t-        |«      |t.        «      } |dz  rd | d |fS | d |d fS |||f|k7  r!|!||t-        |«      fdt!        d«      ddf}}d}"n)|d   \  }#}$}%}&t)        |t1        |#|$|%|&f«      «      }|#}|$}d}"||"d  D ]y  \  }#}$}%}&t)        |t1        |#|$|%|&f«      «      }|}'t3        ||#|'«      }(t3        t5        |«      |$|'«      })t3        ||$|'«      }*t3        ||#|'«      }+t7        |(|)|'«      }t7        |*|+|'«      }Œ{ |j9                  d«      rt;        d|d|«       |dz  rt5        |«      |}}||||fS )NFr9   r  r   TrC   r†   r¢   é   r‰   rl   rm   r  zMUL: wantedr  )r|   r£   r“   r¸   r  rX   r;   r•   r
  r  r  r   r	  ÚmulrD   rŒ   r5   ÚOneÚ	enumerateÚexpandrÃ   r/   r4   rÜ   rŸ   r'   r(   r   rÝ   r   ),rv   r©   rª   r²   r¬   rx   rS   rš   r¸   Úhas_zeror  rX   r  r˜   ÚnumrD   r­   r  Ústartr  rO   r  ÚlastÚ	directionÚcomplex_factorsr{   rR   r™   r‘   ÚmÚeÚbÚw_accr�   Úi0ÚwreÚwimÚwre_accÚwim_accÚuse_precÚAÚBÚCÚDs,                                               rc   Ú	evalf_mulr=  |  sb  € Ü
�q‹/€CÙ
à‰ˆˆ1Ü   D¨'Ó2ÑˆˆAˆv�qØ�R˜˜vÐ%Ð%Ü�—‘‹<€Dð €HØ€GÝØò  ˆÜ�s˜D 'Ó*ˆØ”Q×&Ñ&Ñ&Ø�N‰N˜6Ô"ØØ�!‰9ÐØ�a‰yÐ Ø�ØØˆe�j‰j˜ ™ AÓ&ˆØ”!—%‘%‰<Ü˜˜t TÐ)Ò)Ø�?‹?Ø�N‰N˜3Õð ñ ÙÜ˜˜t TÐ)Ð)ÝÜ‘S˜'�] D¨1¡H¨bÓ1Ð1ÙØ%ð €Cð œ#˜d›)Ñ# aÑ'€Lô ˜q›6 1 a˜<Ð'€E‰LˆC��bô ˆt‹9€DØ€IØ‡K�K”—‘ÔØ€Oä˜D“/ò ‰ˆˆ3Ø�Š9œ cÔ*Ø˜R™ ™×,Ñ,Ó.ˆD�‰HØØ�$ŠY˜3¤!§%¡%™<ØÜ!& s¨L¸'Ó!BÑˆˆB�˜Ù‘"Ø×"Ñ" B¨¨F°FÐ#;Ô<ØÙØ"$ fÐ‰LˆQ��1�a™%ÙØ"$ fÐ‰LˆQ��1�a˜%Ø˜‰N‰Iá)Ø�Q�q‘SÑˆ	Øˆq‰ˆØˆq‰ˆØ
ˆa‰ˆØ�1�\‘>Ò!Ø�LÑ ˆCØ�<ÑˆCØ�,ÑˆBð �1�\‘>Ó!ô �#�u‹o‰ð3ð4 ˜‰M˜aÑ€DÙÜ�d˜C ¤h¨s£m°T¼3Ó?ˆà�qŠ=Ø˜˜D #Ð%Ð%à�d˜C Ð%Ð%ð ��bˆ>˜UÒ"à˜C ¤h¨s£mÐ4°q¼#¸a»&À!ÀQÐ6G�ˆBØ‰Bð *9¸Ñ);Ñ&ˆC��g˜wÜ�cÜ&¨¨S°'¸7Ð'CÓDóFˆCàˆBØˆBØˆBà*9¸"¸#Ð*>ò 	)Ñ&ˆC��g˜wô �cÜ&¨¨S°'¸7Ð'CÓDóFˆCð $ˆHÜ˜˜C Ó*ˆAÜœ › S¨(Ó3ˆAÜ˜˜C Ó*ˆAÜ˜˜C Ó*ˆAÜ˜˜A˜xÓ(ˆBÜ˜˜A˜xÓ(‰Bð	)ð �;‰;�yÔ!Ü�- Ð';¸SÔAà�qŠ=Ü˜R“[ "�ˆBØ�2�s˜CÐÐrd   c                ó‚  — |}| j                   \  }}|j                  �r|j                  }|s
t        d |d fS |t	        t        j                  t        |«      «      «      z  }t        ||dz   |«      }|t        j                  u r|dk  ry|S |\  }}	}
}|r|	st        |||«      d |d fS |	rR|sPt        |	||«      }|dz  }|dk(  r|d |d fS |dk(  rd |d |fS |dk(  rt        |«      d |d fS |dk(  rd t        |«      d |fS |s|dk  rt        j                  S yt        j                  ||	f||«      \  }}	t        ||	|«      S t        ||dz   |«      }|t        j                  u r|j                   r|dk  ry|S t"        ‚|t        j$                  u ru|\  }}}}|r0t        j&                  |xs t(        |f|«      \  }}	t        ||	|«      S |syt+        |t(        «      rd t-        t        |«      |«      d |fS t-        ||«      d |d fS |dz  }t        |||«      }|t        j                  u r
t.        d |d fS |\  }}}}|s|s
t        d |d fS t1        |«      }|dkD  r||z  }t        |||«      \  }}}}|t        j2                  u rB|r0t        j4                  |xs t(        |f|«      \  }}	t        ||	|«      S t7        ||«      d |d fS t        ||dz   |«      \  }}}}|s'|s%|r
t.        d |d fS |d   dk(  rt        j                  S y|rCt        j8                  |xs t(        |xs t(        f|xs t(        |f|«      \  }}	t        ||	|«      S |r1t        j:                  |xs t(        |f||«      \  }}	t        ||	|«      S t+        |t(        «      r-t        j:                  |t(        f||«      \  }}	t        ||	|«      S t=        |||«      d |d fS )	Nr$  r   r¢   r†   r9   rl   rm   r]   )r¸   Ú
is_Integerr�   r   ra   ÚmathÚlog2r`   r£   r;   r•   r+   r(   r¦   Úmpc_pow_intrÆ   Úis_RationalÚNotImplementedErrorÚHalfÚmpc_sqrtr   r&   r.   r   rp   ÚExp1Úmpc_expr$   Úmpc_powÚmpc_pow_mpfr*   )rv   r©   rª   r  ÚbaserO   r�   r˜   rR   rS   r™   rš   ÚzÚcaseÚxreÚximr¬   ÚyreÚyimÚysizes                       rc   Ú	evalf_powrS  ú  s"  € à€KØ—‘�I€Dˆ#ð
 ‡~ƒ~Ø—‘ˆáÜ˜˜t TÐ)Ð)ð 	””D—I‘Iœc !›fÓ%Ó&Ñ&ˆÜ�t˜T A™X wÓ/ˆØ”Q×&Ñ&Ñ&Ø�1ŠuØ-ØˆMØ!'ÑˆˆB�˜á‘bÜ˜r 1 kÓ2°D¸+ÀtÐKÐKá‘bÜ˜B  ;Ó/ˆAØ�q‘5ˆDØ�qŠyØ˜$ ¨TÐ1Ð1Ø�qŠyØ˜Q  kÐ1Ð1Ø�qŠyÜ˜q“z 4¨°dÐ:Ð:Ø�qŠyØœW Q›Z¨¨{Ð:Ð:áØ�1ŠuÜ×(Ñ(Ð(Ø)ä×"Ñ" B¨ 8¨Q°Ó5‰ˆˆBä  B¨Ó4Ð4ä�4˜ ™ 7Ó+€FØ”×"Ñ"Ñ"Ø�?Š?Ø�QŠwØ-ØˆMÜ!Ð!ð Œa�f‰f�}Ø‰ˆˆS�!�QáÜ—^‘^ S¢\¬E°3Ð$7¸Ó>‰FˆB�Ü# B¨¨DÓ1Ð1ÙØ)ä�#”uÔØœ¤'¨#£,°Ó5°t¸TÐAÐAä˜˜TÓ" D¨$°Ð4Ð4ð 	ˆB�J€DÜ�3˜˜gÓ&€FØ”×"Ñ"Ñ"Ü�T˜4 Ð%Ð%Ø�N€Cˆˆa�á‘3Ü�T˜4 Ð%Ð%ä�C‹L€Eð ˆq‚yØ�‰ˆÜ˜s D¨'Ó2‰ˆˆS�!�Qð Œq�v‰v�~ÙÜ—]‘] C¢L¬5°#Ð#6¸Ó=‰FˆB�Ü# B¨¨KÓ8Ð8Ü�s˜KÓ(¨$°¸TÐAÐAä˜4 ¨¡¨7Ó3�N€Cˆˆa�á‘3ÙÜ˜˜t TÐ)Ð)Øˆq‰6�QŠ;Ü×$Ñ$Ð$Ø%ñ Ü—‘ØŠ\”E˜3š<¤%Ð(¨3ª<´%¸Ð*=Øó‰ˆˆBô    B¨Ó4Ð4á
Ü×"Ñ" C¢L¬5°#Ð#6¸¸[ÓI‰ˆˆBÜ  B¨Ó4Ð4ä	�”UÔ	Ü×"Ñ" C¬ <°°kÓB‰ˆˆBÜ  B¨Ó4Ð4ô �s˜C Ó-¨t°[À$ÐFÐFrd   c                ój   — ddl m} t         |t        j                  | j
                  d¬«      ||«      S )Nr9   rE   FrÙ   )ÚpowerrF   rS  r;   rG  rO   )r¨   r©   rª   rF   s       rc   Ú	evalf_exprV  |  s%   € ÝÜ‘SœŸ™ §¡°EÔ:¸DÀ'ÓJÐJrd   c                ór  — ddl m}m}m} t	        | |«      rt
        }n,t	        | |«      rt        }nt	        | |«      rt        }nt        ‚| j                  d   }|dz   }t        |||«      \  }	}
}}|
r4d|v r| j                  |d   «      } t        | j                  |«      ||«      S |	s6t	        | |«      r
t        d|dfS t	        | |«      ryt	        | |«      ryt        ‚t        |	«      }|dk  r ||	|t        «      d|dfS |dk\  r||z   }t        |||«      \  }	}
}}	  ||	|t        «      }t        |«      }| }||z
  |z
  }||k  rm|j!                  d	«      r%t#        d
|d|d|«       t#        t%        |d«      «       ||j!                  dt&        «      kD  r|d|dfS ||z  }t        |||«      \  }	}
}}Œ—|d|dfS )zH
    This function handles sin , cos and tan of complex arguments.

    r   )ÚcosÚsinÚtané   r¡   Nr¢   r9   r]   r  zSIN/COS/TANÚwantedrò   r  )Ú(sympy.functions.elementary.trigonometricrX  rY  rZ  rŠ   r"   r-   r3   rD  r¸   r£   r¡   Ú_eval_evalfr   rp   rÜ   rÝ   r   r2   r  )rv   r©   rª   rX  rY  rZ  Úfuncr  ÚxprecrR   rS   r™   rš   ÚxsizeÚyrR  rò   r´   s                     rc   Ú
evalf_trigrc  �  sé  € ÷
 GÑFÜ�!�SÔÜ‰Ü	�A�sÔ	Ü‰Ü	�A�cÔ	Ü‰ä!Ð!Ø
�&‰&�‰)€Cð �2‰I€EÜ" 3¨¨wÓ7Ñ€BˆˆF�FÙ	Ø�WÑØ—‘�w˜v‘Ó'ˆAÜ�Q—]‘] 4Ó(¨$°Ó8Ð8ÙÜ�a˜ÔÜ˜˜t TÐ)Ð)Ü˜˜3ÔØ)Ü˜˜#ÔØ)ä%Ð%ô �B‹K€Eð ˆq‚yÙ�B˜œcÓ" D¨$°Ð4Ð4à�‚{Ø�u‘ˆÜ!& s¨E°7Ó!;ÑˆˆB�˜ð Ù��Tœ3ÓˆÜ˜“
ˆØˆfˆØ˜E‘M SÑ(ˆØ�dŠ?Ø�{‰{˜9Ô%Ü�m X¨x¸¸uÀcÔJÜ”f˜Q “mÔ$Ø�w—{‘{ 9¬oÓ>Ò>Ø˜$ ¨$Ð.Ð.Ø�S‰LˆEÜ%*¨3°°wÓ%?Ñ"ˆB��F˜FØà�d˜D $Ð&Ð&rd   c           	     ó0  — t        | j                  «      dkD  r| j                  «       } t        | ||«      S | j                  d   }|dz   }t        |||«      }|t        j
                  u r|S |\  }}}}	||cxu r€	n nt        }|rJddlm}
 ddl	m
} t         | |
|d¬«      d¬«      ||«      }t        ||xs t        |«      }|d   ||d   |fS t        |t        «      dk  }t        t        |«      |t         «      }t#        |«      }||z
  |kD  rq|t        k7  rhdd	lm}  |t        j(                  |d¬«      }t+        |||«      \  }}}	}	|t#        |«      z
  }t        t        t-        |t.        |«      «      |t         «      }|}|r|t1        |«      ||fS |d |d fS )
Nr9   r   r]   )rQ   )rP   FrÙ   rl   rA   )rŒ   r¸   Údoitr£   r;   r•   r   rï   rQ   Ú&sympy.functions.elementary.exponentialrP   Ú	evalf_logr    r!   r%   r   rÜ   rp   rÛ   rB   ÚNegativeOner"  r   r   r)   )r¨   r©   rª   r  r   r˜   rN  rO  Úxaccr¬   rQ   rP   rR   rS   Úimaginary_termrê   rB   rÛ   Úprec2r™   s                       rc   rg  rg  Á  s“  € Ü
ˆ4�9‰9ƒ~�aÒØ�y‰y‹{ˆÜ�T˜4 Ó)Ð)Ø
�)‰)�A‰,€CØ�b‰y€HÜ�3˜ 'Ó*€FØ”×"Ñ"Ñ"ØˆØÑ€Cˆˆd�Að ˆc×ô ˆá
Ý<Ý>ô Ù‘�C %Ô(°5Ô9¸4ÀóJˆä�s˜CšL¤5¨$Ó/ˆØ�!‰u�b˜"˜Q™% Ð%Ð%ä˜c¤5Ó)¨AÑ-€Nä	”˜“˜t¤SÓ	)€BÜ�2‹;€DØˆd�{�XÒ "¬¢+Ýá”!—-‘- ¨uÔ5ˆÜ" 3¨¨gÓ6‰ˆˆS�!�QØœ7 3›<Ñ'ˆä”WœW S¬$°Ó6Ó7¸¼sÓCˆà€FáØ”6˜$“< ¨Ð-Ð-à�4˜ Ð%Ð%rd   c                ó–   — | j                   d   }t        ||dz   |«      \  }}}}||cxu r€y |rt        ‚t        ||t        «      d |d fS )Nr   r$  r¢   )r¸   r£   rD  r   rÜ   )rv   r©   rª   r  rN  rO  ÚreaccÚimaccs           rc   Ú
evalf_atanro  ö  s[   € Ø
�&‰&�‰)€CÜ" 3¨¨q©°'Ó:Ñ€Cˆˆe�UØ
ˆcÔØð á
Ü!Ð!Ü�C˜œsÓ# T¨4°Ð5Ð5rd   c                ó”   — i }|j                  «       D ]2  \  }}t        |«      }|j                  r|j                  | «      }|||<   Œ4 |S )z< Change all Float entries in `subs` to have precision prec. )Úitemsr;   Úis_Floatr^  )r©   r¡   ÚnewsubsrÌ   r1  s        rc   Ú
evalf_subsrt     sN   € à€GØ—
‘
“ò ‰ˆˆ1Üˆa‹DˆØ�:Š:Ø—‘˜dÓ#ˆAØˆ�Š
ð	ð
 €Nrd   c                óF  — ddl m}m} d|v r�| j                  t	        ||d   «      «      } |j                  «       }|d= t        | d«      rt        | ||«      S t        | t        «      rt         || «      ||«      S t        | t        «      rt         || «      ||«      S t        ‚)Nr9   )rX   rZ   r¡   r_  )r  rX   rZ   r¡   rt  ÚcopyÚhasattrr£   rŠ   Úfloatra   rD  )r¨   r©   rª   rX   rZ   Únewoptss         rc   Úevalf_piecewiserz    s“   € ß'Ø�ÑØ�y‰yœ D¨'°&©/Ó:Ó;ˆØ—,‘,“.ˆØ�FˆOÜ�4˜Ô Ü˜˜t WÓ-Ð-Ü�dœEÔ"Ü™˜t› d¨GÓ4Ð4Ü�dœCÔ Ü™ ›¨¨gÓ6Ð6ô Ðrd   c                ó8   — t        | j                  «       ||«      S r~   )r£   Úto_root)rÌ   r©   rª   s      rc   Úevalf_alg_numr}    s   € Ü�—‘“˜d GÓ,Ð,rd   c                óð   — ddl m}m}m} t	        | «      } t        | |«      s| dk(  rt        d«      S t        | |«      rt        d«      S t        | |«      rt        d«      S t        | ||«      }t        |«      S )Nr9   )ÚInfinityÚNegativeInfinityru   g        r   r   z-inf)	r  r  r€  ru   r:   rŠ   r   r£   Úquad_to_mpmath)ro   r©   rª   r  r€  ru   r˜   s          rc   Ú	as_mpmathr‚  &  sl   € ß9Ñ9Ü�‹
€AÜ�!�TÔ˜a 3šhÜ�1‹vˆÜ�!�XÔÜ�5‹zÐÜ�!Ð%Ô&Ü�6‹{Ðä�1�d˜GÓ$€FÜ˜&Ó!Ð!rd   c           	     óä  ‡‡‡‡‡— | j                   d   Š| j                   d   \  Š}}||k(  rdx}}n<‰‰j                  vr.|j                  |j                  z  r||z
  }|j                  rd|}}|j                  dt        «      }t        |d|z  «      |d<   t        |dz   «      5  t        ||dz   |«      }t        ||dz   |«      }ddlm	}m
} ddlm}	 d	d	gŠt        Št        Šdˆˆˆˆˆfd
„}
|j                  d«      dk(  r« |	d‰g¬«      } |	d‰g¬«      } |	d«      }‰j                   ||‰z  |z   «      |z  «      }|s ‰j                   ||‰z  |z   «      |z  «      }|st        d«      ‚t        dt         j"                  z  ||   z  |dz   |«      }t%        |
||g|¬«      }t        }n(t'        |
||gd¬«      \  }}t)        |j*                  «      }d d d «       ||d<   ‰d   rtj,                  j*                  }|t.        k(  r/t1        t3        t5        |‰«       «      «      \  }}t1        |«      }n+t3        t5        ‰t)        |«      z
  |z
  «       «      }nd\  }}‰d   rtj6                  j*                  }|t.        k(  r/t1        t3        t5        |‰«       «      «      \  }}t1        |«      }n+t3        t5        ‰t)        |«      z
  |z
  «       «      }nd\  }}||||f}|S # 1 sw Y   �ŒxY w)Nr   r9   r  rl   r$  é   )rX  rY  )ÚWildFc                ó"  •— t        ‰t        j                  d‰	| ii«      \  }}}}|xs ‰d   ‰d<   |xs ‰d   ‰d<   t        ‰t	        |«      «      Št        ‰t	        |«      «      Š|rt        |xs t        |«      S t        |xs t        «      S )Nr¡   r   r9   )r£   r   r©   r—   rp   r   r   r   )
ry   rR   rS   r™   rš   r_  Ú	have_partÚmax_imag_termÚmax_real_termro   s
        €€€€€rc   Úfzdo_integral.<locals>.fW  sŽ   ø€ ä%*¨4´·±¸6ÀAÀqÀ6Ð:JÓ%KÑ"ˆB��F˜FàÒ- ¨1¡ˆI�a‰LØÒ- ¨1¡ˆI�a‰Lä ¬w°r«{Ó;ˆMÜ ¬w°r«{Ó;ˆMáÜ˜2š;¤¨Ó+Ð+Ü�r’{œUÓ#Ð#rd   ÚquadÚoscr9  )Úexcluder:  r<  zbAn integrand of the form sin(A*x+B)*f(x) or cos(A*x+B)*f(x) is required for oscillatory quadrature)Úperiod)ÚerrorrÈ   )ry   r@   Úreturnú	mpc | mpf)r¸   Úfree_symbolsr¤   rÝ   r  rÃ   r   r‚  r]  rX  rY  Úsymbolr…  rn   ÚmatchrŽ   r;   ÚPir   r   rp   rý   Úrealr   r‚   ra   r—   Úimag)r¨   r©   rª   ÚxlowÚxhighÚdiffr!  rX  rY  r…  rŠ  r9  r:  r<  r/  rŽ  r˜   Úquadrature_errorÚquadrature_errrR   Úre_sr™   rS   Úim_srš   r_  r‡  rˆ  r‰  ro   s                            @@@@@rc   Údo_integralrŸ  4  sú  ü€ Ø�9‰9�Q‰<€DØ—Y‘Y˜q‘\�N€A€tˆUØˆu‚}ØÐˆ‰uØ	
�$×#Ñ#Ñ	#ð
 ×Ñ × 1Ñ 1Ò1Ø˜4‘<ˆDØ�~Š~Ø �e�à—‘˜Y¬Ó8€JÜ˜Z¨¨4©Ó0€GˆIÑä	�$˜‘(Ó	ñ /=Ü˜˜t b™y¨'Ó2ˆÜ˜% ¨¡¨GÓ4ˆ÷ 	FÝ à˜E�Nˆ	Ü%.ˆÜ%.ˆ÷	$ñ 	$ð �;‰;�vÓ %Ò'Ù�S 1 #Ô&ˆAÙ�S 1 #Ô&ˆAÙ�S“	ˆAØ—
‘
™3˜q ™s Q™w›<¨™>Ó*ˆAÙØ—J‘J™s 1 Q¡3¨¡7›|¨A™~Ó.�ÙÜ ð "Nó Oð Oä˜q¤§¡™v a¨¡d™{¨D°2©I°wÓ?ˆFÜ˜Q  u °fÔ=ˆFä(Ñä%+¨A°°e¨}ÀAÔ%FÑ"ˆF�NÜ& ~×';Ñ';Ó<Ð÷_/=ðb $€GˆIÑà�‚|Ø#Ÿ[™[×.Ñ.ˆà”Š;Ü&¤s¬C°°mÐEUÓ,VÐ+VÓ'WÓX‰LˆD�&Ü˜TÓ"‰Bäœ#˜m¬g°b«kÑ9¸DÑ@ÐBRÓSÐSÓT‰Fà‰
ˆˆFà�‚|Ø#Ÿ[™[×.Ñ.ˆà”Š;Ü&¤s¬C°°mÐEUÓ,VÐ+VÓ'WÓX‰LˆD�&Ü˜TÓ"‰Bäœ#˜m¬g°b«kÑ9¸DÑ@ÐBRÓSÐSÓT‰Fà‰
ˆˆFà��V˜VÐ#€FØ€M÷U/=ñ /=ús   Â$D0K%Ë%K/c                óH  — | j                   }t        |«      dk7  st        |d   «      dk7  rt        ‚|}d}|j                  dt        «      }	 t        | ||«      }t        |«      }||k\  r	 |S ||k\  r	 |S |dk(  r|dz  }n|t        |d|z  «      z  }t        ||«      }|dz  }ŒW)Nr9   r   rm   r  r‰   rl   )	ÚlimitsrŒ   rD  rÝ   r–   rŸ  rŸ   r—   rÃ   )	r¨   r©   rª   r¡  r   r{   r  r˜   r´   s	            rc   Úevalf_integralr¢  “  sÉ   € Ø�[‰[€FÜ
ˆ6ƒ{�aÒœ3˜v a™y›>¨QÒ.Ü!Ð!Ø€HØ	€AØ�k‰k˜)¤SÓ)€GØ
Ü˜T 8¨WÓ5ˆÜ# FÓ+ˆØ�tÒØð €Mð �wÒØð €Mð �rŠ>ð ˜‰M‰Hàœ˜D ! Q¡$›Ñ'ˆHÜ�x Ó)ˆØ	ˆQ‰ˆð rd   c                óâ  — ddl m}  || |«      } |||«      }|j                  «       }|j                  «       }||z
  }|r|ddfS |j                  «       |j                  «       z  }	ddlm}
  |
t        |	«      d«      s||	dfS |j                  «       |j                  «       cxk(  rdk(  rn n||	dfS |j                  «       d   }|j                  «       d   }||	||z
  |j                  «       z  fS )aI  
    Returns
    =======

    (h, g, p) where
    -- h is:
        > 0 for convergence of rate 1/factorial(n)**h
        < 0 for divergence of rate factorial(n)**(-h)
        = 0 for geometric or polynomial convergence or divergence

    -- abs(g) is:
        > 1 for geometric convergence of rate 1/h**n
        < 1 for geometric divergence of rate h**n
        = 1 for polynomial convergence or divergence

        (g < 0 indicates an alternating series)

    -- p is:
        > 1 for polynomial convergence of rate 1/n**h
        <= 1 for polynomial divergence of rate n**(-h)

    r   )ÚPolyNr9   )Úequal_valued)Úsympy.polys.polytoolsr¤  ÚdegreeÚLCr  r¥  r`   Ú
all_coeffs)ÚnumerÚdenomrb   r¤  ÚnpolÚdpolr�   r   ÚrateÚconstantr¥  ÚpcÚqcs                rc   Úcheck_convergencer²  ­  sä   € õ. +Ù��q‹>€DÙ��q‹>€DØ�‰‹€AØ�‰‹€AØˆq‰5€DÙØ�T˜4ÐÐØ�w‰w‹y˜4Ÿ7™7›9Ñ$€HÝ%Ùœ˜H› qÔ)Ø�X˜tÐ#Ð#Ø‡{�{ƒ}˜Ÿ™›Ô*¨Õ*Ø�X˜qÐ Ð Ø	�‰Ó	˜1Ñ	€BØ	�‰Ó	˜1Ñ	€BØ�˜B ™G T§W¡W£YÑ.Ð.Ð.rd   c                óº  ‡‡‡— ddl m}m} ddlm} |t        d«      k(  rt        d«      ‚|r| j                  |||z   «      }  || |«      }|€t        d«      ‚|j                  «       \  }}	t        ||«      Št        ||	«      Št        ||	|«      \  }
}}|
dk  rt        d	|
 z  «      ‚| j                  |d«      }|j                  st        d
«      ‚|}|
dkD  s|
dk(  r™t        |«      dkD  r‹t        |j                  «      |z  |j                   z  }|}d}t        |«      dkD  rG|t         ‰|dz
  «      «      z  }|t         ‰|dz
  «      «      z  }||z  }|dz  }t        |«      dkD  rŒGt#        || «      S |dk  }t        |«      dk  rt        dt        d|z  «      z  «      ‚|dk  s ||d«      r|st        d| z  «      ‚d}t%        |«      }	 d|z  Št        |j                  «      ‰z  |j                   z  }|gfˆˆˆfd„	}t'        |«      5  t)        |dt*        gd¬«      }ddd«        ||«      }|�||k(  r	 |j,                  S ||z  }|}Œ�# 1 sw Y   Œ.xY w)zÛ
    Sum a rapidly convergent infinite hypergeometric series with
    given general term, e.g. e = hypsum(1/factorial(n), n). The
    quotient between successive terms must be a quotient of integer
    polynomials.
    r9   )rX   r¥  r   )Ú	hypersimpr   zdoes not support inf precNz#a hypergeometric series is requiredzSum diverges like (n!)^%iz3Non rational term functionality is not implemented.r$  zSum diverges like (%i)^nzSum diverges like n^%ir†   c           	     óÌ   •— | rIt        | «      } |dxx   t         ‰| dz
  «      «      z  cc<   |dxx   t         ‰| dz
  «      «      z  cc<   t        t        |d   ‰ «      «      S rÀ   )ra   r5   r
   r   )ÚkÚ_termÚfunc1Úfunc2rk  s     €€€rc   Úsummandzhypsum.<locals>.summand  s]   ø€ ÙÜ˜A›�AØ˜!“H¤¡E¨!¨a©%£LÓ 1Ñ1“HØ˜!“H¤¡U¨1¨q©5£\Ó!2Ñ2“HÜ¤¨U°1©X¸°vÓ >Ó?Ð?rd   Ú
richardson)Úmethod)r  rX   r¥  Úsympy.simplify.simplifyr´  rx  rD  r¡   Úas_numer_denomr>   r²  rŽ   rC  r`   r5   r�   r   r   r8   r   r   Ú
mpmath_infrý   )r¨   rb   r+  r©   rX   r¥  r´  Úhsr*  Údenrx   Úgr�   ÚetermÚtermr‘   r¶  ÚaltÚvoldÚndigÚterm0rº  rv   Úvfr¸  r¹  rk  s                           @@@rc   ÚhypsumrÊ  ×  s‚  ú€ ÷ -Ý1àŒu�U‹|ÒÜ!Ð"=Ó>Ð>áØ�y‰y˜˜A ™IÓ&ˆÙ	�4˜Ó	€BØ	€zÜ!Ð"GÓHÐHØ× Ñ Ó"�H€Cˆä�Q˜Ó€EÜ�Q˜Ó€Eä  S¨!Ó,�G€A€qˆ!àˆ1‚uÜÐ4¸¸Ñ;Ó<Ð<à�I‰I�a˜‹O€EØ×ÒÜ!Ð"WÓXÐXà€Dð 	ˆ1‚u��a’œC ›F QšJÜ�D—F‘F“˜tÑ#¨¯©Ñ.ˆØˆØˆÜ�$‹i˜!ŠmØ”C™˜a !™e›Ó%Ñ%ˆDØ”S™˜q 1™u›Ó&Ñ&ˆDØ�‰IˆAØ�‰FˆAô	 �$‹i˜!‹mô
 ˜A ˜uÓ%Ð%à�!‰eˆÜˆq‹6�AŠ:ÜÐ7¼#¸aÀ¹c»(ÑBÓCÐCØˆqŠ5‘\ ! QÔ'±ÜÐ5¸!¸Ñ<Ó=Ð=àˆÜ˜4Ó ˆØð �d‘FˆEÜ˜Ÿ™“[ EÑ)¨d¯f©fÑ4ˆEà"' ÷ @ô ˜$“ñ HÜ˜ 1¤j /¸,ÔG�÷Há�q˜$“ˆBØÐ D¨B¢JØð �w‰wˆð �D‰LˆDØˆDð) ÷Hð Hús   ÈIÉIc                óÀ   — t        d„ | j                  D «       «      rt        | j                  «       ||¬«      }|S ddlm} t        | j                  |«      ||¬«      }|S )Nc              3  óF   K  — | ]  }|d    |d   z
  j                   –— Œ y­w)r9   rl   N)r?  )r×   Úls     rc   rØ   zevalf_prod.<locals>.<genexpr>'  s"   è ø€ Ò
9¨ˆAˆa‰D�1�Q‘4‰K×#Õ#Ñ
9ùs   ‚!)r©   rª   r   rJ   )rÞ   r¡  r£   re  Úsympy.concrete.summationsrK   Úrewrite)r¨   r©   rª   r˜   rK   s        rc   Ú
evalf_prodrÐ  &  sP   € Ü
Ñ
9¨T¯[©[Ô
9Ô9Ü�t—y‘y“{¨°wÔ?ˆð €Mõ 	2Ü�t—|‘| CÓ(¨t¸WÔEˆØ€Mrd   c                ó   — ddl m} d|v r| j                  |d   «      } | j                  }| j                  }t        |«      dk7  st        |d   «      dk7  rt        ‚|j                  rd d |d fS |dz   }	 |d   \  }}}	|	t        j                  us |t        j                  u s|t        |«      k7  rt        ‚t        ||t        |«      |«      }
|t        |
«      z
  }t        |
«      dk  rt        ||t        |«      |«      }
|
d t        ||«      d fS # t        $ rµ  |d«      | z  }t        dd	«      D ]S  }d
|z  |z  x}}| j!                  |||d¬«      \  }}|j#                  «       }|t        j$                  u rt        ‚||k  sŒS n t        t#        t'        «      d|«      d   «      }t#        ||«      \  }}}}|€| }|€| }||||fcY S w xY w)Nr9   r  r¡   r   rm   r]   iöÿÿÿg       @r$  rl   F)r/  rb   ÚepsÚeval_integralr[  )r  rX   r¡   Úfunctionr¡  rŒ   rD  Úis_zeror;   r  r€  ra   rÊ  rp   rÃ   ÚrangeÚeuler_maclaurinr£   r  r`   )r¨   r©   rª   rX   r_  r¡  rk  rb   rÌ   r1  rv   rÉ   rÒ  r{   r/  r‘   ÚerrrR   rS   r™   rš   s                        rc   Ú	evalf_sumrÙ  /  sð  € ÝØ�ÑØ�y‰y˜ ™Ó)ˆØ�=‰=€DØ�[‰[€FÜ
ˆ6ƒ{�aÒœ3˜v a™y›>¨QÒ.Ü!Ð!Ø‡|‚|Ø�T˜4 Ð%Ð%Ø�2‰I€Eð&Ø˜‘)‰ˆˆ1ˆaØ”A—J‘JÑ !¤q×'9Ñ'9Ñ"9¸QÄ#ÀaÃ&º[Ü%Ð%ä�4˜œC ›F EÓ*ˆØ”w˜q“zÑ!ˆÜ�1‹:˜ÒÜ�t˜Q¤ A£¨Ó.ˆAØ�$œ˜D %Ó(¨$Ð.Ð.øÜò &á�C‹j˜D˜5Ñ!ˆÜ�q˜!“ò 	ˆAØ�q‘D˜4‘KÐˆA�Ø×)Ñ)¨A°¸Ø#ð *ó %‰FˆAˆsà—)‘)“+ˆCØ”a—e‘e‰|Ü)Ð)Ø�c‹zÙð	ô ”eœC ›H b¨'Ó2°1Ñ5Ó6ˆÜ!& q¨%°Ó!9ÑˆˆB�˜Øˆ>Ø�TˆFØˆ>Ø�TˆFØ�2�v˜vÐ%Ò%ð%&ús   Á4BD ÄA3GÆAGÇGc                óö   — |d   |    }t        |t        «      r|sy|j                  d |d fS d|vri |d<   |d   }|j                  | d t        f«      \  }}||k\  r|S t        t        |«      ||«      }||f|| <   |S )Nr¡   r¢   Ú_cache)rŠ   r   rý   rÝ   rn   r£   r:   )ro   r©   rª   ÚvalÚcacheÚcachedÚcached_precrv   s           rc   Úevalf_symbolrà  _  sš   € Ø
�&‰/˜!Ñ
€CÜ�#”sÔÙØ)Ø�y‰y˜$  dÐ*Ð*à˜7Ñ"Ø "ˆG�HÑØ˜Ñ!ˆØ#Ÿi™i¨¨D´)Ð+<Ó=Ñˆ�Ø˜$ÒØˆMÜ”'˜#“,  gÓ.ˆØ�t�9ˆˆa‰Øˆrd   z:dict[Type[Expr], Callable[[Expr, int, OPT_DICT], TMP_RES]]Úevalf_tablec                 ó�  — ddl m}  ddlm} ddlm} ddlm} ddlm	}m
}m}m}m}m}	m}
m}m}m}m}m}m} ddlm} dd	lm}m} dd
lm}m}m} ddlm }m!} ddl"m#}m$} ddl%m&} ddl'm(}m)}m*}m+} ddl,m-}  i |t\        “|t\        “|t^        “|t`        “|tb        “|d„ “|d„ “|d„ “|d„ “|d„ “|d„ “|
d„ “|d„ “|	d„ “|td        “|tf        “|tf        “i |tf        “|th        “|tj        “|tl        “|tn        “|tp        “|tr        “|tt        “|tv        “|tx        “|tz        “| t|        “|t~        “| t€        “|t‚        “|t„        “¥aCy )Nr   rL   rJ   r9   rA   rC   )rG  rX   rE  rt   rZ   r  rh  r&  r•  rY   ru   r•   r[   rE   )ÚDummyrG   )rQ   rS   rR   rN   rT   )Ú	Piecewise)rW   rX  rY  rZ  rH   c                ó   — d d |d fS r~   rj   ©ro   r©   rª   s      rc   ú<lambda>z%_create_evalf_table.<locals>.<lambda>‰  s   € ¨¨d°D¸$Ð'?€ rd   c                ó   — t         d |d fS r~   ©r   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>Š  ó   € ¤t¨T°4¸Ð&>€ rd   c                ó   — t         d |d fS r~   )r   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>‹  s   € ¬¨t°T¸4Ð'@€ rd   c                ó    — t        |«      d |d fS r~   )r)   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>Œ  s   € ¤f¨T£l°D¸$ÀÐ%E€ rd   c                ó    — t        |«      d |d fS r~   )r#   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>�  s   € ¬¨d«°T¸4ÀÐ'F€ rd   c                ó   — d t         d |fS r~   ré  ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>Ž  s   € °´t¸TÀ4Ð0H€ rd   c                ó   — t         d |d fS r~   )r   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>�  s   € ¬u°d¸DÀ$Ð.G€ rd   c                ó"   — t         j                  S r~   )r;   r•   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>�  s   € ´!×2CÑ2C€ rd   c                ó   — t         d |d fS r~   )r   ræ  s      rc   rç  z%_create_evalf_table.<locals>.<lambda>‘  rê  rd   )DÚsympy.concrete.productsrM   rÎ  rK   rÛ   rB   r%  rD   r  rG  rX   rE  rt   rZ   r  rh  r&  r•  rY   ru   r•   r[   rU  rF   r“  rã  rG   rï   rQ   rS   rR   rf  rO   rP   Ú#sympy.functions.elementary.integersrU   rV   Ú$sympy.functions.elementary.piecewiserä  r]  rW   rX  rY  rZ  Úsympy.integrals.integralsrI   rà  rþ   r  r  rV  rc  r"  r=  rS  rg  ro  rº   r½   rÁ   rû   rù   r¢  rÙ  rÐ  rz  r}  rá  )!rM   rK   rB   rD   rG  rX   rE  rt   rZ   r  rh  r&  r•  rY   ru   r•   r[   rF   rã  rG   rQ   rS   rR   rO   rP   rU   rV   rä  rW   rX  rY  rZ  rI   s!                                    rc   Ú_create_evalf_tablerö  s  sæ  € å/Ý-ÝÝ÷/÷ /÷ /õ /åß%ß@Ñ@ß?ßBÝ>ßLÓLÝ2ð)Ø”ð)àŒ|ð)ð 	Œ{ð)ð 	”.ð	)ð
 	”ð)ð 	Ñ?ð)ð 	Ñ>ð)ð 	Ñ@ð)ð 	ÑEð)ð 	ÑFð)ð 	ÑHð)ð 	ÑGð)ð 	ÑCð)ð 	Ñ>ð)ð  	ŒYð!)ð$ 	ŒZð%)ð& 	ŒZñ')ð( 	ŒZð))ð, 	ŒYð-)ð. 	ŒYð/)ð0 	ŒYð1)ð4 	ŒYð5)ð6 	Œjð7)ð8 	ŒYð9)ð< 	ŒHð=)ð> 	ŒHð?)ð@ 	Œ{ðA)ðB 	”ðC)ðF 	”.ðG)ðH 	ŒYðI)ðJ 	”ðK)ðL 	”?ðM)ðP 	œñQ)�Krd   c                ó2  — ddl m}m} 	 t        t	        | «         } || ||«      }|j                  d«      rUt!        d	| «       t!        d
t#        |t$        «      rt'        |d   xs t(        d«      n|«       t!        d|«       t!        «        |j                  dd«      }|rJ|du r|}n7t+        t-        dt/        j0                  |«      z  dz   «      «      }|dk(  r|dz  }t3        ||«      }|j                  d«      rt5        | ||«       |S # t
        $ �r d|v r| j                  t        ||d   «      «      } | j                  |«      }|€t        ‚t        |dd«      }|€t        ‚ |«       \  }	}
 |	j                  |«      s |
j                  |«      rt        ‚|	sd}	d}n3|	j                  r! |	j                  |d¬«      j                  }	|}nt        ‚|
sd}
d}n3|
j                  r! |
j                  |d¬«      j                  }
|}nt        ‚|	|
||f}Y �Œïw xY w)a†  
    Evaluate the ``Expr`` instance, ``x``
    to a binary precision of ``prec``. This
    function is supposed to be used internally.

    Parameters
    ==========

    x : Expr
        The formula to evaluate to a float.
    prec : int
        The binary precision that the output should have.
    options : dict
        A dictionary with the same entries as
        ``EvalfMixin.evalf`` and in addition,
        ``maxprec`` which is the maximum working precision.

    Returns
    =======

    An optional tuple, ``(re, im, re_acc, im_acc)``
    which are the real, imaginary, real accuracy
    and imaginary accuracy respectively. ``re`` is
    an mpf value tuple and so is ``im``. ``re_acc``
    and ``im_acc`` are ints.

    NB: all these return values can be ``None``.
    If all values are ``None``, then that represents 0.
    Note that 0 is also represented as ``fzero = (0, 0, 0, 0)``.
    r   rÏ   r¡   NrÔ   F)Ú
allow_intsr  z	### inputz
### outputé2   z### rawÚchopTgÅ °rh‘
Àg      @rm   r9   rÓ   )rï   rR   rS   rá  ÚtypeÚKeyErrorr¡   rt  r^  rD  ÚgetattrÚhasr¤   Ú
_to_mpmathrý   rÝ   r   rŠ   r‹   r2   r   ra   Úroundr@  Úlog10rÊ   rÍ   )ro   r©   rª   rô   rõ   Úrfr  ÚxerÔ   rR   rS   ÚreprecÚimprecrú  Ú	chop_precs                  rc   r£   r£   ¯  sþ  € ÷> Jð #Üœ˜a›Ñ!ˆÙˆq�$˜Ó ˆð@ ‡{�{�9ÔÜˆk˜1ÔÜˆl¼ÀAÄuÔ9MœF 1 Q¡4¢=¬5°"Ô5ÐSTÔUÜˆi˜ÔÜŒØ�;‰;�v˜uÓ%€DÙØ�4‰<Ø‰Iô
 œE &¬¯©°DÓ)9Ñ"9¸CÑ"?Ó@ÓAˆIØ˜AŠ~Ø˜Q‘�	Ü�q˜)Ó$ˆØ‡{�{�8ÔÜ�Q˜˜4Ô Ø€Høôe ó #à�WÑØ—‘”z $¨°©Ó8Ó9ˆAØ�]‰]˜4Ó ˆØˆ:Ü%Ð%Ü˜r >°4Ó8ˆØÐÜ%Ð%Ù“‰ˆˆBØˆ2�6‰6�#Œ;˜&˜"Ÿ&™& œ+Ü%Ð%ÙØˆBØ‰FØ�\Š\Ø�—‘˜t°Ô6×<Ñ<ˆBØ‰Fä%Ð%ÙØˆBØ‰FØ�\Š\Ø�—‘˜t°Ô6×<Ñ<ˆBØ‰Fä%Ð%Ø��F˜FÐ"‹ð;#ús   ŠD
 Ä
DHÈHc                óä   — |€t         n|j                   }|€t        n|j                  }| t        j                  u rt        ‚| \  }}}}|r|st
        } |||f«      S |r ||«      S  |t
        «      S )z@Turn the quad returned by ``evalf`` into an ``mpf`` or ``mpc``. )r	   r
   r;   r•   rD  r   )r   Úctxr   r   rR   rS   r¬   s          rc   r�  r�    sp   € à�k�( s§|¡|€CØ�k�( s§|¡|€CØŒA×ÑÑÜ!Ð!Ø�L€BˆˆAˆqÙ	ÙÜˆBÙ�B˜�8‹}ÐÙ	Ù�2‹wˆá”5‹zÐrd   c                  óD   — e Zd ZU dZdZded<   d
d„ZeZdd„Zdd„Z	dd	„Z
y)Ú
EvalfMixinz$Mixin class adding evalf capability.rj   ztuple[str, ...]Ú	__slots__Nc           	     óH  — ddl m}m}	 |�|nd}|rt        |«      rt	        d«      ‚|dk(  rGt        | |	«      r;ddlm}
 | j                  d||||||«      } |
|«      }|j                  d|z
  «      }|S t        s
t        «        t        |«      }t        |t        |t        z  «      «      |||dœ}|�||d<   |�||d	<   	 t        | |d
z   |«      }|t*        j,                  u r|S |\  }}}}|t*        j.                  u s|t*        j.                  u rt*        j.                  S |r*t        t1        ||«      d«      } |j2                  ||«      }nt*        j4                  }|r?t        t1        ||«      d«      } |j2                  ||«      }||t*        j6                  z  z   S |S # t         $ r| t#        | d«      r#|�!| j%                  |«      j'                  |«      }n| j'                  |«      }|€| cY S |j(                  s|cY S 	 t        |||«      }n# t         $ r |cY cY S w xY wY �ŒRw xY w)a)  
        Evaluate the given formula to an accuracy of *n* digits.

        Parameters
        ==========

        subs : dict, optional
            Substitute numerical values for symbols, e.g.
            ``subs={x:3, y:1+pi}``. The substitutions must be given as a
            dictionary.

        maxn : int, optional
            Allow a maximum temporary working precision of maxn digits.

        chop : bool or number, optional
            Specifies how to replace tiny real or imaginary parts in
            subresults by exact zeros.

            When ``True`` the chop value defaults to standard precision.

            Otherwise the chop value is used to determine the
            magnitude of "small" for purposes of chopping.

            >>> from sympy import N
            >>> x = 1e-4
            >>> N(x, chop=True)
            0.000100000000000000
            >>> N(x, chop=1e-5)
            0.000100000000000000
            >>> N(x, chop=1e-4)
            0

        strict : bool, optional
            Raise ``PrecisionExhausted`` if any subresult fails to
            evaluate to full accuracy, given the available maxprec.

        quad : str, optional
            Choose algorithm for numerical quadrature. By default,
            tanh-sinh quadrature is used. For oscillatory
            integrals on an infinite interval, try ``quad='osc'``.

        verbose : bool, optional
            Print debug information.

        Notes
        =====

        When Floats are naively substituted into an expression,
        precision errors may adversely affect the result. For example,
        adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is
        then subtracted, the result will be 0.
        That is exactly what happens in the following:

        >>> from sympy.abc import x, y, z
        >>> values = {x: 1e16, y: 1, z: 1e16}
        >>> (x + y - z).subs(values)
        0

        Using the subs argument for evalf is the accurate way to
        evaluate such an expression:

        >>> (x + y - z).evalf(subs=values)
        1.00000000000000
        r9   )rX   r\   r„  z"subs must be given as a dictionary)Ú_magrl   )r  rú  rÓ   r  r¡   r‹  r†   )r  rX   r\   r=   Ú	TypeErrorrŠ   r¨   r  r£   r   rá  rö  r7   r—   ra   ÚLG10rD  rw  r¡   r^  r¤   r;   r•   r  rÃ   r  ru   rt   )Úselfrb   r¡   Úmaxnrú  rÓ   r‹  r  rX   r\   r  r�   r/  r©   rª   r˜   rv   rR   rS   r™   rš   r�   s                         rc   r£   zEvalfMixin.evalf  s  € ÷B 	+Ø�‰A Bˆá”K Ô%ÜÐ@ÓAÐAð �Š6”j  vÔ.Ý"Ø—‘˜A˜t T¨4°¸¸wÓGˆBÙ�R“ˆAØ—‘˜!˜a™%“ˆBØˆIåÜÔ!Ü˜1‹~ˆÜ! $¬¨D´©I«Ó7ÀØ¨Gñ5ˆàÐØ"ˆG�F‰OØÐØ"ˆG�F‰Oð	Ü˜4 ¨¡¨7Ó3ˆFð" ”Q×&Ñ&Ñ&ØˆMØ!'ÑˆˆB�˜Ø”—‘‰;˜"¤§¡™+Ü—5‘5ˆLÙÜ”C˜˜fÓ% qÓ)ˆAØ�—‘˜B Ó"‰Bä—‘ˆBÙÜ”C˜˜fÓ% qÓ)ˆAØ�—‘˜B Ó"ˆBØ˜œ1Ÿ?™?Ñ*Ñ*Ð*àˆIøô? #ò 	ä�t˜VÔ$¨Ð)9Ø—I‘I˜d“O×/Ñ/°Ó5‘à×$Ñ$ TÓ*�ØˆyØ’Ø—[’[Ø’ðä˜q $¨Ó0‘øÜ&ò à”ðúò ð	ús=   Â>F ÆAH!Ç+H!Ç<H
È	H!È
HÈH!ÈHÈH!È H!c                ó0   — | j                  |«      }|€| }|S )z@Helper for evalf. Does the same thing but takes binary precision)r^  )r  r©   r  s      rc   Ú_evalfzEvalfMixin._evalfš  s!   € à×Ñ˜TÓ"ˆØˆ9ØˆAØˆrd   c                 ó   — y r~   rj   )r  r©   s     rc   r^  zEvalfMixin._eval_evalf¡  s   € Ørd   c                ó¸  — d}|r| j                   r| j                  S t        | d«      rt        | j	                  |«      «      S 	 t        | |i «      }t        |«      S # t        $ rô | j                  |«      }|€t        |«      ‚|j                  rt        |j                  «      cY S |j                  «       \  }}|r"|j                   rt        |j                  «      }n$|j                  r|j                  }nt        |«      ‚|r"|j                   rt        |j                  «      }n$|j                  r|j                  }nt        |«      ‚t        ||f«      cY S w xY w)Nzcannot convert to mpmath numberÚ_as_mpf_val)r?  r�   rw  r
   r  r£   r�  rD  r^  rŽ   rr  rý   rÔ   r   r	   )r  r©   rø  Úerrmsgr˜   rv   rR   rS   s           rc   rÿ  zEvalfMixin._to_mpmath¤  s  € à2ˆÙ˜$Ÿ/š/Ø—6‘6ˆMÜ�4˜Ô'Ü˜D×,Ñ,¨TÓ2Ó3Ð3ð	&Ü˜4  rÓ*ˆFÜ! &Ó)Ð)øÜ"ò 	&Ø× Ñ  Ó&ˆAØˆyÜ  Ó(Ð(Ø�zŠzÜ §¡Ó(Ò(à—^‘^Ó%‰FˆB�Ù˜bŸmšmÜ˜bŸd™d“^‘Ø—’Ø—X‘X‘ä  Ó(Ð(Ù˜bŸmšmÜ˜bŸd™d“^‘Ø—’Ø—X‘X‘ä  Ó(Ð(Ü˜R ˜HÓ%Ò%ð)	&ús   ÁA ÁAEÂ&B0EÅE)r„  Néd   FFNF)r©   ra   r�  r@   )r©   ra   r�  úExpr | None)T)rg   rh   ri   Ú__doc__r  Ú__annotations__r£   rb   r  r^  rÿ  rj   rd   rc   r
  r
    s,   … Ù.à!#€IˆÓ#óyðv 	€Aóóô&rd   r
  c                ó>   —  t        | d¬«      j                  |fi |¤ŽS )a   
    Calls x.evalf(n, \*\*options).

    Explanations
    ============

    Both .n() and N() are equivalent to .evalf(); use the one that you like better.
    See also the docstring of .evalf() for information on the options.

    Examples
    ========

    >>> from sympy import Sum, oo, N
    >>> from sympy.abc import k
    >>> Sum(1/k**k, (k, 1, oo))
    Sum(k**(-k), (k, 1, oo))
    >>> N(_, 4)
    1.291

    T)Úrational)r:   r£   )ro   rb   rª   s      rc   r¥   r¥   Å  s#   € ð. +Œ7�1˜tÔ$×*Ñ*¨1Ñ8°Ñ8Ð8rd   c                óN  — |�H|j                   s|j                  r|dkD  st        d«      ‚t        d|z  di «      \  }}}}t	        |«      }t        | di «      \  }}}}t	        |«      t	        |«      }	}t        ||	«      dz   }
t        d||
z   dz   «      }|xs i }t        | ||«      S )a%  
    Evaluate *x* to within a bounded absolute error.

    Parameters
    ==========

    x : Expr
        The quantity to be evaluated.
    eps : Expr, None, optional (default=None)
        Positive real upper bound on the acceptable error.
    m : int, optional (default=0)
        If *eps* is None, then use 2**(-m) as the upper bound on the error.
    options: OPT_DICT
        As in the ``evalf`` function.

    Returns
    =======

    A tuple ``(re, im, re_acc, im_acc)``, as returned by ``evalf``.

    See Also
    ========

    evalf

    r   zeps must be positiver9   )rC  rr  rŽ   r£   rp   r—   )ro   rÒ  r/  rª   r  r¬   rz   ÚdÚnrÚnirb   r�   s               rc   Ú_evalf_with_bounded_errorr"  ß  s°   € ð: €Ø—’ 3§<¢<¸¸aºÜÐ3Ó4Ð4Ü˜1˜S™5 ! RÓ(‰
ˆˆ1ˆa�Ü�A‹Jˆä�q˜!˜R“�J€A€qˆ!ˆQô �Q‹Zœ ›ˆ€BÜˆB�‹�a‰€Aô 	ˆAˆq�1‰u�q‰yÓ€AàŠm˜€GÜ��A�wÓÐrd   )ro   zMPF_TUP | Noner�  ú	int | Any)F)rv   r@   r�  ztuple[Number, Number] | None)r9   )r€   ÚSCALED_ZERO_TUPr�  rî   )r€   ra   r�  ztuple[SCALED_ZERO_TUP, int])r€   zSCALED_ZERO_TUP | intr�  z%MPF_TUP | tuple[SCALED_ZERO_TUP, int])r   z MPF_TUP | SCALED_ZERO_TUP | Noner�  zbool | None)r˜   ÚTMP_RESr�  r#  )r¨   r@   r©   ra   rª   ÚOPT_DICTr�  r%  )
r¨   r@   r±   ra   r©   ra   rª   r&  r�  r%  )r¨   z'Abs'r©   ra   rª   r&  r�  r%  )r¨   z're'r©   ra   rª   r&  r�  r%  )r¨   z'im'r©   ra   rª   r&  r�  r%  )rR   rî   rS   rî   r©   ra   r�  r%  )r³   r%  r©   ra   r�  r%  )r¨   r@   r˜   r%  r©   ra   )r¨   r@   r±   ra   rª   r&  r�  zTMP_RES | tuple[int, int])r¨   z	'ceiling'r©   ra   rª   r&  r�  r%  )r¨   z'floor'r©   ra   rª   r&  r�  r%  )r¨   z'Float'r©   ra   rª   r&  r�  r%  )r¨   z
'Rational'r©   ra   rª   r&  r�  r%  )r¨   z	'Integer'r©   ra   rª   r&  r�  r%  )r  r“   r©   ra   r  ra   r�  z3tuple[MPF_TUP | SCALED_ZERO_TUP | None, int | None])rv   z'Add'r©   ra   rª   r&  r�  r%  )rv   z'Mul'r©   ra   rª   r&  r�  r%  )rv   z'Pow'r©   ra   r�  r%  )r¨   z'exp'r©   ra   rª   r&  r�  r%  )rv   r@   r©   ra   rª   r&  r�  r%  )r¨   z'log'r©   ra   rª   r&  r�  r%  )rv   z'atan'r©   ra   rª   r&  r�  r%  )r©   ra   r¡   Údictr�  r'  )rÌ   z'AlgebraicNumber'r©   ra   rª   r&  r�  r%  )ro   r   r©   ra   rª   r&  r�  r‘  )r¨   z
'Integral'r©   ra   rª   r&  r�  r%  )rª  r@   r«  r@   rb   rG   r�  ztuple[int, Any, Any])
r¨   r@   rb   rG   r+  ra   r©   ra   r�  r   )r¨   z	'Product'r©   ra   rª   r&  r�  r%  )r¨   z'Sum'r©   ra   rª   r&  r�  r%  )ro   r@   r©   ra   rª   r&  r�  r%  r~   )r„  )Nr   N)
ro   r@   rÒ  r  r/  ra   rª   zOPT_DICT | Noner�  r%  )¯r  Ú
__future__r   Útypingr   r   r   r   r   r@  Úmpmath.libmpr¦   Úmpmathr	   r
   r   r   r   r   r   r   r   r   r¿  r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r_   Úmpmath.libmp.backendr5   Úmpmath.libmp.libmpcr6   Úmpmath.libmp.libmpfr7   r8   r:   Ú	singletonr;   Úsympy.external.gmpyr<   Úsympy.utilities.iterablesr=   Úsympy.utilities.lambdifyr>   Úsympy.utilities.miscr?   Úsympy.core.exprr@   Úsympy.core.addrB   Úsympy.core.mulrD   Úsympy.core.powerrF   Úsympy.core.symbolrG   rõ  rI   rÎ  rK   rò  rM   rf  rO   rP   rï   rQ   rR   rS   ró  rU   rV   r]  rW   r  rX   rY   rZ   r[   r\   rA  r  rÜ   rx  r–   rn   r  ÚArithmeticErrorrf   r‹   ra   rî   r%  r'  Ústrr&  rp   r|   r“   r$  r‚   r�   rŸ   r®   rµ   rº   r½   rÁ   rÆ   rÊ   rÍ   rö   rù   rû   rþ   r  r  r  r"  r=  rS  rV  rc  rg  ro  rt  rz  r}  r‚  rŸ  r¢  r²  rÊ  rÐ  rÙ  rà  rá  r  rö  r£   r�  r
  r¥   r"  rj   rd   rc   ú<module>r;     sº  ðòõ #ß ?Õ ?ã å ÷G÷ Gõ Gå $÷W÷ W÷ W÷ W÷ W÷ W÷ W÷ Wõ Wõ
 5Ý $Ý )ß 8å Ý Ý *Ý 1Ý -Ý 'áÝ$Ý"Ý"Ý$Ý(Ý2Ý-Ý/ß?ß@Ñ@ßBÝ=ßJÕJà€t‡y�y�ƒ}€Ø€ò(ñ ˆJÓ€Ù�:�+Ó€	ð €ô	˜ô 	ðð ��S˜#˜sÐ"Ñ
#€ðð& €ð ��S�‰>€ó!ôHð> ˜˜S™	 3¨¨SÐ0Ñ1€ð 
óó 
ðà	óó 
ðð$JØ-ó$JôNGóó:&ó,ó 0ó<ó<ó"ó&"ó,0ðl$Ø!ól$ó^6ó7ó(óAó4ðSØ;óSól."ób{ ó|xGóDKó
='ó@2&ój6óóó"-ó"ó\ó~ó4'/óTLó^ó'&ó`ð" KM€ÐGÓ Lò9óxUóp÷"j&ñ j&óZ9ð4 ;?Ø'(Ø9=ð1 Ø!$ð1 à'6ð1 àBIô1 rd   