zpr c++ quick reference

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.

1. Numeracja Matrix - podstawowy typ macierzy (gęstej)

• Wypunktowanie Identity Matrix
• Wypunktowanie Zero Matrix
• Wypunktowanie Scalar Matrix

Triangular Matrix Triangular Matrix Triangular Adaptor Symmetric Matrix Symmetric Matrix Symmetric Adaptor Hermitian Matrix Hermitian Matrix Hermitian Adaptor Banded Matrix Banded Matrix Banded Adaptor Sparse Matrix Mapped Matrix Compressed Matrix Coordinate Matrix

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.

#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");
}