Boost
boost
arrow_drop_down
Boost.Multiprecision

This Release

John Maddock
John Maddock
Maintainer
Chris Kormanyos
Chris Kormanyos
Maintainer
Kefu Chai
Kefu Chai
Contributor - New
Matt Borland
Matt Borland
Contributor
Christopher Kormanyos
Contributor

Boost Multiprecision Library

Master Develop
Drone Build Status Build Status
Github Actions Build Status Build Status
Codecov codecov codecov

Boost.Multiprecision is a C++ library that provides integer, rational, floating-point, complex and interval number types having more range and precision than the language's ordinary built-in types.

Language adherence:

  • Boost.Multiprecision requires a compliant C++14 compiler.
  • It is compatible with C++14, 17, 20, 23 and beyond.

The big number types in Boost.Multiprecision can be used with a wide selection of basic mathematical operations, elementary transcendental functions as well as the functions in Boost.Math. The Multiprecision types can also interoperate with the built-in types in C++ using clearly defined conversion rules. This allows Boost.Multiprecision to be used for all kinds of mathematical calculations involving integer, rational and floating-point types requiring extended range and precision.

Multiprecision consists of a generic interface to the mathematics of large numbers as well as a selection of big number back ends, with support for integer, rational and floating-point types. Boost.Multiprecision provides a selection of back ends provided off-the-rack in including interfaces to GMP, MPFR, MPIR, TomMath as well as its own collection of Boost-licensed, header-only back ends for integers, rationals, floats and complex. In addition, user-defined back ends can be created and used with the interface of Multiprecision, provided the class implementation adheres to the necessary concepts.

Depending upon the number type, precision may be arbitrarily large (limited only by available memory), fixed at compile time (for example $50$ or $100$ decimal digits), or a variable controlled at run-time by member functions. The types are expression-template-enabled by default. This usually provides better performance than naive user-defined types. If not needed, expression templates can be disabled when configuring the number type with its backend.

The full documentation is available on boost.org.

Using Multiprecision

In the following example, we use Multiprecision's Boost-licensed binary floating-point backend type cpp_bin_float to compute ${\sim}100$ decimal digits of

$$\sqrt{\pi} = \Gamma \left( \frac{1}{2} \right)~{\approx}~1.772453850905516027298{\ldots}\text{,}$$

where we also observe that Multiprecision can seemlesly interoperate with Boost.Math.

#include <iomanip>
#include <iostream>
#include <sstream>

#include <boost/multiprecision/cpp_bin_float.hpp>
#include <boost/math/special_functions/gamma.hpp>

auto main() -> int
{
  using big_float_type = boost::multiprecision::cpp_bin_float_100;

  const big_float_type sqrt_pi { sqrt(boost::math::constants::pi<big_float_type>()) };

  const big_float_type half { big_float_type(1) / 2 };

  const big_float_type gamma_half { boost::math::tgamma(half) }; 

  std::stringstream strm { };

  strm << std::setprecision(std::numeric_limits<big_float_type>::digits10) << "sqrt_pi   : " << sqrt_pi << '\n';
  strm << std::setprecision(std::numeric_limits<big_float_type>::digits10) << "gamma_half: " << gamma_half;

  std::cout << strm.str() << std::endl;
}

Standalone

Defining BOOST_MP_STANDALONE allows Boost.Multiprecision to be used with the only dependency being Boost.Config.

Our package on this page already includes a copy of Boost.Config so no other downloads are required. Some functionality is reduced in this mode. A static_assert message will alert you if a particular feature has been disabled by standalone mode. Boost.Math standalone mode is compatiable, and recommended if special functions are required for the floating point types.

Support, bugs and feature requests

Bugs and feature requests can be reported through the Gitub issue tracker (see open issues and closed issues).

You can submit your changes through a pull request.

There is no mailing-list specific to Boost Multiprecision, although you can use the general-purpose Boost mailing-list using the tag [multiprecision].

Development

Clone the whole boost project, which includes the individual Boost projects as submodules (see boost+git doc):

  git clone https://github.com/boostorg/boost
  cd boost
  git submodule update --init

The Boost Multiprecision Library is located in libs/multiprecision/.

Running tests

First, build the b2 engine by running bootstrap.sh in the root of the boost directory. This will generate b2 configuration in project-config.jam.

  ./bootstrap.sh

Now make sure you are in libs/multiprecision/test. You can either run all the tests listed in Jamfile.v2 or run a single test:

  ../../../b2                        <- run all tests
  ../../../b2 test_complex           <- single test

All Time

jzmaddock
Contributor
Madhur Chauhan
Madhur Chauhan
Contributor
Paul A. Bristow
Paul A. Bristow
Contributor
NAThompson
NAThompson
Contributor
jzmaddock
Contributor
Iskandarov Lev Andreevich
Contributor
Nick
Nick
Contributor
jzmaddock
Contributor
Edward Diener
Edward Diener
Contributor
Andrey Semashev
Andrey Semashev
Contributor
Marshall Clow
Marshall Clow
Contributor
Beman Dawes
Beman Dawes
Contributor
Paolo Galeone
Paolo Galeone
Contributor
Peter Dimov
Peter Dimov
Contributor
Glen Fernandes
Glen Fernandes
Contributor
Pavel I. Kryukov
Pavel I. Kryukov
Contributor
Raffi Enficiaud
Raffi Enficiaud
Contributor
Tinko Bartels
Tinko Bartels
Contributor
Alexandre Hamez
Alexandre Hamez
Contributor
Rene Rivera
Rene Rivera
Contributor
emfrias
emfrias
Contributor
AntonBikineev
AntonBikineev
Contributor
Cosmin Boaca
Contributor
Ryan
Ryan
Contributor
sdarwin
sdarwin
Contributor
Adam Wulkiewicz
Adam Wulkiewicz
Contributor
Jürgen Hunold
Jürgen Hunold
Contributor
Laurent Rineau
Laurent Rineau
Contributor
Daniel James
Daniel James
Contributor
Marcel Raad
Marcel Raad
Contributor
Romain Geissler
Romain Geissler
Contributor
E Kawashima
E Kawashima
Contributor
Hans Dembinski
Hans Dembinski
Contributor
Giovanni Mascellani
Giovanni Mascellani
Contributor
zerotypos-found
zerotypos-found
Contributor
Sergey Zubkov
Sergey Zubkov
Contributor
Paul A. Bristow
Paul A. Bristow
Contributor
acc987
acc987
Contributor
Sergei Fedorov
Sergei Fedorov
Contributor
Jay Freeman (saurik)
Jay Freeman (saurik)
Contributor
Mikhail Komarov
Mikhail Komarov
Contributor
Mikhail Komarov
Mikhail Komarov
Contributor
Brian Wignall
Brian Wignall
Contributor
anilmuthigi
anilmuthigi
Contributor
Stefan Vigerske
Stefan Vigerske
Contributor
Shivam Gupta
Shivam Gupta
Contributor
Mark Geck
Mark Geck
Contributor
Marcin Niestroj
Marcin Niestroj
Contributor
Stefan Dragnev
Stefan Dragnev
Contributor
Stefan Vigerske
Stefan Vigerske
Contributor
Claudio DeSouza
Claudio DeSouza
Contributor
Mario Sanchez Prada
Mario Sanchez Prada
Contributor
warren
warren
Contributor