PG/MNP02
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

sprawozdanie

Browse Source
This commit is contained in:
Kacper Donat 2018-05-08 16:36:44 +02:00
parent af9dfe6f8c
commit 862a51157d
6 changed files with 776 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

401
argh.h Normal file
View File

@ -0,0 +1,401 @@
#pragma once
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <cassert>
namespace argh
{
// Terminology:
// A command line is composed of 2 types of args:
// 1. Positional args, i.e. free standing values
// 2. Options: args beginning with '-'. We identify two kinds:
// 2.1: Flags: boolean options => (exist ? true : false)
// 2.2: Parameters: a name followed by a non-option value
#if !defined(__GNUC__) || (__GNUC__ >= 5)
using string_stream = std::istringstream;
#else
// Until GCC 5, istringstream did not have a move constructor.
// stringstream_proxy is used instead, as a workaround.
class stringstream_proxy
{
public:
stringstream_proxy() = default;
// Construct with a value.
stringstream_proxy(std::string const& value) :
stream_(value)
{}
// Copy constructor.
stringstream_proxy(const stringstream_proxy& other) :
stream_(other.stream_.str())
{
stream_.setstate(other.stream_.rdstate());
}
void setstate(std::ios_base::iostate state) { stream_.setstate(state); }
// Stream out the value of the parameter.
// If the conversion was not possible, the stream will enter the fail state,
// and operator bool will return false.
template<typename T>
stringstream_proxy& operator >> (T& thing)
{
stream_ >> thing;
return *this;
}
// Get the string value.
std::string str() const { return stream_.str(); }
std::stringbuf* rdbuf() const { return stream_.rdbuf(); }
// Check the state of the stream.
// False when the most recent stream operation failed
operator bool() const { return !!stream_; }
~stringstream_proxy() = default;
private:
std::istringstream stream_;
};
using string_stream = stringstream_proxy;
#endif
class parser
{
public:
enum Mode { PREFER_FLAG_FOR_UNREG_OPTION = 1 << 0,
PREFER_PARAM_FOR_UNREG_OPTION = 1 << 1,
NO_SPLIT_ON_EQUALSIGN = 1 << 2,
SINGLE_DASH_IS_MULTIFLAG = 1 << 3,
};
parser() = default;
parser(std::initializer_list<char const* const> pre_reg_names)
{ add_params(pre_reg_names); }
parser(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
{ parse(argv, mode); }
parser(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION)
{ parse(argc, argv, mode); }
void add_param(std::string const& name);
void add_params(std::initializer_list<char const* const> init_list);
void parse(const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
void parse(int argc, const char* const argv[], int mode = PREFER_FLAG_FOR_UNREG_OPTION);
std::multiset<std::string> const& flags() const { return flags_; }
std::map<std::string, std::string> const& params() const { return params_; }
std::vector<std::string> const& pos_args() const { return pos_args_; }
// begin() and end() for using range-for over positional args.
std::vector<std::string>::const_iterator begin() const { return pos_args_.cbegin(); }
std::vector<std::string>::const_iterator end() const { return pos_args_.cend(); }
//////////////////////////////////////////////////////////////////////////
// Accessors
// flag (boolean) accessors: return true if the flag appeared, otherwise false.
bool operator[](std::string const& name) const;
// multiple flag (boolean) accessors: return true if at least one of the flag appeared, otherwise false.
bool operator[](std::initializer_list<char const* const> init_list) const;
// returns positional arg string by order. Like argv[] but without the options
std::string const& operator[](size_t ind) const;
// returns a std::istream that can be used to convert a positional arg to a typed value.
string_stream operator()(size_t ind) const;
// same as above, but with a default value in case the arg is missing (index out of range).
template<typename T>
string_stream operator()(size_t ind, T&& def_val) const;
// parameter accessors, give a name get an std::istream that can be used to convert to a typed value.
// call .str() on result to get as string
string_stream operator()(std::string const& name) const;
// accessor for a parameter with multiple names, give a list of names, get an std::istream that can be used to convert to a typed value.
// call .str() on result to get as string
// returns the first value in the list to be found.
string_stream operator()(std::initializer_list<char const* const> init_list) const;
// same as above, but with a default value in case the param was missing.
// Non-string def_val types must have an operator<<() (output stream operator)
// If T only has an input stream operator, pass the string version of the type as in "3" instead of 3.
template<typename T>
string_stream operator()(std::string const& name, T&& def_val) const;
// same as above but for a list of names. returns the first value to be found.
template<typename T>
string_stream operator()(std::initializer_list<char const* const> init_list, T&& def_val) const;
private:
string_stream bad_stream() const;
std::string trim_leading_dashes(std::string const& name) const;
bool is_number(std::string const& arg) const;
bool is_option(std::string const& arg) const;
bool got_flag(std::string const& name) const;
private:
std::vector<std::string> args_;
std::map<std::string, std::string> params_;
std::vector<std::string> pos_args_;
std::multiset<std::string> flags_;
std::set<std::string> registeredParams_;
std::string empty_;
};
//////////////////////////////////////////////////////////////////////////
inline void parser::parse(const char * const argv[], int mode)
{
int argc = 0;
for (auto argvp = argv; *argvp; ++argc, ++argvp);
parse(argc, argv, mode);
}
//////////////////////////////////////////////////////////////////////////
inline void parser::parse(int argc, const char* const argv[], int mode /*= PREFER_FLAG_FOR_UNREG_OPTION*/)
{
// convert to strings
args_.resize(argc);
std::transform(argv, argv + argc, args_.begin(), [](const char* const arg) { return arg; });
// parse line
for (auto i = 0u; i < args_.size(); ++i)
{
if (!is_option(args_[i]))
{
pos_args_.emplace_back(args_[i]);
continue;
}
auto name = trim_leading_dashes(args_[i]);
if (!(mode & NO_SPLIT_ON_EQUALSIGN))
{
auto equalPos = name.find('=');
if (equalPos != std::string::npos)
{
params_.insert({ name.substr(0, equalPos), name.substr(equalPos + 1) });
continue;
}
}
// if the option is unregistered and should be a multi-flag
if (1 == (args_[i].size() - name.size()) && // single dash
argh::parser::SINGLE_DASH_IS_MULTIFLAG & mode && // multi-flag mode
registeredParams_.find(name) == registeredParams_.end()) // unregistered
{
for (auto const& c : name)
{
flags_.emplace(std::string{ c });
}
}
// any potential option will get as its value the next arg, unless that arg is an option too
// in that case it will be determined a flag.
if (i == args_.size() - 1 || is_option(args_[i + 1]))
{
flags_.emplace(name);
continue;
}
// if 'name' is a pre-registered option, then the next arg cannot be a free parameter to it is skipped
// otherwise we have 2 modes:
// PREFER_FLAG_FOR_UNREG_OPTION: a non-registered 'name' is determined a flag.
// The following value (the next arg) will be a free parameter.
//
// PREFER_PARAM_FOR_UNREG_OPTION: a non-registered 'name' is determined a parameter, the next arg
// will be the value of that option.
if (registeredParams_.find(name) != registeredParams_.end() ||
argh::parser::PREFER_PARAM_FOR_UNREG_OPTION & mode)
{
params_.insert({ name, args_[i + 1] });
++i; // skip next value, it is not a free parameter
continue;
}
if (argh::parser::PREFER_FLAG_FOR_UNREG_OPTION & mode)
flags_.emplace(name);
};
}
//////////////////////////////////////////////////////////////////////////
inline string_stream parser::bad_stream() const
{
string_stream bad;
bad.setstate(std::ios_base::failbit);
return bad;
}
//////////////////////////////////////////////////////////////////////////
inline bool parser::is_number(std::string const& arg) const
{
// inefficient but simple way to determine if a string is a number (which can start with a '-')
std::istringstream istr(arg);
double number;
istr >> number;
return !(istr.fail() || istr.bad());
}
//////////////////////////////////////////////////////////////////////////
inline bool parser::is_option(std::string const& arg) const
{
assert(0 != arg.size());
if (is_number(arg))
return false;
return '-' == arg[0];
}
//////////////////////////////////////////////////////////////////////////
inline std::string parser::trim_leading_dashes(std::string const& name) const
{
auto pos = name.find_first_not_of('-');
return std::string::npos != pos ? name.substr(pos) : name;
}
//////////////////////////////////////////////////////////////////////////
inline bool argh::parser::got_flag(std::string const& name) const
{
return flags_.end() != flags_.find(trim_leading_dashes(name));
}
//////////////////////////////////////////////////////////////////////////
inline bool parser::operator[](std::string const& name) const
{
return got_flag(name);
}
//////////////////////////////////////////////////////////////////////////
inline bool parser::operator[](std::initializer_list<char const* const> init_list) const
{
return std::any_of(init_list.begin(), init_list.end(), [&](char const* const name) { return got_flag(name); });
}
//////////////////////////////////////////////////////////////////////////
inline std::string const& parser::operator[](size_t ind) const
{
if (ind < pos_args_.size())
return pos_args_[ind];
return empty_;
}
//////////////////////////////////////////////////////////////////////////
inline string_stream parser::operator()(std::string const& name) const
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
return bad_stream();
}
//////////////////////////////////////////////////////////////////////////
inline string_stream parser::operator()(std::initializer_list<char const* const> init_list) const
{
for (auto& name : init_list)
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
}
return bad_stream();
}
//////////////////////////////////////////////////////////////////////////
template<typename T>
string_stream parser::operator()(std::string const& name, T&& def_val) const
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
std::ostringstream ostr;
ostr << def_val;
return string_stream(ostr.str()); // use default
}
//////////////////////////////////////////////////////////////////////////
// same as above but for a list of names. returns the first value to be found.
template<typename T>
string_stream parser::operator()(std::initializer_list<char const* const> init_list, T&& def_val) const
{
for (auto& name : init_list)
{
auto optIt = params_.find(trim_leading_dashes(name));
if (params_.end() != optIt)
return string_stream(optIt->second);
}
std::ostringstream ostr;
ostr << def_val;
return string_stream(ostr.str()); // use default
}
//////////////////////////////////////////////////////////////////////////
inline string_stream parser::operator()(size_t ind) const
{
if (pos_args_.size() <= ind)
return bad_stream();
return string_stream(pos_args_[ind]);
}
//////////////////////////////////////////////////////////////////////////
template<typename T>
string_stream parser::operator()(size_t ind, T&& def_val) const
{
if (pos_args_.size() <= ind)
{
std::ostringstream ostr;
ostr << def_val;
return string_stream(ostr.str());
}
return string_stream(pos_args_[ind]);
}
//////////////////////////////////////////////////////////////////////////
inline void parser::add_param(std::string const& name)
{
registeredParams_.insert(trim_leading_dashes(name));
}
//////////////////////////////////////////////////////////////////////////
inline void parser::add_params(std::initializer_list<char const* const> init_list)
{
for (auto& name : init_list)
registeredParams_.insert(trim_leading_dashes(name));
}
}

