Double versus float

I have a constant for pi in my code:

const float PI = acos(-1);

Would it be better to declare it as a double? An answer to another question on this site said floating point operations aren't exactly pre开发者_如何转开发cise, and I'd like the constant to be accurate.

---

"precise" is not a boolean concept. float provides a certain amount of precision. Whether or not that amount is sufficient for your application depends on, well, your application.

most applications don't need more precision than float provides, though many prefer to use double to (try and) gloss over problems with unstable algorithms or "just because" due to misconceptions like "floating point operations aren't exactly precise".

In most cases when a float is "not precise enough", the problem is not float, it's the code that uses it.

Edit: That being said, most modern CPUs only do calculations in double precision or greater anyway, so you might as well use double unless you're working with large arrays and memory usage is an issue.

---

From standard:

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.

Of the three (notice that this goes hand in hand with the 3 versions of acos) you should choose long double if what you are aiming for is precision (but you should also know that after some degree, further precision may be redundant in some cases).

So you should use this to get the most precise result from acos

long double result = acos(-1L);

(Note: There might be some platform specific types or some user defined types which provide more precision)

---

I'd like the constant to be accurate.

There is nothing like accurate floating point values. They cannot be stored with perfect precision, because of their representation in memory. This is only possible with integers. double give you double the precision a float offers (who would have guessed). double should fit your needs in almost every case.

I would recommend using M_PI from <cmath>, which should be available in all POSIX compliant implementations of the standard.

---

It depends exactly how precise you need to be. I've never had to you doubles because floats are not precise enough.

The most accurate representation of pi is M_PI from math.h

---

The question boils down to: how much accuracy do you need?

Let's quote wikipedia:

For example, the decimal representation of π truncated to 11 decimal places is good enough to estimate the circumference of any circle that fits inside the Earth with an error of less than one millimetre, and the decimal representation of π truncated to 39 decimal places is sufficient to estimate the circumference of any circle that fits in the observable universe with precision comparable to the radius of a hydrogen atom.

I've written a small java program, here's its output:

As string: 3.14159265358979323846264338327950288419716939937510
As double: 3.141592653589793
As float:  3.1415927

Remember, that if you want to have the double precision of a double, all your numbers you're calculating with need also to be doubles. _{(That is not entierly true, but is close enough.)}

---

For most applications, float would do just fine for PI. Double is definitely has more precision, but it doesn't guarantee precision anymore than floats can. By that I mean that the number 1.0 represented in binary is not a rational number. Therefore, if you try to represent it, you'll only succeed to an nth digit where n is determined by how many bytes you use to represent that number.

Unfortunately to contain many digits of PI, you'd probably need to hold it in a string. Though now we're talking about some impressive number crunching here that you might see in molecule simulations. You're probably not going to need that level of precision.

---

As this site says, there are three overloaded versions of acos function.

Therefore the call acos(-1) is ambiguous.

Having said that, you should declare PI as long double to avoid any loss of precision, by using

   const long double PI = acos(-1.0L);