# Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world.

##### 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.