Catching thrown exceptions

Hypotenuse, the root sum of the squares of its two arguments. A numerically stable formula is , where max and min are the larger and smaller, respectively, of the absolute values of the two arguments. But the formula breaks down if both arguments are zero or infinite. SampleHypotenuse catches the invalid exception that arises from or and performs the simple fix.

  #pragma fenv_access on
  double SampleHypotenuse(double x, double y) { // May be called with any rounding.
      TFPEnvironmentSaveAndUpdate localEnvironment;
      double_t min = Min(Abs(x), Abs(y));
      double_t max = Max(Abs(x), Abs(y));
      try {
          
TFPExceptionHandler invalidHandler(kFPInvalid);
          return max * SquareRoot(1.0 + Square(min / max));
      }
      
catch (const TFPInvalidException& caughtInvalid) {
          localEnvironment.ClearFlags(kFPInvalid); // clear spurious exception
          return max; // two zeroes or two infinities
      }
  }

1. Saves the current environment
   
2. Records the TFPExceptionSet argument indicating which exceptions are to be thrown
   

1. Checks to see if one of the exceptions to be thrown has been raised
   
2. Merges the flags saved by the constructor into the current environment
   
3. Throws the exception of highest precedence detected in Step 1, if any
   

• Inexact arises if any intermediate result is rounded.
• Underflow can arise if max is much larger than min, or if both are very tiny. There is never a serious error due to underflow.
• Overflow can arise if max is very large. The result is or the largest normal number, depending on the rounding mode.