
    dv                     N    d Z ddlmZ ddlmZmZmZ ddlmZm	Z	 d	dZ
d ZdgZdS )
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  }dt          t	          |                     v rt          |           } t          | t                    r| }n+t          st          j        |           }nt          |           }|dk     rt          ||z            |z  }n|                    |t                    }|rt          |          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         8lib/python3.11/site-packages/future/builtins/newround.pyr   r      s    J 
v{## )(((t}}'*H $tF||$$$ v&'"" & 	&"6**AAf%%A{ @!h,''(2H?? 6{{V}}    c                    ddl }ddlm} t          | t          t
          f          rt          |           S |                    |           s|                    |           rt          t          |                     S |
                    d|           dk    rd}nd}t          |                                           \  }}d } ||          dz
  } ||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    | dk    r,t          t          t          |                               dz
  S dS )Nr      )lenbinabs)r   s    r   
bit_lengthz!from_float_26.<locals>.bit_length_   s2    6 	s3q66{{##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	   * ((((((!c4[!! qzz{{1~~  Q  tAww~~c1$ q66""$$DAq  
 	
1AdC!Q$KK!44F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   