Da

✏️ Editing: newround.cpython-311.pyc

�

�����|oiv�����������������������N�����d�Z�ddlmZ�ddlmZmZmZ�ddlmZm	Z	�d	d�Z
d��ZdgZdS�)
zD
``python-future``: pure Python implementation of Python 3 round().
�����)�division)�PYPY�PY26�bind_method)�Decimal�ROUND_HALF_EVENNc����������������������d}|�d}d}t����������|�d������������r|����������������������|������������S�t����������d������������|�z��}dt����������t	����������|�������������������������v�rt����������|�������������}�t
����������|�t����������������������r|�}n+t����������st����������j��������|�������������}nt����������|�������������}|dk�����rt����������||z��������������|z��}n|���������������������|t�����������������������}|rt����������|������������S�t����������|������������S�)	a���
    See Python 3 documentation: uses Banker's Rounding.

Delegates to the __round__ method if for some reason this exists.

If not, rounds a number to a given precision in decimal digits (default
    0 digits). This returns an int when called with one argument,
    otherwise the same type as the number. ndigits may be negative.

See the test_round method in future/tests/test_builtins.py for
    examples.
    FNTr����	__round__�10�numpy)�rounding)�hasattrr
���r����repr�type�float�
isinstancer����
from_float�
from_float_26�newround�quantizer����int)�number�ndigits�
return_int�exponent�d�results���      �j/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/future/builtins/newround.pyr���r���
���s�������J����
����v�{�#�#��)�����(�(�(��t�}�}�'��*�H���$�t�F�|�|�$�$�$�$��v�����&�'�"�"��&������	&��"�6�*�*�A�A��f�%�%�A���{�{��!�h�,�'�'�(�2������H���?�?������6�{�{���V�}�}������c�����������������������ddl�}ddlm}�t����������|�t����������t
����������f������������rt
����������|�������������S�|���������������������|�������������s|���������������������|�������������rt
����������t����������|�������������������������S�|�
��������������������d|�������������dk����rd}nd}t����������|������������������������������������������������\��}}d��}�||������������dz
��}�||t����������|d|z��z��������������|�������������}|S�)a���Converts a float to a decimal number, exactly.

Note that Decimal.from_float(0.1) is not the same as Decimal('0.1').
    Since 0.1 is not exactly representable in binary floating point, the
    value is stored as the nearest representable value which is
    0x1.999999999999ap-4.  The exact equivalent of the value in decimal
    is 0.1000000000000000055511151231257827021181583404541015625.

>>> Decimal.from_float(0.1)
    Decimal('0.1000000000000000055511151231257827021181583404541015625')
    >>> Decimal.from_float(float('nan'))
    Decimal('NaN')
    >>> Decimal.from_float(float('inf'))
    Decimal('Infinity')
    >>> Decimal.from_float(-float('inf'))
    Decimal('-Infinity')
    >>> Decimal.from_float(-0.0)
    Decimal('-0')

r���N)�_dec_from_tripleg�������?����c������������������j�����|�dk����r,t����������t����������t����������|�������������������������������������dz
��S�dS�)Nr�������)�len�bin�abs)r���s��� r����
bit_lengthz!from_float_26.<locals>.bit_length_���s/��������6�6��s�3�q�6�6�{�{�#�#�a�'�'��1r�������)�math�decimalr!���r���r����longr����isinf�isnanr����copysignr'����as_integer_ratio�str)	�f�_mathr!����sign�nr���r(����kr���s	���         r���r���r���=���s�����*�����(�(�(�(�(�(��!�c�4�[�!�!����q�z�z���{�{�1�~�~�� ����Q���� ��t�A�w�w�����~�~�c�1����$�$�������q�6�6�"�"�$�$�D�A�q������
�	�
�1�
�
���A�
�
�d�C��!�Q�$��K�K�!��
4�
4�F��Mr���r���)N)
�__doc__�
__future__r����future.utilsr���r���r���r+���r���r���r���r����__all__��r���r����<module>r<������s���������� ������������0��0��0��0��0��0��0��0��0��0��-��,��,��,��,��,��,��,�+��+��+��+�`)��)��)�X��,���r���

📁 Sid Gifari File Manager