403WebShell

403Webshell
Server IP : 93.86.61.54 / Your IP : 216.73.216.206
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /lib/python3/dist-packages/mpmath/libmp/__pycache__/
Upload File :
[ Back ]
Current File : /lib/python3/dist-packages/mpmath/libmp/__pycache__/libmpf.cpython-310.pyc
o

�"`ޯ�
@s�dZdZddlZddlmZddlZdaddlmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!e
dkrYd	d
�Z"ndd
�Z"dd
�Z#Gdd�de$�Z%ze&Wn
e'yzdd�Z&Ynwe&d�Z(e&d�Z)e&d�Z*e&d�Z+e&d�Z,e,Z-dd�Z.dd�Z/dd�Z0de	ddfZ1de	ddfZ2de
ddfZ3de
ddfZ4de
ddfZ5deddfZ6de
ddfZ7de	ddfZ8de	d d!fZ9de	d"d#fZ:d$Z;d%d&�Z<Gd'd(�d(�Z=dgd)d*�e>dd+�D�Z?e=�e?gZ@e)d,e*d-e,d.e+d/iZAd0d1�ZBd2d3�ZCzeDeEfZFWn
e'�yeDfZFYnwd4d5�ZGd6d7�ZHe
d8k�r8d9eIe�v�r8ejJZBejJZCe
dk�rBejKZBZCe�rJeGZKeHZLneBZKeCZLde-fd:d;�ZMeNd<d=�e>d>d?�D��ZOe
d8k�rpd@eIe�v�rpejPZMe
dk�rxejMZMde-fdAdB�ZQdCdD�ZRd�dEdF�ZSdGdH�ZTde-fdIdJ�ZUde-fdKdL�ZVde-fdMdN�ZWde-fdOdP�ZXdQe-fdRdS�ZYdTe-fdUdV�ZZde-fdWdX�Z[dYe-fdZd[�Z\e-fd\d]�Z]d^d_�Z^d`da�Z_dbdc�Z`ddde�Zadfdg�Zbdhdi�Zcdjdk�Zddldm�Zedndo�Zfdpdq�Zgdrds�Zhde-fdtdu�Zide-fdvdw�Zjde-fdxdy�Zkdzd{�Zlde-dfd|d}�Zmde-fd~d�Znde-dYfd�d��Zode-fd�d��Zpe-fd�d��Zqde-fd�d��Zre-fd�d��Zse
d8k�rJepZteqZunerZtesZud�d��Zvd�d��Zwe-fd�d��Zxe-fd�d��Zye-fd�d��Zze,e+e+e,e)e*e*e)e(e(iZ{e,e,e+e+e)e*e*e)e(e(iZ|e-fd�d��Z}d�d��Z~d�d��Z		Yd�d�d��Z�d�d�d��Z�e9e9e:e8d��Z�e-fd�d��Z�d�d��Z�d�d��Z�e-fd�d��Z�e-fd�d��Z�e
dk�r�zddl�m�m�m�Z�e�jmZme�jnZne�jtZte�jxZxe�j�Z�WdSe��y�YdSwdS)�zH
Low-level functions for arbitrary-precision floating-point arithmetic.
�	plaintext�N)�bisect�)
�MPZ�MPZ_TYPE�MPZ_ZERO�MPZ_ONE�MPZ_TWO�MPZ_FIVE�BACKEND�STRICT�HASH_MODULUS�	HASH_BITS�gmpy�sage�
sage_utils)
�giant_steps�
trailtable�bctable�lshift�rshift�bitcount�trailing�
sqrt_fixed�numeral�isqrt�
isqrt_fast�sqrtrem�bin_to_radixrcCs|\}}}}|t|�||fS�N��hex��x�sign�man�exp�bc�r(�5/usr/lib/python3/dist-packages/mpmath/libmp/libmpf.py�to_pickablesr*cCs$|\}}}}|t|�dd�||fS)N�r r"r(r(r)r*#scCs|\}}}}|t|d�||fS)N�)rr"r(r(r)�
from_pickable'sr-c@seZdZdS)�
ComplexResultN)�__name__�
__module__�__qualname__r(r(r(r)r.+sr.cCs|Srr()r#r(r(r)�<lambda>1sr2�n�f�c�u�dcCstdttt|�d�d��S)zZReturn number of accurate decimals that can be represented
    with a precision of n bits.r�r�y	O�
@��max�int�round�r3r(r(r)�prec_to_dps;�r>cCstdttt|�dd���S)zJReturn the number of bits required to represent n decimals
    accurately.rr8r9r=r(r(r)�dps_to_prec@r?r@cCst|�}|dkr
dS|dS)z�Return the number of decimal digits required to represent
    a number with n-bit precision so that it can be uniquely
    reconstructed from the representation.���)r>)r3�dpsr(r(r)�repr_dpsEsrErC���i����i8������i�����g�cCs�|tkr2|dkr*||d?}|d@r&|d@s |t|dk|@r&|d?dS|d?St|||�S|tkr:||?S|tkrD||?S|tkrV|dkrP||?S||?S|tkrh|dkrd||?S||?SdS)Nrrr+�,)�
