Różnice

Różnice między wybraną wersją a wersją aktualną.

--- reprezentacje_macierzy [2009/04/28 19:25]
zfabijan
+++ reprezentacje_macierzy [2009/04/28 21:06]
zfabijan
@@ Linia 1: / Linia 1: @@
 ====== Biblioteka Boost.uBLAS ======
-==== Wstęp ====
+===== Wstęp =====
-uBLAS (Basic Linear Algebra Subprograms) – biblioteka klas szablonowych, dostarczająca struktur do reprezentacji wektorów i macierzy różnego typu (np. macierz trójkątna, symetryczna, rzadka) oraz operacji na nich. Rozne reprezentacje macierzy sluza przestrzeganiu zasad danego typu macierzy oraz zoptymalizowanemu przechowywaniu (np. macierzy rzadkich - w formie upakowanej).
+uBLAS (Basic Linear Algebra Subprograms) – biblioteka klas szablonowych, dostarczająca struktur do reprezentacji wektorów i macierzy różnego typu (np. macierz trójkątna,
-Biblioteka uBLAS reaguje w rozny sposob na proby modyfikacji niezgodnej z cecha danego typu macierzy:
+symetryczna, rzadka) oraz operacji na nich. Różne reprezentacje macierzy służą przestrzeganiu zasad danego typu macierzy oraz zoptymalizowanemu przechowywaniu (np. macierzy
-- blad kompilacji - np.:
-* nie mozna modyfikowac macierzy jednostkowej, zerowej, skalarnej - gdyz w momencie tworzenia sa one inicjowane na stale.
-- blad wykonania - np.:
-* nie mozna modyfikowac elementu nad glowna przekatna dolnej macierzy trojkatnej, ale pozostale elementy mozna
-* nie mozna przypisac wartosci elementowi macierzy wstegowej, nie nalezacemu do glownej przekatnej lub jednej z jego wsteg, okreslonych przy definicji danego obiektu klasy.
-- brak sygnalizacji niezgodnosci - np.:
-* możliwość definicji macierzy o innej liczbie wierszy, niż kolumn, dla macierzy, które z definicji powinny być kwadratowe (np. macierz jednostkowa, trójkątna)
-* mozna przypisac elementom na glownej przekatnej macierzy hermitowskiej wartosci zespolone o niezerowej czesci urojonej - mimo, ze definicja macierzy Hermitowskiej nakazuje wartosci rzeczywiste na glownej przekatnej.
+rzadkich - w formie upakowanej).
-==== Typy ====
+Biblioteka uBLAS reaguje w różny sposob na próby modyfikacji niezgodnej z cecha danego typu macierzy:
+  - błąd kompilacji - np.:
+    * nie można modyfikować macierzy jednostkowej, zerowej, skalarnej - gdyż w momencie tworzenia są one inicjowane na stałe.
+  - błąd wykonania - np.:
+    * nie można modyfikować elementu nad głowną przekatną dolnej macierzy trójkątnej, ale pozostałe elementy można
+    * nie można przypisać wartości elementowi macierzy wstęgowej, nie należącemu do głównej przekątnej lub jednej z jego wstęg, określonych przy definicji danego obiektu klasy.
+  - brak sygnalizacji niezgodności - np.:
+    * możliwość definicji macierzy o innej liczbie wierszy, niż kolumn, dla macierzy, które z definicji powinny być kwadratowe (np. macierz jednostkowa, trójkątna)
+    * mozna przypisac elementom na głównej przekątnej macierzy hermitowskiej wartosci zespolone o niezerowej części urojonej - mimo, ze definicja macierzy Hermitowskiej nakazuje
-=== Matrix - podstawowy kontener dla macierzy gestych ===
+wartości rzeczywiste na głównej przekątnej.
-Szablon klasy: matrix<T, F, A>
-	T - typ macierzy
-	F - organizacja zapisu
-		row_major (domyslne) - wierszami
-		column_major - kolumnami
-	A - typ tablicy zapisu:
-		unbounded_array<T> (domyslne) - brak ograniczenia na rozmiar macierzy podawany przy definicji
-		bounded_array<T, N, ALLOC> - alokacja macierzy na stercie, macierz moze miec <= N elementow;
-ALLOC - domyslnie std::allocator
-		std::vector<T>
-Inne typy macierzy gestych - typy stale, nie mozna modyfikowac elementow.
+===== Typy =====
-Tak jak klasa matrix<>, inne klasy rowniez obsluguja rozszerzona deklaracje z kilkoma parametrami szablonu klasy.
+Biblioteka uBLAS udostępnia następujące typy macierzy:
+  - Matrix - podstawowy kontener dla macierzy gęstych
+    * Identity Matrix - macierz jednostkowa. Jest macierzą kwadratową (wymiary M=N).
+    * Zero Matrix - macierz zerowa
+    * Scalar Matrix - macierz skalarna
+  - Triangular Matrix - macierz trójkątna
+  - Symmetric Matrix - macierz symetryczna
+  - Hermitian Matrix - macierz Hermitowska
+  - Banded Matrix - macierz wstęgowa
+  - Sparse Matrix - macierz rzadka
+    * Mapped Matrix - macierz odwzorowania
+    * Compressed Matrix - macierz skompresowana
+    * Coordinate Matrix - macierz koordynacji
-== Identity Matrix - macierz jednostkowa. Jest macierza kwadratowa (wymiary M=N). ==
-Dla wymiarow macierzy NxN, 0 <= i < N, 0 <= j < N
-	jesli i <> j to id(i,j) = 0
-	id(i,i) = 1.
+==== Matrix ====
+== Szablon klasy: matrix<T, F, A> ==
+  * T - typ macierzy
+  * F - organizacja zapisu
+    * row_major (domyslne) - wierszami
+    * column_major - kolumnami
+  * A - typ tablicy zapisu:
+    * unbounded_array<T> (domyslne) - brak ograniczenia na rozmiar macierzy podawany przy definicji
+    * bounded_array<T, N, ALLOC> - alokacja macierzy na stercie, macierz moze miec <= N elementow; ALLOC - domyślnie std::allocator
+    * std::vector<T>
-== Zero Matrix - macierz zerowa ==
+Inne typy macierzy gęstych - typy stałe, nie można modyfikowac ich elementow.
-Wszystkie elementy = 0.
+Tak jak klasa matrix<>, inne klasy również obsługują rozszerzoną deklarację z kilkoma parametrami szablonu klasy.
-Proba modyfikacji dowolnej wartosci macierzy w kodzie konczy sie bledem kompilacji.
+=== Identity Matrix ===
+== Dla wymiarów macierzy NxN, 0 <= i < N, 0 <= j < N ==
+  * jesli i <> j to id(i,j) = 0
+  * jesli i=j to id(i,i) = 1.
-== Scalar Matrix - macierz skalarna ==
+=== Zero Matrix ===
-Kazdy element macierzy = stala wartosc, podana w konstruktorze (domyslnie: 0);
+Wszystkie elementy mają wartosc 0.
-Proba modyfikacji dowolnej wartosci macierzy w kodzie konczy sie bledem kompilacji.
+Próba modyfikacji dowolnej wartości macierzy w kodzie kończy sie błędem kompilacji.
+=== Scalar Matrix ===
+Każdy element macierzy to stała wartość, podana w konstruktorze (domyslnie 0).
+Próba modyfikacji dowolnej wartości macierzy w kodzie kończy się błędem kompilacji.
-=== Triangular Matrix - macierz trojkatna ===
-Jest to rodzaj macierzy kwadratowej, jednak w klasie nalezy definiowac rozmiar obu wymiarow.
-Dla wymiarow macierzy NxN, 0 <= i < N,0 <= j < N
-	jesli dla i<j: id(i,j)=0 - dolna macierz trojkatna (lower)
-		jesli dodatkowo id(i,i) = 1 - dolna jednostkowa macierz trojkatna (unit_lower)
-	jesli dla i>j: id(i,j)=0 - gorna macierz trojkatna (upper)
-		jesli dodatkowo id(i,i) = 1 - gorna jednostkowa macierz trojkatna (unit_upper)
-Szablon klasy: triangular_matrix<T, F1, F2, A>
-	F1 - typ macierzy: lower (domyslny), unit_lower, upper, unit_upper
-	F2 - organizacja zapisu, jak F w matrix<T, F, A>
+==== Triangular Matrix ====
+Jest to rodzaj macierzy kwadratowej, jednak w klasie należy definiować rozmiar obydwu wymiarow.
+== Dla wymiarów macierzy NxN, 0 <= i < N,0 <= j < N ==
+  * jesli dla i<j: id(i,j)=0 - dolna macierz trójkątna (lower)
+    * jesli dodatkowo id(i,i) = 1 - dolna jednostkowa macierz trójkątna (unit_lower)
+  * jesli dla i>j: id(i,j)=0 - gorna macierz trojkątna (upper)
+    * jesli dodatkowo id(i,i) = 1 - gorna jednostkowa macierz trójkątna (unit_upper)
-== Triangular Adaptor - adapter dla macierzy innych typow ==
+== Szablon klasy: triangular_matrix<T, F1, F2, A> ==
-Zmiana wartosci w macierzy adaptowanej jest odzwierciedlona w obiektcie klasy adaptera.
+  * F1 - typ macierzy: lower (domyślny), unit_lower, upper, unit_upper
-Tu takze proba zmiany wartosci na glownej przekatnej dla typu macierzy unit_lower lub unit_upper konczy sie wyjatkiem.
+  * F2 - organizacja zapisu, jak F w matrix<T, F, A>
-Szablon klasy: triangular_adaptor<M, F>
-	M - typ adaptowanej macierzy
+=== Triangular Adaptor - adapter dla macierzy innych typów ===
+Zmiana wartości w macierzy adaptowanej jest odzwierciedlona w obiekcie klasy adaptera.
+Tu także próba zmiany wartości na głównej przekątnej dla typu macierzy unit_lower lub unit_upper kończy się wyjątkiem.
+== Szablon klasy: triangular_adaptor<M, F> ==
+  * M - typ adaptowanej macierzy
-=== Symmetric Matrix - macierz symetryczna. ===
-Jest to rodzaj macierzy kwadratowej, jednak w klasie nalezy definiowac rozmiar obu wymiarow.
-Dla wymiarow macierzy NxN, 0 <= i < N,0 <= j < N
-	id(i,j)=id(j,i)
-		jesli dodatkowo dla i<j: id(i,j)=0 - dolna macierz symetryczna (lower)
-		jesli dodatkowo dla i>j: id(i,j)=0 - gorna macierz symetryczna (upper)
-Szablon klasy: symetric_matrix<T, F1, F2, A>
-	F1 - typ macierzy: lower (domyslny), upper
-	F2 - organizacja zapisu, jak F w matrix<T, F, A>
+==== Symmetric Matrix ====
+Jest to rodzaj macierzy kwadratowej, jednak w klasie należy definiować rozmiar obydwu wymiarów.
+== Dla wymiarów macierzy NxN, 0 <= i < N,0 <= j < N ==
+  * id(i,j)=id(j,i)
+    * jeśli dodatkowo dla i<j: id(i,j)=0 - dolna macierz symetryczna (lower)
+    * jeśli dodatkowo dla i>j: id(i,j)=0 - górna macierz symetryczna (upper)
+== Szablon klasy: symetric_matrix<T, F1, F2, A> ==
+  * F1 - typ macierzy: lower (domyslny), upper
+  * F2 - organizacja zapisu, jak F w matrix<T, F, A>
-== Symmetric Adaptor - adapter dla macierzy innych typow. ==
+=== Symmetric Adaptor - adapter dla macierzy innych typów ===
-Zmiana wartosci w macierzy adaptowanej jest odzwierciedlona w obiektcie klasy adaptera.
+Zmiana wartości w macierzy adaptowanej jest odzwierciedlona w obiektcie klasy adaptera.
-Szablon klasy: symmetric_adaptor<M, F>
+== Szablon klasy: symmetric_adaptor<M, F> ==
-	M - typ adaptowanej macierzy
+  * M - typ adaptowanej macierzy
-=== Hermitian Matrix - macierz Hermitowska. ===
+==== Hermitian Matrix ====
-Jest to rodzaj macierzy kwadratowej, jednak w klasie nalezy definiowac rozmiar obu wymiarow.
+Jest to rodzaj macierzy kwadratowej, jednak w klasie należy definiować rozmiar obydwu wymiarow.
-Szablon klasy: hermitian_matrix<T, F1, F2, A>
+== Szablon klasy: hermitian_matrix<T, F1, F2, A> ==
-Dla wymiarow macierzy NxN, 0 <= i < N,0 <= j < N
+== Dla wymiarów macierzy NxN, 0 <= i < N,0 <= j < N ==
-	id(i,j) = id'(j,i), gdzie id' = liczba sprzezona z id
+  * id(i,j) = id'(j,i), gdzie id' = liczba sprzężona z id
-Implementacja macierzy Hermitowskiej w uBLAS dopuszcza umieszszczenie na glownej przekatnej macierzy
+Implementacja macierzy Hermitowskiej w uBLAS dopuszcza umieszszczenie na głównej przekątnej macierzy
-wartosci zespolonych o niezerowej czesci urojonej mimo, ze nie jest to macierz Hermitowska.
+wartości zespolonych o niezerowej cześci urojonej mimo, ze nie jest to macierz Hermitowska.
-Banded Matrix - kwadratowa macierz rzadka
+==== Banded Matrix ====
-wszystkie elementy macierzy wstegowej sa zerowe poza glowna przekatna i okreslonymi przekatnymi (wstegami).
+Wszystkie elementy macierzy wstęgowej są zerowe poza główna przekątną i określonymi przekątnymi (wstęgami).
-Dla wymiarow macierzy MxN, 0 <= i < M,0 <= j < N, l-liczba niezerowych dolnych przekatnych (tych pod przekatna glowna), u-liczba gornych przekatnych.
+== Dla wymiarów macierzy MxN, 0 <= i < M,0 <= j < N, l-liczba niezerowych dolnych przekątnych (tych pod przekątna główną), u-liczba górnych przekątnych ==
-	Dla i>j+l lub i<j-u: id(i,j)=0
+  * jesli i>j+l lub i<j-u to id(i,j)=0
-Szablon klasy: banded_matrix<T, F, A>
+== Szablon klasy: banded_matrix<T, F, A> ==
-=== Sparse Matrix - macierz rzadka. ===
+==== Sparse Matrix ====
-Ponizsze klasy macierzy rzadkich roznia sie tylko sposobem przechowywania macierzy.
+Poniższe klasy macierzy rzadkich różnią się tylko sposobem przechowywania macierzy.
-== Mapped Matrix - macierz odwzorowania. ==
+=== Mapped Matrix ===
-Kontenerem jest mapa (indeks elementu, wartosc)
+Kontenerem jest mapa (indeks elementu, wartość).
-Dla wymiarow macierzy MxN, 0 <= i < M,0 <= j < N
+== Dla wymiarów macierzy MxN, 0 <= i < M,0 <= j < N ==
-	odwzorowuje _niezerowe_ elementy id(i,j) na elementy kontenera typu podanego jako trzeci parametr (A) szablonu klasy.
+  * odwzorowuje _niezerowe_ elementy id(i,j) na elementy kontenera typu podanego jako trzeci parametr (A) szablonu klasy.
-Szablon klasy: mapped_matrix<T, F, A>
+== Szablon klasy: mapped_matrix<T, F, A> ==
-	F - organizacja zapisu:
+  * F - organizacja zapisu:
-		row_major (domyslne) - wierszami, id(i,j) -> (i*n+j)-ty element kontenera
+    * row_major (domyslne) - wierszami, id(i,j) -> (i*n+j)-ty element kontenera
-		column_major - kolumnami, id(i,j) -> (j*n+i)-ty element kontenera
+    * column_major - kolumnami, id(i,j) -> (j*n+i)-ty element kontenera
-	A - typ kontenera zapisu:
+  * A - typ kontenera zapisu:
-		map_array<std::size_t, T>
+    * map_array<std::size_t, T>
-		map_std<std::size_t, T>, czyli std::map<std::size_t, T>
+    * map_std<std::size_t, T>, czyli std::map<std::size_t, T>
+=== Compressed Matrix, Coordinate Matrix ===
+Osobne kontenery dla indeksów elementu i wartości.
+== Szablon klasy: compressed_matrix<T, F, IB, IA, TA> ==
+  * IB - baza indeksu skompresowanego kontenera (domyślnie: 0)
+  * IA - typ kontenera indeksow elementow macierzy
+  * TA - typ kontenera wartosci elementow
+    * unbounded_array<T> - domyslnie: unbounded_array<std::size_t>
+    * bounded_array<T>
+    * std::vector<T>
-== Compressed Matrix - macierz skompresowana, Coordinate Matrix - macierz koordynacji ==
+===== Kod źródłowy =====
-Osobne kontenery dla indeksow elementu i wartosci.
-Szablon klasy: compressed_matrix<T, F, IB, IA, TA>
-	IB - baza indeksu skompresowanego kontenera (domyslnie: 0)
-	IA - typ kontenera indeksow elementow macierzy
-	TA - typ kontenera wartosci elementow
-		unbounded_array<T> - domyslnie: unbounded_array<std::size_t>
-		bounded_array<T>
-		std::vector<T>
+[[http://staff.elka.pw.edu.pl/~rnowak2/zprwiki/lib/exe/fetch.php?id=biblioteki_boost&cache=cache&media=ublas_repr.cpp|ublas_repr.cpp]]
-==== Kod źródłowy ====
+===== Linki zewnętrzne =====
-Poniższy kod prezentuje zastosowanie przykładowych klas biblioteki uBLAS.
-<code cpp>
+[[http://www.boost.org/doc/libs/1_38_0/libs/numeric/ublas/doc/index.htm | Dokumentacja uBLAS]]
-// Zbigniew Fabijanski, H1ISIII
-// ZPR - praca domowa - Zad.27 - Biblioteki boost - boost::uBLAS (reprezentacje macierzy).
-#include <boost/numeric/ublas/matrix.hpp> // Macierz gesta.
-#include <boost/numeric/ublas/triangular.hpp> // Macierz trojkatna.
-#include <boost/numeric/ublas/symmetric.hpp> // Macierz symetryczna.
-#include <boost/numeric/ublas/hermitian.hpp> // Macierz Hermitowska
-#include <boost/numeric/ublas/banded.hpp> // Macierz wstegowa.
-#include <boost/numeric/ublas/matrix_sparse.hpp> // Macierze rzadkie.
-#include <boost/numeric/ublas/io.hpp> // Operatory << i >> dla klas macierzy.
-int main () {
-	// import przestrzeni nazw
-	using namespace boost::numeric::ublas;
-	using std::cout;
-	using std::endl;
-	// --------------------------------------- Matrix ---------------------------------------
-	{
-		// Definicja macierzy gestej o 2 wierszach i 3 kolumnach.
-		matrix<double> m (2, 3); // Typ rownowazny: matrix<double, row_major, unbounded_array<double> >
-		try {
-			std::cout << "Proba deklaracji macierzy 3x3 zapisane w kontenerze o rozmiarze 8: " << std::endl;
-			// Nieprawidlowa definicja klasy z wieksza liczba elementow (3*3=9), niz okreslono w typie kontenera przechowujacego zawartosci macierzy (8).
-			// matrix<double, row_major, bounded_array<double, 8> > mb (3, 3);
-			// Taki rodzaj deklaracji jest rowniez dostepny dla wszystkich innych klas macierzy.
-			matrix<double, row_major, bounded_array<double, 8> > mb (3, 3); // Ta definicja wygeneruje wyjatek blednego rozmiaru przydzielonej na zawartosc macierzy sterty.
-		}
-		catch (std::exception &e){
-			std::cout << "Exception: " << e.what() << std::endl;
-		}
-		// Przypisanie do macierzy wartosci kolejny liczb naturalnych - wierszami.
-		for (unsigned i = 0; i < m.size1 (); ++ i) // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j < m.size2 (); ++ j) // dla kazdej kolumny macierzy
-				m (i, j) = 3 * i + j;
-		// Wyswietlenie zawartosci macierzy - przeciazony operator<< dla klas macierzy.
-		std::cout << "Macierz gesta:" << std::endl << m << std::endl;
-	}
-	// Macierz jednostkowa
-	{
-		// W definicji nastepuje automatyczne inicjowanie _stalych_ wartosci macierzy.
-		identity_matrix<double> m (3); // Podajemy jedyny wymiar macierzy, poniewaz macierz jednostkowa jest z definicji kwadratowa (M=N).
-		std::cout << "Macierz jednostkowa:"  << std::endl << m << std::endl;
-		// Odkomentowanie ponizszej linijki skutkuje bledem kompilacji, bez wzgledu na to, czy naruszymy reguly wartosci elementow macierzy jednostkowej, czy nie.
-		// m(0,0) = 1;
-	}
-	// Macierz zerowa
-	{
-		// Tu rowniez inicjalizacja wszystkich elementow - na wartosci zerowe.
-		zero_matrix<double> m (3,4); // Mozliwy takze konstruktor z 1 argumentem - macierz kwadratowa.
-		std::cout << "Macierz zerowa:"  << std::endl << m << std::endl;
-	}
-	// Macierz skalarna
-	{
-		scalar_matrix<double> m(3,3,4); // Macierz o wymiarach 3x3, wypelniona wartosciami 4.
-		std::cout << "Macierz skalarna:"  << std::endl << m << std::endl;
-	}
-	// --------------------------------------- Triangular Matrix ---------------------------------------
-	{
-		// Wypelnienie kolejnymi liczbami tylko dolnej czesci macierzy i glownej przekatnej, gdyz jest to macierz dolna,
-		// a wiec elementy nad glowna przekatna maja wartosci 0 przypisane na stale w definicji.
-		triangular_matrix<double, lower> tml (3, 4);
-		for (unsigned i = 0; i < tml.size1 (); ++ i) // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j <= i; ++ j) // dla kazdej kolumny macierzy, ale dla elementow pod glowna przekatna
-				tml (i, j) = 3 * i + j;
-		std::cout << "Dolna macierz trojkatna:" << std::endl << tml << std::endl;
-		// Definicja gornej jednostkowej macierzy trojkatnej.
-		triangular_matrix<double, unit_upper> tmup (3, 3);
-		// Wypelnienie liczbami tylko elementow nad glowna przekatna macierzy.
-		for (unsigned i = 0; i < tmup.size1 (); ++ i) // dla kazdego wiersza macierzy
-			// Wartosci na glownej przekatnej zostaly juz zainicjowane przy definicji macierzy,
-			// dlatego petla wewnetrzna od j=i+1, a nie j=i.
-			for (unsigned j = i+1; j < tmup.size2 (); ++ j) // dla kazdej kolumny macierzy, ale dla elementow nad glowna przekatna
-				tmup (i, j) = 3 * i + j;
-		std::cout << "Gorna jednostkowa macierz trojkatna:" << std::endl << tmup << std::endl;
-		// Proba zmiany wartosci na glownej przekatnej macierzy jednostkowej.
-		try {
-			std::cout << "Proba zmiany wartosci na glownej przekatnej gornej jednostkowej macierzy trojkatnej:" << std::endl;
-			tmup(0,0)=-1; // Ta linijka rzuci wyjatek, poniewaz w gornej _jednostkowej_ macierzy trojkatnej
-							// mozemy zmieniac tylko wartosci pod glowna przekatna.
-		}
-		catch (std::exception &e){
-			std::cout << "Exception: " << e.what() << std::endl;
-		}
-	}
-	// Triangular Adaptor
-	{
-		// Definicja macierzy gestej - adaptowanej.
-		matrix<double> m(3,3);
-		for (unsigned i = 0; i < m.size1 (); ++ i) // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j < m.size2 (); ++ j) // dla kazdej kolumny macierzy
-				m (i, j) = 3 * i + j + 1; // Przypisanie macierzy adaptowanej kolejnych liczb naturalnych.
-		// Definicja dolnego adaptera macierzy gestej.
-		triangular_adaptor<matrix<double>, lower> tal (m);
-		std::cout << "Dolny adapter trojkatny macierzy : " << m << " to: " << std::endl;
-		std::cout << tal << std::endl; // Elementy nad glowna przekatna maja wartosc 0.
-	}
-	// --------------------------------------- Symmetric Matrix ---------------------------------------
-	{
-		// Dolna macierz symetryczna. Wartosci nad glowna przekatna wskazuja na odpowiednie wartosci symetrycznych pod przekatna.
-		symmetric_matrix<double, lower> sml (3, 3);
-		// Wystarczy przypisac wartosci czesci macierzy po jednej stronie glownej przekatnej,
-		//	gdyz elementy po drugiej stronie wskazuja na swoich symetrycznych odpowiednikow.
-		for (unsigned i = 0; i < sml.size1 (); ++ i) // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j < /*i*/sml.size2 (); ++ j) // dla kazdej kolumny macierzy, ten sam efekt, co dla petli z warunkiem j <= i
-				sml(i, j) = 3 * i + j + 1;
-		// Modyfikacja wartosci id(i,j) powoduje modyfikacje takze id(j,i).
-		sml(1, 0)=-1; // Ten sam efekt, co instrukcja sml(0,1)=-1;
-		std::cout << "Dolna macierz symetryczna: " << std::endl << sml << std::endl;
-	}
-	// Symmetric Adaptor
-	{
-		// Macierz adaptowana.
-		matrix<double> m(3,3);
-		for (unsigned i = 0; i < m.size1 (); ++ i) // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j < m.size2 (); ++ j) // dla kazdej kolumny macierzy
-				m (i, j) = 3 * i + j + 1;
-		// Poniewaz adaptowanie przebiega w porzadku wierszowym, a nie kolumnowym,
-		//	wartosci po gornej stronie glownej przekatnej wskazuja symetryczne wartosci spod glownej przekatnej, a nie odwrotnie.
-		symmetric_adaptor<matrix<double> > sa (m); // Brak 2.argumentu klasy szablonu => wartosc domyslna (lower)
-		// Dopiero tutaj widac roznice pomiedzy dolna a gorna macierza symetryczna.
-		// Instrukcja zmiany wartosci adaptera zmienia oba symetryczne elementy obiektu adaptera macierzy.
-		// Ale poniewaz jest to gorny adapter macierzy, w macierzy adaptowanej zmienia sie tylko element nad glowna przekatna macierzy.
-		sa(1,0)=-1; // A dla macierzy adaptowanej m - ten sam efekt, co instrukcja sa(0,1)=-1;
-		std::cout << "Dolny adapter symetryczny stworzonej z macierzy gestej: " << m << " to: " << std::endl;
-		std::cout << sa << std::endl;
-	}
-	// --------------------------------------- Hermitian Matrix ---------------------------------------
-	{
-		// Deklaracja dolnej macierzy Hermitowskiej.
-		hermitian_matrix<std::complex<double>, lower> hml (3, 3);
-		for (unsigned i = 0; i < hml.size1 (); ++ i) { // dla kazdego wiersza macierzy
-			for (unsigned j = 0; j < i; ++ j) // dla kazdej kolumny macierzy
-				hml (i, j) = std::complex<double> (3 * i + j, 3 * i + j); // Wypelniamy macierzy liczbami zespolonymi (complex)
-			hml (i, i) = std::complex<double> (4 * i, 0); // wartosci na glownej przekatnej
-		}
-		std::cout << "Dolna macierz Hermitowska:" << std::endl << hml << std::endl;
-	}
-	// Hermitian Adaptor - analogicznie do innych adapterow.
-	// --------------------------------------- Banded Matrix ---------------------------------------
-	{
-		signed l=1, u=1; // l,u - ilosc niezerowych przekatnych pod,nad przekatna glowna
-		banded_matrix<double> bm (3, 3, l, u); // l=1, u=1
-		// Dla wszystkich wierszy.
-		for (signed i = 0; i < signed (bm.size1 ()); ++ i) // dla kazdego wiersza macierzy
-			// Dla kolumn, ktorych indeks nalezy do przedzialu [-l,u) wzgledem
-			for (signed j = std::max (i - l, 0); j < std::min (i + u, signed (bm.size2 ())); ++ j)
-				bm (i, j) = 3 * i + j + 1;
-		std::cout << "Macierz wstegowa:" << std::endl << bm << std::endl;
-		//	bm(2,0)=0; // ta instrukcja generuje wyjatek
-	}
-	// Banded Adaptor - analogicznie do innych adapterow.
-}
-</code cpp>
-===== Linki zewnętrzne =====
-[[http://www.boost.org/doc/libs/1_38_0/libs/numeric/ublas/doc/index.htm | Strona domowa uBLAS]]
+ --- //[[Z.Fabijanski@stud.elka.pw.edu.pl|Zbigniew Fabijański H1ISI]]//

zpr c++ quick reference

Narzędzia użytkownika

Narzędzia witryny

Różnice

Narzędzia strony