C99

 ( Programming Language Standards ) 

On platforms with IEEE 754 floating point:

float tends to limit the risk of Round-off error affecting numerically unstable expressions (see IEEE 754 design rationale) and is the designed default method for x87 hardware, but yields unintuitive behavior for the unwary user; double was the default evaluation method originally used in K&R C, which promoted all floats to double in expressions; and [[long double]] is also commonly used and specifies a strict "evaluate to type" of the operands. (For gcc, FLT_EVAL_METHOD == 2 is the default on 32 bit x86, and FLT_EVAL_METHOD == 1 is the default on 64 bit x86-64, but FLT_EVAL_METHOD == 0 can be specified on x86-64 with option -mfpmath=387.) Before C99, compilers could round intermediate results inconsistently, especially when using x87 floating-point hardware, leading to compiler-specific behaviour; such inconsistencies are not permitted in compilers conforming to C99 (annex F).

1. include
2. include
3. include
4. include
5. include
6. include
7. include

double compute_fn(double z) { // 1

   #pragma STDC FENV_ACCESS ON  // [2]
     

   assert(FLT_EVAL_METHOD == 2);  // [3]
     

   if (isnan(z)) {  // [4]
       puts("z is not a number");
   }
     

   if (isinf(z)) {
       puts("z is infinite");
   }
     

   long double r = 7.0 - 3.0 / (z - 2.0 - 1.0 / (z - 7.0 + 10.0 / (z - 2.0 - 2.0 / (z - 3.0)))); // [5, 6]
     

   feclearexcept(FE_DIVBYZERO);  // [7]
     

   bool raised = fetestexcept(FE_OVERFLOW);  // [8]
     

   if (raised) {
       puts("Unanticipated overflow.");
   }
     

   return r;
     

int main(void) {

   #ifndef __STDC_IEC_559__
   puts("Warning: __STDC_IEC_559__ not defined. IEEE 754 floating point not fully supported."); // [9]
   #endif
     

   #pragma STDC FENV_ACCESS ON
     

   #ifdef TEST_NUMERIC_STABILITY_UP
   fesetround(FE_UPWARD);                   // [10]
   #elif TEST_NUMERIC_STABILITY_DOWN
   fesetround(FE_DOWNWARD);
   #endif
     

   printf("%.7g\n", compute_fn(3.0));
   printf("%.7g\n", compute_fn(NAN));
     

   return 0;
     

Footnotes:

1. Compile with:
2. As the IEEE 754 status flags are manipulated in this function, this #pragma is needed to avoid the compiler incorrectly rearranging such tests when optimising. (Pragmas are usually implementation-defined, but those prefixed with FLT_EVAL_METHOD == 2 are defined in the C standard.)
3. C99 defines a limited number of expression evaluation methods: the current compilation mode can be checked to ensure it meets the assumptions the code was written under.
4. The special values such as NaN and positive or negative infinity can be tested and set.
5. FLT_EVAL_METHOD == 1 is defined as IEEE 754 double extended or quad precision if available. Using higher precision than required for intermediate computations can minimize round-off error (the typedef FLT_EVAL_METHOD == 0 can be used for code that is portable under all FLT_EVAL_METHOD == 2s).
6. The main function to be evaluated. Although it appears that some arguments to this continued fraction, e.g., 3.0, would lead to a divide-by-zero error, in fact the function is well-defined at 3.0 and division by 0 will simply return a +infinity that will then correctly lead to a finite result: IEEE 754 is defined not to trap on such exceptions by default and is designed so that they can very often be ignored, as in this case. (If FLT_EVAL_METHOD == 0 is defined as 2 then all internal computations including constants will be performed in long double precision; if FLT_EVAL_METHOD == 2 is defined as 0 then additional care is need to ensure this, including possibly additional casts and explicit specification of constants as long double.)
7. As the raised divide-by-zero flag is not an error in this case, it can simply be dismissed to clear the flag for use by later code.
8. In some cases, other exceptions may be regarded as an error, such as overflow (although it can in fact be shown that this cannot occur in this case).
9. STDC is to be defined only if "Annex F IEC 60559 floating-point arithmetic" is fully implemented by the compiler and the C library (users should be aware that this macro is sometimes defined while it should not be).
10. The default rounding mode is round to nearest (with the even rounding rule in the halfway cases) for IEEE 754, but explicitly setting the rounding mode toward + and - infinity (by defining long double etc. in this example, when debugging) can be used to diagnose numerical instability. This method can be used even if double_t is part of a separately compiled binary library. But depending on the function, numerical instabilities cannot always be detected.

1. if __STDC_VERSION__ >= 199901L

 /* "inline" is a keyword */
     

1. else
2. define inline static
3. endif

Historically, Microsoft has been slow to implement new C features in their Visual C++ tools, instead focusing mainly on supporting developments in the C++ standards. However, with the introduction of Visual C++ 2013 Microsoft implemented a limited subset of C99, which was expanded in Visual C++ 2015.

The next revision of the C standard, C11, was ratified in 2011. The C standards committee adopted guidelines that limited the adoption of new features that have not been tested by existing implementations. Much effort went into developing a memory model, in order to clarify and to support threaded programming.

• Compatibility of C and C++
• Outline of the C programming language
• C++ Technical Report 1
• IEEE 754, for further discussion of usage of IEEE 754

• N1256 (final draft of C99 standard plus TC1, TC2, TC3); WG14; 2007. ( HTML and ASCII versions)
• ISO/IEC 9899:1999 (official C99 standard); ISO; 1999.
• Rationale for C99; WG14; 2003.

• C Language Working Group 14 (WG14) Documents
• C9X Charter - WG14
• New things in C9X
• Features of C99