round_nearest�h_mask�	round_int�round_floor�
round_ceiling�
round_down�round_up)r#r3�rnd�tr(r(r)rLks($�rLc@seZdZdd�ZdS)�
h_mask_bigcCst|d>dS)Nr�r)�selfr3r(r(r)�__getitem__�szh_mask_big.__getitem__N)r/r0r1rVr(r(r(r)rS�srScCsg|]
}t|d>d�qS)rrT)�.0�_r(r(r)�
<listcomp>�srYrI)rr)rr)rr)rrcCs|stS||}|dkrK|tkr4||d?}|d@r/|d@s(|t|dk|@r/|d?d}n|d?}nt||r?||L}n||?}||7}|}|d@s�tt|d@�}|su|d@sm|dL}|d7}|d8}|d@r]tt|d@�}||L}||7}||8}|dkr�d}||||fS)a�
    Create a raw mpf tuple with value (-1)**sign * man * 2**exp and
    normalized mantissa. The mantissa is rounded in the specified
    direction if its size exceeds the precision. Trailing zero bits
    are also stripped from the mantissa to ensure that the
    representation is canonical.

    Conditions on the input:
    * The input must represent a regular (finite) number
    * The sign bit must be 0 or 1
    * The mantissa must be positive
    * The exponent must be an integer
    * The bitcount must be exact

    If these conditions are not met, use from_man_exp, mpf_pos, or any
    of the conversion functions to create normalized raw mpf tuples.
    rrr+rI����fzerorJrK�shifts_downrr;�r$r%r&r'�precrQr3rRr(r(r)�
_normalize�s:$

�racCs&|stS||kr||||fS||}|tkr:||d?}|d@r5|d@s.|t|dk|@r5|d?d}n|d?}nt||rE||L}n||?}||7}|}|d@s�tt|d@�}|s{|d@ss|dL}|d7}|d8}|d@rctt|d@�}||L}||7}||8}|dkr�d}||||fS)zSsame as normalize, but with the added condition that
       man is odd or zero
    rr+rIrZr[r\r_r(r(r)�_normalize1�s<$

�rbcCsRt|�tksJ�t|�tvsJ�t|�tvsJ�|t|�ks J�t||||||�S)�zAdditional checks on the components of an mpf. Enable tests by setting
       the environment variable MPMATH_STRICT to Y.)�typer�
_exp_typesrra�r$r%r&r'r`rQr(r(r)�strict_normalize�s
rgcCsbt|�tksJ�t|�tvsJ�t|�tvsJ�|t|�ks J�|r(|d@s(J�t||||||�S)rcr)rdrrerrbrfr(r(r)�strict_normalize1srhr�_mpmath_normalizecCs�t|�}d}|dkrd}|}|dkrtt|�}nt|�}|sp|s$tS|d@sj|d@r8||d?|d|dfStt|d@�}|s^|d@sV|dL}|d7}|d8}|d@rFtt|d@�}||L}||7}||8}||||fSt||||||�S)z�Create raw mpf from (man, exp) pair. The mantissa may be signed.
    If no precision is specified, the mantissa is stored exactly.rr�r+rZr[)rrr;rr]r�	normalize)r%r&r`rQr$r'rRr(r(r)�from_man_exp#s6�rlccs�|]
}|t|d�fVqdS)rN)rl)rWr3r(r(r)�	<genexpr>Bs�rmi����i�_mpmath_createcCs"|s
|tvr
t|St|d||�S)zcCreate a raw mpf from an integer. If no precision is specified,
    the mantissa is stored exactly.r)�	int_cacherl)r3r`rQr(r(r)�from_intJsrpcCs(|\}}}}|s|rtd|��||fS)z:Return (man, exp) of a raw mpf. Raise an error if inf/nan.z*mantissa and exponent are undefined for %s��
