Narzędzia użytkownika

Narzędzia witryny


ublas

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.

#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");
}
ublas.txt · ostatnio zmienione: 2008/04/16 14:50 przez zkocon