zpr c++ quick reference

Ta strona jest tylko do odczytu. Możesz wyświetlić źródła tej strony ale nie możesz ich zmienić.
===== 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.
==== Typy macierzy dostępne w bibliotece ====

  - 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 

==== 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>
zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Narzędzia strony
