Hello, I got th following problem: a function is returning a value from type 'double', but the caller receives the wrong value. In the function's body all is correct, but the return value does not match. The prototype is as follows:
double grad2rad( int grad_angle );
and the body is:

double grad2rad( int grad_angle ){
  double new_angle;
  new_angle = (grad_angle/180.0)*PI;
  return new_angle;
}

PI is a constant: (22.0/7.0). Will be thankful for any help.

What's wrong with M_PI? Your code should look like this:

double grad2rad( int grad_angle ){
   return (double)grad_angle*M_PI/180.0;
}

M_PI lives in <math.h> by the way...

Thank you people, but the problem is not in the calculation, but in the data transfer (that's the reason I assign the value to a variable instead of just returning it). Before I return the variable, it has the right value, but afterwards not any more...

By the way, the result should be 1.570796 and the caller actually receives 1227133513.000000...

Show the "caller"'s code then.

you are right,in your situation the compiler will recognize the return value of
this function as int by default.

It does (math.h, MSVC 7.1).

Well, at least it's better than 3.

You people make mathematicians and your math teachers cry. Like this:

It's exactly that what Corelian was referring to...

And before you talk about performance, do some profiling to find out, where your program does spend its time. You will be surprised!

Show me the advantage of using 10 instead of 3 significant figures in the average game... anyway using, for example, floats (less precision) instead of doubles is surely faster, likewise if i knew i was using 2 digits of precision i could simply treat everything as an int and just divide by 100 at the end, this would be much harder if i had to use M_PI (god knows how many digits of precision it uses).
I agree that this isn't a huge impact on performance but it just seems an overkill to use 20 digits of precision when at the end you're working with pixels (integers...)

Try shooting a missile or particle under a specific angle across the screen and see if it moves to where it's supposed to go. You'll be surprised at how far off course it will go. If you can do it right for the same cost as doing it wrong, why not do it right?

That wasn't what I asked you though. I asked you how it's wasteful to use the normal approximation of pi instead of, say, 22/7.

Did you read the rest of the post?

Agreed, but does it really matter much while playing?

With some types of games it does. Suppose you have a racing simulation where you simulate the suspension and all other things. Now if after a few seconds the suspension starts to wobble more and more and finally goes completely out of control because you're physics simulation is unstable, then I'd say it matters.