C/Visual C - problema con flotantes

buenas. A ve si me podeis echar una ayuda con este codigo, es parte de un programa mas grande pero lo he metido como prueba en otro archivo:
#include <stdio.h>
#include <conio.h>
float mot_AT_integ_num(float x);

void main(){
float valor,valor2;
do{
scanf("%f",&valor);
valor2=mot_AT_integ_num(valor);
printf("mot at num =%f\n",valor2);
}while(valor!=-2);

}
float mot_AT_integ_num(float x){
if (x>=-0.6 && x<=-0.2){
printf("%f\n",(float)(x*x*x/1.2));
printf("%f\n",(float)((0.6*x*x)/(0.8)));
printf("%f\n",(float)(x*x*x/1.2)+((0.6*x*x)/(0.8)));
return (float)((float)(x*x*x/1.2)+(float)((0.6*x*x)/(0.8)));
}
if (x>-0.2 && x<=0.2){
return (float)(((-x*x*x)/(1.2))+((0.2*x*x)/(0.8)));
}
return 0;
}

lo que me ocurre es que cuando le envio el valor -0.6 me devuelve el valor 0, es decir, no entra en el if, cuando deberia entrar y devolverme un 0.09.

Muchas gracias de antemano.

<>

#include <stdio.h>
#include <conio.h>
float mot_AT_integ_num(float x);

void main(){
float valor,valor2;
do{
scanf("%f",&valor);
valor2=mot_AT_integ_num(valor);
printf("mot at num =%f\n",valor2);
}while(valor!=-2);

}
float mot_AT_integ_num(float x){
if (x>=-0.6F && x<=-0.2F){
printf("%f\n",(float)(x*x*x/1.2));
printf("%f\n",(float)((0.6*x*x)/(0.8)));
printf("%f\n",(float)(x*x*x/1.2)+((0.6*x*x)/(0.8)));
return (float)((float)(x*x*x/1.2)+(float)((0.6*x*x)/(0.8)));
}
if (x>-0.2 && x<=0.2){
return (float)(((-x*x*x)/(1.2))+((0.2*x*x)/(0.8)));
}
return 0;
}

Nota que la única línea que cambia es if (x>=-0.6F && x<=-0.2F). Cuando compares contra valores numéricos, trata siempre de indicar cómo quieres que se traten. En este caso, x es float, y -0.6 puede tratarse como float o como double. Y es por ello que se ha de estar atarugnado.

No sé si con lo que te han comentado s y fernando se arregla el tema. De todas formas te comento otra cosa.

Los float y doubles se suelen guardar internamente en C en un numero finito de bits (16, 32, 64, dependiendo del tipo y de la maquina). Por ello, no son posibles todas las representaciones de numeros. Me explico, si tienes un bit para decimales, solo se puede poner .0 o .5, si tienes 2, se puede poner .00, .25, .50, .75, con 3 bits solo hay 8 posibilidades, etc, etc.

Por ello, las comparaciones de doubles y floats, en el caso de ==, pueden fallar aunque aparentemente sean iguales. Es posible que tu -0.6 en realidad internamente sea -0.60000001 y por eso te falle la comparación (sobre todo si es resultado de unas cuentas, prueba a escribir el valor en pantalla justo antes de la comparación).

Para evitar estos problemas suele hacerse alguna "trampa" como redondear hasta un numero de decimales adecuado, pero menor que el que da la máquina o bien ver que la resta de las dos cantidades a comparar es menor que un numero pequeño (1e-6, por ejemplo). Lo suyo además es calcular este número de forma que coincida con el sitio decimal donde se pierde precisión.

Se bueno.

Lo que Chui te comenta es cierto. Esto me ha dado muchos dolores de cabeza, y pasa en todos los lenguajes (al menos los que conozco). El problema aquí es que tu variable compara contra -0.6, que se puede tomar como -0.60000000000001. Por eso, el sufijo F te lo evalúa como Float. De hecho, en otros lenguajes como C#, si haces x == 1, el compilador te genera un mensaje de advertencia, de que no se especificó cómo evaluar 1.