U
    ÿŠÑhU«  ã                	   @   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© úD/tmp/user/2202/pip-unpacked-wheel-j8n5wfdx/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Úq1Z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    ri   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   ri   )ZcoefsrG   r\   Z	extraprecÚsrZ   r[   rK   rK   rL   Úmachin’   s
    "rk   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©rk   ©rG   rK   rK   rL   Ú	ln2_fixed¢   s    rq   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>   é¡   Tro   rp   rK   rK   rL   Ú
ln10_fixedª   s    rw   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   rg   rY   ZmidZg1r^   r_   Zg2r`   ra   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_baserf   rM   rg   rY   ZsqrtCrS   rK   rK   rL   Úpi_fixedé   s    	
r…   c                 C   s   t | ƒd S )Né´   )r…   rp   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_   r`   ra   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   rd   re   rˆ   )rG   rf   rg   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…   rp   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.   )rj   Ú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Úy1rh   ÚfnÚextraZextra1Úprevprg   rœ   r�   rb   Ú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   Trz   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   )rj   r˜   rG   rQ   ÚsignÚmanrš   r™   Zflag_inverseZextra_inverseÚprec2r¤   Znthrh   Ú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±   )rj   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   Nrz   )	Úlog_int_cacheÚLOG_TAYLOR_SHIFTrq   r   Úlog_taylor_cachedr   rŒ   r   ÚMAX_LOG_INT_CACHE)	r˜   rG   Úln2ÚvalueZvprecrR   rh   Ú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   Úx2rj   rZ   r[   r‘   rg   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   rz   rA   r   )r   r7   r   )r¹   rG   rh   r¼   ÚonerS   r¬   Úv2Úv4Ús0Ús1Úkrj   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   rz   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Å   rj   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   rq   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a2Zb2r¥   Ú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   )rd   ÚatanrF   r   r   Úcos_sin_fixedr   r   )
r¹   rG   rh   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   rz   )rÙ   rÛ   r   )r¹   rG   r˜   rZ   rÚ   r«   rÃ   rS   rÁ   rÂ   rÄ   rÅ   rj   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Ó?rc   rB   N)rF   r   Úmaxr   ÚEXP_SERIES_U_CUTOFFr   r   ÚappendÚsumr7   r»   )r¹   rG   Útyper¬   rh   Zxmagr¥   rR   rÀ   Zaltr¾   rZ   Zx4rÃ   rÄ   rÅ   r•   rª   Zxpowersr¼   Zsumsrj   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   rh   rÃ   rÄ   rÅ   rZ   r¾   rj   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!   rq   Ú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+   rq   r  rF   rù   r   )r¹   rG   rQ   Útanhr¬   r­   rš   r™   rÌ   rR   r÷   rø   r•   rj   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—   Ú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•   rj   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•   rj   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  )rq   r  rF   rö   )r¹   rG   r·   r˜   r‘   rS   rK   rK   rL   Ú	exp_fixed{  s    
r  Zsagez)Warning: Sage imports in libelefun failed)F)FN)N)r   )r   )N)N)šrO   rd   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   ri   rk   rq   rw   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



