+
    i                         R t ^RIHtHt ^ RIt]P
                  ! ]4      t. ROtRt	R R lt
R tR tR tR tR	 tR
 tR tR tR# )a  
The `OpenType specification <https://docs.microsoft.com/en-us/typography/opentype/spec/otff#data-types>`_
defines two fixed-point data types:

``Fixed``
        A 32-bit signed fixed-point number with a 16 bit twos-complement
        magnitude component and 16 fractional bits.
``F2DOT14``
        A 16-bit signed fixed-point number with a 2 bit twos-complement
        magnitude component and 14 fractional bits.

To support reading and writing data with these data types, this module provides
functions for converting between fixed-point, float and string representations.

.. data:: MAX_F2DOT14

        The maximum value that can still fit in an F2Dot14. (1.99993896484375)
)otRoundnearestMultipleShortestReprNc                <    V ^8  d   QhR\         R\        R\         /# )   valueprecisionBitsreturn)floatint)formats   "y/Users/tonyclaw/.openclaw/workspace/skills/math-calculator/venv/lib/python3.14/site-packages/fontTools/misc/fixedTools.py__annotate__r   *   s!     ( ( (c (e (    c                "    V ^V,          ,          # )a~  Converts a fixed-point number to a float given the number of
precision bits.

Args:
        value (int): Number in fixed-point format.
        precisionBits (int): Number of precision bits.

Returns:
        Floating point value.

Examples::

        >>> import math
        >>> f = fixedToFloat(-10139, precisionBits=14)
        >>> math.isclose(f, -0.61883544921875)
        True
 r   r   s   &&r   fixedToFloatr   *   s    $ A&''r   c                4    \        V ^V,          ,          4      # )a  Converts a float to a fixed-point number given the number of
precision bits.

Args:
        value (float): Floating point value.
        precisionBits (int): Number of precision bits.

Returns:
        int: Fixed-point representation.

Examples::

        >>> floatToFixed(-0.61883544921875, precisionBits=14)
        -10139
        >>> floatToFixed(-0.61884, precisionBits=14)
        -10139
r   r   s   &&r   floatToFixedr   ?   s    $ 5A./00r   c                D    ^V,          p\        W,          4      V,          # )a  Converts a float to a fixed-point number and back again.

By converting the float to fixed, rounding it, and converting it back
to float again, this returns a floating point values which is exactly
representable in fixed-point format.

Note: this **is** equivalent to ``fixedToFloat(floatToFixed(value))``.

Args:
        value (float): The input floating point value.
        precisionBits (int): Number of precision bits.

Returns:
        float: The transformed and rounded value.

Examples::
        >>> import math
        >>> f1 = -0.61884
        >>> f2 = floatToFixedToFloat(-0.61884, precisionBits=14)
        >>> f1 != f2
        True
        >>> math.isclose(f2, -0.61883544921875)
        True
r   r   r   scales   && r   floatToFixedToFloatr   T   s     2 E5=!E))r   c                H    ^V,          p\        W,          RV,          R7      # )a  Converts a fixed-point number to a string representing a decimal float.

This chooses the float that has the shortest decimal representation (the least
number of fractional decimal digits).

For example, to convert a fixed-point number in a 2.14 format, use
``precisionBits=14``::

        >>> fixedToStr(-10139, precisionBits=14)
        '-0.61884'

This is pretty slow compared to the simple division used in ``fixedToFloat``.
Use sporadically when you need to serialize or print the fixed-point number in
a human-readable form.
It uses nearestMultipleShortestRepr under the hood.

Args:
        value (int): The fixed-point value to convert.
        precisionBits (int): Number of precision bits, *up to a maximum of 16*.

Returns:
        str: A string representation of the value.
      ?factorr   r   s   && r   
fixedToStrr   q   s!    0 E&u}S5[IIr   c                J    \        V 4      p\        V^V,          ,          4      # )a  Converts a string representing a decimal float to a fixed-point number.

Args:
        string (str): A string representing a decimal float.
        precisionBits (int): Number of precision bits, *up to a maximum of 16*.

Returns:
        int: Fixed-point representation.

Examples::

        >>> ## to convert a float string to a 2.14 fixed-point number:
        >>> strToFixed('-0.61884', precisionBits=14)
        -10139
r	   r   )stringr   r   s   && r   
strToFixedr#      s"      &ME5A./00r   c                Z    \        V 4      p^V,          p\        W#,          4      V,          # )a  Convert a string to a decimal float with fixed-point rounding.

This first converts string to a float, then turns it into a fixed-point
number with ``precisionBits`` fractional binary digits, then back to a
float again.

This is simply a shorthand for fixedToFloat(floatToFixed(float(s))).

Args:
        string (str): A string representing a decimal float.
        precisionBits (int): Number of precision bits.

Returns:
        float: The transformed and rounded value.

Examples::

        >>> import math
        >>> s = '-0.61884'
        >>> bits = 14
        >>> f = strToFixedToFloat(s, precisionBits=bits)
        >>> math.isclose(f, -0.61883544921875)
        True
        >>> f == fixedToFloat(floatToFixed(float(s), precisionBits=bits), precisionBits=bits)
        True
r!   )r"   r   r   r   s   &&  r   strToFixedToFloatr%      s)    6 &MEE5=!E))r   c                <    ^V,          p\        V RV,          R7      # )a9  Convert float to string with fixed-point rounding.

This uses the shortest decimal representation (ie. the least
number of fractional decimal digits) to represent the equivalent
fixed-point number with ``precisionBits`` fractional binary digits.
It uses nearestMultipleShortestRepr under the hood.

>>> floatToFixedToStr(-0.61883544921875, precisionBits=14)
'-0.61884'

Args:
        value (float): The float value to convert.
        precisionBits (int): Number of precision bits, *up to a maximum of 16*.

Returns:
        str: A string representation of the value.

r   r   r   r   s   && r   floatToFixedToStrr'      s    & E&uS5[AAr   c                ^    V R8  d&   \        V ^4      p\        P                  RV V4       Tp V # )a  Ensure a table version is an unsigned long.

OpenType table version numbers are expressed as a single unsigned long
comprising of an unsigned short major version and unsigned short minor
version. This function detects if the value to be used as a version number
looks too small (i.e. is less than ``0x10000``), and converts it to
fixed-point using :func:`floatToFixed` if so.

Args:
        value (Number): a candidate table version number.

Returns:
        int: A table version number, possibly corrected to fixed-point.
i   zDTable version value is a float: %.4f; fix to use hex instead: 0x%08x)r   logwarning)r   newValues   & r   ensureVersionIsLongr,      s8     wr*U	

 Lr   c                x    V P                  R4      '       d   \        V ^ 4      M
\        V 4      p \        V 4      p V # )zEnsure a table version number is fixed-point.

Args:
        value (str): a candidate table version number.

Returns:
        int: A table version number, possibly corrected to fixed-point.
0)
startswithr
   r	   r,   )r   s   &r   versionToFixedr0      s4     #--c22CqMeE&ELr   )
MAX_F2DOT14r   r   r   r'   r   r#   r%   r,   r0   g    ?)__doc__
roundToolsr   r   logging	getLogger__name__r)   __all__r1   r   r   r   r   r#   r%   r'   r,   r0   r   r   r   <module>r8      s`   & = ! !(*1**:J81(*@B.4r   