Math and Numerics
Boost.Integer

This library provides useful functionality for integer types, such as compile-time
constants for the minimum and maximum values,
[3]
suitably sized types based on
the number of required bits, static binary logarithm calculations, and more. Also
included are typedefs from the 1999 C Standard header <stdint.h>.
[3]
std::numeric_limits only provide these as functions.
The authors of Integer are Beman Dawes and Daryle Walker.
Boost.Interval

The Interval library helps when working with mathematical intervals. It provides
arithmetic operators for the class template interval. A common use case for
working with intervals (besides the obvious case of computations including
intervals) is when computations provide inexact results; intervals make it possible
to quantify the propagation of rounding errors.
The authors of Interval are Guillaume Melquiond, Sylvain Pion, and Hervé
Brönniman, and the library is inspired by previous work from Jens Maurer.
Boost.Math

Math is a collection of mathematics templates: quaternions and octonions
(generalizations of complex numbers); numerical functions such as acosh,
asinh, and sinhc; functionality for calculating the greatest common divisor
(GCD) and least common multiple (LCM); and more.
The authors of Math are Hubert Holin, Daryle Walker, and Eric Ford.

This is a library for professional use of random numbers, including a number of
generators and distributions that are commonly used in a wide variety of domains
such as simulation and security. Random has been accepted for the upcoming
Library Technical Report.
The author of Random is Jens Maurer.
Boost.Rational

Integer types and floating-
point types are built into the C++ language, and complex
numbers are part of the C++ Standard Library, but what about rational numbers?
Rational numbers avoid the problems with loss of precision in floating-
point types,
so their use in tracking money, for example, is popular. Rational provides rational
numbers built atop any integral type, including user-defined types (where a type
with unlimited precision is obviously the most useful).
The author of Rational is Paul Moore.
Boost.uBLAS

The uBLAS library provides basic linear algebra operations on vectors and
matrices using mathematical notation, via operator ov
erloading, with efficient code
generation (using expression templates).
The authors of uBLAS are Joerg Walter and Mathias Koch.

Input/Output
Boost.Assign


This is not possible with formatting functions using a variable number of
arguments through use of ellipsis.
The author of Format is Samuel Krempp.
Boost.Io_state_savers

The Io_state_savers library allows the state of IOStream objects to be saved, and
later restored, to undo any intervening state changes that may occur. Many
manipulators permanently change the state of the stream on which they operate,
and it can be cumbersome at best and error prone at worst to manually reset the
state. There are state savers for control flags, precision, width, exception masks,
locale for the stream, and more.
The author of Io_state_savers is Daryle Walker.
Boost.Serialization

This library allows arbitrary C++ data structures to be saved to, and restored from,
archives. An archive could be, for example, a text file or XML file.
Boost.Serialization is highly portable and offers a very mature set of features, such
as class versioning, serialization of common classes from the C++ Standard
Library, serialization of shared data, and more.
The author of Serialization is Robert Ramey.

Miscellaneous
Boost.Conversion

The Conversion library contains functions that augment the existing cast operators
(static_cast, const_cast, and dynamic_cast). Conversion adds
polymorphic_cast and polymorphic_downcast for safe polymorphic

the class template optional, which is a type that semantically has an additional
state, one that is in effect when instances of optional are not containing
instances of the wrapped object.
The author of Optional is Fernando Cacciola.
Boost.Pool

The Pool library provides a pool memory allocatorthat is, a tool for managing
dynamic memory in a single, large allocation. Using memory pools is a good
solution when allocating and deallocating many small objects, or when memory
control needs to be made more efficient.
The author of Pool is Steve Cleary.
Boost.Preprocessor

Using the preprocessor is hard when you need to express common constructs such
as recursion, it doesn't have containers, doesn't provide means for iteration, and so
forth. Nevertheless, the preprocessor is a powerful and portable tool. The
Preprocessor library provides abstractions on top of the preprocessor. These
include lists, tuples, and arrays, as well as algorithms that operate on the elements
of those types. The library helps eliminate repetitive code, thus reducing your
effort, while making code more readable, expressive, and maintainable.
The authors of Preprocessor are Vesa Karvonen and Paul Mensonides.
Boost.Program_options

The Program_options library retrieves program configuration options (name/value
pairs), typically provided through command-line arguments or configuration files.
The library relieves the programmer from the task of parsing the data by hand.
The author of Program_options is Vladimir Prus.
Boost.Python

The Python library provides interoperability between C++ and Python.

execution. The Program Execution Monitor, a component in the library, is also
useful in some production (nontest) environments.
The author of Test is Gennadiy Rozental (based upon earlier work by Beman
Dawes).
Boost.Thread

Portable threading is tricky business, and there's no help to be had from C++ itself,
as the language includes no threading support, nor acknowledges it in any way. Of
course, there's POSIX, available on many platforms, but POSIX defines a C API.
Thread is a library that offers portable threading through a number of threading
primitives and higher-level abstractions.
The author of Thread is William Kempf.
Boost.Timer

The Timer library contains features for measuring time, and aims to be as
consistent as possible across different platforms. Although there are typically
platform-specific APIs that allow programmers to measure time, there is no
portable way of attaining high-resolution timers. Boost.Timer addresses this
problem by offering the best possible resolution whilst remaining portable, in
return for a certain degree of freedom of guaranteed accuracy and precision.
The author of Timer is Beman Dawes.
Boost.Tribool

This library contains a tribool class, which implements three-state Boolean
logic. A three-state Boolean type has an additional state besides true and false:
indeterminate (this state could also be named maybe; the name is configurable).
The author of Tribool is Douglas Gregor.
Boost.Utility

Some useful stuff just doesn't find its way into a separate library, typically because