extended-precision

The standard Haskell's Double uses the standard double-precision arithmetic : data Double Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type. Does GHC/Haskell offer somewhere also the extended precision (80-bit) floating point numbers, perhaps using some external library? As chuff has pointed out, you might want to take a look a the numbers package on hackage. You can install it with cabal install numbers . Here is an example: import Data.Number.CReal -- from numbers main :: IO () main = putStrLn

This question already has an answer here: Is it possible to use SSE and SSE2 to make a 128-bit wide integer? 1 answer My impression is definitely not but perhaps there is a clever trick? Thanks. Not directly, but there are 64 bit arithmetic operations which can be easily combined to perform 128 bit (or greater) precision. The xmm registers can do arithmetics on 8, 16, 32 and 64 bit integers. It doesn't produce a carry flag so you can't extend the precision beyond 64 bits. The extended precision math libraries use the general purpose registers which are 32 bit or 64 bit, depending on the OS. 来源

This question already has an answer here: Is there a 128 bit integer in gcc? 3 answers Does gcc support 128-bit int on amd64? How to define it? How to use scanf/printf to read/write it? rkhayrov GCC supports built-in __int128 and unsigned __int128 types (on 64-bit platforms only), but it looks like formatting support for 128-bit integers is less common in libc. Note: <stdint.h> defines __int128_t and __uint128_t on versions before gcc4.6. See also Is there a 128 bit integer in gcc? for a table of gcc/clang/ICC versions. How to know if __uint128_t is defined for detecting __int128 void f(_

It is nearly impossible(*) to provide strict IEEE 754 semantics at reasonable cost when the only floating-point instructions one is allowed to used are the 387 ones. It is particularly hard when one wishes to keep the FPU working on the full 64-bit significand so that the long double type is available for extended precision. The usual “solution” is to do intermediate computations at the only available precision, and to convert to the lower precision at more or less well-defined occasions. Recent versions of GCC handle excess precision in intermediate computations according to the