Subversion Repositories openrisc

         xml:id="std.numerics" xreflabel="Numerics">

      ISO C++

      library

   Using complex<> becomes even more comple- er, sorry,

      complicated, with the not-quite-gratuitously-incompatible

      addition of complex types to the C language.  David Tribble has

      compiled a list of C++98 and C99 conflict points; his description of

      C's new type versus those of C++ and how to get them playing together

      nicely is

here.

   complex<> is intended to be instantiated with a

      floating-point type.  As long as you meet that and some other basic

      requirements, then the resulting instantiation has all of the usual

      math operators defined, as well as definitions of op<<

      and op>> that work with iostreams: op<<

      prints (u,v) and op>> can read u,

      (u), and (u,v).

   There are four generalized functions in the <numeric> header

      that follow the same conventions as those in <algorithm>.  Each

      of them is overloaded:  one signature for common default operations,

      and a second for fully general operations.  Their names are

      self-explanatory to anyone who works with numerics on a regular basis:

      accumulate

      inner_product

      chapterial_sum

      adjacent_difference

   Here is a simple example of the two forms of accumulate.

   int   ar[50];

   int   someval = somefunction();

   // ...initialize members of ar to something...

   int  sum       = std::accumulate(ar,ar+50,0);

   int  sum_stuff = std::accumulate(ar,ar+50,someval);

   int  product   = std::accumulate(ar,ar+50,1,std::multiplies<int>());

   The first call adds all the members of the array, using zero as an

      initial value for sum.  The second does the same, but uses

      someval as the starting value (thus, sum_stuff == sum +

      someval).  The final call uses the second of the two signatures,

      and multiplies all the members of the array; here we must obviously

      use 1 as a starting value instead of 0.

   The other three functions have similar dual-signature forms.

   One of the major reasons why FORTRAN can chew through numbers so well

      is that it is defined to be free of pointer aliasing, an assumption

      that C89 is not allowed to make, and neither is C++98.  C99 adds a new

      keyword, restrict, to apply to individual pointers.  The

      C++ solution is contained in the library rather than the language

      (although many vendors can be expected to add this to their compilers

      as an extension).

   That library solution is a set of two classes, five template classes,

      and "a whole bunch" of functions.  The classes are required

      to be free of pointer aliasing, so compilers can optimize the

      daylights out of them the same way that they have been for FORTRAN.

      They are collectively called valarray, although strictly

      speaking this is only one of the five template classes, and they are

      designed to be familiar to people who have worked with the BLAS

      libraries before.

   In addition to the other topics on this page, we'll note here some

      of the C99 features that appear in libstdc++.

   The C99 features depend on the --enable-c99 configure flag.

      This flag is already on by default, but it can be disabled by the

      user.  Also, the configuration machinery will disable it if the

      necessary support for C99 (e.g., header files) cannot be found.

   As of GCC 3.0, C99 support includes classification functions

      such as isnormal, isgreater,

      isnan, etc.

      The functions used for 'long long' support such as strtoll

      are supported, as is the lldiv_t typedef.  Also supported

      are the wide character functions using 'long long', like

      wcstoll.