Jahnke-Emden-Lambda function

The following code uses <boost/cstdfloat.hpp> in combination with <boost/math/special_functions.hpp> to compute a simplified version of the Jahnke-Emden-Lambda function. Here, we specify a floating-point type with exactly 64 bits (i.e., float64_t). If we were to use, for instance, built-in double, then there would be no guarantee that the code would behave identically on all platforms. With float64_t from <boost/cstdfloat.hpp>, however, it is very likely to be identical.

Using float64_t, we know that this code is as portable as possible and uses a floating-point type with approximately 15 decimal digits of precision, regardless of the compiler or version or operating system.

#include <boost/cstdfloat.hpp> // For float_64_t, float128_t. Must be first include!
#include <cmath>  // for pow function.
#include <boost/math/special_functions.hpp> // For gamma function.

boost::float64_t jahnke_emden_lambda(boost::float64_t v, boost::float64_t x)
{
  const boost::float64_t gamma_v_plus_one = boost::math::tgamma(v + 1);
  const boost::float64_t x_half_pow_v     = std::pow(x /2, v);

  return gamma_v_plus_one * boost::math::cyl_bessel_j(x, v) / x_half_pow_v;
}

Ensure that all possibly significant digits (17) including trailing zeros are shown.

std::cout.precision(std::numeric_limits<boost::float64_t>::max_digits10);
std::cout.setf(std::ios::showpoint); // Show trailing zeros.

try
{ // Always use try'n'catch blocks to ensure any error messages are displayed.

// Evaluate and display an evaluation of the Jahnke-Emden lambda function:
boost::float64_t v = 1.;
boost::float64_t x = 1.;
std::cout << jahnke_emden_lambda(v, x) << std::endl; // 0.88010117148986700

For details, see cstdfloat_example.cpp - a extensive example program.

Normal distribution table

This example shows printing tables of a normal distribution's PDF and CDF, using boost::math implementation of normal distribution.

A function templated on floating-point type prints a table for a range of standard variate z values.

The example shows use of the specified-width typedefs to either use a specific width, or to use the maximum available on the platform, perhaps a high as 128-bit.

The number of digits displayed is controlled by the precision of the type, so there are no spurious insignificant decimal digits:

float_32_t    0    0.39894228
float_128_t  0    0.398942280401432702863218082711682655

Some sample output for two different platforms is appended to the code at normal_tables.cpp.

#ifdef BOOST_FLOAT32_C
    normal_table<boost::float32_t>(); // Usually type float
#endif
    normal_table<boost::float64_t>(); // Usually type double. Assume that float64_t is always available.
#ifdef BOOST_FLOAT80_C
    normal_table<boost::float80_t>(); // Type long double on some X86 platforms.
#endif
#ifdef BOOST_FLOAT128_C
    normal_table<boost::float128_t>(); // Type _Quad on some Intel and __float128 on some GCC platforms.
#endif
    normal_table<boost::floatmax_t>();