Boost

#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>

using namespace boost::numeric::ublas;

/* "y = Ax" приклад*/
int main ()
{
	vector<double> x (2);
	x(0) = 1; x(1) = 2;

	matrix<double> A(2,2);
	A(0,0) = 0; A(0,1) = 1;
	A(1,0) = 2; A(1,1) = 3;

	vector<double> y = prod(A, x);

	std::cout << y << std::endl;

	return 0;
}

#include <boost/random.hpp>
#include <ctime>

using namespace boost;

double SampleNormal (double mean, double sigma)
{
    // вибір генератора випадкових чисел
    mt19937 rng;
    // ініціалізація генератора числом секунд з 1970 року
    rng.seed(static_cast<unsigned> (std::time(0)));

    // вибір потрібного розподілу
    normal_distribution<double> norm_dist(mean, sigma);

    // прив'язка генератора до розподілу
    variate_generator<mt19937&, normal_distribution<double> >  normal_sampler(rng, norm_dist);

    // приклад роботи
    return normal_sampler();
}

#include <boost/spirit/core.hpp>
#include <boost/spirit/actor/push_back_actor.hpp>
#include <iostream>
#include <vector>
#include <string>

using namespace std;
using namespace boost::spirit;

// Парсер розділених комою чисел
bool parse_numbers(const char* str, vector<double>& v)
{
   return parse(str,
       //  початок граматики
       (
           real_p[push_back_a(v)] >> *(',' >> real_p[push_back_a(v)])
       )
       ,
       //  кінець граматики
       space_p).full;
}

#include <boost/regex.hpp>
#include <vector>
#include <string>

// Приклад програми розбору URL
int main(int argc, char** argv)
{
// Перевірка на число параметрів
    if (argc < 2) return 0;

// Контейнер для значень
std::vector<std::string> values;
// Вираз для розбору
boost::regex expression(
// proto host port
        "^(\?:([^:/\?#]+)://)\?(\\w+[^/\?#:]*)(\?::(\\d+))\?"
// path file parameters
        "(/\?(\?:[^\?#/]*/)*)\?([^\?#]*)\?(\\\?(.*))\?"
                       );
// Формування початкового рядка для розбору (береться з командного рядка)
std::string src(argv[1]);

    // Розбір і заповнення контейнера
    if (boost::regex_split(std::back_inserter(values), src, expression))
    {
        // Виведення результату
        const char* names[] = {"Protocol", "Host", "Port", "Path", "File", "Parameters", NULL};
        for (int i = 0; names[i]; i++)
            printf("%s: %s\n", names[i], values[i].c_str());
    }
    return 0;
}

#include <iostream>
#include <list>
#include <algorithm>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/topological_sort.hpp>
#include <iterator>
#include <utility>
 
int main(int , char* [])
{
  using namespace boost;

 // тип графу
 typedef adjacency_list<vecS, vecS, directedS, 
   property<vertex_color_t, default_color_type> > Graph;
 // описувач вершин
 typedef boost::graph_traits<Graph>::vertex_descriptor Vertex;
 // контейнер для ланцюжка вершин
 typedef std::vector<Vertex> container;
 // тип подання дуг графу
 typedef std::pair<std::size_t,std::size_t> Pair;

 // Дуги графу 
 Pair edges[6] = { Pair(0,1), Pair(2,4),
                   Pair(2,5),
                   Pair(0,3), Pair(1,4),
                   Pair(4,3) };
 // Граф
 Graph G(edges, edges + 6, 6);
 // словник для отримання номерів вершин по описувачах вершин
 boost::property_map<Graph, vertex_index_t>::type id = get(vertex_index, G);
 // контейнер для зберігання відсортованих вершин
 container c;

 // виконання алгоритму
 topological_sort(G, std::back_inserter(c));

 // Виведення результату: перебір описувачів графу в контейнері
 // отримання порядкових номерів вершин
 std::cout << "Топологічна перевірка: ";
 for (container::reverse_iterator ii = c.rbegin(); ii != c.rend(); ++ii)
   std::cout << id[*ii] << " ";
 std::cout << std::endl;

 return 0;
}

#include <boost/thread/thread.hpp>
#include <iostream>

using namespace std; 

void hello_world() {
  cout << "Привіт світ, я потік!" << endl;
}

int main(int argc, char* argv[]) {
  // запустити новий потік, що викликає функцію "hello_world"
  boost::thread my_thread (&hello_world);
  // чекаємо завершення потоку
  my_thread.join();
  
  return 0;
}