Advanced C++ with Boost Library

The goal of the Boost Libraries is to be widely applicable and used in a variety of applications. For instance, they can in handy when working with huge numbers whose range extends over C++'s long long, long double data type (2⁶⁴).

The Boost libraries are created and published by the Boost community. The community is made up of a sizable number of C++ programmers from all over the world who communicate with each other via a number of mailing groups and the website www.boost.org. The source code repository is GitHub. The community's objective is to create and assemble top-notch libraries that will enhance the existing library. There is a significant likelihood that libraries that are proved useful and become crucial for the creation of C++ programs will eventually be added to the standard library.

Around the time the first version of the standard was issued in 1998, the Boost community started to take shape. Since then, it has continued to expand and currently has a significant impact on C++ standardisation.

When your requirements go beyond what is provided in the standard library, the Boost libraries are a viable option to boost productivity in C++ applications. You have earlier access to new innovations since the Boost libraries develop more quickly than the standard library, and you don't have to wait for those developments to be included in a new version of the standard library. So, owing to the Boost libraries, you can profit from C++'s advancement more quickly.

Example Applications

Competitive programming can effectively use this library, but first we need to make sure that our online judge supports boost. Here are some fun techniques we can employ:

1. Big Integer Data Type

Depending on our needs, we can utilise the int128_t, int256_t, int512_t, or int1024_t data types. We may easily get precision up to 1024 by employing these ones.

Implementation code in C++ is provided below for determining the product of huge numbers:

//Big Integer data type demonstration in C++ Program
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using namespace std;
int128_t boost_product(long long A, long long B)
{
    int128_t ans = (int128_t)A * B;
    return ans;
}
int main()
{
    long long first = 98745636214564698;
    long long second = 7459874565236544789;
    cout << "Product of " << first << " * " << second
         << " = \n"
         << boost_product(first, second);
    return 0;
}

Output:

2. Arbitrary Precision Data Type

 If we are unsure of how much precision will be required in the future, we can employ any precision with the help of the C++ int data type. At runtime, it automatically translates the desired precision.

The factorial of 30 is calculated using the C++ code below.

 // CPP Demonstration Program for Arbitrary Precision Data Type
#include <boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
using namespace std;


cpp_intboost_factorial(int num)
{
	cpp_int fact = 1;
	for (int i = num; i > 1; --i)
		fact *= i;
	return fact;
}


int main()
{
	int num = 30;
	cout << "Factorial of " <<num<< " = "
		<<boost_factorial(num);
	return 0;
}

Output:

3. Multiprecision Float

By using the Boost Multiprecision float functions C++ float 50 and C++ dec float 100, respectively, we may achieve precision up to 50 and 100 decimal places.

The C++ code to determine a circle's area using float, decimal, and cpp float 50 types is provided below:

// To illustrate Boost Multiprecision Float, CPP Program
#include <boost/math/constants/constants.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <iostream>
using boost::multiprecision::cpp_dec_float_50;
using namespace std;
template <typename T> inline T area_of_a_circle(T r)
{
	// Pi is a predetermined constant with a value.
	// 3.1415926535897932384...
	using boost::math::constants::pi;
	return pi<T>() * r * r;
}
int main()
{
	float radius_f = 123.0 / 100;
	float area_f = area_of_a_circle(radius_f);
	double radius_d = 123.0 / 100;
	double area_d = area_of_a_circle(radius_d);
	cpp_dec_float_50 r_mp = 123.0 / 100;
	cpp_dec_float_50 area_mp = area_of_a_circle(r_mp);
	// digits10 in numeric limits::represent the number
	 //the maximum number of decimal digits that a specific
	// type of data without any loss.
	// Using the float data type, area
	cout << "Float: "
		<<setprecision(numeric_limits<float>::digits10)
		<<area_f<<endl;
	// Using a double data type, area
	cout << "Double: "
		<<setprecision(numeric_limits<double>::digits10)
		<<area_d<<endl;
	// Utilizing Boost Multiprecision, area
	cout << "Boost Multiprecision: "
		<<setprecision(
				numeric_limits<cpp_dec_float_50>::digits10)
		<<area_mp<<endl;
	return 0;
}

Output: