o
     ôjU«  ã                	   @   sì  d Z ddlZddlmZ ddlmZ ddlmZmZmZmZm	Z	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#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l9m:Z: e
d	kr�d
Z;ndZ;dZ<e
d	kr˜dZ=ndZ=dZ>i Z?dZ@i ZAdZBdZCi ZDdZEdZFdZGi ZHddgZIedeeBƒd ƒD ]ZJeIeKdeJ eBƒd gdeJd   7 ZIq½dd„ ZLdd„ ZMdd„ ZNdd„ ZOd’d d!„ZPeLd"d#„ ƒZQeLd$d%„ ƒZR	 ed&ƒZSed'ƒZTed(ƒZUed)ƒZVd*d+„ ZWeLd“d,d-„ƒZXd.d/„ ZYd0d1„ ZZeLd2d3„ ƒZ[eLd4d5„ ƒZ\eMe\ƒZ]eMeXƒZ^eMe[ƒZ_eMeYƒZ`eMeQƒZaeMeRƒZbeLd6d7„ ƒZceLd8d9„ ƒZdeMedƒZeeMecƒZfefd:d;„Zgd<d=„ Zhd>d?„ Ziefd@dA„ZjefdBdC„Zkd”dDdE„ZldFdG„ ZmdHdI„ Znd•dJdK„ZodLdM„ ZpefdNdO„ZqdPdQ„ ZrdRdS„ ZsdTdU„ ZtdVdW„ ZudXdY„ ZvefdZd[„Zwefd\d]„Zxefd^d_„Zyefd`da„Zzefdbdc„Z{efddde„Z|efdfdg„Z}efdhdi„Z~d•djdk„Zdldm„ Z€dndo„ Z�dpdq„ Z‚efdrds„Zƒedfdtdu„Z„dvdw„ Z…eddfdxdy„Z†efdzd{„Z‡efd|d}„Zˆefd~d„Z‰efd€d�„ZŠefd‚dƒ„Z‹efd„d…„ZŒefd†d‡„Z�efdˆd‰„ZŽefdŠd‹„Z�d”dŒd�„Z�d”dŽd�„Z‘e
d�k�rtz*ddl’m“  m”  m•Z– e–j4Z4e–jƒZƒe–jqZqe–j‡Z‡e–jˆZˆe–jgZge–j‘Z‘e–j�Z�e–jlZlW dS  e—e˜f�ys   e™d‘ƒ Y dS w dS )–a(  
This module implements computation of elementary transcendental
functions (powers, logarithms, trigonometric and hyperbolic
functions, inverse trigonometric and hyperbolic) for real
floating-point numbers.

For complex and interval implementations of the same functions,
see libmpc and libmpi.

é    N)Úbisecté   )Úxrange)ÚMPZÚMPZ_ZEROÚMPZ_ONEÚMPZ_TWOÚMPZ_FIVEÚBACKEND)-Úround_floorÚround_ceilingÚ
round_downÚround_upÚround_nearestÚ
round_fastÚComplexResultÚbitcountÚbctableÚlshiftÚrshiftÚgiant_stepsÚ
sqrt_fixedÚfrom_intÚto_intÚfrom_man_expÚto_fixedÚto_floatÚ
from_floatÚfrom_rationalÚ	normalizeÚfzeroÚfoneÚfnoneÚfhalfÚfinfÚfninfÚfnanÚmpf_cmpÚmpf_signÚmpf_absÚmpf_posÚmpf_negÚmpf_addÚmpf_subÚmpf_mulÚmpf_divÚ	mpf_shiftÚmpf_rdiv_intÚmpf_pow_intÚmpf_sqrtÚreciprocal_rndÚnegative_rndÚmpf_perturbÚ
isqrt_fast)ÚifibÚpythonéX  i�  iÜ  éÈ   é   iÐ  iÄ	  é	   é   i¸  é   é   é   c                    s,   dˆ _ dˆ _‡ fdd„}ˆ j|_ˆ j|_|S )zè
    Decorator for caching computed values of mathematical
    constants. This decorator should be applied to a
    function taking a single argument prec as input and
    returning a fixed-point value with the given precision.
    éÿÿÿÿNc                    sR   ˆ j }| |krˆ j||  ? S t| d d ƒ}ˆ |fi |¤Žˆ _|ˆ _ ˆ j||  ? S )NgÍÌÌÌÌÌð?é
   )Ú	memo_precÚmemo_valÚint)ÚprecÚkwargsrD   Znewprec©Úf© úi/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/mpmath/libmp/libelefun.pyÚg^   s   zconstant_memo.<locals>.g)rD   rE   Ú__name__Ú__doc__)rJ   rM   rK   rI   rL   Úconstant_memoU   s   rP   c                    s   t f‡ fdd„	}ˆ j|_|S )zÿ
    Create a function that computes the mpf value for a mathematical
    constant, given a function that computes the fixed-point value.

    Assumptions: the constant is positive and has magnitude ~= 1;
    the fixed-point function rounds to floor.
    c                    s<   | d }ˆ |ƒ}|t tfv r|d7 }td|| t|ƒ| |ƒS )Nr>   r   r   )r   r   r   r   )rG   ÚrndÚwpÚv©ÚfixedrK   rL   rJ   r   s
   zdef_mpf_constant.<locals>.f)r   rO   )rU   rJ   rK   rT   rL   Údef_mpf_constantj   s   rV   c                 C   s    || dkr't d| d ƒ}|s|d@ rt|| d  |fS t || d  |fS || d }t| |||ƒ\}}}t| |||ƒ\}	}
}|
| ||	  ||
 || fS )Nr   rA   é   )r   r   Úbsp_acot)ÚqÚaÚbÚ
