Validacion doble

[alvarito_gool]

Hola soy nuevo en el foro.
Estoy haciendo un programa, y tengo un pequeño problema:
El programa consiste de un vector de 11 elementos, al cual se le ingresan valores menores que 1. Entonces valido con while, que todo valor que se ingrese, debe ser menor que 1 o si no el programa vuelve a pedir ese elemento del vector LIQST. Hasta ahí funciona bien, después la siguiente validación consiste en que la sumatoria de los elementos del vector LIQST, debe ser igual a 1.
Esto funciona para distintas casos. Ejemplo:


LIQST[0]=0.2
LIQST[1]=0.2
LIQST[2]=0
LIQST[3]=0
LIQST[4]=0
LIQST[5]=0.2
LIQST[6]=0.2
LIQST[7]=0
LIQST[8]=0
LIQST[9]=0
LIQST[10]=0.2

Y el resto de convinaciones.
pero no me funciona para una en particular:

LIQST[0]=0.1
LIQST[1]=0.1
LIQST[2]=0.1
LIQST[3]=0.1
LIQST[4]=0.1
LIQST[5]=0.1
LIQST[6]=0.1
LIQST[7]=0.1
LIQST[8]=0.1
LIQST[9]=0.1
LIQST[10]=0.0

La sumatoria es igual a 1

Sin importar Donde se ponga el valor igual a 0, el programa no pasa cuando se le ingresan esos datos.
No se si sea el compilador que uso, u otra cosa. Por cierto uso Dev-C++
Aqui el programa

#include<iostream.h>
#include<string.h>
int main()
{float GASSEP[11],GASST[11],LIQST[11],M=0,V=0,c, PMA[11],SGC7,VM[11],D,SG,API,Densidades[11]={50.032,51.044,19.98,29.34,31.62,35.11,36.42,38.9 6,39.36,41.40,53.11};
short i,j,k,PM[11]={34,44,16,30,44,58,58,72,72,86};
char comp[11][15]={"CO2","H2S","C1","C2","C3","iC4","nC4","iC5","nC 5","C6","C7+"};

cout<<"DATOS DEL STOK TANK\nComposicion liqido:\n";
do{for(i=0;i<=10;i++)
{cout<<comp[i]<<"\t";
cin>>LIQST[i];
while(LIQST[i]>1)
{cout<<comp[i]<<"\t";
cin>>LIQST[i];}
while(LIQST[i]>1);}
system ("cls");
c=0;
for(j=0;j<=10;j++)
c=c+LIQST[j];
cout<<"\n";}
while(c!=1);
system ("pause");
}

Si alguien me puede ayudar, agradeceria.

[Fw190]

a) Utiliza tipo double en lugar de float.

b) En las comparaciones que estás haciendo en los while (estás comparando con 1), haz la comparación con 1.0. Aparentemente es lo mismo, pero para el compilador puede no serlo. El formato interno es distinto para los tipos en coma flotante que para los tipos enteros.

c) El valor 0.1, al pasar a binario, resulta ser un decimal periódico. Dado que la precisión es limitada (32 bits para float, 64 para double), tendrás una pérdida de información, por lo que, dependiendo de la forma de redondear de la máquina (o del compilador), al pasar 0.1 a binario y luego volver a decimal (con tipo float), te puedes encontrar con 0.099999994 ó con 0.10000000149012. De ahí la primera recomendación: Utiliza double.

[alvarito_gool]

Muchas gracias Fw190 , tome en cuenta tus dos recomendaciones y no funciono, a veces pienso que podría ser algo en el código.
Pero al parecer esta bien No?
Deberia cambiar o evitar esa validacion?
Gracias nuevamente.

[Fw190]

El código está bien. El tema está en las comparaciones cuando hablamos de tipos en coma flotante, que es asunto de la máquina o del compilador, y pòco puedes hacer desde fuera.

Prueba incluyendo el archivo <math.h>, ahí puede que haya alguna definición o se active alguna cosa para el compilador que pueda ayudarte (aunque, francamente, lo dudo).

Prueba esta porción de código (el mismo que posteaste, pero simplificado), así puedes hacerte idea de lo que está pasando.

Código C:

#include <stdio.h>
#include <math.h>
 
int main (void)
{
    double  LIQST[11],c;
    double  eps = 1.0e-8;
    int     i,j,k;
    char    comp[11][15]={"CO2","H2S","C1","C2","C3","iC4","nC4","iC5","nC 5","C6","C7+"};
 
    do
    {
        printf("DATOS DEL STOK TANK\nComposicion liquido:\n");
        c = 0.0;
        for(i=0; i<=10; i++)
        {
            printf("(%d) %s : ", (i+1), comp[i]);
            scanf("%lf", &LIQST[i]);
            c += LIQST[i];
            printf("%24.20f  ***  %24.20f\n", LIQST[i], c);
        }
    }
    while (fabs(c - 1.0) > eps);
    system("pause");
}
 

(está en C y no C++, no controlo C++). El formato de printf es para que muestre 20 cifras decimales.

El valor eps lo he establecido arbitrariamente para la comparación, si quieres seguir con la doble validación utiliza este sistema, prueba distintos valores. Dependerá de la precisión que necesites.

En cualquier caso, procura evitar las comparaciones de igualdad entre valores en coma flotante.

Si quieres probar también con tipos float, cambia el especificador de formato de scanf de %lf (double, 64 bits) a %f (float, 32 bits). Así podrás ver dónde empiezan a cambiar las cifras decimales.

El Análisis Numérico no es solamente resolver problemas matemáticos mediante un ordenador. Una de sus partes es, precisamente, minimizar los errores por redondeo. Fíjate en el que se te ha presentado con algo tan sencillo como una comprobación de unos pocos datos introducidos por teclado.

Saludos,

[alvarito_gool]

Muchas gracias Fw190 vere si se puede solucionar con esto.