| Home | Libraries | People | FAQ | More

##### Area of Circle

Generic numeric programming employs templates to use the same code for different floating-point types and functions. Consider the area of a circle a of radius r, given by

> a = π * r2

The area of a circle can be computed in generic programming using Boost.Math for the constant π as shown below:

    #include <boost/math/constants/constants.hpp>

    template<typename T>
    inline T area_of_a_circle(T r)
    {
       using boost::math::constants::pi;
       return pi<T>() * r * r;
    }

It is possible to use `area_of_a_circle()` with built-in floating-point types as well as floating-point types from Boost.Multiprecision. In particular, consider a system with 4-byte single-precision float, 8-byte double-precision double and also the `cpp_dec_float_50` data type from Boost.Multiprecision with 50 decimal digits of precision.

We can compute and print the approximate area of a circle with radius 123/100 for `float`, `double` and `cpp_dec_float_50` with the program below (see next section for choosing 123/100 instead of 1.23).

    #include <iostream>
    #include <iomanip>
    #include <boost/multiprecision/cpp_dec_float.hpp>

    using boost::multiprecision::cpp_dec_float_50;

    int main(int, char**)
    {
       const float r_f(float(123) / 100);
       const float a_f = area_of_a_circle(r_f);

       const double r_d(double(123) / 100);
       const double a_d = area_of_a_circle(r_d);

       const cpp_dec_float_50 r_mp(cpp_dec_float_50(123) / 100);
       const cpp_dec_float_50 a_mp = area_of_a_circle(r_mp);

       // 4.75292
       std::cout
          << std::setprecision(std::numeric_limits<float>::digits10)
          << a_f
          << std::endl;

       // 4.752915525616
       std::cout
          << std::setprecision(std::numeric_limits<double>::digits10)
          << a_d
          << std::endl;

       // 4.7529155256159981904701331745635599135018975843146
       std::cout
          << std::setprecision(std::numeric_limits<cpp_dec_float_50>::digits10)
          << a_mp
          << std::endl;
    }

In later examples we'll look at calling both standard library and Boost.Math functions from within generic code. We'll also show how to cope with template arguments which are expression-templates rather than number types.

But first some warnings about how multiprecision types are slightly but significantly different fundamental (built-in) types.