hyperbolicÚa1ÚmÚp1Úq1Úr1Úp2Úq2Úr2rK   rK   rL   rX   {   s   rX   c                 C   sB   t d| t | ¡ d ƒ}t| d||ƒ\}}}|| |> ||   S )zœ
    Compute acot(a) or acoth(a) for an integer a with binary splitting; see
    http://numbers.computation.free.fr/Constants/Algorithms/splitting.html
    çffffffÖ?r>   r   )rF   ÚmathÚlogrX   )rZ   rG   r\   ÚNÚprY   ÚrrK   rK   rL   Ú
acot_fixed‰   s   rk   Fc                 C   s>   d}t }| D ]\}}|t|ƒtt|ƒ|| |ƒ 7 }q||? S )zì
    Evaluate a Machin-like formula, i.e., a linear combination of
    acot(n) or acoth(n) for specific integer values of n, using fixed-
    point arithmetic. The input should be a list [(c, n), ...], giving
    c*acot[h](n) + ...
    rC   )r   r   rk   )ÚcoefsrG   r\   Ú	extraprecÚsrZ   r[   rK   rK   rL   Úmachin’   s
   "ro   c                 C   ó   t g d¢| dƒS )zz
    Computes ln(2). This is done with a hyperbolic Machin-type formula,
    with binary splitting at high precision.
    ))é   é   )éþÿÿÿiÁ  )r<   i-"  T©ro   ©rG   rK   rK   rL   Ú	ln2_fixed¢   s   rv   c                 C   rp   )zN
    Computes ln(10). This is done with a hyperbolic Machin-type formula.
    ))é.   é   )é"   é1   )r>   é¡   Trt   ru   rK   rK   rL   Ú
ln10_fixedª   s   r|   iqcÏ i¦-~ i@Å	 é   c                 C   sà   ||  dkr1t d| d d| d  d| d  ƒ}|d td  d }d| | tt|   }n:|r=|dk r=td	| |ƒ | | d }t| ||d |ƒ\}}	}
t|||d |ƒ\}}}|	| }|| }|
| ||  }|||fS )
z×
    Computes the sum from a to b of the series in the Chudnovsky
    formula. Returns g, p, q where p/q is the sum as an exact
    fraction and g is a temporary value used to save work
    for recursive calls.
    r   é   é   rA   rW   é   rB   é   z  binary splitting)r   ÚCHUD_CÚCHUD_AÚCHUD_BÚprintÚbs_chudnovsky)rZ   r[   ÚlevelÚverboserM   ri   rY   ÚmidÚg1r_   r`   Úg2rb   rc   rK   rK   rL   r†   Ó   s   (
r†   c           	      C   sf   t | d d d ƒ}|rtd|ƒ td|d|ƒ\}}}ttd|  > ƒ}|t | |t|  t  }|S )z“
    Compute floor(pi * 2**prec) as a big integer.

    This is done using Chudnovsky's series (see comments in
    libelefun.py for details).
    gÿ¢v	O“
@g biå ],@rA   zbinary splitting with N =r   )rF   r…   r†   r7   r‚   rƒ   ÚCHUD_D)	rG   rˆ   Zverbose_baserh   rM   ri   rY   ZsqrtCrS   rK   rK   rL   Úpi_fixedé   s   	
r�   c                 C   s   t | ƒd S )Né´   )r�   ru   rK   rK   rL   Údegree_fixedú   s   r�   c                 C   sT   ||  dkrt t|ƒfS | | d }t| |ƒ\}}t||ƒ\}}|| | || fS )ze
    Sum series for exp(1)-1 between a, b, returning the result
    as an exact fraction (p, q).
    r   rA   )r   r   Úbspe)rZ   r[   r^   r_   r`   rb   rc   rK   rK   rL   r�   ý   s   r�   c                 C   s8   t d|  t | ¡ d ƒ}td|ƒ\}}|| | > | S )zö
    Computes exp(1). This is done using the ordinary Taylor series for
    exp, with binary splitting. For a description of the algorithm,
    see:

        http://numbers.computation.free.fr/Constants/
            Algorithms/splitting.html
    gš™™™™™ñ?r>   r   )rF   rf   rg   r�   )rG   rh   ri   rY   rK   rK   rL   Úe_fixed	  s   r‘   c                 C   s(   | d7 } t td|  > ƒt| >  }|d? S )z2
    Computes the golden ratio, (1+sqrt(5))/2
    rC   rA   é   )r7   r	   r   )rG   rZ   rK   rK   rL   Ú	phi_fixed  s   r“   c                 C   s&   | d }t ttt|ƒdƒ|ƒ| d ƒS )NrC   r   )r   Úmpf_logr0   Úmpf_pi)rG   rR   rK   rK   rL   Úln_sqrt2pi_fixed*  s   r–   c                 C   s   t t| ƒ| ƒS ©N)r   r�   ru   rK   rK   rL   Úsqrtpi_fixed0  ó   r˜   c                 C   sì   | \}}}}|\}}	}
}|r|
dk rt dƒ‚|
dkr't| d| |	|
>  ||ƒS |
dkre|	dkrF|r@ttt| |d t| ƒ||ƒS t| ||ƒS |rXtt| |d t| ƒ|	 ||ƒS tt| |d |ƒ|	||ƒS t| |d |ƒ}tt||ƒ||ƒS )zV
    Compute s**t. Raises ComplexResult if s is negative and t is
    fractional.
    r   z,negative number raised to a fractional powerrB   r   rC   )	r   r2   r/   r!   r3   r4   r”   Úmpf_expr.   )rn   ÚtrG   rQ   ÚssignÚsmanÚsexpÚsbcÚtsignÚtmanÚtexpÚtbcÚcrK   rK   rL   Úmpf_pow>  s0   ÿÿÿÿr¥   c           
      C   s  |dkr
| |  dfS t | ƒ}d}d|dt |ƒ  d  }t\}}}}		 |d@ r\||  }|| }|	|d 7 }	|	tt||	? ƒ  }	|	|krQ||	| ? }||	| 7 }|}	|d8 }|s\	 ||fS | |  } || }|| d }|tt| |? ƒ  }||kr†| || ? } ||| 7 }|}|d }q#)z‡n-th power of a fixed point number with precision prec

       Returns the power in the form man, exp,
       man * 2**exp ~= y**n
    rA   r   r�   r   )r   r!   r   rF   )
ÚyÚnrG   ÚbcÚexpÚworkprecÚ_ÚpmÚpeÚpbcrK   rK   rL   Úint_pow_fixedZ  s<   
÷ër¯   c                 C   s  d}zt | |||  ƒ}tt|d|  ƒƒ}W n" ty9   t||ƒ}t|ƒ}td||ƒ}t|||ƒ}t|ƒ}Y nw d}|}	|}
t||| ƒD ]9}t	||d |
ƒ\}}t ||d |
 | | |	 ƒ}t
| d| | |	 ƒ| }||d t
|||
 ƒ  | }|}
qG|S )Né2   g      ð?r   rC   rA   )r   r   rF   ÚOverflowErrorr   r1   r¥   r   r   r¯   r   )r¦   r§   rG   Úexp1ÚstartÚy1rj   ÚfnÚextraÚextra1Úprevpri   r¬   r­   rd   ÚBrK   rK   rL   Únthroot_fixed�  s*   
ûrº   c                 C   sl  | \}}}}|rt dƒ‚|s2| tkrtS | tkr&|dkrtS |dkr$tS tS |s*tS |dk r0tS tS d}|dk rb|dkr>tS |dkrHt| ||ƒS |dkrStt| ||ƒS t| }d}d}	||	7 }| }|d	kr©|d
ksv|tdd|d   ƒk r©|d }
t	|ƒ}t
d||
ƒ}t| ||
|ƒ}t|d |d |d |d ||ƒ} |r§tt| ||	 |ƒS | S |d|  ||  }
|dkrÃ|
|
d 7 }
|
|
|  }
||
 }d}|| }|dk rÖd}| }|rß||| 7 }n||| 8 }t||ƒ}d}|| |d |
  | | }d}|�r|dk�s	|dk�rd}n|dk�s|dk�rd}t|| ||
|ƒ}t||||ƒ} |�r4tt| ||	 |ƒS | S )zanth-root of a positive number

    Use the Newton method when faster, otherwise use x**(1/n)
    znth root of a negative numberr   FrA   r   rB   Tr   r>   i N  éé   gÍÌÌÌÌL<@g×£p=
×ã?rC   rW   Úur¤   ÚdrJ   )r   r&   r    r!   r$   r*   r/   r4   rF   r   r1   r¥   r   r   rº   r   )rn   r§   rG   rQ   ÚsignÚmanr©   r¨   Zflag_inverseZextra_inverseÚprec2rµ   Únthrj   ÚshiftZsign1Úesr¶   r²   Z	rnd_shiftrK   rK   rL   Úmpf_nthroot¦  s†   ("
€rÄ   c                 C   s   t | d||ƒS )zcubic root of a positive numberrW   )rÄ   )rn   rG   rQ   rK   rK   rL   Úmpf_cbrtù  r™   rÅ   c           	      C   s¨   | t v rt |  \}}||kr||| ? S |d }|tkr8|du r$t|ƒ}t| ƒ}| || > }t||ƒ||  }nttt| ƒ|d ƒ|ƒ}| tk rN||ft | < ||| ? S )z`
    Fast computation of log(n), caching the value for small n,
    intended for zeta sums.
    rC   Nr   )	Úlog_int_cacheÚLOG_TAYLOR_SHIFTrv   r   Úlog_taylor_cachedr   r”   r   ÚMAX_LOG_INT_CACHE)	r§   rG   Úln2ÚvalueZvprecrR   rj   ÚxrS   rK   rK   rL   Úlog_int_fixed  s   rÍ   c                 C   sH   d}	 | | d? }|dkrt | | ƒdk r| S t| | ƒ}|} |d7 }q)z^
    Fixed-point computation of agm(a,b), assuming
    a, b both close to unit magnitude.
    r   r   r�   r<   )Úabsr7   )rZ   r[   rG   ÚiZanewrK   rK   rL   Ú	agm_fixed  s   úrÐ   c                 C   sÜ   | |  |? }| } }}|r || |? }|| |? }||7 }|s|t |> 7 }|| |d ? }|t| |> ƒ |? }|  } }}|rR|| |? }|| |? }||7 }|s@t |> |d>  }|| |? }t|||ƒ}t|ƒ|> | S )a*  
    Fixed-point computation of -log(x) = log(1/x), suitable
    for large precision. It is required that 0 < x < 1. The
    algorithm used is the Sasaki-Kanada formula

        -log(x) = pi/agm(theta2(x)^2,theta3(x)^2). [1]

    For faster convergence in the theta functions, x should
    be chosen closer to 0.

    Guard bits must be added by the caller.

    HYPOTHESIS: if x = 2^(-n), n bits need to be added to
    account for the truncation to a fixed-point number,
    and this is the only significant cancellation error.

    The number of bits lost to roundoff is small and can be
    considered constant.

    [1] Richard P. Brent, "Fast Algorithms for High-Precision
        Computation of Elementary Functions (extended abstract)",
        http://wwwmaths.anu.edu.au/~brent/pd/RNC7-Brent.pdf

    rA   r   )r   r7   rÐ   r�   )rÌ   rG   Úx2rn   rZ   r[   r›   ri   rK   rK   rL   Úlog_agm)  s(   ýýrÒ   c                 C   sâ   t |ƒD ]}t| |> ƒ} qt|> }| | |> | |  }|dk }|r$| }|| |? }|| |? }|}	|d }
|| |? }d}|r\|	|| 7 }	|d7 }|
|| 7 }
|| |? }|d7 }|s@|
| |? }
|	|
 d| > }|ro| S |S )a:  
    Fixed-point calculation of log(x). It is assumed that x is close
    enough to 1 for the Taylor series to converge quickly. Convergence
    can be improved by specifying r > 0 to compute
    log(x^(1/2^r))*2^r, at the cost of performing r square roots.

    The caller must provide sufficient guard bits.
    r   rW   r   rA   r   )r   r7   r   )rÌ   rG   rj   rÏ   ÚonerS   r¾   Úv2Úv4Ús0Ús1Úkrn   rK   rK   rL   Ú
log_taylorX  s2   	ûrÙ   c                 C   s&  | |t  ? }t| }|| }||ftv rt||f \}}n||t  > }t||dƒ}||ft||f< ||L }||L }| | |> | }||> t|> |  }|| |? }	|	|	 |? }
|}|d }||
 |? }d}|rƒ||| 7 }|d7 }||| 7 }||
 |? }|d7 }|sg||	 |? }|| d> }|| S )zd
    Fixed-point computation of log(x), assuming x in (0.5, 2)
    and prec <= LOG_TAYLOR_PREC.
    r<   rW   r   rA   r   )rÇ   Úcache_prec_stepsÚlog_taylor_cacherÙ   r   )rÌ   rG   r§   Zcached_precÚdprecrZ   Zlog_ar¼   rS   rÔ   rÕ   rÖ   r×   rØ   rn   rK   rK   rL   rÈ   z  s8   ûrÈ   c                 C   s¬  | \}}}}|s| t krtS | tkrtS | tkrtS |r tdƒ‚|d }|dkr8|s,t S t|t|ƒ | ||ƒS || }t|ƒ}	|	dkr{d|	 }
|
rQt|> | }n|t|d >  }t	|ƒ}|| }||krwt
|
||	| ||dƒ}t||
||ƒS ||7 }|	dkr‘t	|	ƒ|kr‘t|t|ƒ | ||ƒS |tkrªtt||| ƒ|ƒ}|r©||t|ƒ 7 }n$| t }|| }t| |ƒ} || 7 }tt| |ƒ|ƒ }||t|ƒ 8 }t|| ||ƒS )zj
    Compute the natural logarithm of the mpf value x. If x is negative,
    ComplexResult is raised.
    zlogarithm of a negative numberr>   r   r§   i'  )r    r%   r$   r&   r   r   rv   rÎ   r   r   r   r6   ÚLOG_TAYLOR_PRECrÈ   r   ÚLOG_AGM_MAG_PREC_RATIOr0   rÒ   r   )rÌ   rG   rQ   r¾   r¿   r©   r¨   rR   ÚmagZabs_magr    r¡   r£   Úcancellationr›   r^   Zoptimal_magr§   rK   rK   rL   r”   œ  sP   €


r”   c           
      C   s  |d s	|| } }| d s;|d s'| |  krt krtS  t| |fv r%tS tS | t kr3tt|ƒ||ƒS | tkr9tS tS t| | ƒ}t||ƒ}d}t|||| ƒ}t|tdƒ}|d |d  }	|t ksh|	| d k ryt|||| t	|d |d ƒ ƒ}t
t|||ƒdƒS )z1
    Computes log(sqrt(a^2+b^2)) accurately.
    r   r>   rC   rA   rW   rB   )r    r%   r&   r$   r”   r)   r.   r,   r"   Úminr0   )
rZ   r[   rG   rQ   Úa2Úb2r¶   Úh2Ú	cancelledZmag_cancelledrK   rK   rL   Úmpf_log_hypotä  s0   
ÿ

"ræ   c           
      C   sÜ   |dkrt  t| |d ? ƒd ¡}nt  t| ƒd|  ¡}d}tt|d ƒd| ? ƒ}d}t||ƒD ]4}||7 }||| > }t||ƒ\}}||> | }|t| || ƒ |> t|> |d |?   }	||	 }|}q2t||| ƒS )Néd   é5   g      @Cg       @r°   rA   )rf   ÚatanrF   r   r   Úcos_sin_fixedr   r   )
rÌ   rG   rj   r¸   Zextra_prR   ÚcosÚsinÚtanrZ   rK   rK   rL   Úatan_newton  s   *rî   c                 C   sp   dt |d ƒ> d }|| }| |ftv rt| |f \}}n| |t > }t||ƒ}||ft| |f< ||? ||? fS )Nr   r>   )r   Úatan_taylor_cacheÚATAN_TAYLOR_SHIFTrî   )r§   rG   rÀ   rÜ   rZ   Úatan_arK   rK   rL   Úatan_taylor_get_cached"  s   
rò   c                 C   sÖ   | |t  ? }t||ƒ\}}| | }||> |d |? || |?  t|>    }}|d |? }|| |? }	|d }
||	 |? }d}|r]||| 7 }|d7 }|
|| 7 }
||	 |? }|d7 }|sA|
| |? }
||
 }|| S )NrA   rW   r   )rð   rò   r   )rÌ   rG   r§   rZ   rñ   r½   rÖ   rS   rÔ   rÕ   r×   rØ   rn   rK   rK   rL   Úatan_taylor1  s&   ,ûró   c                 C   s,   | s
t t||ƒdƒS tt t|t| ƒdƒƒS )NrB   )r0   r•   r+   r5   )r¾   rG   rQ   rK   rK   rL   Úatan_infE  s   rô   c                 C   s  | \}}}}|s$| t krt S | tkrtd||ƒS | tkr"td||ƒS tS || }||d kr4t|||ƒS | |d krDt| d| ||ƒS |d t|ƒ }|dkrYtd| |ƒ} d}	nd}	t| |ƒ}
|re|
 }
|t	k rot
|
|ƒ}nt|
|ƒ}|	r€t|ƒd? d | }|r…| }t|| ||ƒS )Nr   r   r>   é   rA   TF)r    r$   rô   r%   r&   r6   rÎ   r1   r   ÚATAN_TAYLOR_PRECró   rî   r�   r   )rÌ   rG   rQ   r¾   r¿   r©   r¨   rß   rR   Ú
reciprocalr›   rZ   rK   rK   rL   Úmpf_atanJ  s6   

rø   c                 C   s>  |\}}}}| \}}	}
}|	sK| t kr#|tkr#t|ƒdkrt S t||ƒS | ttfv rI|ttfv r1tS | tkr=tt||ƒdƒS ttt|t| ƒdƒƒS tS |rZtt	t| ƒ||t| ƒƒS |s|tkrbtS |tkrht S |tkrqt||ƒS | t krwt S tt||ƒdƒS t
t| ||d ƒ|d ƒ}|r™tt|d ƒ|||ƒS t|||ƒS )Nr   rB   r�   )r    r&   r(   r•   r$   r%   r0   r+   r5   Ú	mpf_atan2rø   r/   r,   r*   )r¦   rÌ   rG   rQ   ÚxsignÚxmanÚxexpÚxbcZysignZymanZyexpZybcZtquorK   rK   rL   rù   m  s<   

rù   c                 C   sv   | \}}}}|| dkr| t tfvrtdƒ‚|d }t| | ƒ}tt ttt ||ƒ|ƒ|ƒ}	t| |	|ƒ}
tt	|
||ƒdƒS )Nr   z%asin(x) is real only for -1 <= x <= 1é   r   )
r!   r"   r   r.   r,   r3   r-   r/   r0   rø   ©rÌ   rG   rQ   r¾   r¿   r©   r¨   rR   rZ   r[   r¤   rK   rK   rL   Úmpf_asin�  s   
r   c                 C   sˆ   | \}}}}|| dkr| t tfvrtdƒ‚| tkrt||ƒS |d }t| | ƒ}ttt ||ƒ|ƒ}	t|	tt | |ƒ|ƒ}
t	t
|
||ƒdƒS )Nr   z%acos(x) is real only for -1 <= x <= 1rþ   r   )r!   r"   r   r•   r.   r3   r-   r/   r,   r0   rø   rÿ   rK   rK   rL   Úmpf_acos›  s   

r  c           
      C   s–   |d }| \}}}}|| }|dk r%|| k r t | d| ||ƒS || 7 }ttt| | ƒt|ƒ|ƒ}	tt| ƒ|	|ƒ}	|rEtt|	|t| ƒƒS t|	||ƒS )Nr>   éøÿÿÿr   )	r6   r3   r,   r.   r!   r)   r+   r”   r5   )
rÌ   rG   rQ   rR   r¾   r¿   r©   r¨   rß   rY   rK   rK   rL   Ú	mpf_asinh©  s   

r  c                 C   sJ   |d }t | tƒdkrtdƒ‚ttt| | ƒt|ƒ|ƒ}tt| ||ƒ||ƒS )Nrþ   rB   z acosh(x) is real only for x >= 1)r'   r!   r   r3   r,   r.   r"   r”   )rÌ   rG   rQ   rR   rY   rK   rK   rL   Ú	mpf_acoshº  s
   r  c                 C   sÄ   | \}}}}|s|r| t tfv r| S tdƒ‚|| }|dkr0|dkr,|dkr,ttg| S tdƒ‚|d }|dk rI|| k rDt| |||ƒS || 7 }t| t|ƒ}	tt| |ƒ}
t	t
t|	|
|ƒ||ƒdƒS )Nz&atanh(x) is real only for -1 <= x <= 1r   r   rþ   r  rB   )r    r&   r   r$   r%   r6   r,   r!   r-   r0   r”   r/   )rÌ   rG   rQ   r¾   r¿   r©   r¨   rß   rR   rZ   r[   rK   rK   rL   Ú	mpf_atanhÂ  s$   

r  c                 C   sÂ   | \}}}}|s| t krtS | S t|| ƒ}|dkr.|dk s$|t|ƒkr.ttt| ƒƒ||ƒS || d }t|ƒ}	tt	|	dƒt
|ƒ}
t|	| |ƒ}t| |ƒ}t|||ƒ}t|||ƒ}t||
||ƒ}|S )Nr   rC   r>   r   )r%   r&   rÎ   r   r   r8   r   Úmpf_phir,   r0   r"   r¥   Ú
mpf_cos_pir/   r-   )rÌ   rG   rQ   r¾   r¿   r©   r¨   ÚsizerR   rZ   r[   r¼   rS   rK   rK   rL   Úmpf_fibonacci×  s$   
r	  c                 C   sÜ  | dk r
|  } d}nd}t d|d  ƒ}t| ƒ| }td|| ƒ}ddt|| ƒ  }|| }| || K } t|> }|dk}	|tk r•| |  |?  }
}|
|
 |? }t }}d}|r||d |  }||7 }|d7 }||d |  }||7 }|d7 }|| |? }|sW|
| |? }|	rŽ|| | }n…|| | }n~t d|d  ƒ}| |  |?  }
}||
g}td|ƒD ]}| |d |
 |? ¡ q®tg| }d}|rùt|ƒD ]%}||d |  }|	râ|d@ râ||  |8  < n||  |7  < |d7 }qÉ||d  |? }|sÅtd|ƒD ]}|| ||  |? ||< qþt|ƒ| }|dk�r@t	|| ||>  ƒ}|�r*|| }n|| }t|ƒD ]	}|| |? }�q2||? S |d }t|ƒD ]}|| |? | }�qHt	t
||> ||  ƒƒ}|�rf| }||? ||? fS )	zÇ
    Taylor series for cosh/sinh or cos/sin.

    type = 0 -- returns exp(x)  (slightly faster than cosh+sinh)
    type = 1 -- returns (cosh(x), sinh(x))
    type = 2 -- returns (cos(x), sin(x))
    r   r   ç      à?rC   rA   g333333Ó?re   rB   )rF   r   Úmaxr   ÚEXP_SERIES_U_CUTOFFr   r   ÚappendÚsumr7   rÎ   )rÌ   rG   Útyper¾   rj   Zxmagr¶   rR   rÓ   ZaltrÑ   rZ   Zx4rÖ   r×   rØ   r¤   r¼   ZxpowersrÏ   Zsumsrn   rS   ZpshiftrK   rK   rL   Úexponential_seriesó  sv     ý

ú

r  c           
      C   sÈ   |t kr
t| |dƒS t|d ƒ}||7 }t|>  }}d}| |  |?  }}|rF|| }||7 }|d7 }|| }||7 }|d7 }|| |? }|s&||  |? }|| }|}	|r`|| |? }|d8 }|sT||	? S )zÄ
    Compute exp(x) as a fixed-point number. Works for any x,
    but for speed should have |x| < 1. For an arbitrary number,
    use exp(x) = exp(x-m*log(2)) * 2^m where m = floor(x/log(2)).
    r   r
  rA   r   )ÚEXP_COSH_CUTOFFr  rF   r   )
