diff --git a/argh.h b/argh.h new file mode 100644 index 0000000..a17a76b --- /dev/null +++ b/argh.h @@ -0,0 +1,401 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +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 + 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 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 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 const& flags() const { return flags_; } + std::map const& params() const { return params_; } + std::vector const& pos_args() const { return pos_args_; } + + // begin() and end() for using range-for over positional args. + std::vector::const_iterator begin() const { return pos_args_.cbegin(); } + std::vector::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 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 + 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 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 + 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 + string_stream operator()(std::initializer_list 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 args_; + std::map params_; + std::vector pos_args_; + std::multiset flags_; + std::set 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 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 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 + 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 + string_stream parser::operator()(std::initializer_list 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 + 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 init_list) + { + for (auto& name : init_list) + registeredParams_.insert(trim_leading_dashes(name)); + } +} + + diff --git a/main.cpp b/main.cpp index ee6f783..8afe23a 100644 --- a/main.cpp +++ b/main.cpp @@ -1,19 +1,29 @@ #include "matrix.h" #include "solver.h" +#include "argh.h" + #include +#include +#include #include -const size_t N = 10; - -std::pair, Matrix> prepare(size_t index, size_t n) +std::pair, Matrix> 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::diag(n, a1) - + Matrix::diag(n, a2, 1) + Matrix::diag(n, a2, -1) - + Matrix::diag(n, a3, 2) + Matrix::diag(n, a3, -2); + auto M = Matrix::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 b(n, 1); for (size_t i = 0; i < n; ++i) { @@ -23,23 +33,87 @@ std::pair, Matrix> prepare(size_t index, size_t n) return std::make_pair(M, b); } +void help(const char* program) +{ + std::cout + << "Usage: " << program << " [options]" << std::endl + << " - size of generated matrix" << std::endl + << " - index used for matrix generation" << std::endl + << " - 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(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 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; } diff --git a/matrix.h b/matrix.h index 6352dfc..5cf9f0a 100644 --- a/matrix.h +++ b/matrix.h @@ -163,12 +163,15 @@ std::ostream &operator<<(std::ostream &os, const Matrix &matrix) { template Matrix Matrix::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; } diff --git a/solver.h b/solver.h index 8b0df6d..36e37e7 100644 --- a/solver.h +++ b/solver.h @@ -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 iteration(const Matrix& M, const Matrix& b, const Matrix& old) = 0; virtual Matrix solve(const Matrix& M, const Matrix& b) override; + + size_t iterations() const; + void output(std::ostream* csv); }; class JacobiSolver : public IterativeSolver { @@ -54,17 +60,35 @@ Matrix IterativeSolver::solve(const Matrix& M, const Matrix 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 JacobiSolver::iteration(const Matrix& M, const Matrix& b, const Matrix& old) { diff --git a/sprawozdanie/sprawozdanie.tex b/sprawozdanie/sprawozdanie.tex new file mode 100644 index 0000000..4ef2263 --- /dev/null +++ b/sprawozdanie/sprawozdanie.tex @@ -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} diff --git a/tags b/tags new file mode 100644 index 0000000..f502222 --- /dev/null +++ b/tags @@ -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::Matrix(const Matrix &m) : Matrix(m._rows, m._cols) {$/;" f class:Matrix +Matrix .\matrix.h /^Matrix::Matrix(size_t n) : Matrix(n, n) { }$/;" f class:Matrix +Matrix .\matrix.h /^Matrix::Matrix(size_t n, size_t m) : _rows(n), _cols(m), values(new T[m*n]) {$/;" f class:Matrix +Matrix .\matrix.h /^Matrix::Matrix(std::initializer_list> 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::cols() const {$/;" f class:Matrix +diag .\matrix.h /^Matrix Matrix::diag(size_t n, T value, int offset) {$/;" f class:Matrix +error .\solver.h /^ double error;$/;" m class:IterativeSolver +hvec .\matrix.h /^Matrix Matrix::hvec(std::initializer_list values) {$/;" f class:Matrix +iteration .\solver.h /^Matrix JacobiSolver::iteration(const Matrix& M, const Matrix& b, const Matrix& 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& matrix, unsigned norm = 2)$/;" f +operator () .\matrix.h /^T &Matrix::operator()(size_t n, size_t m) {$/;" f class:Matrix +operator () .\matrix.h /^T Matrix::operator()(size_t n, size_t m) const {$/;" f class:Matrix +operator * .\matrix.h /^Matrix Matrix::operator*(const Matrix &rhs) {$/;" f class:Matrix +operator * .\matrix.h /^Matrix Matrix::operator*(const T rhs) {$/;" f class:Matrix +operator + .\matrix.h /^Matrix Matrix::operator+(const Matrix &rhs) {$/;" f class:Matrix +operator + .\matrix.h /^Matrix Matrix::operator+(const T rhs) {$/;" f class:Matrix +operator - .\matrix.h /^Matrix Matrix::operator-() {$/;" f class:Matrix +operator - .\matrix.h /^Matrix Matrix::operator-(const Matrix& rhs) {$/;" f class:Matrix +operator << .\matrix.h /^std::ostream &operator<<(std::ostream &os, const Matrix &matrix) {$/;" f +override .\solver.h /^ virtual Matrix solve(const Matrix& M, const Matrix& b) override;$/;" m class:IterativeSolver +prepare .\main.cpp /^std::pair, Matrix> prepare(size_t index, size_t n) {$/;" f +residuum .\solver.h /^double residuum(const Matrix& M, const Matrix& b, const Matrix& x)$/;" f +rows .\matrix.h /^inline size_t Matrix::rows() const {$/;" f class:Matrix +solve .\solver.h /^Matrix IterativeSolver::solve(const Matrix& M, const Matrix& b)$/;" f class:IterativeSolver +vvec .\matrix.h /^Matrix Matrix::vvec(std::initializer_list values) {$/;" f class:Matrix