U
    ZÊ¹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�r4d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 ZI�q~dd„ ZLdd„ ZMdd„ ZNdd„ ZOd’d d!„ZPeLd"d#„ ƒZQeLd$d%„ ƒZRe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�rêzRd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 n" e—e˜fk
�rè   e™d‘ƒ Y nX 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                    sN   ˆ j }| |krˆ j||  ? S t| d d ƒ}ˆ |f|Žˆ _|ˆ _ ˆ j||  ? S )NgÍÌÌÌÌÌð?é
   )Ú	memo_precÚmemo_valÚint)ÚprecÚkwargsrD   Znewprec©Úf© úU/var/www/html/bwave/python/venv/lib/python3.8/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k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rNt 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Ú
hyperbolicZ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    rj   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   rj   )ZcoefsrG   r\   Z	extraprecÚsrZ   r[   rK   rK   rL   Úmachin’   s
    "rl   c                 C   s   t dddg| 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©rl   ©rG   rK   rK   rL   Ú	ln2_fixed¢   s    rr   c                 C   s   t dddg| dƒS )zN
    Computes ln(10). This is done with a hyperbolic Machin-type formula.
    )é.   é   )é"   é1   )r>   é¡   Trp   rq   rK   rK   rL   Ú
ln10_fixedª   s    rx   iqcÏ i¦-~ i@Å	 é   c                 C   sà   ||  dkrbt d| d d| d  d| d  ƒ}|d td  d }d| | tt|   }nt|rz|dk rzt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   rh   rY   ÚmidÚg1r^   r_   Úg2ra   rb   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_baserg   rM   rh   rY   ZsqrtCrS   rK   rK   rL   Úpi_fixedé   s    	
r‰   c                 C   s   t | ƒd S )Né´   )r‰   rq   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_   ra   rb   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   re   rf   rŒ   )rG   rg   rh   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‰   rq   rK   rK   rL   Úsqrtpi_fixed0  s    r“   c                 C   sì   | \}}}}|\}}	}
}|r,|
dk r,t dƒ‚|
dkrNt| d| |	|
>  ||ƒS |
dkrÊ|	dkrŒ|r€ttt| |d t| ƒ||ƒS t| ||ƒS |r°t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.   )rk   ÚtrG   rQ   ZssignZsmanZsexpZsbcÚtsignÚtmanZtexpÚtbcÚcrK   rK   rL   Úmpf_pow>  s6    ÿ ÿÿ  ÿrš   c           
      C   s  |dkr| |  dfS t | ƒ}d}d|dt |ƒ  d  }t\}}}}	|d@ r°||  }|| }|	|d 7 }	|	tt||	? ƒ  }	|	|kr ||	| ? }||	| 7 }|}	|d8 }|s°�q| |  } || }|| d }|tt| |? ƒ  }||k�r| || ? } ||| 7 }|}|d }qD||fS )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ÚexpZworkprecÚ_ÚpmÚpeZpbcrK   rK   rL   Úint_pow_fixedZ  s8    

r¢   c                 C   s  d}z*t | |||  ƒ}tt|d|  ƒƒ}W nF tk
rt   t||ƒ}t|ƒ}td||ƒ}t|||ƒ}t|ƒ}Y nX d}|}	|}
t||| ƒD ]r}t	||d |
ƒ\}}t ||d |
 | | |	 ƒ}t
| d| | |	 ƒ| }||d t
|||
 ƒ  | }|}
q�|S )Né2   g      ð?r   rC   rA   )r   r   rF   ÚOverflowErrorr   r1   rš   r   r   r¢   r   )r›   rœ   rG   Úexp1ÚstartÚy1ri   ÚfnÚextraZextra1Úprevprh   r    r¡   rc   ÚBrK   rK   rL   Únthroot_fixed�  s(    
r¬   c                 C   s|  | \}}}}|rt dƒ‚|sd| tkr(tS | tkrL|dkr<tS |dkrHtS tS |sTtS |dk r`tS tS d}|dk rÄ|dkr|tS |dkr�t| ||ƒS |dkr¦tt| ||ƒS t| }d}d}	||	7 }| }|d	k�rX|d
ksð|tdd|d   ƒk �rX|d }
t	|ƒ}t
d||
ƒ}t| ||
|ƒ}t|d |d |d |d ||ƒ} |�rTt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�s8|dk�r<d}t|| ||
|ƒ}t||||ƒ} |�rttt| ||	 |ƒS | S d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   N)r   r&   r    r!   r$   r*   r/   r4   rF   r   r1   rš   r   r   r¬   r   )rk   rœ   rG   rQ   ÚsignÚmanrž   r�   Zflag_inverseZextra_inverseÚprec2r¨   Znthri   Ú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µ   )rk   rG   rQ   rK   rK   rL   Úmpf_cbrtù  s    r¶   c           	      C   s¨   | t kr(t |  \}}||kr(||| ? S |d }|tkrp|dkrHt|ƒ}t| ƒ}| || > }t||ƒ||  }nttt| ƒ|d ƒ|ƒ}| tk rœ||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_SHIFTrr   r   Úlog_taylor_cachedr   r�   r   ÚMAX_LOG_INT_CACHE)	rœ   rG   Úln2ÚvalueZvprecrR   ri   ÚxrS   rK   rK   rL   Úlog_int_fixed  s    r¾   c                 C   sJ   d}| | d? }|dkr,t | | ƒdk r,| S t| | ƒ}|} |d7 }q| S )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 }q|t |> 7 }|| |d ? }|t| |> ƒ |? }|  } }}|r || |? }|| |? }||7 }qzt |> |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   Úx2rk   rZ   r[   r•   rh   rK   rK   rL   Úlog_agm)  s$    

rÃ   c                 C   sà   t |ƒD ]}t| |> ƒ} qt|> }| | |> | |  }|dk }|rH| }|| |? }|| |? }|}	|d }
|| |? }d}|r¶|	|| 7 }	|d7 }|
|| 7 }
|| |? }|d7 }q||
| |? }
|	|
 d| > }|rÜ| 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   ri   rÀ   ÚonerS   r°   Úv2Úv4Ús0Ús1Úkrk   rK   rK   rL   Ú
log_taylorX  s0    	
rÊ   c                 C   s&  | |t  ? }t| }|| }||ftkr:t||f \}}n(||t  > }t||dƒ}||ft||f< ||L }||L }| | |> | }||> t|> |  }|| |? }	|	|	 |? }
|}|d }||
 |? }d}|�r||| 7 }|d7 }||| 7 }||
 |? }|d7 }qÊ||	 |? }|| 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É   rk   rK   rK   rL   r¹   z  s6    
r¹   c                 C   s´  | \}}}}|s4| t krtS | tkr(tS | tkr4tS |r@tdƒ‚|d }|dkrp|sXt S t|t|ƒ | ||ƒS || }t|ƒ}	|	dkröd|	 }
|
r¢t|> | }n|t|d >  }t	|ƒ}|| }||krît
|
||	| ||dƒ}t||
||ƒS ||7 }|	dk�r&t	|	ƒ|k�r&t|t|ƒ | ||ƒS |tk�r\tt||| ƒ|ƒ}|�r¤||t|ƒ 7 }nH| 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   rr   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˜   Zcancellationr•   r]   Zoptimal_magrœ   rK   rK   rL   r�   œ  sT       




r�   c           
      C   s  |d s||  } }| d sz|d sR| |  kr6t kr>n ntS t| |fkrNtS tS | t krjtt|ƒ||ƒS | tkrvtS tS t| | ƒ}t||ƒ}d}t|||| ƒ}t|tdƒ}|d |d  }	|t ksÔ|	| d k röt|||| 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   Za2Úb2r©   Zh2Z	cancelledZmag_cancelledrK   rK   rL   Úmpf_log_hypotä  s.    


"rÓ   c           
      C   sÜ   |dkr$t  t| |d ? ƒd ¡}nt  t| ƒd|  ¡}d}tt|d ƒd| ? ƒ}d}t||ƒD ]h}||7 }||| > }t||ƒ\}}||> | }|t| || ƒ |> t|> |d |?   }	||	 }|}qdt||| ƒS )Néd   é5   g      @Cg       @r£   rA   )re   ÚatanrF   r   r   Úcos_sin_fixedr   r   )
r½   rG   ri   rª   Zextra_prR   ÚcosÚsinÚtanrZ   rK   rK   rL   Úatan_newton  s    *rÛ   c                 C   sp   dt |d ƒ> d }|| }| |ftk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 }q~|
| |? }
||
 }|| S )NrA   rW   r{   )rÝ   rß   r   )r½   rG   rœ   rZ   rÞ   r¯   rÇ   rS   rÅ   rÆ   rÈ   rÉ   rk   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  | \}}}}|sH| t krt S | tkr0td||ƒS | tkrDtd||ƒS tS || }||d krht|||ƒS | |d krˆt| d| ||ƒS |d t|ƒ }|dkr²td| |ƒ} d}	nd}	t| |ƒ}
|rÊ|
 }
|t	k rÞt
|
|ƒ}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   Z
reciprocalr•   rZ   rK   rK   rL   Úmpf_atanJ  s<       

rä   c                 C   sD  |\}}}}| \}}	}
}|	s–| t krF|tkrFt|ƒdkr<t S t||ƒS | ttfkr’|ttfkrbtS | tkrztt||ƒdƒS ttt|t| ƒdƒƒS tS |r´tt	t| ƒ||t| ƒƒS |sþ|tkrÄtS |tkrÐt S |tkrât||ƒS | t krît S tt||ƒdƒS t
t| ||d ƒ|d ƒ}|�r4tt|d ƒ|||ƒS t|||ƒS d S )Nr   rB   r}   )r    r&   r(   r‘   r$   r%   r0   r+   r5   Ú	mpf_atan2rä   r/   r,   r*   )r›   r½   rG   rQ   ZxsignZxmanZxexpZxbcZysignZymanZyexpZybcZtquorK   rK   rL   rå   m  s<    

rå   c                 C   sv   | \}}}}|| dkr,| t tfk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k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 rJ|| k r@t | d| ||ƒS || 7 }ttt| | ƒt|ƒ|ƒ}	tt| ƒ|	|ƒ}	|rŠtt|	|t| ƒƒS t|	||ƒS d 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kr$| S tdƒ‚|| }|dkr`|dkrX|dkrXttg| S tdƒ‚|d }|dk r’|| k rˆt| |||ƒ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 sH|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 }|| |? }q¬|
| |? }|	�r|| | }n|| | }�nt d|d  ƒ}| |  |?  }
}||
g}td|ƒD ]}| |d |
 |? ¡ �q`tg| }d}|�r t|ƒD ]P}||d |  }|	�rÐ|d@ �rÐ||  |8  < n||  |7  < |d7 }�qš||d  |? }�qŒtd|ƒD ]}|| ||  |? ||< �q
t|ƒ| }|dk�r�t	|| ||>  ƒ}|�rd|| }n|| }t|ƒD ]}|| |? }�qt||? S |d }t|ƒD ]}|| |? | }�q t	t
||> ||  ƒƒ}|�rÜ| }||? ||? fS d	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Ó?rd   rB   N)rF   r   Úmaxr   ÚEXP_SERIES_U_CUTOFFr   r   ÚappendÚsumr7   r¿   )r½   rG   Útyper°   ri   Zxmagr©   rR   rÄ   ZaltrÂ   rZ   Zx4rÇ   rÈ   rÉ   r™   r®   ZxpowersrÀ   Zsumsrk   rS   ZpshiftrK   rK   rL   Úexponential_seriesó  s|    
    
 

rø   c           
      C   sÄ   |t krt| |dƒS t|d ƒ}||7 }t|>  }}d}| |  |?  }}|rŠ|| }||7 }|d7 }|| }||7 }|d7 }|| |? }qH||  |? }|| }|}	|r¼|| |? }|d8 }q¢||	? 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   ri   rÇ   rÈ   rÉ   rZ   rÂ   rk   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krl|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 }||  |?  }qº|	| |
|  |? |
| |	|  |? 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  s8          r  c                 C   s6  | \}}}}|�r|| }|d }|r,| }|dkrb|dkrbt |td| ƒ ƒ}	t|	||> ||ƒS || k rztt|||ƒS |dkrÖ|| }
||
 }|dkr¤||> }n
|| ? }t|
ƒ}t||ƒ\}}t|ƒ}||L }n(|| }|dkrð||> }n
|| ? }d}t||ƒ}t||| ||ƒS |�s$tS | t	k�r2t
S | S )Né   r:   r   g333333÷?r   )Úmpf_erF   r2   r6   r!   rr   Ú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   sP  | \}}}}|s\|r\|r4| t kr$tS | tkr0tS tS | t krDt t fS | tkrTt tfS ttfS || }|d }	|dk rÂ||	 k r¸|r”t| d| ||ƒS ttd||ƒ}
t| |||ƒ}|
|fS |	| 7 }	|dk�r2dd|d >  |	k�r2|�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 d	S )
z4Simultaneously compute (cosh(x), sinh(x)) for real xr  éüÿÿÿr   r   rC   rW   rB   rA   N)r$   r!   r%   r"   r&   r6   r0   r”   r)   r+   rr   r  rF   rý   r   )r½   rG   rQ   Útanhr°   r±   rž   r�   rÐ   rR   rû   rü   r™   rk   r  r  r•   r	  rœ   rZ   r[   rK   rK   rL   Úmpf_cosh_sinh¬  sr        










r  c                 C   sî   |dkr²d}d|> }|| | }t |d ƒ}|d? }|| }	|	dkrN| |	> }
n
| |	 ? }
t|
|ƒ\}}||krx|| }n|}||| d ? r¦t|ƒ}||? }
|| }qä|d7 }qn2|| 7 }|| }	|	dkrÖ| |	> }
n
| |	 ? }
d}|
||fS )Nr   r>   r   rC   )r‰   r  rF   )r±   rž   rÐ   rR   rÀ   Zcancellation_precr  Úpi2Zpi4r  r•   rœ   r›   ZsmallrK   rK   rL   Úmod_pi2ï  s6    





r  c                 C   s  | \}}}}|s^|r t t  }	}
n
tt }	}
|dkr:|	|
fS |dkrF|	S |dkrR|
S |dkr^|
S || }|d }|dk rð|| k rð|r’t| t|ƒƒ} ttd||ƒ}	t| d| ||ƒ}
|dkrÂ|	|
fS |dkrÎ|	S |dkrÚ|
S |dkrðt| |||ƒ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�rZ|	|
fS |dk�rh|	S |dk�rv|
S |dk�rŽt|
|	||ƒS || d ? d d? }||| d >  }t	|ƒ| }|d | }|| }|dk�rê||> }n
|| ? }|t
|ƒ |? }nt||||ƒ\}}}t||ƒ\}	}
|d@ }|dk�rH|
 |	 }	}
n0|dk�rb|	 |
  }	}
n|dk�rx|
|	  }	}
|�r„|
 }
|dk�r¶t|	| ||ƒ}	t|
| ||ƒ}
|	|
fS |dk�rÐt|	| ||ƒS |dk�rêt|
| ||ƒS |dk�rt|
|	||ƒ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™   rk   rÐ   rR   rœ   Zmag2r  r•   r]   rK   rK   rL   Úmpf_cos_sin  s–    

    
    




 
 
 
 



 
 
 



r  c                 C   s   t | ||dƒS ©Nr   ©r  ©r½   rG   rQ   rK   rK   rL   Úmpf_cosb  ó    r  c                 C   s   t | ||dƒS )NrA   r  r  rK   rK   rL   Úmpf_sinc  r  r  c                 C   s   t | ||dƒS )NrW   r  r  rK   rK   rL   Úmpf_tand  r  r  c                 C   s   t | ||ddƒS )Nr   r   r  r  rK   rK   rL   Úmpf_cos_sin_pie  r  r  c                 C   s   t | ||ddƒS r  r  r  rK   rK   rL   rï   f  r  rï   c                 C   s   t | ||ddƒS )NrA   r   r  r  rK   rK   rL   Ú
mpf_sin_pig  r  r  c                 C   s   t | ||ƒd S ©Nr   ©r  r  rK   rK   rL   Úmpf_coshh  r  r  c                 C   s   t | ||ƒd S r  r  r  rK   rK   rL   Úmpf_sinhi  r  r  c                 C   s   t | ||dd�S )Nr   )r  r  r  rK   rK   rL   Úmpf_tanhj  r  r   c                 C   sŒ   |d krt |d ƒ}t| |ƒ\}}t|ƒ}t||ƒ\}}|d@ }|dkrP||fS |dkrb| |fS |dkrv| | fS |dkrˆ|| fS d S )Nr   rW   r   rA   )r‰   r  rF   r  )r½   rG   r  rœ   r•   r™   rk   r]   rK   rK   rL   r×   o  s      
  r×   c                 C   sN   |d krt |ƒ}t| |ƒ\}}t|ƒ}t||ƒ}|dkr@||> S || ? S d S r  )rr   r  rF   rú   )r½   rG   r»   rœ   r•   rS   rK   rK   rL   Ú	exp_fixed{  s    
r!  Úsagez)Warning: Sage imports in libelefun failed)F)FN)N)r   )r   )N)N)šrO   re   r   Úbackendr   r   r   r   r   r	   r
   Z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   Z
libintmathr8   rù   rô   rþ   rÿ   r   rº   r·   rÎ   r¸   rÌ   rÏ   rã   rÝ   rÜ   rË   rÉ   rÑ   rP   rV   rX   rj   rl   rr   rx   r   r€   r~   rˆ   r‚   r‰   r‹   rŒ   r�   r�   rî   r‘   r  Z
mpf_degreeZmpf_ln2Z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  r  r  r  r  rï   r  r  r  r   r×   r!  Zsage.libs.mpmath.ext_libmpZlibsZmpmathZ	ext_libmpZ_lbmpÚImportErrorÚAttributeErrorr�   rK   rK   rK   rL   Ú<module>   sì    ¼


(		


#



	6S
/
""H,##
K-C$O



