¿Cómo uso try ... catch para detectar los errores de coma flotante?

Question

estoy usando C++ en Visual Studio Express para generar árboles de expresión al azar para su uso en un tipo de algoritmo genético del programa.

Como son aleatorios, los árboles suelen generar: dividir por cero, desbordamiento, desbordamiento, así como devolver "inf" y otras cadenas. Puedo escribir controladores para las cuerdas, pero la literatura me dejó desconcertado sobre los demás. Si lo entiendo correctamente, ¿tengo que establecer algunas banderas primero?

asesoramiento y/o un puntero a alguna literatura sería apreciada. Editar: los valores devueltos en la variable doble son 1. # INF o -1. # IND. Me equivoqué al llamarlos hilos.

Answer 1

¿Seguro que desea para su captura en lugar de simplemente ignorarlos? Suponiendo que lo que desea es hacer caso omiso de ellas:

ver esto: http://msdn.microsoft.com/en-us/library/c9676k6h.aspx

Para la máscara _MCW_EM, despejando la máscara establece la excepción, que permite la excepción de hardware; establecer la máscara oculta la excepción.

por lo que vamos a querer hacer algo como esto:

#include <float.h> 
#pragma fenv_access (on) 

void main() 
{ 
    unsigned int fp_control_word; 
    unsigned int new_fp_control_word; 

    _controlfp_s(&fp_control_word, 0, 0); 

    // Make the new fp env same as the old one, 
    // except for the changes we're going to make 
    new_fp_control_word = fp_control_word | _EM_INVALID | _EM_DENORMAL | _EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW | _EM_INEXACT; 
    //Update the control word with our changes 
    _controlfp_s(&fp_control_word, new_fp_control_word, _MCW_EM) 


} 

Parte de la confusión que aquí puede haber sobre el uso de la palabra "excepción". En C++, eso generalmente se refiere al sistema de manejo de excepciones integrado en el lenguaje. Las excepciones de puntos flotantes son una bestia completamente diferente. Las excepciones que una FPU estándar debe soportar son todas definidas en IEEE-754. Suceden dentro de la unidad de punto flotante, que puede hacer cosas diferentes dependiendo de cómo se configuren los indicadores de control de la unidad de punto flotante. Por lo general, ocurre una de estas dos cosas: 1) Se ignora la excepción y la FPU establece un indicador que indica que se ha producido un error en su (s) registro (s) de estado. 2) La excepción no es ignorado por el FPU, así que en vez de una interrupción se genera, y cualquiera que sea controlador de interrupción se creó para los errores de punto flotante se vuelve a llamar.Por lo general, esto hace algo bueno para ti, como provocar que rompas esa línea de código en el depurador o generes un archivo central.

Puede encontrar más información sobre IEE-754 aquí: http://www.openwatcom.org/ftp/devel/docs/ieee-754.pdf

Algunas referencias adicionales de punto flotante: http://docs.sun.com/source/806-3568/ncg_goldberg.html http://floating-point-gui.de/

Answer 2

nunca había probado, pero asumiendo división por cero produce una excepción, que sólo podría envolver el código en un try/catch como esta:

tratar {// potencial de división por cero ... } captura (...) {// ... captura todas las excepciones }

Answer 3

el entorno de ejecución de C++ no le ayudará el más mínimo aquí. Debe realizar estos controles usted mismo, explícitamente en su código. A menos, por supuesto, que las funciones a las que llama hagan estos controles, en cuyo caso depende de cómo se comporten en caso de error.

Me explico:

double divide(double a, double b) { 
    return a/b; // undefined if b is zero 
} 

Debe ser, de hecho,

double divide(double a, double b) { 
    if(b == 0) { 
     // throw, return, flag, ... you choose how to signal the error 
    } 
    return a/b; // b can't possibly be zero here 
} 

Si el código que falla en la división por cero y tal no es el suyo, entonces tendrás que cavar más profundo para encontrar lo que hace en el caso de una amenaza por un error. ¿Lanza? Establecer una bandera? Pregunta al autor y/o lee la fuente.

He aquí un ejemplo de una excepción:

struct bad_value : public std::exception { }; 

double divide(double a, double b) { 
    if(b == 0) throw bad_value("Division by zero in divide()"); 
    return a/b; // b can't possibly be zero here 
} 

// elsewhere (possibly in a parallel universe) ... 

    try { 
     double r1 = divide(5,4); 
     double r2 = divide(5,0); 
    } catch(bad_value e) { 
     // ... 
    } 

Answer 4

Según http://msdn.microsoft.com/en-us/library/aa289157%28v=vs.71%29.aspx#floapoint_topic8,
parece posible lanzar excepciones de C++ en MSVC

Cree las clases de excepciones:

class float_exception : public std::exception {}; 
class fe_denormal_operand : public float_exception {}; 
class fe_divide_by_zero : public float_exception {}; 
class fe_inexact_result : public float_exception {}; 
class fe_invalid_operation : public float_exception {}; 
class fe_overflow : public float_exception {}; 
class fe_stack_check : public float_exception {}; 
class fe_underflow : public float_exception {}; 

Mapa C++ tirar a excepciones FPU usando gestor de excepciones estructurado

void se_fe_trans_func(unsigned int u, EXCEPTION_POINTERS* pExp) 
{ 
    switch (u) 
    { 
    case STATUS_FLOAT_DENORMAL_OPERAND: throw fe_denormal_operand(); 
    case STATUS_FLOAT_DIVIDE_BY_ZERO:  throw fe_divide_by_zero(); 
    etc... 
    }; 
} 
. . . 
_set_se_translator(se_fe_trans_func); 

A continuación, puede utilizar tratar captura

try 
{ 
    floating-point code that might throw divide-by-zero 
    or other floating-point exception 
} 
catch(fe_divide_by_zero) 
{ 
    cout << "fe_divide_by_zero exception detected" << endl; 
} 
catch(float_exception) 
{ 
    cout << "float_exception exception detected" << endl; 
}