wrong calculation when using float - c

Question

I'm trying to do a calculation and for some reason when I'm using float I'm getting -nan(ind) but when I'm changing the variables (x,y) to double I'm getting to right answer maybe you guys have any idea why its happening ?
Thank you
#include <stdio.h>
#include <math.h>
#define pi 3.1416
#define L1 0.5
#define L2 0.5
void main()
{
float q1[12], q2[12], q1_Degrees[12], q2_Degrees[12];
float x = 0.8;
float y = 0.6;
q2[0] = acos((pow(x, 2) + pow(y, 2) - pow(L1, 2) - pow(L2, 2)) / (2 * L1*L2));
q1[0] = atan(y / x) - atan((L2*sin(q2[0])) / (L1 + L2 * cos(q2[0])));
q1_Degrees[0] = (q1[0] * 180) / pi;
q2_Degrees[0] = (q2[0] * 180) / pi;
printf_s("q1 is = %.1f q2 is = %.1f\n\n", q1_Degrees[0], q2_Degrees[0]);
}

Answer 1

2 concerns
acos()
The x in acos(x) needs to be in the range [-1...1]. Outside that, the result may be NaN.
(pow(x, 2) + pow(y, 2) - pow(L1, 2) - pow(L2, 2)) / (2 * L1*L2) is prone to slight effects of computation that result in a value just outside [-1...1] even if mathematically the result should be in range.
A quick work-around:
double z = (pow(x, 2) + pow(y, 2) - pow(L1, 2) - pow(L2, 2)) / (2 * L1*L2);
if (z < -1.0) z = -1.0;
else if (z > 1.0) z = 1.0;
q2[0] = acos(z);
The issue applies to double, float, long double. The fact it "worked" with one type is no reason to believe code is robust with other values.
Note that code is calling double functions like acos(), pow() and not their float counterparts acosf(), powf(). I recommend to use double throughout unless you have a compelling reason otherwise.
atan
atan() provides a [-π/2... +π/2] radians (aka [-90...90] degrees) result.
A whole circle result of [-π... +π] radians (aka [-180...180] degrees) is available with atan2(y,x)
atan((L2*sin(q2[0])) / (L1 + L2 * cos(q2[0])))
// or
atan2(L2*sin(q2[0]), L1 + L2 * cos(q2[0]))
A better solution is to use a different form of trig manipulation that does not depend on the edge of acos(). Easiest to do if OP also posted the higher level goal of the exercise.

Answer 2

Some basic debugging:
First, you can narrow down your code to:
#include <stdio.h>
#include <math.h>
void main()
{
float x = 0.8;
float y = 0.6;
double q = acos((pow(x, 2) + pow(y, 2) - 0.5) * 2);
printf("q = %lf\n", q);
}
Then, it becomes obvious that either pow(x, 2) or pow(y, 2) yield slightly different results for float and double.
At this point, let's investigate the actual differences:
Between the value of (float)0.8 and the value of (double)0.8
Between the value of (float)0.6 and the value of (double)0.6
#include <stdio.h>
void main()
{
printf("(float)0.8 = %.10f\n", (float)0.8);
printf("(double)0.8 = %.10lf\n", (double)0.8);
printf("(float)0.6 = %.10f\n", (float)0.6);
printf("(double)0.6 = %.10lf\n", (double)0.6);
}
The printout is:
(float)0.8 = 0.8000000119
(double)0.8 = 0.8000000000
(float)0.6 = 0.6000000238
(double)0.6 = 0.6000000000
Does that answer your question?

Answer 3

You're getting accumulated roundoff which runs a bit past the domain of acos().
Simplifying your example to a minimum that shows the issue:
#include <stdio.h>
#include <math.h>
#define L1 0.5
#define L2 0.5
int main()
{
float x = 0.8;
float y = 0.6;
float acos_param = (pow(x, 2) + pow(y, 2) - pow(L1, 2) - pow(L2, 2)) / (2 * L1*L2);
float q2 = acos(acos_param);
printf("acos_param = %.9f; q2 = %.9f\n", acos_param, q2);
return 0;
}
And running this - with floats - we see:
acos_param = 1.000000119; q2 = nan
Aha: greater than 1.0 is out of range of acos so you get NaN (not a number).
Changing all the float to double we get:
acos_param = 1.000000000; q2 = 0.000000000
which is more in line with expectations.
EDIT - Expanding on comments in the comments, variadic functions in C always pass floating-point values as double, and the misleadingly-named format %f really means double, not float.
Even if you attempt to cast "down" to a float, it will get promoted again back to double before it's called, but will truncate the precision.
Try this:
#include <stdio.h>
int main()
{
double d1 = 0.8;
double d2 = (float)0.8;
printf("d1=%.9f; d2=%.9f\n", d1, d2);
return 0;
}
Which on my compiler produces:
d1=0.800000000; d2=0.800000012
Here, d1 is the full real-deal double, while d2 is the float-truncated version promoted back to double.
And in no case is the l format specifier need; %f and %lf are the same thing.