10

IEEE 754 defines 128-bit floating point, though perhaps in a three-way chicken and egg problem, it's rarely supported by hardware, rarely supported by compilers, and rarely used.

Have there been, historically, any

  • Computers that supported 128-bit floating point

  • Compilers that supported it

  • Workloads that used it?

I'm interested in both references and anecdotes from personal experience, and particularly specific information, not just that a certain computer supported 128-bit FP, but how it was implemented, what it was used for or both.

Improve this question
1
  • In a way, it's always supported, just write an implementation yourself, or use an existing one.
    – user1095108
    Commented Jun 7, 2020 at 1:08

1 Answer 1

Reset to default
10

I never used it, so I can't give any anecdotes. But the 'implementation' section of the wikipedia about this topic cites some hardware and compilers. I quote some parts of the article:

Hardware: "Native support of 128-bit floats is defined in SPARC V8 and V9 architectures, but no SPARC CPU implements quad-precision operations in hardware as of 2004. POWER9 (ISA 3.0) will have 128-bit hardware support."

Compilers: "Quadruple precision is specified in Fortran by the real(real128), or as real(selected_real_kind(33, 4931)), or in a non-standard way as REAL*16. (Quadruple-precision REAL*16 is supported by the Intel Fortran Compiler and by the GNU Fortran compiler on x86, x86-64, and Itanium architectures, for example.) (...) in C/C++ with a few systems and compilers, quadruple precision may be specified by the long double type, but this is not required by the language (which only requires long double to be at least as precise as double), nor is it common (...) some C/C++ compilers provide a nonstandard quadruple-precision type as an extension. For example, gcc provides a quadruple-precision type called __float128 for x86, x86-64 and Itanium CPUs, and on PowerPC as IEEE 128-bit floating-point using the -mfloat128-hardware or -mfloat128 options; and some versions of Intel's C/C++ compiler for x86 and x86-64 supply a nonstandard quadruple-precision type called _Quad"

Libraries and toolboxes: "The Boost multiprecision library Boost.Multiprecision provides unified cross-platform C++ interface for __float128 and _Quad types, and includes a custom implementation of the standard math library. The Multiprecision Computing Toolbox for MATLAB allows quadruple-precision computations in MATLAB. It includes basic arithmetic functionality as well as numerical methods, dense and sparse linear algebra. The DoubleDouble package provides support for double-double computations for the Julia programming language."

Improve this answer
5
  • 4
    Although I hardly believe this is really a "retro" question: A partial implementation of quadruple precision floats has been implemented in AIX compilers for quite a long time. Also, most Common Lisp implementations seem to have support for 128-bit floats.
    – tofro
    Commented May 5, 2017 at 11:47
  • 3
    On SPARCs, there are quad-precision instructions which trigger traps so that the OS can emulate them (as no existing SPARC supports them natively). FP registers used for simple and double are reused for quad, an hardware implementation would be entirely compatible with existing OSes and software.This "trap-and-emulate" method is slower than using a 128bits software library though, so existing software really needing that precision is unlikely to use these instructions.
    – Grabul
    Commented May 5, 2017 at 20:21
  • 4
    Is this specifically about IEEE 754? Some VAXen had 128-bit float ("H-float") support.
    – dave
    Commented Dec 4, 2018 at 23:02
  • 2
    double-double is not the same as float128: not only does it have 2×53=106-bit significand instead of 113-bit found in float128, but it also has 11 bits of exponent instead of 15, limiting to ~10^308 maximum order of magnitude instead of ~10^4932.
    – Ruslan
    Commented Apr 27, 2019 at 6:52
  • 1
    IBM System/370 (ca. 1975) supported a 128-bit hexadecimal floating-point format, exposed in the Fortran H-extended compiler as REAL*16.
    – njuffa
    Commented Nov 13, 2020 at 20:22

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .