Question

我正在尝试实现一个简单的半精度浮点类型，完全用于存储目的（没有算术，隐式转换为double），但我得到了奇怪的行为。我在{0}和0.5之间得到完全错误的Half值。此外，我得到一个令人讨厌的“偏移”值，例如0.8被解码为0.7998。

我对C ++很陌生，所以如果你能指出我的错误并帮助我提高准确性，我会很棒。我也很好奇这个解决方案的便携性。谢谢！

这是输出 - 来自一半的双倍值和实际解码值：

-1 -1
-0.9 -0.899902
-0.8 -0.799805
-0.7 -0.699951
-0.6 -0.599854
-0.5 -0.5
-0.4 -26208
-0.3 -19656
-0.2 -13104
-0.1 -6552
-1.38778e-16 -2560
0.1 6552
0.2 13104
0.3 19656
0.4 26208
0.5 32760
0.6 0.599854
0.7 0.699951
0.8 0.799805
0.9 0.899902

以下是目前的代码：

#include <stdint.h>
#include <cmath>
#include <iostream>

using namespace std;

#define EXP 4
#define SIG 11

double normalizeS(uint v) {
    return (0.5f * v / 2048 + 0.5f);
}

uint normalizeP(double v) {
    return (uint)(2048 * (v - 0.5f) / 0.5f);
}

class Half {

    struct Data {
        unsigned short sign : 1;
        unsigned short exponent : EXP;
        unsigned short significant : SIG;
    };

public:
    Half() {}
    Half(double d) { loadFromFloat(d); }

    Half & operator = (long double d) {
        loadFromFloat(d);
        return *this;
    }

    operator double() {
        long double sig = normalizeS(_d.significant);
        if (_d.sign) sig = -sig;
        return ldexp(sig, _d.exponent /*+ 1*/);
    }

private:
    void loadFromFloat(long double f) {
        long double v;
        int exp;
        v = frexp(f, &exp);
        v < 0 ? _d.sign = 1 : _d.sign = 0;
        _d.exponent = exp/* - 1*/;
        _d.significant = normalizeP(fabs(v));
    }

    Data _d;
};

int main() {

        Half a[255];

        double d = -1;

        for (int i = 0; i < 20; ++i) {
            a[i] = d;
            cout << d << " " << a[i] << endl;
            d += 0.1;
        }
}

Answer 1

我最终得到了一个非常简单的（天真的）解决方案，能够表示我需要的范围内的每个值：0 - 64，精度为0.001。

由于想法是将其用于存储，因此这实际上更好，因为它允许从double转换到class Half { public: Half() {} Half(const double d) { load(d); } operator double() const { return _d.i + ((double)_d.f / 1000); } private: struct Data { unsigned short i : 6; unsigned short f : 10; }; void load(const double d) { int i = d; _d.i = i; _d.f = round((d - i) * 1000); } Data _d; };，而不会丢失任何分辨率。它也更快。它实际上失去了一些分辨率（小于16位），具有更好的最小步骤，因此它可以代表任何输入值而无需近似 - 所以在这种情况下LESS更多。对浮动组件使用完整的2 ^ 10分辨率将导致奇数步骤无法准确表示十进制值。

{{1}}

Answer 2

上次解决方案错误...抱歉......

尝试将expoent更改为已签名...它在这里工作。

问题在于，当expoent变为负数时，值<＆lt; 0.5你将expoent保存为正数，这是当abs（val）<0.5时导致数字变大的问题。

在C ++中实现半精度浮点数

2 个答案: