===== boost::uBLAS =====
Boost::uBLAS jest częścią boost odpowiedzialną za algebrę liniową. Biblioteka wykonuje działania dla dwóch typów obiektów: wektorów i macierzy.



==== Grupy macierzy i typy reprezentujące ====

1. Matrix - podstawowy typ macierzy (gęstej)
  * Matrix
  * Identity Matrix 
  * Zero Matrix 
  * Scalar Matrix
2. Triangular Matrix - macierz trójkątna
  * Triangular Matrix
  * Triangular Adaptor
3. Symmetric Matrix - macierz symetryczna
  * Symmetric Matrix
  * Symmetric Adaptor
4. Hermitian Matrix - macierz hermitowska
  * Hermitian Matrix
  * Hermitian Adaptor
5. Banded Matrix - macierz wstęgowa
  * Banded Matrix
  * Banded Adaptor
6. Sparse Matrix - macierz rzadka
  * Mapped Matrix
  * Compressed Matrix
  * Coordinate Matrix 

==== Kod pracy domowej ====
Jest prostym programem, demonstrującym najważniejsze typy i operacje na nich. Kod ukazuje szereg operacji, poczynając od podstawowych takich jak dodawanie, odejmowanie dwóch macierzy, mnożenie przez skalar, mnożenie dwóch macierzy kwadratowych, a kończąc na odwracaniu macierzy trójkątnych i m.in obsłudze macierzy hermitowskich.
<code cpp>
#include <boost/numeric/ublas/matrix.hpp>	
#include <boost/numeric/ublas/triangular.hpp>	
#include <boost/numeric/ublas/symmetric.hpp>	
#include <boost/numeric/ublas/hermitian.hpp>
#include <boost/numeric/ublas/io.hpp>
#include <iomanip>


int main () {
	using namespace boost::numeric::ublas;		//ustawienie przestrzenie nazw typowej dla ublas
	std::cout.precision(2);		//ustawienie precyzji wyswietlania na 2 cyfry po przecinku

	matrix<double> m1 (3, 3), m2 (3, 3), m4(4, 4); //dwie macierze 3 x 3 o wartościach rzecywistych
	identity_matrix<double> m3(3);		// macierz jednostkowa 

	//wypełnienie macierzy A (m1) i B(m2) przykładowymi danymi
	for (unsigned i = 0; i < std::min (m1.size1 (), m2.size1 ()); ++i)
	for (unsigned j = 0; j < std::min (m1.size2 (), m2.size2 ()); ++j)
	{
		m1 (i, j) = 3.0 * i + j + 0.5;	//operator()
		m2 (i, j) = 3.0 * i + j - 0.25;
	}
	
	//wypełnienie macierzy m4 przykładowymi danymi
	for (unsigned i = 0; i < m4.size1(); ++i)
	for (unsigned j = 0; j < m4.size2(); ++j)
	{
		m4 (i, j) = 2.0 * i + 1.5 * j;
	}
	
	try 
	{
		std::cout << "Macierz A:" << std::endl;
		std::cout << m1 << std::endl << std::endl;		//operator<<

		std::cout << "Macierz B:" << std::endl;			
		std::cout << m2 << std::endl << std::endl;		//operator<<

		std::cout << "Macierz jednostkowa:" << std::endl;
		std::cout << m3 << std::endl << std::endl;		//operator<< dla macierzy jednostkowej

		std::cout << "2.0 * A:" << std::endl;
		std::cout << 2.0 * m1 << std::endl << std::endl;	//operator*

		std::cout << "A / 2.0:" << std::endl;
		std::cout << m1 / 2.0 << std::endl << std::endl;	//operator/

		std::cout << "A + B:" << std::endl;
		std::cout << m1 + m2 << std::endl << std::endl;		//operator+

		std::cout << "A - B:" << std::endl;
		std::cout << m1 - m2 << std::endl << std::endl;		//operator-

		std::cout << "A * B:" << std::endl;
		std::cout << prod(m1, m2) << std::endl << std::endl;	//mnożenie macierzy

		std::cout << "B * A:" << std::endl;
		std::cout << prod(m2, m1) << std::endl << std::endl;	//mnożenie macierzy (odwrotna kolejność)

		std::cout << "Proba blednej operacji - mnozenie macierzy o nieprawidlowych wymiarach" << std::endl;
		std::cout << prod(m1, m4) << std::endl << std::endl;	//próba wymnożenia macierzy 3x3 z macierzą 4x4, powoduje wyjątek
		
	} 
	catch (std::exception &e)
	{ 
		std::cout << "Zlapano wyjatek" << std::endl << std::endl;	//zasygnalizowanie złapania wyjątku
	}

	try
	{
		m1.resize(4, 4, true);	//zmiana rozmiarów z zachowanmiem danych

		//wypełnienie macierzy brakującymi danymi (dodane kolumny i wiersze mają wartości niezdefiniowane)
		for (unsigned i = 0; i < m1.size1(); ++i)
		m1(i, 3) = 1.0;
		for (unsigned i = 0; i < m1.size2() - 1; ++i)
		m1(3, i) = 2.0;

		std::cout << "Zmiana rozmiarow macierzy A na 4 x 4 i wypelnienie reszty danymi:" << std::endl;
		std::cout << m1 << std::endl << std::endl;

		m1.clear();		//wyczyszczenie macierzy
		std::cout << "Macierz po wyczyszczeniu:" << std::endl;
		std::cout << m1 << std::endl << std::endl;

		triangular_adaptor<matrix<double>, lower> tal (m2);		//zastosowanie adaptora macierzy trójkątnej (cześć dolna)
		triangular_adaptor<matrix<double>, upper> tau (m2);		//zastosowanie adaptora macierzy trójkątnej (cześć górna)
		
		std::cout << "Macierz trojkatna stworzona z macierzy B - czesc dolna" << std::endl;
		std::cout << tal << std::endl << std::endl;
		std::cout << "Macierz trojkatna stworzona z macierzy B - czesc gorna" << std::endl;
		std::cout << tau << std::endl << std::endl;

		triangular_matrix<double> t = solve(tal, m3, lower_tag());
		std::cout << "Macierz trojkatna odwrocona:" << std::endl;
		std::cout << t << std::endl << std::endl;
		
		symmetric_adaptor<matrix<double>, lower> sal (m2);	//zastosowanie adaptora macierzy sysmetrycznej (cześć dolna brana jako dane)
		symmetric_adaptor<matrix<double>, upper> sau (m2);	//zastosowanie adaptora macierzy sysmetrycznej (cześć górnabrana jako dane)

		std::cout << "Macierz symetryczna stworzona z macierzy B - czesc dolna" << std::endl;
		std::cout << sal << std::endl << std::endl;
		std::cout << "Macierz symetryczna stworzona z macierzy B - czesc gorna" << std::endl;
		std::cout << sau << std::endl << std::endl;


		hermitian_matrix<std::complex<double>, lower> h1 (3, 3);	//macierz hermitowska, uzupełniana od dołu
		
		//wypełnienie przykładowymi danymi
		for (unsigned i = 0; i < h1.size1 (); ++ i)
		{
			for (unsigned j = 0; j < i; ++ j)
			h1 (i, j) = std::complex<double> (3 * i + j, 3 * i + j);
			h1 (i, i) = std::complex<double> (4 * i, 0);
		}

		std::cout << "Macierz hermitowska - uzupelniana od dolu:" << std::endl;
		std::cout << h1 << std::endl << std::endl;

	}
	catch (std::exception &e) 
	{ 
		std::cout << "Zlapano wyjatek" << std::endl << std::endl;	//zasygnalizowanie złapania wyjątku
	}
	system("pause");
}
</code>