ValueError��sr$r%r&r'r(r(r)�
to_man_expRsrucCsz|\}}}}|s|rtd��|dkr|r||>S||>S|s,|r'||?S||?S|r6t|||�St|||�S)z�Convert a raw mpf to the nearest int. Rounding is done down by
    default (same as int(float) in Python), but can be changed. If the
    input is inf/nan, an exception is raised.z cannot convert inf or nan to intr)rrrL)rtrQr$r%r&r'r(r(r)�to_intYs

rvcCs�|\}}}}|s|r|S|dkr|S||}|dkrD|tkr$|r"tStS|tkr.|r,tStS|tkrB|dks:|tkr<tS|r@tStSt�t|t	||�|�S�Nrr)
rNr]�fonerM�fnonerJr�NotImplementedError�mpf_pos�min)rtrQr$r%r&r'�magr(r(r)�
mpf_round_intos&r~cC�t|t�}|r
t|||�}|Sr)r~rMr{�rtr`rQ�vr(r(r)�	mpf_floor��
r�cCrr)r~rNr{r�r(r(r)�mpf_ceil�r�r�cCrr)r~rJr{r�r(r(r)�mpf_nint�r�r�cCst|t|�||�Sr)�mpf_subr�)rtr`rQr(r(r)�mpf_frac�sr��5cCs�||krtSz	t�|�\}}Wn|tkrtYS|tkr$tYStYS|tkr.tS|tkr5tStt|d�|d||�S)z�Create a raw mpf from a Python float, rounding if necessary.
    If prec >= 53, the result is guaranteed to represent exactly the
    same number as the input. If prec is not specified, use prec=53.lr�)�fnan�math�frexp�math_float_inf�finf�fninfrlr;)r#r`rQ�m�er(r(r)�
from_float�sr��qcCs~t|�}||krt|||�Sddl}|�|�r/|�|�\}}tt|�|d��t|d�||�S|�|�r6t	S|�
|�r=tStS)z�Create a raw mpf from a numpy float, rounding if necessary.
    If prec >= 113, the result is guaranteed to represent exactly the
    same number as the input. If prec is not specified, use prec=113.rNr�)
�floatr��numpy�isfiniter�rlr;�ldexp�isposinfr��isneginfr�r�)r#r`rQ�y�npr�r�r(r(r)�from_npfloat�s
"r�cCsT|��rtS|��r|��rtStS|dur"tt|��d�d�}t	t
|�||�S)z�Create a raw mpf from a Decimal, rounding if necessary.
    If prec is not specified, use the equivalent bit precision
    of the number of significant digits in x.Nrr8)�is_nanr��is_infinite�	is_signedr�r�r;�len�as_tuple�from_str�str)r#r`rQr(r(r)�from_Decimal�s
r�FcCs�|\}}}}|s|tkrdS|tkrtS|tkrtSttS|dkr0t||||d|�\}}}}|r5|}zt�||�WStyZ|rF�||dkrW|rStYStYSYdSw)a
    Convert a raw mpf to a Python float. The result is exact if the
    bitcount of s is <= 53 and no underflow/overflow occurs.

    If the number is too large or too small to represent as a regular
    float, it will be converted to inf or 0.0. Setting strict=True
    forces an OverflowError to be raised instead.

    Warning: with a directed rounding mode, the correct nearest representable
    floating-point number in the specified direction might not be computed
    in case of overflow or (gradual) underflow.
    gr�r)r]r�r�r��
normalize1r�r��
OverflowError)rt�strictrQr$r%r&r'r(r(r)�to_float�s*

�r�cCstt|�t|�||�S)zDCreate a raw mpf from a rational number p/q, round if
    necessary.)�mpf_divrp)�p�qr`rQr(r(r)�
from_rational�sr�cCsP|\}}}}|r|}|dkrtd|��|dkr!|d|>dfS|d|>fS)z]Convert a raw mpf to a rational number. Return integers (p, q)
    such that s = p/q exactly.rFz&cannot convert %s to a rational numberrrrqrsr(r(r)�to_rational�sr�cCsP|\}}}}||}|r|dkr||>S||?S|dkr#||>S||?S)z.Convert a raw mpf to a fixed-point big integerrr()rtr`r$r%r&r'�offsetr(r(r)�to_fixed�s