rÌ   rG   rj   rÖ   r×   rØ   rZ   rÑ   rn   r¼   rK   rK   rL   Úexp_basecase>  s(   ýþr  c                 C   sJ   |t krt| |dƒ\}}|| || fS t| |ƒ}t|| > | }||fS )z(
    Computation of exp(x), exp(-x)
    r   )r  r  r  r   )rÌ   rG   ÚcoshÚsinhrZ   r[   rK   rK   rL   Úexp_expneg_basecaseW  s   
r  c                 C   s4  |t kr
t| |dƒS |t }| |? }t|ƒ}|tvr6|dt  t > }t|dt  dƒ\}}|d? |d? ft|< t| \}}t | }||L }||L }| ||> 8 } t|> }	| }
d}| |  |?  }|r†|| }|	|7 }	|d7 }||  |? }|| }|
|7 }
|d7 }||  |?  }|s_|	| |
|  |? |
| |	|  |? fS )zÈ
    Compute cos(x), sin(x) as fixed-point numbers, assuming x
    in [0, pi/2). For an arbitrary number, use x' = x - m*(pi/2)
    where m = floor(x/(pi/2)) along with quarter-period symmetries.
    rA   rC   r   )ÚCOS_SIN_CACHE_PRECr  ÚCOS_SIN_CACHE_STEPrF   Úcos_sin_cacher   )rÌ   rG   Zprecsr›   r§   ÚwZcos_tZsin_tÚoffsetrë   rì   rØ   rZ   rK   rK   rL   Úcos_sin_basecaseb  s.   $&þ(r  c                 C   s0  | \}}}}|rŒ|| }|d }|r| }|dkr0|dkr0t |td| ƒ ƒ}	t|	||> ||ƒS || k r<tt|||ƒS |dkrj|| }
