Feature request: Floating point parsing

[lorrden]

I could not find a way to read floating point numbers in the package out of the box, sure we can do something like this:

extension Double {
  init(parsingLittleEndian input: inout ParserSpan) throws {
    let tmp = try UInt64(parsingLittleEndian: &input)
    self = withUnsafePointer(to: tmp) { ptr in
      let rawPtr = UnsafeRawPointer(ptr)
      return rawPtr.load(as: Double.self)
    }
  }
}

The above is obviously limited to IEEE types, but as other formats like MIL-STD-1750A exist, some kind of extensible floating point encoding mechanism would be useful.

I could think of these formats being somewhat useful / common where obviously, at least IEEE float32 and float64 are very prevalent:

• IEEE float16
• IEEE float32
• IEEE float64
• IEEE float128
• IEEE float256
• Extended x86 format (80 bits)
• bfloat16
• Nvidia tensor float
• AMD fp24
• PXR24
• MIL-STD-1750 formats

[natecook1000]

Thanks, @lorrden! All the floating point types have a bit pattern-based initializer, which significantly simplifies that kind of initializer:

extension Double {
  init(parsingLittleEndian input: inout ParserSpan) throws {
    let tmp = try UInt64(parsingLittleEndian: &input)
    self = Double(bitPattern: tmp)
  }
}

I've found that the kind of formats for floating point values varies pretty widely. Given that, library-provided initializers might not be that widely usable, since per-task parsers are easy to make. Are there some specific formats that you've seen used more broadly?

[lorrden]

Didn't know about the bitPattern init, thanks.

I do think standard IEEE floats that maps directly to swift Float / Double should probably have these pre-defined though.

Float16 is only available on Apple Silicon, my assumption was it was IEEE 16.
Float80 is x87 FPU thing, and only on Intel.

I guess both of these could be useful to have in terms of native formats, but given lack of multi-platform support of them, maybe less important than Float and Double.

I guess the most common formats are IEEE 16/32/64, bfloat16, and extended 80 bit x86 floats.