r�cCs&ts	ddl}|jatt|�||t�S)zQReturn a raw mpf chosen randomly from [0, 1), with prec bits
    in the mantissa.rN)�getrandbits�randomrlrM)r`r�r(r(r)�mpf_randsr�cCs,|dr|ds|tks|tkrdS||kS)z�Test equality of two raw mpfs. This is simply tuple comparison
    unless either number is nan, in which case the result is False.rF)r��rtrRr(r(r)�mpf_eqsr�cCs�tjdkrT|\}}}}|s&|tkrtjjS|tkrtjjS|tkr&tjjS|t}|dkr3|t	}n
t	dd|t	}||>t}|rH|}|dkrP|dkt
|�Sz	tt|dd��WSt
yjt|�YSw)N)rCr+rrrFrG)r�)�sys�version_infor��	hash_info�nanr��infr�r
rr;�hashr�r�)rt�ssign�sman�sexp�sbc�hr(r(r)�mpf_hash!s&


�r�c
Cs"|\}}}}|\}}}}	|r|s;|tkrt|�S|tkr!t|�S||kr'dS|tkr-dS|tkr3dS|tkr9dSdS||krE|sCdSdS||kr_||krOdS||krY|rWdSdS|r]dSdS||}
|	|}|rv|
|krodS|
|krudSn|
|kr|dS|
|kr�dSt||dt�}|dr�dSdS)z�Compare the raw mpfs s and t. Return -1 if s < t, 0 if s == t,
    and 1 if s > t. (Same convention as Python's cmp() function.)rrrF�)r]�mpf_signr�r�r�r�rM)
rtrRr�r�r�r��tsign�tman�texp�tbc�a�b�deltar(r(r)�mpf_cmp>s@r�cCs"|tks|tkr
dSt||�dkS�NFr�r�r�r�r(r(r)�mpf_ltr�r�cCs"|tks|tkr
dSt||�dkSr�r�r�r(r(r)�mpf_lewr�r�cCs"|tks|tkr
dSt||�dkSr�r�r�r(r(r)�mpf_gt|r�r�cCs"|tks|tkr
dSt||�dkSr�r�r�r(r(r)�mpf_ge�r�r�cCsB|d}}|dd�D]}t||�r|}t||�r|}q||fSrw)r�r�)�seqr|r:r#r(r(r)�mpf_min_max�s�r�cCs2|r|\}}}}|s|r|St||||||�S|S)zPCalculate 0+s for a raw mpf (i.e., just round s to the specified
    precision).)r��rtr`rQr$r%r&r'r(r(r)r{�sr{cCsZ|\}}}}|s|r|tkrtS|tkrtS|S|s"d||||fStd||||||�S)z�Negate a raw mpf (return -s), rounding the result to the
    specified precision. The prec argument can be omitted to do the
    operation exactly.r)r�r�r�r�r(r(r)�mpf_neg�sr�cCsN|\}}}}|s|r|tkrtS|S|s|rd|||fS|Std|||||�S)z�Return abs(s) of the raw mpf s, rounded to the specified
    precision. The prec argument can be omitted to generate an
    exact result.r)r�r�r�r�r(r(r)�mpf_abs�sr�cCs4|\}}}}|s|tkrdS|tkrdSdSd|S)z�Return -1, 0, or 1 (as a Python int, not a raw mpf) depending on
    whether s is negative, zero, or positive. (Nan is taken to give 0.)rrFr)r�r�rsr(r(r)r��sr�cCs�|\}}}}|\}	}
}}|	|N}	|�r0|
�r0||}
|
r�|
dkr�|
dkrV|rV||||}||dkrV|d}
||
K}|	|krE|d7}n|d8}t||||
t|�||�S||	kra|
||
>}n|rj|
||
>}n||
>|
}|dkrwd}n|}d}t|�}t|||||p�||�S|
dkr�|
dkr�|r�||||}||dkr�|d}
|
|
K}
||	kr�|
d7}
n|
d8}
t|	|
||
t|
�||�S||	kr�||
|
>}n|	r�||
|
>}n|
|
>|}|dkr�d}n|}d}t|�}t|||||p�||�S||	k�r|
|}n|�r|
|}n||
}|dk�rd}n|}d}t|�}t|||||�p-||�S|�r7t|�}|�s]|�rL||k�sH|
�sH|�sJ|StS|
�r[t|	|
|||�pX||�S|S|�rb|S|�rqt|||||�pn||�S|S)z�
    Add the two raw mpf values s and t.

    With prec=0, no rounding is performed. Note that this can
    produce a very large mantissa (potentially too large to fit
    in memory) if exponents are far apart.
    r�d�ri����)r�rrkr�r�)rtrRr`rQ�_subr�r�r�r�r�r�r�r�r�r�r%r'r(r(r)�mpf_add�s�
�
�


r�cCst||||d�S)zxReturn the difference of two raw mpfs, s-t. This function is
    simply a wrapper of mpf_add that changes the sign of t.r)r�)rtrRr`rQr(r(r)r�sr�cCs�d}d}|dp	d}d}|D]_}|\}	}
}}|
r]|	r|s|
}
||}
||krC|
|kr<|r7|
tt|��|kr<|
}|}q||
|
>7}q|
}
|
||krT|sS|
|}}q||
>|
}|}q|rm|ret|�}t|pit|d�}q|rr|St||||�S)a>
    Sum a list of mpf values efficiently and accurately
    (typically no temporary roundoff occurs). If prec=0,
    the final result will not be rounded either.

    There may be roundoff error or cancellation if extremely
    large exponent differences occur.

    With absolute=True, sums the absolute values.
    rr+i@BNr)r�absr�r�r]rl)�xsr`rQ�absoluter%r&�max_extra_prec�specialr#�xsign�xman�xexp�xbcr�r(r(r)�mpf_sum"sB�
��r�cCs�|\}}}}|\}}	}
}||A}||	}
|
r/t|
�}|r't||
||
|||�S||
||
|fS|o3|}|	o8|
}|s?|s?tSt||fvrGtS|	sP|
rP||}}|tkrVtSttd�t|�t|�S)�Multiply two raw mpfs�rrF)rr�r]r�r�r�r��rtrRr`rQr�r�r�r�r�r�r�r�r$r%r'�	s_special�	t_specialr(r(r)�gmpy_mpf_mulRs"