110
main.cpp
View File

@ -1,19 +1,29 @@
#include "matrix.h"
#include "solver.h"
#include "argh.h"
#include <iostream>
#include <fstream>
#include <chrono>
#include <utility>
const size_t N = 10;
std::pair<Matrix<double>, Matrix<double>> prepare(size_t index, size_t n)
std::pair<Matrix<double>, Matrix<double>> prepare(double a1, size_t n, size_t index)
{
double a1, a2, a3;
double a2, a3;
a2 = a3 = -1;
a1 = 5 + (index / 100) % 10;
auto M = Matrix<double>::diag(n, a1)
+ Matrix<double>::diag(n, a2, 1) + Matrix<double>::diag(n, a2, -1)
+ Matrix<double>::diag(n, a3, 2) + Matrix<double>::diag(n, a3, -2);
auto M = Matrix<double>::diag(n, a1);
for(size_t i = 0; i < n; i++) {
if (i >= 1) {
M(i, i-1) = a2;
M(i-1, i) = a2;
}
if (i >= 2) {
M(i, i-2) = a3;
M(i-2, i) = a3;
}
}
Matrix<double> b(n, 1);
for (size_t i = 0; i < n; ++i) {
@ -23,23 +33,87 @@ std::pair<Matrix<double>, Matrix<double>> prepare(size_t index, size_t n)
return std::make_pair(M, b);
}
void help(const char* program)
{
std::cout
<< "Usage: " << program << " <N> <index> <method> [options]" << std::endl
<< " <N> - size of generated matrix" << std::endl
<< " <index> - index used for matrix generation" << std::endl
<< " <method> - one of: gauss, jacobi, lu" << std::endl;
std::cout << std::endl
<< "Options:" << std::endl
<< " -x, --solution - displays result (x)" << std::endl
<< " -M, --matrix - displays matrix (M)" << std::endl
<< " -b, --result - displays result vector (b)" << std::endl
<< " -r, --residuum - displays residuum norm" << std::endl
<< std::endl
<< " -a a1 - sets diagonal element" << std::endl
<< " -o, --output output - sets residuum output file" << std::endl
;
}
int main(int argc, const char* argv[])
{
auto tuple = prepare(165581, N);
std::ofstream output;
JacobiSolver jacobi;
GaussSolver gauss;
LUSolver lu;
Solver* solver;
if (argc < 4) {
help(argv[0]);
return -1;
}
argh::parser args;
args.add_param("a");
args.add_params({"o", "output"});
args.parse(argc, argv);
size_t N, index;
std::string method, csv;
double a1;
args(1) >> N;
args(2) >> index;
args(3) >> method;
args({"a"}, (index / 100) % 10 + 5) >> a1;
args({"o", "output"}, "") >> csv;
auto tuple = prepare(a1, N, index);
auto M = std::get<0>(tuple);
auto b = std::get<1>(tuple);
JacobiSolver jacobi;
std::cout << jacobi.solve(M, b);
if (args[{"M", "matrix"}]) std::cout << "Matrix:" << std::endl << M << std::endl;
if (args[{"b", "result"}]) std::cout << "Result:" << std::endl << b << std::endl;
GaussSolver gauss;
std::cout << gauss.solve(M, b);
if (method == "gauss") solver = &gauss;
else if (method == "jacobi") solver = &jacobi;
else if (method == "lu") solver = &lu;
else {
std::cout << "Method unknown: " << method << std::endl;
help(argv[0]);
return -1;
}
LUSolver lu;
IterativeSolver* iterative = dynamic_cast<IterativeSolver*>(solver);
if (iterative && !method.empty()) {
output.open(csv);
iterative->output(&output);
}
auto pair = LUSolver::decompose(M);
auto L = std::get<0>(pair);
auto U = std::get<1>(pair);
std::cout << "Solving using " << method << " method..." << std::endl;
auto start = std::chrono::high_resolution_clock::now();
std::cout << lu.solve(L, U, b);
auto x = solver->solve(M, b);
if (args[{"x", "solution"}]) std::cout << "Solution:" << std::endl << x << std::endl;
if (args[{"r", "residuum"}]) std::cout << "Residuum:" << norm(M*x - b, 2) << std::endl;
std::chrono::duration<double> duration = std::chrono::high_resolution_clock::now() - start;
if (iterative) std::cout << "Iterations: " << iterative->iterations() << std::endl;
std::cout << "Solving time: " << duration.count() << "s" << std::endl;
}

11
matrix.h
View File

@ -163,12 +163,15 @@ std::ostream &operator<<(std::ostream &os, const Matrix<T> &matrix) {
template<typename T>
Matrix<T> Matrix<T>::diag(size_t n, T value, int offset) {
self_t result(n);
if (offset >= 0)
for(size_t i = 0; i < n - offset; i++)
if (offset >= 0) {
for(size_t i = 0; i < n - offset; i++) {
result(i,i+offset) = value;
else
for(size_t i = 0; i < n - offset; i++)
}
} else {
for(size_t i = 0; i < n + offset; i++) {
result(i-offset, i) = value;
}
}
return result;
}

34
solver.h
View File

@ -24,12 +24,18 @@ public:
class IterativeSolver : public Solver {
protected:
double error;
size_t _iterations;
std::ostream* csv;
public:
IterativeSolver();
IterativeSolver(double error);
virtual Matrix<double> iteration(const Matrix<double>& M, const Matrix<double>& b, const Matrix<double>& old) = 0;
virtual Matrix<double> solve(const Matrix<double>& M, const Matrix<double>& b) override;
size_t iterations() const;
void output(std::ostream* csv);
};
class JacobiSolver : public IterativeSolver {
@ -54,17 +60,35 @@ Matrix<double> IterativeSolver::solve(const Matrix<double>& M, const Matrix<doub
Matrix<double> x(n, 1);
for (size_t i = 0; i < n; ++i) x(i, 0) = 1.;
size_t iterations = 0;
while(residuum(M, b, x) > error) {
_iterations = 0;
double r;
if (csv) *csv << "iter,residuum" << std::endl;
while((r = residuum(M, b, x)) > error) {
x = iteration(M, b, x);
iterations ++;
if (csv) *csv << iterations() << "," << r << std::endl;
_iterations ++;
if (_iterations >= 100) {
std::cerr << "Giving up after " << _iterations << " iteration, residuum: " << r << std::endl;
return x;
}
}
return x;
}
IterativeSolver::IterativeSolver() : error(1e-9) {}
IterativeSolver::IterativeSolver(double error) : error(error) {}
void IterativeSolver::output(std::ostream* stream)
{
this->csv = stream;
}
size_t IterativeSolver::iterations() const
{
return _iterations;
}
IterativeSolver::IterativeSolver() : IterativeSolver(1e-9) {}
IterativeSolver::IterativeSolver(double error) : error(error), csv(nullptr) {}
Matrix<double> JacobiSolver::iteration(const Matrix<double>& M, const Matrix<double>& b, const Matrix<double>& old)
{

202
sprawozdanie/sprawozdanie.tex Normal file
View File

@ -0,0 +1,202 @@
\documentclass[]{article}
\usepackage[T1]{fontenc}
\usepackage{polski}
\usepackage[utf8]{inputenc}
\usepackage[margin=1.25in]{geometry}
\usepackage{alltt}
\usepackage{titling}
\usepackage{pdfpages}
\usepackage{float}
\usepackage{amsmath}
\usepackage{booktabs}
\usepackage{tabularx}
\usepackage{amstext}
\usepackage{pgfplots}
\usepackage{tikz}
\usepackage{xspace}
\usepackage{enumerate}
\usepackage{lmodern}
\usepackage{amsfonts}
\usepackage{mathtools}
\usepackage{alphalph}
\usepackage{algorithm}
\usepackage{algpseudocode}
\usepackage{wrapfig}
\usepackage[polish]{babel}
\usepackage{siunitx}
\usepackage{subcaption}
\usepackage{csvsimple} % kurwa
\pgfplotsset{compat=1.15}
\usepgfplotslibrary{groupplots}
\DeclarePairedDelimiter\ceil{\lceil}{\rceil}
\DeclarePairedDelimiter\floor{\lfloor}{\rfloor}
\usetikzlibrary{decorations.pathmorphing, arrows.meta, positioning}
\usetikzlibrary{shapes.geometric, arrows, intersections}
\pgfdeclarelayer{background}
\pgfdeclarelayer{foreground}
\pgfsetlayers{background,main,foreground}
% opening
\title{Rozwiązywanie Układów Równań \\ \normalsize Projekt \#2 z \texttt{MN}}
\author{Kacper Donat}
\newenvironment{column}[1]{\noindent\begin{minipage}{#1\linewidth}}{\end{minipage}\vspace{.5\baselineskip}}
\floatname{algorithm}{Program}
\begin{document}
\maketitle
\section{Porównanie metod rozwiązywania układów równań}
\begin{equation*}
\underbrace{\begin{bmatrix}
10 & -1 & -1 & 0 & \cdots & 0 \\
-1 & 10 & -1 & -1 & \cdots & 0 \\
-1 & -1 & 10 & -1 & \cdots & 0 \\
0 & -1 & -1 & 10 & \cdots & 0 \\
\vdots & \vdots & \vdots & \vdots & \ddots & \vdots \\
0 & 0 & 0 & 0 & \cdots & 10
\end{bmatrix}}_{M}
\underbrace{\begin{bmatrix}
-0.048\\
-0.084 \\
-0.12 \\
-0.14 \\
\vdots \\
-0.12 \\
\end{bmatrix}}_{x}
=
\underbrace{\begin{bmatrix}
-0.28 \\
-0.54 \\
-0.75 \\
-0.96 \\
\vdots \\
-0.97 \\
\end{bmatrix}}_{b}
\end{equation*}
\begin{table}[H]
\centering
\begin{tabular}{l|rrr}
& \textbf{Jacobi} & \textbf{Gauss} & \textbf{LU} \\ \hline
\textbf{Czas $[\si{s}]$} & 0.085 & 0.062 & 0.58 \\
\textbf{Iteracje} & 29 & 19 & - \\
\textbf{Residuum} & $3.78 \cdot 10^{-10}$ & $8.21 \cdot 10^{-10}$ & $6.00 \cdot 10^{-16}$
\end{tabular}
\caption{Porównanie czasów oraz ilości iteracji dla pkt. \textbf{A} tj. dla $N = 981$}
\end{table}
Dla danych z podpunktu A, tj. dla $a_1 = 10$ wszystkie metody się zbiegają bez problemu. zadowalające wyniki
najszybciej osiąga metoda Gaussa-Seidla, co nie jest zakoczeniem, dodatkowo metoda Gaussa potrzebuje około $33\%$
iteracji mniej (patrz rys. \ref{fig:A:residuum}). Macierz $M$ wydaje się być dobrze uwarunkowaną macierzą dla obu
metod iteracyjnych. Metoda LU natomiast daje najdokładniejszy wynik - jednak nie jest to wynik dokładny ponieważ
obliczenia zmiennoprzecinkowe nie są dokładne. Dodatkowo, obliczanie metodą LU zajmuje około 10x więcej czasu.
\begin{equation*}
\underbrace{\begin{bmatrix}
3 & -1 & -1 & 0 & \cdots & 0 \\
-1 & 3 & -1 & -1 & \cdots & 0 \\
-1 & -1 & 3 & -1 & \cdots & 0 \\
0 & -1 & -1 & 3 & \cdots & 0 \\
\vdots & \vdots & \vdots & \vdots & \ddots & \vdots \\
0 & 0 & 0 & 0 & \cdots & 3
\end{bmatrix}}_{M}
\underbrace{\begin{bmatrix}
-1.64 \\
-2.18 \\
-2.44 \\
-1.92 \\
\vdots \\
2.26 \\
\end{bmatrix}}_{x}
=
\underbrace{\begin{bmatrix}
-0.28 \\
-0.54 \\
-0.75 \\
-0.96 \\
\vdots \\
-0.97 \\
\end{bmatrix}}_{b}
\end{equation*}
\begin{table}[H]
\centering
\begin{tabular}{l|rrr}
& \textbf{Jacobi} & \textbf{Gauss} & \textbf{LU} \\ \hline
\textbf{Czas $[\si{s}]$} & - & - & 0.79 \\
\textbf{Iteracje} & 100 $\times$ & 100 $\times$ & - \\
\textbf{Residuum} & $7.20 \cdot 10^{13}$ & $1.79 \cdot 10^{31}$ & $5.16 \cdot 10^{-13}$
\end{tabular}
\caption{Porównanie czasów oraz ilości iteracji dla pkt. \textbf{E} tj. dla $a1 = 3$}
\end{table}
Tak skonstruowana macierz $M$ nie jest dobrze uwarunkowana do rozwiązań iteracyjnych, żadna z metod iteracyjnych się
nie zbiegła. Po 100 próbach wyraźnie widać, że metoda gaussa nie tylko szybciej się zbiega - ale w wypadku źle
uwarunkowanej macierzy również szybciej się rozbiega (rys. \ref{fig:C:residuum}), o czym świadczy znacznie większy
wektor residuum. Warto również zauważyć, że dla tego wypadku metoda LU również poradziła sobie zdecydowanie gorzej -
osiągając wynik o 3 rzędy wielkości mniej dokładny (względem normy z residuum)
Po analizie czasu dla różnych $N$, widać że metody Jacobiego oraz Gaussa-Seidla róznią się stosunkowo mało, jednak
różnica między czasem metod iteracyjnych a LU jest znaczna i wynosi nawe 2 rzędy wielkości - rys. \ref{fig:E:time}
\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{semilogyaxis}[
ylabel={norma z residuum}, axis x line = bottom,
xlabel={iteracja}, axis y line = left,
grid=both, width=.7\textwidth
]
\addplot table [x=iter, y=residuum, col sep=comma] {../zadA_residuum_gauss.csv};
\addlegendentry{Gauss-Seidel}
\addplot table [x=iter, y=residuum, col sep=comma] {../zadA_residuum_jacobi.csv};
\addlegendentry{Jacobi}
\end{semilogyaxis}
\end{tikzpicture}
\caption{Zależność normy z residuum od iteracji dla zadania \textbf{A}}
\label{fig:A:residuum}
\end{figure}
\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{semilogyaxis}[
ylabel={norma z residuum}, axis x line = bottom,
xlabel={iteracja}, axis y line = left,
grid=both, width=.7\textwidth, no marks
]
\addplot table [x=iter, y=residuum, col sep=comma] {../zadC_residuum_gauss.csv};
\addlegendentry{Gauss-Seidel}
\addplot table [x=iter, y=residuum, col sep=comma] {../zadC_residuum_jacobi.csv};
\addlegendentry{Jacobi}
\end{semilogyaxis}
\end{tikzpicture}
\caption{Zależność normy z residuum od iteracji dla zadania \textbf{C}}
\label{fig:C:residuum}
\end{figure}
\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{semilogyaxis}[
ylabel={czas [$\si{s}$]}, axis x line = bottom,
xlabel={$N$}, axis y line = left,
grid=both, width=.7\textwidth,
smooth
]
\addplot table [x=n, y=lu, col sep=comma] {../zadE.csv};
\addlegendentry{LU}
\addplot table [x=n, y=gauss, col sep=comma] {../zadE.csv};
\addlegendentry{Gauss-Seidel}
\addplot table [x=n, y=jacobi, col sep=comma] {../zadE.csv};
\addlegendentry{Jacobi}
\end{semilogyaxis}
\end{tikzpicture}
\caption{Zależność czasu od wielkości N}
\label{fig:E:time}
\end{figure}
\end{document}

45
tags Normal file
View File

@ -0,0 +1,45 @@
!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/
!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/
!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/
!_TAG_PROGRAM_NAME Exuberant Ctags //
!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/
!_TAG_PROGRAM_VERSION 5.8 //
IterativeSolver .\solver.h /^IterativeSolver::IterativeSolver() : error(1e-9) {}$/;" f class:IterativeSolver
IterativeSolver .\solver.h /^IterativeSolver::IterativeSolver(double error) : error(error) {}$/;" f class:IterativeSolver
IterativeSolver .\solver.h /^class IterativeSolver : Solver {$/;" c
JacobiSolver .\solver.h /^class JacobiSolver : Solver {$/;" c
Matrix .\matrix.h /^Matrix<T>::Matrix(const Matrix<T> &m) : Matrix(m._rows, m._cols) {$/;" f class:Matrix
Matrix .\matrix.h /^Matrix<T>::Matrix(size_t n) : Matrix(n, n) { }$/;" f class:Matrix
Matrix .\matrix.h /^Matrix<T>::Matrix(size_t n, size_t m) : _rows(n), _cols(m), values(new T[m*n]) {$/;" f class:Matrix
Matrix .\matrix.h /^Matrix<T>::Matrix(std::initializer_list<std::initializer_list<T>> values) : Matrix(values.size(), values.begin()->size()) {$/;" f class:Matrix
Matrix .\matrix.h /^class Matrix {$/;" c
N .\main.cpp /^const size_t N = 10;$/;" v
NORM_INF .\matrix.h 11;" d
P02_MATRIX_H .\matrix.h 2;" d
P02_SOLVER_H .\solver.h 2;" d
Solver .\solver.h /^class Solver {$/;" c
_cols .\matrix.h /^ size_t _rows, _cols;$/;" m class:Matrix
_rows .\matrix.h /^ size_t _rows, _cols;$/;" m class:Matrix
cols .\matrix.h /^inline size_t Matrix<T>::cols() const {$/;" f class:Matrix
diag .\matrix.h /^Matrix<T> Matrix<T>::diag(size_t n, T value, int offset) {$/;" f class:Matrix
error .\solver.h /^ double error;$/;" m class:IterativeSolver
hvec .\matrix.h /^Matrix<T> Matrix<T>::hvec(std::initializer_list<T> values) {$/;" f class:Matrix
iteration .\solver.h /^Matrix<double> JacobiSolver::iteration(const Matrix<double>& M, const Matrix<double>& b, const Matrix<double>& old)$/;" f class:JacobiSolver
main .\main.cpp /^int main(int argc, const char* argv[])$/;" f
noexcept .\matrix.h /^ self_t& operator=(self_t&& rhs) noexcept;$/;" m class:Matrix
norm .\matrix.h /^double norm(const Matrix<T>& matrix, unsigned norm = 2)$/;" f
operator () .\matrix.h /^T &Matrix<T>::operator()(size_t n, size_t m) {$/;" f class:Matrix
operator () .\matrix.h /^T Matrix<T>::operator()(size_t n, size_t m) const {$/;" f class:Matrix
operator * .\matrix.h /^Matrix<T> Matrix<T>::operator*(const Matrix<T> &rhs) {$/;" f class:Matrix
operator * .\matrix.h /^Matrix<T> Matrix<T>::operator*(const T rhs) {$/;" f class:Matrix
operator + .\matrix.h /^Matrix<T> Matrix<T>::operator+(const Matrix<T> &rhs) {$/;" f class:Matrix
operator + .\matrix.h /^Matrix<T> Matrix<T>::operator+(const T rhs) {$/;" f class:Matrix
operator - .\matrix.h /^Matrix<T> Matrix<T>::operator-() {$/;" f class:Matrix
operator - .\matrix.h /^Matrix<T> Matrix<T>::operator-(const Matrix<T>& rhs) {$/;" f class:Matrix
operator << .\matrix.h /^std::ostream &operator<<(std::ostream &os, const Matrix<T> &matrix) {$/;" f
override .\solver.h /^ virtual Matrix<double> solve(const Matrix<double>& M, const Matrix<double>& b) override;$/;" m class:IterativeSolver
prepare .\main.cpp /^std::pair<Matrix<double>, Matrix<double>> prepare(size_t index, size_t n) {$/;" f
residuum .\solver.h /^double residuum(const Matrix<T>& M, const Matrix<T>& b, const Matrix<T>& x)$/;" f
rows .\matrix.h /^inline size_t Matrix<T>::rows() const {$/;" f class:Matrix
solve .\solver.h /^Matrix<double> IterativeSolver::solve(const Matrix<double>& M, const Matrix<double>& b)$/;" f class:IterativeSolver
vvec .\matrix.h /^Matrix<T> Matrix<T>::vvec(std::initializer_list<T> values) {$/;" f class:Matrix