||
 }|dkrQ||> }n|| ? }t|
ƒ}t||ƒ\}}t|ƒ}||L }n|| }|dkrw||> }n|| ? }d}t||ƒ}t||| ||ƒS |s�tS | t	kr–t
S | S )Né   r:   r   g333333÷?r   )Úmpf_erF   r2   r6   r!   rv   Údivmodr  r   r%   r    )rÌ   rG   rQ   r¾   r¿   r©   r¨   rß   rR   ÚeÚwpmodr  r›   Úlg2r§   rK   rK   rL   rš     sB   






rš   c                 C   s<  | \}}}}|s.|r.|r| t krtS | tkrtS tS | t kr"t t fS | tkr*t tfS ttfS || }|d }	|dk ra||	 k r\|rJt| d| ||ƒS ttd||ƒ}
t| |||ƒ}|
|fS |	| 7 }	|dkr•dd|d >  |	kr•|r~tttg| d| ||ƒS ttt| ƒ||ƒdƒ }}|r‘t	|ƒ}||fS |dkrÃ|	| }|| }|dkrª||> }n|| ? }t
|ƒ}t||ƒ\}}t|ƒ}||L }n||	 }|dkrÐ||> }n|| ? }d}t||	ƒ\}}||d| ?  }
||d| ?  }|ró| }|�r||	> |
 }t||	 ||ƒS t|
||	 d ||ƒ}
t|||	 d ||ƒ}|
|fS )	z4Simultaneously compute (cosh(x), sinh(x)) for real xr  éüÿÿÿr   r   rC   rW   rB   rA   )r$   r!   r%   r"   r&   r6   r0   rš   r)   r+   rv   r  rF   r  r   )rÌ   rG   rQ   Útanhr¾   r¿   r©   r¨   rß   rR   r  r  r¤   rn   r   r  r›   r!  r§   rZ   r[   rK   rK   rL   Úmpf_cosh_sinh¬  sj   






r$  c                 C   sð   |dkrZd}	 d|> }|| | }t |d ƒ}|d? }|| }	|	dkr(| |	> }
n| |	 ? }
t|
|ƒ\}}||kr=|| }n|}||| d ? rTt|ƒ}||? }
|| }n|d7 }qn|| 7 }|| }	|	dkrl| |	> }
n| |	 ? }
d}|
||fS )Nr   r   r>   rC   )r�   r  rF   )r¿   r©   rß   rR   rÏ   Zcancellation_precr   Úpi2Zpi4r  r›   r§   r¦   ÚsmallrK   rK   rL   Úmod_pi2ï  s<   


ì



r'  c                 C   sô  | \}}}}|s/|rt t }	}
ntt}	}
|dkr|	|
fS |dkr#|	S |dkr)|
S |dkr/|
S || }|d }|dk rx|| k rx|rIt| t|ƒƒ} ttd||ƒ}	t| d| ||ƒ}
|dkra|	|
fS |dkrg|	S |dkrm|
S |dkrxt| |||ƒS |rú|dkr¿|dkr‘t}	ttft|d@ ƒ|A  }
n|dkr›tt}	}
ntt}	}
|dkr¨|	|
fS |dkr®|	S |dkr´|
S |dkr¿t|
|	||ƒS || d ? d d? }||| d >  }t	|ƒ| }|d | }|| }|dkrì||> }n|| ? }|t
|ƒ |? }n
t||||ƒ\}}}t||ƒ\}	}
|d@ }|dk�r|
 |	}	}
