fenv

---

1. Checking for Support of Floating-Point Exceptions (FE_ALL_EXCEPT)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  if (fegetexceptflag(&env, FE_ALL_EXCEPT) & FE_ALL_EXCEPT) {
    printf("All floating-point exceptions are supported.\n");
  } else {
    printf("Some or all floating-point exceptions are not supported.\n");
  }
  return 0;
}

2. Setting Floating-Point Exceptions (FE_ALL_EXCEPT)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  fesetenv(&env);
  if (fegetexceptflag(&env, FE_ALL_EXCEPT) & FE_ALL_EXCEPT) {
    printf("All floating-point exceptions are enabled.\n");
  }
  return 0;
}

3. Clearing Floating-Point Exceptions (FE_ALL_EXCEPT)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  feclearexcept(FE_ALL_EXCEPT);
  if (fegetexceptflag(&env, FE_ALL_EXCEPT) == 0) {
    printf("All floating-point exceptions are cleared.\n");
  }
  return 0;
}

4. Getting the Exception Status (FE_ALL_EXCEPT)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int exceptions = fegetexceptflag(&env, FE_ALL_EXCEPT);
  if (exceptions & FE_INVALID) {
    printf("Invalid operation.\n");
  }
  return 0;
}

5. Raising an Invalid Operation Exception (FE_INVALID)

#include <fenv.h>
int main() {
  feclearexcept(FE_ALL_EXCEPT);
  float x = 0.0;
  float y = 0.0;
  float z = x / y;  // Raising an invalid operation exception (division by zero)
  if (fetestexcept(FE_INVALID)) {
    printf("Invalid operation exception raised.\n");
  }
  return 0;
}

6. Ignoring Floating-Point Exceptions (FE_NOMASK)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  fesetround(FE_TONEAREST);
  env.__status &= ~FE_NOMASK;
  fesetenv(&env);
  float x = 0.1;
  float y = 0.2;
  float z = x - y;  // Floating-point exception is ignored
  return 0;
}

7. Trapping Floating-Point Exceptions (FE_NOTIFY)

#include <fenv.h>
#include <signal.h>
void handler(int sig) {
  printf("Floating-point exception occurred.\n");
}
int main() {
  signal(SIGFPE, handler);
  fenv_t env;
  fegetenv(&env);
  env.__status |= FE_NOTIFY;
  fesetenv(&env);
  float x = 0.0;
  float y = 0.0;
  float z = x / y;  // Floating-point exception is trapped
  return 0;
}

8. Setting the Floating-Point Rounding Mode (FE_TONEAREST)

#include <fenv.h>
int main() {
  fesetround(FE_TONEAREST);
  float x = 0.1;
  float y = 0.2;
  float z = x + y;  // Result rounded to nearest even
  return 0;
}

9. Getting the Floating-Point Rounding Mode (FE_TONEAREST)

#include <fenv.h>
int main() {
  int rounding_mode = fesetround(FE_TONEAREST);
  if (rounding_mode == FE_TONEAREST) {
    printf("Rounding mode set to nearest even.\n");
  }
  return 0;
}

10. Checking the Current Processor's Floating-Point State (FE_DFL_ENV)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  if (env.__control == FE_DFL_ENV) {
    printf("Current processor's floating-point state is default.\n");
  }
  return 0;
}

11. Setting the Processor's Floating-Point State (FE_DFL_ENV)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__control = FE_DFL_ENV;
  fesetenv(&env);
  printf("Processor's floating-point state set to default.\n");
  return 0;
}

12. Checking for Floating-Point Unit (FE_HARDWARE)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_HARDWARE)) {
    printf("Floating-point unit is present.\n");
  } else {
    printf("Floating-point unit is not present.\n");
  }
  return 0;
}

13. Checking for In-Range Support (FE_INEXACT)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_INEXACT)) {
    printf("In-range support is available.\n");
  } else {
    printf("In-range support is not available.\n");
  }
  return 0;
}

14. Checking for Underflow Support (FE_UNDERFLOW)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_UNDERFLOW)) {
    printf("Underflow support is available.\n");
  } else {
    printf("Underflow support is not available.\n");
  }
  return 0;
}

15. Checking for Overflow Support (FE_OVERFLOW)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_OVERFLOW)) {
    printf("Overflow support is available.\n");
  } else {
    printf("Overflow support is not available.\n");
  }
  return 0;
}

16. Checking for Divide-by-Zero Support (FE_DIVBYZERO)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_DIVBYZERO)) {
    printf("Divide-by-zero support is available.\n");
  } else {
    printf("Divide-by-zero support is not available.\n");
  }
  return 0;
}

17. Getting the Floating-Point Status Flags

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int flags = env.__status;
  printf("Current floating-point status flags: 0x%x\n", flags);
  return 0;
}

18. Setting the Floating-Point Status Flags

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__status |= FE_INVALID;
  fesetenv(&env);
  printf("Setting the invalid operation flag in the floating-point status flags.\n");
  return 0;
}

19. Resetting the Floating-Point Status Flags

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__status &= ~FE_INVALID;
  fesetenv(&env);
  printf("Resetting the invalid operation flag in the floating-point status flags.\n");
  return 0;
}

20. Getting the Floating-Point Control Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int control_mode = env.__control;
  printf("Current floating-point control mode: 0x%x\n", control_mode);
  return 0;
}

21. Setting the Floating-Point Control Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__control |= FE_DFL_ENV;
  fesetenv(&env);
  printf("Setting the floating-point control mode to default.\n");
  return 0;
}

22. Resetting the Floating-Point Control Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__control &= ~FE_DFL_ENV;
  fesetenv(&env);
  printf("Resetting the floating-point control mode to default.\n");
  return 0;
}

23. Getting the Floating-Point Precision Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int precision = env.__precision;
  printf("Current floating-point precision mode: %d\n", precision);
  return 0;
}

24. Setting the Floating-Point Precision Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__precision = FE_DOUBLE;
  fesetenv(&env);
  printf("Setting the floating-point precision mode to double.\n");
  return 0;
}

25. Resetting the Floating-Point Precision Mode

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__precision = FE_SINGLE;
  fesetenv(&env);
  printf("Resetting the floating-point precision mode to single.\n");
  return 0;
}

26. Rounding to a Specified Precision

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__precision = FE_EXTENDED;
  fesetenv(&env);
  double x = 1.234567890123456789;
  double y = fesetprecision(env, FE_DOUBLE);
  printf("Rounded value of x to double precision: %.16f\n", y);
  return 0;
}

27. Getting the Floating-Point Rounding Direction

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int rounding_direction = env.__rounding;
  printf("Current floating-point rounding direction: %d\n", rounding_direction);
  return 0;
}

28. Setting the Floating-Point Rounding Direction

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__rounding = FE_TONEAREST;
  fesetenv(&env);
  printf("Setting the floating-point rounding direction to nearest even.\n");
  return 0;
}

29. Resetting the Floating-Point Rounding Direction

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__rounding = FE_UPWARD;
  fesetenv(&env);
  printf("Resetting the floating-point rounding direction to upward.\n");
  return 0;
}

30. Getting the Floating-Point MXCSR Register

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  unsigned int mxcsr = env.__mxcsr;
  printf("Current value of the floating-point MXCSR register: 0x%x\n", mxcsr);
  return 0;
}

31. Setting the Floating-Point MXCSR Register

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__mxcsr |= MXCSR_MASKED_INVALID_OP;
  fesetenv(&env);
  printf("Setting the masked invalid operation bit in the floating-point MXCSR register.\n");
  return 0;
}

32. Resetting the Floating-Point MXCSR Register

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__mxcsr &= ~MXCSR_MASKED_INVALID_OP;
  fesetenv(&env);
  printf("Resetting the masked invalid operation bit in the floating-point MXCSR register.\n");
  return 0;
}

33. Checking if the Floating-Point Unit is Busy (FE_BUSY)

#include <fenv.h>
int main() {
  if (fegetexceptflag(FE_BUSY)) {
    printf("Floating-point unit is busy.\n");
  } else {
    printf("Floating-point unit is not busy.\n");
  }
  return 0;
}

34. Clearing the Floating-Point Unit Busy Flag (FE_BUSY)

#include <fenv.h>
int main() {
  feclearexcept(FE_BUSY);
  printf("Clearing the floating-point unit busy flag.\n");
  return 0;
}

35. Getting the Floating-Point Status of an FPU Register (FE_STATUS)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int status = fegetstatus(env.__status);
  printf("Floating-point status of the status register: %d\n", status);
  return 0;
}

36. Setting the Floating-Point Status of an FPU Register (FE_STATUS)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__status |= FE_INVALID;
  fesetstatus(env.__status, env.__status);
  printf("Setting the invalid operation bit in the floating-point status register.\n");
  return 0;
}

