主页 / 问题 / 1192360
Accepted
Mikhail Murugov
Asked:2021-10-19 19:41:09 +0000 UTC2021-10-19 19:41:09 +0000 UTC

如何在不丢失信息的情况下将浮点数表示为整数？

  • 772

有一个任务是在不丢失信息的情况下将float值转换为类型值int（一个float值到一个int值），即，这样您就可以执行反向转换。如何实施？

重要的

在这种转换过程中必须保留顺序和总和，
即 对于任何a, b: float应该执行：

to_float(to_int(a) + to_int(b)) == a + b

to_int(a) < to_int(b) при a < b и т.д.

我在英文 SO 上找到了答案，其中float值结构是一点一点表示的，但我无法想象它如何应用于我的任务。

注意：我的任务也不NaN需要inf转换。

解决方案尝试

最初，想到用这些字节序列化pickle.dumps然后int从这些字节中获取，但这根本不是一个合理的解决方案，它根本不满足要求。

已经尝试通过数字的字节表示来实现这一点（Qwertiy♦ 的答案），它不存储总和。

python

6 个回答

  1. to_float(to_int(a) + to_int(b)) == a + b
to_int(a) < to_int(b) при a < b и т.д.

    我记得在 python 中整数是无限的。Double的每次幂为11 位，这意味着当乘以 2**(2**12) 时，您会得到一个可以放入 int 的整数。只需要在翻译时相乘，而不是小数 - 否则会发生溢出。

    • 2

  2. 您只需要将浮点数的二进制表示重新解释为整数。

    基于https://stackoverflow.com/a/14431225/4928642

    import struct

def floatBits(f):
  s = struct.pack('>f', f)
  return struct.unpack('>l', s)[0]

    基于https://stackoverflow.com/a/58362843/4928642

    import ctypes

def floatBits(x):
  f = ctypes.c_float(x)
  return ctypes.c_int.from_address(ctypes.addressof(f)).value

    这种转换不会保存总和:(

    lhs = random.getrandbits(30)
rhs = random.getrandbits(30)
assert int_to_float(lhs) + int_to_float(rhs) == int_to_float(lhs + rhs)

    它不应该。总的来说，它不会证明它可以节省。

    • 1

  3. 而且你不想存储在两个整数中是徒劳的。在 Python 中甚至有一个专门的库。它可以将任何float数字表示为精确的分数，并以完全自然的方式处理这些数字：

    from fractions import Fraction

print(Fraction(0.123456789))
# 8895999182988127/72057594037927936

print(float(Fraction(8895999182988127, 72057594037927936)))
# 0.123456789
    • 1
  4. Best Answer

    最简单的方法是简单地乘以和除以一个足够大的因子以覆盖所需的值范围。

    ratio = (1 << 156)

def to_int(f):
    """ Если точности недостаточно, может вернуть 0 или бросить OverflowError при конвертации получившейся при умножении бесконечности
    """
    return int(f * ratio)

def to_float(d):
    return d / ratio


def to_int_2(f):
    r = (f * ratio).as_integer_ratio()
    assert r[1] == 1, 'Not enough precision'
    return r[0]

    几句话：

    # На некоторых ratio мы таки будем получать получать ровно 0.3 при сложении, так что тут поведение нестабильно    
assert to_float(to_int(0.1) + to_int(0.2)) == 0.1 + 0.2

assert to_float(to_int(-1.03e-30) + to_int(-2.04e-31)) == (-1.234e-30)
assert to_float(to_int(-1.03e+130) + to_int(-2.04e+129)) == (-1.234e+130)


assert to_int(1e-300) == 0
try:
    print(to_int(1e+300))
except OverflowError as e:
    assert str(e) == 'cannot convert float infinity to integer'

# to_int_2
assert to_float(to_int_2(0.1) + to_int_2(0.2)) == 0.1 + 0.2
assert to_float(to_int_2(-1.03e-30) + to_int_2(-2.04e-31)) == (-1.234e-30)
assert to_float(to_int_2(-1.03e+130) + to_int_2(-2.04e+129)) == (-1.234e+130)
try:
    to_int_2(1e-300) == 0
except AssertionError as e:
    assert str(e) == 'Not enough precision'
try:
    print(to_int_2(1e+300))
except OverflowError as e:
    assert str(e) == 'cannot convert Infinity to integer ratio'

    现在我得出的结论是不需要 as_integer_ratio，检查res == 0 and f != 0to_int 就足够了。

    • 1

  5. 第一种方式

    好在编程中没有无理数:)，这意味着任何浮点数都是有理数

    因此，它可以表示为分数 - 即 2个号码int

    鉴于在python中整数值不限于long，那么一个数中可以有2个数

    例如0,5是[5][10]，

    可以实现这样的存储

    第二种方式

    float很容易翻译成固定的数字——具有固定点的数字——例如，如果我们假设前 n 个字符是整数部分，而后 m 个字符是小数部分，那么

    数字的加法和减法将与 float 或 int 完全相同

    数字的比较将与 float 或 int 完全相同

    乘法会略有不同 -

    (a * b) >> m

    浮动到固定翻译：

    fixed_value = 2**m * float_value

    分别返回

    float_value = fixed_value / 2**m
    • 0

  6. 2种方法：

    出去float_long

    def floatToRawLongBits(f):
    s = struct.pack('=f', f)
    return struct.unpack('=l', s)[0]

    从long回到float

    def longToRawFloatBits(l):
    s = struct.pack('=l', l)
    return struct.unpack('=f', s)[0]

    在 Python 熟练之前，请不要重击、踢腿

    Java 有一个方法Float.floatToRawIntBits()，根据 IEEE 754 位定义，它表示整数的位。以此类推，有一个解决办法

    • 0

相关问题