n|dk�r(|	 |
 }	}
n|dk�r3|
|	 }	}
|�r9|
 }
|dk�rRt|	| ||ƒ}	t|
| ||ƒ}
|	|
fS |dk�r_t|	| ||ƒS |dk�rlt|
| ||ƒS |dk�rxt|
|	||ƒS dS )z–
    which:
    0 -- return cos(x), sin(x)
    1 -- return cos(x)
    2 -- return sin(x)
    3 -- return tan(x)

    if pi=True, compute for pi*x
    r   r   rA   rW   rC   rB   N)r&   r!   r    r.   r•   r6   r"   Úboolr/   r   r�   r'  r  r   r   )rÌ   rG   rQ   ÚwhichÚpir¾   r¿   r©   r¨   r¤   rn   rß   rR   r§   Zmag2r  r›   r^   rK   rK   rL   Úmpf_cos_sin  sz   









ÿr+  c                 C   ó   t | ||dƒS ©Nr   ©r+  ©rÌ   rG   rQ   rK   rK   rL   Úmpf_cosb  ó    r0  c                 C   r,  )NrA   r.  r/  rK   rK   rL   Úmpf_sinc  r1  r2  c                 C   r,  )NrW   r.  r/  rK   rK   rL   Úmpf_tand  r1  r3  c                 C   ó   t | ||ddƒS )Nr   r   r.  r/  rK   rK   rL   Úmpf_cos_sin_pie  ó    r5  c                 C   s   t | ||ddƒS r-  r.  r/  rK   rK   rL   r  f  r6  r  c                 C   r4  )NrA   r   r.  r/  rK   rK   rL   Ú
mpf_sin_pig  r6  r7  c                 C   ó   t | ||ƒd S ©Nr   ©r$  r/  rK   rK   rL   Úmpf_coshh  r6  r;  c                 C   r8  r-  r:  r/  rK   rK   rL   Úmpf_sinhi  r6  r<  c                 C   s   t | ||dd�S )Nr   )r#  r:  r/  rK   rK   rL   Úmpf_tanhj  r6  r=  c                 C   sŒ   |d u r
t |d ƒ}t| |ƒ\}}t|ƒ}t||ƒ\}}|d@ }|dkr(||fS |dkr1| |fS |dkr;| | fS |dkrD|| fS d S )Nr   rW   r   rA   )r�   r  rF   r  )rÌ   rG   r%  r§   r›   r¤   rn   r^   rK   rK   rL   rê   o  s   rê   c                 C   sJ   |d u rt |ƒ}t| |ƒ\}}t|ƒ}t||ƒ}|dkr ||> S || ? S r9  )rv   r  rF   r  )rÌ   rG   rÊ   r§   r›   rS   rK   rK   rL   Ú	exp_fixed{  s   

r>  Úsagez)Warning: Sage imports in libelefun failed)F)FNr—   )r   )šrO   rf   r   Úbackendr   r   r   r   r   r	   r
   Úlibmpfr   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   r5   r6   r7   Ú
libintmathr8   r  r  r  r  r  rÉ   rÆ   rÝ   rÇ   rÛ   rÞ   rö   rð   rï   rÚ   rØ   rá   rP   rV   rX   rk   ro   rv   r|   rƒ   r„   r‚   rŒ   r†   r�   r�   r�   r‘   r“   r  r•   r  Ú
mpf_degreeÚmpf_ln2Úmpf_ln10r–   r˜   Z
mpf_sqrtpiZmpf_ln_sqrt2pir¥   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  r2  r3  r5  r  r7  r;  r<  r=  rê   r>  Úsage.libs.mpmath.ext_libmpÚlibsÚmpmathÚ	ext_libmpÚ_lbmpÚImportErrorÚAttributeErrorr…   rK   rK   rK   rL   Ú<module>   sô     ¼
&	
	





	6S

/""H,##
K-C$O


ÿô