37. Resetting the Floating-Point Status of an FPU Register (FE_STATUS)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__status &= ~FE_INVALID;
  fesetstatus(env.__status, env.__status);
  printf("Resetting the invalid operation bit in the floating-point status register.\n");
  return 0;
}

38. Getting the Floating-Point Control Mode of an FPU Register (FE_CONTROL)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int control_mode = fegetcontrol(env.__control);
  printf("Floating-point control mode of the control register: %d\n", control_mode);
  return 0;
}

39. Setting the Floating-Point Control Mode of an FPU Register (FE_CONTROL)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__control |= FE_DFL_ENV;
  fesetcontrol(env.__control, env.__control);
  printf("Setting the default environment in the floating-point control register.\n");
  return 0;
}

40. Resetting the Floating-Point Control Mode of an FPU Register (FE_CONTROL)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__control &= ~FE_DFL_ENV;
  fesetcontrol(env.__control, env.__control);
  printf("Resetting the default environment in the floating-point control register.\n");
  return 0;
}

41. Getting the Floating-Point Precision Mode of an FPU Register (FE_PRECISION)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int precision = fegetprecision(env.__precision);
  printf("Floating-point precision mode of the precision register: %d\n", precision);
  return 0;
}

42. Setting the Floating-Point Precision Mode of an FPU Register (FE_PRECISION)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__precision |= FE_DOUBLE;
  fesetprecision(env.__precision, env.__precision);
  printf("Setting the double precision in the floating-point precision register.\n");
  return 0;
}

43. Resetting the Floating-Point Precision Mode of an FPU Register (FE_PRECISION)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__precision &= ~FE_DOUBLE;
  fesetprecision(env.__precision, env.__precision);
  printf("Resetting the double precision in the floating-point precision register.\n");
  return 0;
}

44. Getting the Floating-Point Rounding Direction of an FPU Register (FE_ROUNDING)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  int rounding_direction = fegetrounding(env.__rounding);
  printf("Floating-point rounding direction of the rounding register: %d\n", rounding_direction);
  return 0;
}

45. Setting the Floating-Point Rounding Direction of an FPU Register (FE_ROUNDING)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__rounding |= FE_TONEAREST;
  fesetrounding(env.__rounding, env.__rounding);
  printf("Setting the nearest even rounding direction in the floating-point rounding register.\n");
  return 0;
}

46. Resetting the Floating-Point Rounding Direction of an FPU Register (FE_ROUNDING)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__rounding &= ~FE_TONEAREST;
  fesetrounding(env.__rounding, env.__rounding);
  printf("Resetting the nearest even rounding direction in the floating-point rounding register.\n");
  return 0;
}

47. Getting the Floating-Point MXCSR Register of an FPU Register (FE_MXCSR)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  unsigned int mxcsr = fegetmxcsr(env.__mxcsr);
  printf("Floating-point MXCSR register of the MXCSR register: 0x%x\n", mxcsr);
  return 0;
}

48. Setting the Floating-Point MXCSR Register of an FPU Register (FE_MXCSR)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__mxcsr |= MXCSR_MASKED_INVALID_OP;
  fesetmxcsr(env.__mxcsr, env.__mxcsr);
  printf("Setting the masked invalid operation bit in the floating-point MXCSR register.\n");
  return 0;
}

49. Resetting the Floating-Point MXCSR Register of an FPU Register (FE_MXCSR)

#include <fenv.h>
int main() {
  fenv_t env;
  fegetenv(&env);
  env.__mxcsr &= ~MXCSR_MASKED_INVALID_OP;
  fesetmxcsr(env.__mxcsr, env.__mxcsr);
  printf("Resetting the masked invalid operation bit in the floating-point MXCSR register.\n");
  return 0;
}

50. Combining and Using Multiple Floating-Point Environment Functions

#include <fenv.h>
int main() {
  fenv_t env;
  // Get the current floating-point environment
  fegetenv(&env);
  // Set the floating-point rounding direction to nearest even
  fesetround(FE_TONEAREST);
  // Set the floating-point exception status flags to all masked
  env.__status |= FE_ALL_EXCEPT;
  fesetstatus(env.__status, env.__status);
  // Set the floating-point control mode to default
  fesetcontrol(env.__control, FE_DFL_ENV);
  // Enable the floating-point exception trap
  env.__status |= FE_NOTIFY;
  fesetenv(&env);
  printf("Floating-point environment configuration complete.\n");
  return 0;
}