CODEWITHSUNDEEP
c++types
Cool_Coder
Cool_Coder

Reputation: 5083

More Precise Floating point Data Types than double?

In my project I have to compute division, multiplication, subtraction, addition on a matrix of double elements. The problem is that when the size of matrix increases the accuracy of my output is drastically getting affected. Currently I am using double for each element which I believe uses 8 bytes of memory & has accuracy of 16 digits irrespective of decimal position. Even for large size of matrix the memory occupied by all the elements is in the range of few kilobytes. So I can afford to use datatypes which require more memory. So I wanted to know which data type is more precise than double. I tried searching in some books & I could find long double. But I dont know what is its precision. And what if I want more precision than that?

Upvotes: 12

Views: 46160

Answers (4)

fons
fons

Reputation: 5147

On Intel architectures the precision of long double is 80bits.

What kind of values do you want to represent? Maybe you are better off using fixed precision.

Upvotes: 0

ogni42
ogni42

Reputation: 1276

You might want to consider the sequence of operations, i.e. do the additions in an ordered sequence starting with the smallest values first. This will increase overall accuracy of the results using the same precision in the mantissa:

1e00 + 1e-16 + ... + 1e-16 (1e16 times) = 1e00
1e-16 + ... + 1e-16 (1e16 times) + 1e00 = 2e00

The point is that adding small numbers to a large number will make them disappear. So the latter approach reduces the numerical error

Upvotes: 10

Potatoswatter
Potatoswatter

Reputation: 137940

According to Wikipedia, 80-bit "Intel" IEEE 754 extended-precision long double, which is 80 bits padded to 16 bytes in memory, has 64 bits mantissa, with no implicit bit, which gets you 19.26 decimal digits. This has been the almost universal standard for long double for ages, but recently things have started to change.

The newer 128-bit quad-precision format has 112 mantissa bits plus an implicit bit, which gets you 34 decimal digits. GCC implements this as the __float128 type and there is (if memory serves) a compiler option to set long double to it.

Upvotes: 15

Telgin
Telgin

Reputation: 1604

Floating point data types with greater precision than double are going to depend on your compiler and architecture.

In order to get more than double precision, you may need to rely on some math library that supports arbitrary precision calculations. These probably won't be fast though.

Upvotes: 3

Related Questions