r�cCs^|\}}}}|st|t|�||�S|stS|dkr |dN}|}||9}t|||t|�||�S)�Multiply by a Python integer.rr)�mpf_mulrpr]rkr�rtr3r`rQr$r%r&r'r(r(r)�gmpy_mpf_mul_intgsr�cCs�|\}}}}|\}}	}
}||A}||	}
|
r9||d}|t|
|?�7}|r1t||
||
|||�S||
||
|fS|o=|}|	oB|
}|sI|sItSt||fvrQtS|	sZ|
rZ||}}|tkr`tSttd�t|�t|�S)r�rr�)r;r�r]r�r�r�r�r�r(r(r)�python_mpf_mults$

r�cCs�|\}}}}|st|t|�||�S|stS|dkr |dN}|}||9}|dkr3|tt|�d7}n|t|�d7}|t||?�7}t||||||�S)r�rrrj)r�rpr]rr;rrkr�r(r(r)�python_mpf_mul_int�sr�cCs$|\}}}}|s
|S|||||fS)z8Quickly multiply the raw mpf s by 2**n without rounding.r()rtr3r$r%r&r'r(r(r)�	mpf_shift�sr�cCs<|\}}}}|s|tkrtdfSt�t|||�||fS)z?Convert x = y*2**n to (y, n) with abs(y) in [0.5, 1) if nonzeror)r]rrr�r"r(r(r)�	mpf_frexp�sr�cCsZ|\}}}}|\}}	}
}|r|	sY|tkr"|tkrt�|tkr tStS|tkr(t�|o,|}|	o1|
}
|r8|
r8tS|tks@|tkrBtS|
sW|tkrJtSttd�t|�t|�StS||A}|	dkrlt||||
|||�S|||d}|dkrzd}t||>|	�\}}|r�|d>d}|d7}t||||
|t|�||�St	||||
|t|�||�S)zFloating-point divisionr�rr�)
r]�ZeroDivisionErrorr�r�r�r�r��divmodrrk)rtrRr`rQr�r�r�r�r�r�r�r�r�r�r$�extra�quot�remr(r(r)r��s@

r�cCs�|\}}}}|r
|stt|�|||�S|dkr|dN}|}||d}t||>|�\}	}
|
rG|	d>d}	|d7}t||	||t|	�||�St||	||t|	�||�S)z>Floating-point division n/t with a Python integer as numeratorrrr�)r�rpr�r�rrk)r3rRr`rQr$r%r&r'r�r�r�r(r(r)�mpf_rdiv_int�sr�cCs�|\}}}}|\}}	}
}|s|s|	s|
rtS||kr"|
||kr"|S|	dkr.||
|kr.tSt||
�}d||}d||	}	|||>|	|
|>}
|
dkrRd}n|
}
d}t||
|t|
�||�S)NrrFr)r�r]r|rkr)rtrRr`rQr�r�r�r�r�r�r�r��baser%r$r(r(r)�mpf_mod�s"
r�cCs�|\}}}}|s6|r6|tkr|dkr|S|dkrtStS|tkr4|dkr,ttg|d@S|dkr2tStStSt|�}|dkr@tS|dkrJt|||�S|dkr�|\}}}}|sXtS||}|dkrhdt||dfS||d}|tt||?�7}t	d||||||�S|dkr�t
t|||�S|dkr�t|||dt|�}	t
t|	||�S||@}
|dkr�|
t||dfS||dkr�||C}t	|
|||t
|�||�S|tkp�t||
}|dt
|�d}t\}}
}}	|d@�r+|
|}
||}||d7}|tt|
|?�}||k�r#|�r|
||?}
n|
||?}
|||7}|}|d8}|�s+n<||}||}||d}|tt||?�}||k�rb|�rR|||?}n|||?}|||7}|}|d}q�t|
|
||||�S)z=Compute s**n, where s is a raw mpf and n is a Python integer.rrr+rFr�i�r�)r�r�r]r�r;rxr{rrr�r��mpf_pow_int�reciprocal_rndrrJr^rk)rtr3r`rQr$r%r&r'rX�inverse�result_sign�rounds_down�workprec�pm�pe�pbcr(r(r)r�s�
�


�r�c
Cs||tkr
t|||�S|\}}}}|t|||ddf}|r'|ttfv|A}	n|ttfv|A}	|	r8t||||�St|||�S)a
    For nonzero x, calculate x + eps with directed rounding, where
    eps < prec relatively and eps has the given sign (0 for
    positive, 1 for negative).

    With rounding to nearest, this is taken to simply normalize
    x to the given precision.
    r)rJr{rrOrNrPr�)
r#�eps_signr`rQr$r%r&r'�eps�awayr(r(r)�mpf_perturbfs	rcCs@|drd}t|�}nd}|\}}}}|sdSt|t�dd��d}||}t|�dkrgdd	lm}	m}
tt|��d
}t	|�}t
||	|��}t||
|�|�}t|�}
t|t
t|
|�|�}|\}}}}|
}nd}t|||d�}t|t�dd�d�}t||�}t||d|�}t|d|d�}|t|�|d7}|||fS)
a0Helper function for representing the floating-point number s as
    a decimal with dps digits. Returns (sign, string, exponent) where
    sign is '' or '-', string is the digit string, and exponent is
    the decimal exponent as an int.

    If inexact, the decimal representation is rounded toward zero.r�-�)r�0r�
r+i�
r)�mpf_ln2�mpf_ln10r�g�?)r��size)r�r;r��logr��	libelefunrrrrpr�r�rvr��ftenr:r�rrr�)rtrDr$�_signr%r&r'�bitprec�
exp_from_1rr�expprec�tmpr��exponent�fixprec�fixdps�sf�sd�digitsr(r(r)�
to_digits_exp�s6	


rTcCsj|ds+|tkr|r
d}nd}|r|d7}|S|tkrdS|tkr#dS|tkr)dSt�|dur7t|d	d
�}|dur=|}t||d	�\}}}	|sV|ddvrS|	d7}	d}n�t|�|kr�||dvr�|d|�}|d}
|
dkr�||
d
kr�|
d8}
|
dkr�||
d
ksv|
dkr�|d|
�tt	||
�d�d||
d}ndd|d}|	d7}	n|d|�}||	kr�|kr�nn#|	dkr�dt	|	�|}d}n|	d}||kr�|d||7}d}	nd}|d|�d||d�}|�r|�
d�}|ddk�r|d7}|	dk�r|�r|�s||S|	dk�r$||dt|	�S|	dk�r3||dt|	�SdS)a{
    Convert a raw mpf to a decimal floating-point literal with at
    most `dps` decimal digits in the mantissa (not counting extra zeros
    that may be inserted for visual purposes).

    The number will be printed in fixed-point format if the position
    of the leading digit is strictly between min_fixed
    (default = min(-dps/3,-5)) and max_fixed (default = dps).

    To force fixed-point format always, set min_fixed = -inf,
    max_fixed = +inf. To force floating-point format, set
    min_fixed >= max_fixed.

    The literal is formatted so that it can be parsed back to a number
    by to_str, float() or Decimal().
    rz0.0z.0ze+0�+inf�-infr�NrC���r�56789�9r	�1�.rFze+r�)r]r�r�r�rrr|rr�r�r;�rstrip)rtrD�strip_zeros�	min_fixed�	max_fixed�show_zero_exponentrRr$rr�i�splitr(r(r)�to_str�s\
�2

"r+r
cCs�|���d�}t|�|�d�}t|�dkrd}n
|d}t|d�}|�d�}t|�dkrD|d|d�d�}}|t|�8}||}tt||��}||fS)zHelper function for from_str.�lr�rrr#r+r	)�lowerr$r�r*r�r;r)r#r��partsr&r�r�r(r(r)�str_to_man_exp
s

r/)r�rrr�cCs�|����}|tvrt|Sd|vr/|�d�\}}|�d�|�d�}}tt|�t|�||�St|dd�\}}t|�dkrSt	||d�}t
|tt||d�||�}|S|dkrct	|d|||�}|St|d|||�}|S)aVCreate a raw mpf from a decimal literal, rounding in the
    specified direction if the input number cannot be represented
    exactly as a binary floating-point number with the given number of
    bits. The literal syntax accepted is the same as for Python
    floats.

    TODO: the rounding does not work properly for large exponents.
    �/r,r
�r�i�r)
r-�strip�special_strr*r$r�r;r/r�rpr�r�r)r#r`rQr�r�r%r&rtr(r(r)r�!s"	��r�cCsHt|dd�\}}t|�}d}|dkr|}d}t|�}t|||||t�S)Nr+r1rr)r/rrrkrM)r#r%r&r$r'r(r(r)�	from_bstrDsr4cCs2|\}}}}ddg|t|t|�dd�d|S)Nrrr+)r
r�ze%i)rrr"r(r(r)�to_bstrNs&r5c	Cs�|\}}}}|rtd��|s|S|d@r!|d8}|dK}|d7}n|dkr0t|||d|||�Stdd||d�}||d@7}|dvrLt||>�}nt||>�\}}|r`|d>d}|d7}t|||d||�S)zb
    Compute the square root of a nonnegative mpf value. The
    result is correctly rounded.
    z square root of a negative numberrr+r��fd)r.r�r:rrrl)	rtr`rQr$r%r&r'�shiftr�r(r(r)�mpf_sqrtXs(
r8cCsP|tkr
t|||�S|tkrt|||�Stt||�t||�|d�}t|||�S)zICompute the Euclidean norm sqrt(x**2 + y**2) of two raw mpfs
    x and y.r�)r]r�r�r�r8)r#r�r`rQ�hypot2r(r(r)�	mpf_hypottsr:r)TNNF)r
)��__doc__�
__docformat__r�rr�r��backendrrrrr	r
rrr
rrrr�
libintmathrrrrrrrrrrrrrr*r-rrr.�intern�	NameErrorrJrMrNrPrO�
round_fastr>r@rEr]�fnzerorxry�ftwor�fhalfr�r�r�r�rLrS�range�h_mask_smallrKr^rarbr;�longrergrh�dirrirkr�rl�dictrornrprurvr~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��mpf_mul_intr�r�r�r�r�r��negative_rndr�rrr+r/r3r�r4r5r8r:�sage.libs.mpmath.ext_libmp�libs�mpmath�	ext_libmp�ext_lib�ImportErrorr(r(r(r)�<module>s0<<

�	
�7)
�	





%
	4

_0


%�	�T4
�
U#


	��
Youez - 2016 - github.com/yon3zu
LinuXploit