Diferente precisión en C++ y Fortran

2 minutos de lectura

Diferente precision en C y Fortran
EL KESRI Amina

Para un proyecto en el que estoy trabajando, he codificado en C++ una función muy simple:

Fne(x) = 0.124*x*x, el problema es cuando calculo el valor de la función

por x = 3.8938458092314270 con los lenguajes Fortran 77 y C++, obtuve una precisión diferente.

Para Fortran tengo Fne(x) = 1.8800923323458316 y para C++ tengo Fne(x) = 1.8800923630725743. Para ambos lenguajes, la función Fne está codificada para valores de doble precisión y devuelve también valores de doble precisión.

Código C++:

double FNe(double X) {
    double FNe_out;
    FNe_out = 0.124*pow(X,2.0);
    return FNe_out;
}

Código Fortran:

  real*8 function FNe(X)
  implicit real*8 (a-h,o-z)
  FNe = 0.124*X*X
  return
  end

¿Me pueden ayudar a encontrar de dónde es esta diferencia?

Una fuente de diferencia es el tratamiento predeterminado, por parte de C++ y Fortran, de constantes literales como su 0.124. De forma predeterminada, Fortran considerará esto como un número de punto flotante de precisión simple (en casi cualquier combinación de computadora y compilador que pueda usar), mientras que C++ lo considerará como un número fp de precisión doble.

En Fortran puede especificar el kind de un número fp (o cualquier otra constante numérica intrínseca y en ausencia de opciones del compilador para cambiar el comportamiento predeterminado más probable) agregando el sufijo selector de tipo como esto

0.124_8

Prueba eso, a ver qué resultados.

Ah, y mientras escribo, ¿por qué escribes Fortran como si fuera 1977? Y a todos los demás expertos en Fortran por aquí, sí, sé que *8 y _8 no son las mejores prácticas, pero no tengo tiempo en este momento para ampliar todo eso.

  • sí, funciona, ahora tengo la misma precisión, muchas gracias por tu ayuda

    – EL KESRI Amina

    26 de mayo de 2015 a las 10:25

  • En cuanto a la forma en que escribo el fortran, no es realmente mi código, mi trabajo consiste en convertir un programa largo de fortran 77 en uno de C++

    – EL KESRI Amina

    26 mayo 2015 en 10:34

  • @ELKESRIAmine Si esto responde a su pregunta, considere marcarla como la respuesta correcta.

    – Avi Ginsburg

    26 mayo 2015 en 11:42

Como señaló High Performance Mark, el problema es la precisión predeterminada de los literales. Utilizando

double xx = 3.8938458092314270;
std::cout << std::setprecision(16);
std::cout << " (float) * x*x: " << 0.124f*xx*xx << std::endl;
std::cout << "(double) * x*x: " << 0.124*xx*xx << std::endl;

Obtenemos

 (float) * x*x: 1.880092332345832
(double) * x*x: 1.880092363072574

que es la misma diferencia que notaste.

.

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad