Convert ieee754 half-precision bytes to double and vise versa in Flutter

Question

I have a device that provides temperature data in ieee754 half-precision float format, i.e. [78, 100] = +25.5C.
Now, Dart/Flutter doesn't support HP-Float conversions out of the box. After googling around, I have found several solutions that I was able to put together into one that seems to be working fine. Having not done this for many years I am asking pro's to look this over. Also, I'm sure this will save some time to folks like me who need this functionality. This has been tested in temperatures from -10C to +35C and seems to convert correctly both ways. Here _ieee754HpBytesToDouble converts HPF bytes to 64-bit double and _ieee754HpBytesFromDouble converts 64-bit double to half-precision bytes.

  ///
  /// Double to Uint8List
  ///
  Uint8List _ieee754HpBytesFromDouble(double fval) {
    int result = _doubleToBits(fval);
    Uint8List beef = _int32bytes(result);
    return Uint8List.fromList(beef.reversed.skip(2).toList());
  }

  ///
  /// Double to hp-float bits
  ///
  int _doubleToBits(double fval) {
    ByteData bdata = ByteData(8);
    bdata.setFloat32(0, fval);
    int fbits = bdata.getInt32(0);

    int sign = fbits >> 16 & 0x8000;
    int val = (fbits & 0x7fffffff) + 0x1000;

    if (val >= 0x47800000) {
      if ((fbits & 0x7fffffff) >= 0x47800000) {
        if (val < 0x7f800000) return sign | 0x7c00;
        return sign | 0x7c00 | (fbits & 0x007fffff) >> 13;
      }
      return sign | 0x7bff;
    }
    if (val >= 0x38800000) return sign | val - 0x38000000 >> 13;
    if (val < 0x33000000) return sign;
    val = (fbits & 0x7fffffff) >> 23;
    return sign |
        ((fbits & 0x7fffff | 0x800000) + (0x800000 >> val - 102) >> 126 - val);
  }

  ///
  ///
  ///
  Uint8List _int32bytes(int value) =>
      Uint8List(4)..buffer.asInt32List()[0] = value;

  ///
  ///
  ///
  double _bitsToDouble(int bits) {
    Uint8List list = _int32bytes(bits);
    ByteBuffer buffer = new Int8List.fromList(list.reversed.toList()).buffer;
    ByteData byteData = new ByteData.view(buffer);
    double result = byteData.getFloat32(0);
    return result;
  }

  ///
  ///
  ///
  double _ieee754HpBytesToDouble(List<int> i) {
    int hbits = i[0] * 256 + i[1];
    int mant = hbits & 0x03ff;
    int exp = hbits & 0x7c00;
    if (exp == 0x7c00)
      exp = 0x3fc00;
    else if (exp != 0) {
      exp += 0x1c000;
      if (mant == 0 && exp > 0x1c400) {
        return _bitsToDouble((hbits & 0x8000) << 16 | exp << 13 | 0x3ff);
      }
    } else if (mant != 0) {
      exp = 0x1c400;
      do {
        mant <<= 1;
        exp -= 0x400;
      } while ((mant & 0x400) == 0);
      mant &= 0x3ff;
    }
    return _bitsToDouble((hbits & 0x8000) << 16 | (exp | mant) << 13);
  }

Answer 1

For FP64<->FP32 conversion, use standard casting and for FP32<->FP16 conversion use these ultra-efficient conversion algorithms:

double half_to_double(const ushort x) { // IEEE-754 16-bit floating-point format (without infinity): 1-5-10, exp-15, +-131008.0, +-6.1035156E-5, +-5.9604645E-8, 3.311 digits
    return (double)half_to_float(x);
}
ushort double_to_half(const double x) { // IEEE-754 16-bit floating-point format (without infinity): 1-5-10, exp-15, +-131008.0, +-6.1035156E-5, +-5.9604645E-8, 3.311 digits
    return float_to_half((float)x);
}