123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101 |
- [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, typically __multiprecision,
- All of the following return a `boost::multiprecision::cpp_bin_quad_float` result:
- cyl_bessel_j(0, boost::multiprecision::cpp_bin_quad_float(2));
- cyl_bessel_j(boost::multiprecision::cpp_bin_quad_float(2), 3);
- cyl_bessel_j(boost::multiprecision::cpp_bin_quad_float(2), boost::multiprecision::cpp_bin_quad_float(3));
- but rely on the parameters provided being exactly representable, avoiding loss of precision from construction from `double`.
- [tip All new projects should use Boost.Multiprecision.]
- During development of Boost.Math, __NTL was invaluable to create highly precise tables.
- 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.high_precision.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] [/section:result_type Calculation of the Type of the Result]
- [/
- Copyright 2006, 2012 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).
- ]
|