result_type_calc.qbk

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

[section:result_type Calculation of the Type of the Result]

The functions in this library are all overloaded to accept
mixed floating point (or mixed integer and floating point type)
arguments.  So for example:

   foo(1.0, 2.0);
   foo(1.0f, 2);
   foo(1.0, 2L);

etc, are all valid calls, as long as "foo" is a function taking two 
floating-point arguments.  But that leaves the question:

[blurb ['"Given a special function with N arguments of
types T1, T2, T3 ... TN, then what type is the result?"]]

[*If all the arguments are of the same (floating point) type then the 
result is the same type as the arguments.]

Otherwise, the type of the result
is computed using the following logic:

# Any arguments that are not template arguments are disregarded from 
further analysis.
# For each type in the argument list, if that type is an integer type
then it is treated as if it were of type double for the purposes of
further analysis.
# If any of the arguments is a user-defined class type, then the result type
is the first such class type that is constructible from all of the other
argument types.
# If any of the arguments is of type `long double`, then the result is of type
`long double`.
# If any of the arguments is of type `double`, then the result is of type
`double`.
# Otherwise the result is of type `float`.

For example:
   
   cyl_bessel(2, 3.0);
   
Returns a `double` result, as does:

   cyl_bessel(2, 3.0f);
   
as in this case the integer first argument is treated as a `double` and takes
precedence over the `float` second argument.  To get a `float` result we would need
all the arguments to be of type float:

   cyl_bessel_j(2.0f, 3.0f);
   
When one or more of the arguments is not a template argument then it
doesn't effect the return type at all, for example:

   sph_bessel(2, 3.0f);
   
returns a `float`, since the first argument is not a template argument and
so doesn't effect the result: without this rule functions that take
explicitly integer arguments could never return `float`.

And for user defined types, all of the following return an NTL::RR result:

   cyl_bessel_j(0, NTL::RR(2));
   
   cyl_bessel_j(NTL::RR(2), 3);
   
   cyl_bessel_j(NTL::quad_float(2), NTL::RR(3));
   
In the last case, quad_float is convertible to RR, but not vice-versa, so
the result will be an NTL::RR.  Note that this assumes that you are using
a [link math_toolkit.using_udt.use_ntl patched NTL library].

These rules are chosen to be compatible with the behaviour of 
['ISO/IEC 9899:1999 Programming languages - C]
and with the
[@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf Draft Technical Report on C++ Library Extensions, 2005-06-24, section 5.2.1, paragraph 5].

[endsect]

[/ 
  Copyright 2006 John Maddock and Paul A. Bristow.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]