cfenv

---

1. Get Environment Variables

#include <cfenv>
#include <cstdio>

int main() {
  std::printf("Current floating-point environment:\n");

  // Get control word
  const int cw = _control87(0, 0);
  std::printf("Control word: %x\n", cw);

  // Get rounding mode
  const int rm = (cw >> 10) & 0x3;
  switch (rm) {
    case 0: std::printf("Rounding mode: Round to nearest\n"); break;
    case 1: std::printf("Rounding mode: Round towards zero\n"); break;
    case 2: std::printf("Rounding mode: Round towards positive infinity\n"); break;
    case 3: std::printf("Rounding mode: Round towards negative infinity\n"); break;
  }

  // Get exception flags
  const int ef = (cw >> 13) & 0xf;
  if (ef & _EM_INVALID) std::printf("Invalid operation exception flag is set\n");
  if (ef & _EM_DENORMAL) std::printf("Denormalized number exception flag is set\n");
  if (ef & _EM_ZERODIVIDE) std::printf("Zero divide exception flag is set\n");
  if (ef & _EM_OVERFLOW) std::printf("Overflow exception flag is set\n");
  if (ef & _EM_UNDERFLOW) std::printf("Underflow exception flag is set\n");
  if (ef & _EM_INEXACT) std::printf("Inexact result exception flag is set\n");

  return 0;
}

2. Set Control Word

#include <cfenv>

int main() {
  // Set control word to round towards zero
  const int cw = _control87(_RC_NEAR, _MCW_RC);

  std::printf("New control word: %x\n", cw);
  return 0;
}

3. Get Exception Status

#include <cfenv>

int main() {
  // Get exception status
  const int es = _status87();

  std::printf("Exception status: %x\n", es);
  return 0;
}

4. Clear Exception Flags

#include <cfenv>

int main() {
  // Clear exception flags
  _clear87();

  std::printf("Exception flags cleared\n");
  return 0;
}

5. Raise Invalid Operation Exception

#include <cfenv>

int main() {
  // Raise invalid operation exception
  _fpreset();

  std::printf("Invalid operation exception raised\n");
  return 0;
}

6. Handle Invalid Operation Exception

#include <cfenv>
#include <exception>

int main() {
  try {
    // Perform an operation that may raise an invalid operation exception
    ...

  } catch (const std::fenv\<InvalidOperationException>) {
    // Handle invalid operation exception
  }

  return 0;
}

7. Get Floating-Point Precision

#include <cfenv>

int main() {
  // Get floating-point precision
  const int prec = __fpclassify(0.0);

  switch (prec) {
    case _FPCLASS_SNAN: std::printf("Floating-point precision: Signalling NaN\n"); break;
    case _FPCLASS_QNAN: std::printf("Floating-point precision: Quiet NaN\n"); break;
    case _FPCLASS_NINF: std::printf("Floating-point precision: Negative infinity\n"); break;
    case _FPCLASS_PINF: std::printf("Floating-point precision: Positive infinity\n"); break;
    case _FPCLASS_NZERO: std::printf("Floating-point precision: Negative zero\n"); break;
    case _FPCLASS_PZERO: std::printf("Floating-point precision: Positive zero\n"); break;
    case _FPCLASS_NDENORM: std::printf("Floating-point precision: Negative denormalized\n"); break;
    case _FPCLASS_PDENORM: std::printf("Floating-point precision: Positive denormalized\n"); break;
    case _FPCLASS_0: std::printf("Floating-point precision: 0\n"); break;
    case _FPCLASS_SUBNORMAL: std::printf("Floating-point precision: Subnormal\n"); break;
    case _FPCLASS_NORMAL: std::printf("Floating-point precision: Normal\n"); break;
  }

  return 0;
}

8. Get Floating-Point Class

#include <cfenv>

int main() {
  // Get floating-point class
  const int cls = fpclassify(0.0);

  switch (cls) {
    case FP_SNAN: std::printf("Floating-point class: Signalling NaN\n"); break;
    case FP_QNAN: std::printf("Floating-point class: Quiet NaN\n"); break;
    case FP_INFINITE: std::printf("Floating-point class: Infinity\n"); break;
    case FP_ZERO: std::printf("Floating-point class: Zero\n"); break;
    case FP_SUBNORMAL: std::printf("Floating-point class: Subnormal\n"); break;
    case FP_NORMAL: std::printf("Floating-point class: Normal\n"); break;
  }

  return 0;
}

9. Test Floating-Point Predicate

#include <cfenv>

int main() {
  // Test floating-point predicate
  const bool is_nan = std::isnan(0.0);

  std::printf("Is NaN: %d\n", is_nan);
  return 0;
}

10. Convert Floating-Point Value to Integer

#include <cfenv>

int main() {
  // Convert floating-point value to integer
  const int i = std::fpclassify(0.0);

  std::printf("Integer value: %d\n", i);
  return 0;
}

11. Convert Integer to Floating-Point Value

#include <cfenv>

int main() {
  // Convert integer to floating-point value
  const float f = std::fpclassify(0);

  std::printf("Floating-point value: %f\n", f);
  return 0;
}

12. Set Default Floating-Point Environment

#include <cfenv>

int main() {
  // Set default floating-point environment
  _control87(0, _MCW_DEFAULT);

  std::printf("Default floating-point environment set\n");
  return 0;
}

13. Get Floating-Point Status Word

#include <cfenv>

int main() {
  // Get floating-point status word
  const int sw = _get_statusword();

  std::printf("Floating-point status word: %x\n", sw);
  return 0;
}

14. Set Floating-Point Status Word

#include <cfenv>

int main() {
  // Set floating-point status word
  _set_statusword(0);

  std::printf("Floating-point status word set\n");
  return 0;
}

15. Get Floating-Point Control Word

#include <cfenv>

int main() {
  // Get floating-point control word
  const int cw = _get_controlword();

  std::printf("Floating-point control word: %x\n", cw);
  return 0;
}

16. Set Floating-Point Control Word

#include <cfenv>

int main() {
  // Set floating-point control word
  _set_controlword(0);

  std::printf("Floating-point control word set\n");
  return 0;
}

17. Get Floating-Point Tag Word

#include <cfenv>

int main() {
  // Get floating-point tag word
  const int