6

According to IEEE 754-2008 there are

There are three binary floating-point basic formats (which can be encoded using 32, 64 or 128 bits) and two decimal floating-point basic formats (which can be encoded using 64 or 128 bits).

This chart is under it. In C++ I believe float and double are single and double precision (binary32 and binary64).

Name        Common name         Base  Digits E min  E max   Digits  E max
binary32    Single precision    2     23+1   −126   +127    7.22    38.23
binary64    Double precision    2     52+1   −1022  +1023   15.95   307.95
binary128   Quadruple precision 2     112+1  -16382 +16383  34.02   4931.77
decimal32                       10    7      −95    +96     7       96
decimal64                       10    16     −383   +384    16      384
decimal128                      10    34     −6143  +6144   34      6144

What class/struct may I use for decimalX and is there something I can use for binary128? Are these classes/structs standard or nonstandard?

phuclv
  • 37,963
  • 15
  • 156
  • 475
  • 2
    What system? For example, for PowerPC Macs, `long double` is equivalent to `binary64` in your chart with optional use of `binary128`, while on Intel Macs a `long double` is 80 bits. (although the latter has 128 bits of storage) – Matt K Feb 16 '12 at 18:03
  • 1
    C++ doesn't detail how `float`, `double`, and `long double` are represented. For all you know, they could all three be `decimal128`. – Mooing Duck Feb 16 '12 at 18:04

5 Answers5

8

In addition to the 32-bit float and 64-bit double, GCC offers __float80, __float128, _Decimal32, _Decimal64, _Decimal128; for ARM targets, it also offers the half-precision __fp16.

Intel CPUs support 80-bit floats in hardware using the old scalar x87 FPU instructions (but not with the SSE vector instructions). I'm not aware of any mainstream CPUs with hardware support for the decimal FP types.

It looks like the current crop of Microsoft compilers provide 64-bit for both double and long double, but older ones gave you 80-bit for long double.

See documentation here:

Russell Borogove
  • 18,516
  • 4
  • 43
  • 50
  • Question is not tagged GCC. Question is tagged C++. – Lightness Races in Orbit Feb 17 '12 at 01:34
  • 9
    And yet the OP seems to have found concrete information valuable. Astonishing, isn't it? – Russell Borogove Feb 17 '12 at 01:42
  • @LightnessRacesinOrbit This answer talked about both hardware and software. I didn't care what the standard defines (which was essentially "we don't support that"). I cared about how i can use it and hardware support. Also this answer was clear that its a compiler extension. Also only two of the 4 actually answer the title. How i might use it in C++. I did give you an upvote for taking standard text was made it clear C++11 doesn't support it natively. –  Feb 17 '12 at 19:01
  • @RussellBorogove: No; that would be off-topic, despite the fact that it would doubtless hold value to some people. It really is delicious. – Lightness Races in Orbit Feb 17 '12 at 19:19
  • Shall I tag the question with `gcc`, `visual c++`, and `recipes`, then? – Russell Borogove Feb 17 '12 at 22:18
7

C++ does not specify that floats must be 32-bit or that doubles must be 64-bit. It does not even require there to be 8 bits in a byte (though there do have to be at least 8).

[C++11: 3.9.1/8]: There are three floating point types: float, double, and long double. The type double provides at least as much precision as float, and the type long double provides at least as much precision as double. The set of values of the type float is a subset of the set of values of the type double; the set of values of the type double is a subset of the set of values of the type long double. The value representation of floating-point types is implementation-defined. Integral and floating types are collectively called arithmetic types. Specializations of the standard template std::numeric_limits (18.3) shall specify the maximum and minimum values of each arithmetic type for an implementation.

See the documentation for your toolchain and platform to see what its type sizes are. It might support long double, which in turn might be what you want.

Lightness Races in Orbit
  • 378,754
  • 76
  • 643
  • 1,055
7

Intel has a decimal floating-point library which will work with either ICC or GCC on Mac, Linux, HP/UX, or Solaris; or the ICC or CL compilers on Windows. It's not as useful as using operators on built-in types. If you're using C++, maybe someone has already written helpful classes that override all the necessary operators for that.

Matt K
  • 13,370
  • 2
  • 32
  • 51
5

C++ does not provide decimal types; the only floating point types are float, double and long double.

Neither does C++ specify that these use IEEE754 representations, or that they have any particular size. The only requirement is that double provides at least as much precision as float, and that long double provides at least as much precision as double.

Mike Seymour
  • 249,747
  • 28
  • 448
  • 644
3

If you want the convenience of built-in operators, but don't want to write it yourself, I'd recommend checking out Bloomberg Finance's open-source C++ libraries on GitHub. In particular, the BDE package contains a IEEE 754 "Decimal 32/64/128" implementation (see bdldfp_decimal.h)

The nice thing about this library is that it supports multiple different IEEE 754 backend implementations, including a C99 reference implementation, the decNumber implementation that comes with GCC, and Intel's open-source IntelDFP library (see bdldfp_decimalplatform.h for details). It also supports configurable endian-ness.

Chris Kline
  • 2,249
  • 26
  • 32
  • 1
    Using that on a daily basis at Bloomberg. Engineering any kind of trading, market data, or otherwise financial-related applications in a mathematically correct way is literally impossible without something comprehensive like this implementation. – Alexander Shukaev Oct 09 '19 at 22:16