[SOLUCIONADO] Duda sobre representación de números decimales

[dmorill]

Hola Foro, luego de una larga temporada los saludo de nuevo.

Os traigo una duda existencial jeje, quizá sea algo básico pero no me queda claro qué pasa.

Tengo un código que hace mogollón de cálculos con decimales, para corroborar que lo hace bien, hice unas pruebas en excel. Luego de varias correcciones, y con la seguridad que lo hacía bien me daba cuenta que excel decía una cosa y mi código otra (muy similar pero diferente); y me dí de esto:



y este era el problema, que aunque por precisión sea muy parecido, luego de muchos cálculos los resultados difieren significativamente. Eso sin contar con que 0.0058999999 no es 0.0059.

Esto tiene solución?, para que coincida con excel por ejemplo.

Muchas gracias por su atención equipo.

Saludos,

[prueba230683]

Internamente, es imposible. Los tipos float y double no son capaces de almacenar con total precisión las cifras decimales de un número porque trabajan con fracciones.

Lo que sí puedes hacer es imprimir con printf el valor redondeando a x cifras decimales (%.xf), por ejemplo:

Código C:

double jjaa = 0.00589;
 
printf("%.4f", jjaa); // 0.0059
 
printf("%.3f", jjaa); // 0.006
 

Pero esto no evita que en memoria estén almacenados de forma imprecisa.

[dmorill]

Muchas gracias por tu respuesta. De ser así, cómo hace google para funcionar bien, o las calculadoras o bien excel?

Es una limitante de c++?

Saludos,

[prueba230683]

No es algo específico de C/C++. Ocurre en casi todos, por no decir todos los lenguajes.

La única solución a esto es utilizar librerías que realicen las operaciones manualmente.

En el caso de la calculadora de Google, me imagino que estará utilizando alguna librería tipo MathJS, que permite que las operaciones con decimales sean precisas, pero a JavaScript le ocurre lo mismo nativamente. Por ejemplo:

Código Javascript:

0.1 + 0.2
 

Esto arroja 0.30000000000000004.

[dmorill]

Muchas gracias,

Comprendo, estoy buscando si en c+ hay alguna alternativa. He encontrado 2 una es usar floats que se supone da mejor y la segunda es una librería de boost.

Saludos,

[prueba230683]

Me imagino que te refieres a Boost.Multiprecision. No parece nada fácil de usar.

Yo te recomendaría pasarte a Java. Mira qué sencillo es hacerlo con Java:

https://www.javamexico.org/blogs/lux...os_financieros

No es por ser un detractor de C/C++, pero hay que reconocer que el tiempo que ahorras usando Java es bestial.

[dmorill]

Muchas gracias. Lamentablemente tengo todo montado en c++ y pasarme a java sería complicado.

Que lío esto de los decimales y la precisión parece que lo mejor es usar enteros multiplicados por 10^x.

Saludos,

[prueba230683]

Buscando en github he encontrado una librería de precisión para decimales y enteros escrita en C++:

https://github.com/Sam-bit/BigDecimal-CPP

La acabo de probar y definitivamente es mejor opción que Boost. Te adjunto un ejemplo:

Código C++:

#include "BigDecimal.h"
#include <iostream>
#include <iomanip> 
 
using namespace std;
 
int main(int argc, char** argv) {
    // usando la libreria
    BigDecimal C;
    BigDecimal A("0.1");
    BigDecimal B("0.2");
    C = A + B;
    cout << "C = " << C.toString() << endl; // 0.3
 
    // forma nativa (con error)
    float a = 0.1;
    float b = 0.2;
    float c = a + b;
    cout << "C = " << setprecision(10) << c << endl; // 0.3000000119 (tiene un pequeño error de 0.0000000119)
}
 

PD: Evidentemente, puedes utilizar cualquier operador aritmético (+-/*), no solo suma.

PD2: El método toString() solamente lo debes utilizar cuando quieras imprimir un número en pantalla. Para realizar operaciones, es igual que en C/C++ solo que declarando tipo BigDecimal.

[dmorill]

Mil gracias!!!

La probaré ahora mismo.

Un abrazo.

[prueba230683]

Otra cosa. Algunas veces (no entiendo por qué) tira por stderr lo siguiente:

Scale (-2147483648) Cant Be Negative!!!

Parece ser un pequeño bug, porque doy fe de que funciona bien (al menos, para operaciones aritméticas):

Código C++:

#include <iomanip> 
#include <iostream>
#include "BigDecimal.h"
 
using namespace std;
 
int main() {
  BigDecimal C;
  BigDecimal A("1");
  BigDecimal B("1000000000000000000000000000000000000000000000000000000000000");
  BigDecimal D("2");
  C = A / B;
  cout << "C = " << C.toString() << endl; // 0.000000000000000000000000000000000000000000000000000000000001
  C = C / D;
  cout << "C = " << C.toString() << endl; // 0.0000000000000000000000000000000000000000000000000000000000005
  C = C + (A / B);
  cout << "C = " << C.toString() << endl; // 0.0000000000000000000000000000000000000000000000000000000000015
  C = C * D;
  cout << "C = " << C.toString() << endl; // 0.000000000000000000000000000000000000000000000000000000000003
}
 

Yo comentaría todos los std::cerr en BigDecimal.cpp para que no te lance errores innecesarios.

PD: También he visto en el código que tiene soporte para algunos operadores más: potencia ^, módulo % etc.