I'm done 😂😂😂😂

2024-11-11 00:40:18 +01:00 · 2024-11-11 00:40:18 +01:00 · d14dc840d1
commit d14dc840d1
parent 278cc7f1fc
7 changed files with 793 additions and 5 deletions
--- a/l2/1.jl
+++ b/l2/1.jl
@ -61,10 +61,10 @@ function sumvectorsdecreasing(x::Vector{T}, y::Vector{T})::T where T <: Abstract
        s[i] = x[i] * y[i]
    end

-    spos::Vector{T} = s[s .> 0]
+    spos::Vector{T} = s[s .> zero(T)]
    sort!(spos, rev = true)

-    sneg::Vector{T} = s[s .<= 0]
+    sneg::Vector{T} = s[s .<= zero(T)]
    sort!(sneg)

    neg::T = zero(T)
@ -99,10 +99,10 @@ function sumvectorsincreasing(x::Vector{T}, y::Vector{T})::T where T <: Abstract
        s[i] = x[i] * y[i]
    end

-    spos::Vector{T} = s[s .> 0]
+    spos::Vector{T} = s[s .> zero(T)]
    sort!(spos)

-    sneg::Vector{T} = s[s .<= 0]
+    sneg::Vector{T} = s[s .<= zero(T)]
    sort!(sneg, rev = true)

    neg::T = zero(T)
--- a/l2/2.jl
+++ b/l2/2.jl
@ -6,7 +6,17 @@ import Pkg
 Pkg.add("Plots")
 using Plots

-f(x::Float64)::Float64 = exp(x) * log(one(Float64) + exp(-x))
+"""
+    f(x::Float64)::Float64 
+
+Calculate `e^x * ln(1 + e^-x)`.
+
+# Arguments
+- `x::Float64`: argument of the function
+"""
+function f(x::Float64)::Float64 
+    return exp(x) * log(one(Float64) + exp(-x))
+end

 x = range(-10, 40, length=1000)
 y = map(x -> f(x), x)
--- a/l2/3.jl
+++ b/l2/3.jl
@ -7,11 +7,28 @@ using LinearAlgebra
 include("hilb.jl")
 include("matcond.jl")

+"""
+Errors of the solutions for a system of linear equations
+for the Gauss and inverse matrix methods.
+
+# Fields
+- `gauss::Float64`: the error for the Gauss method
+- `inverse::Float64`: the error for the inverse matrix method
+"""
 struct Errors
    gauss::Float64
    inverse::Float64
 end

+"""
+    solve(A::Matrix{Float64}, n::Int)::Errors 
+
+Solve the system of linear equations given by the matrix `A`.
+
+# Arguments
+- `A::Matrix{Float64}`: the matrix
+- `n::Int`: size of the matrix
+"""
 function solve(A::Matrix{Float64}, n::Int)::Errors
    x::Vector{Float64} = ones(Float64, n)
    b::Vector{Float64} = A * x
--- a/l2/4.jl
+++ b/l2/4.jl
@ -0,0 +1,61 @@
+#!/usr/bin/env julia
+
+# Jacek Poziemski 272389
+
+import Pkg
+Pkg.add("Polynomials")
+using Polynomials
+
+coefficients::Vector{Float64} = [1, -210.0, 20615.0,-1256850.0,
+         53327946.0,-1672280820.0, 40171771630.0, -756111184500.0,
+         11310276995381.0, -135585182899530.0,
+         1307535010540395.0,     -10142299865511450.0,
+         63030812099294896.0,     -311333643161390640.0,
+         1206647803780373360.0,     -3599979517947607200.0,
+         8037811822645051776.0,      -12870931245150988800.0,
+         13803759753640704000.0,      -8752948036761600000.0,
+         2432902008176640000.0]
+
+polynomial::Polynomial = Polynomial(reverse(coefficients))
+
+polynomialroots::Vector{Float64} = roots(polynomial)
+
+wilkinson::Polynomial = fromroots(polynomialroots)
+
+println("P(n):")
+
+for k in 1:20
+    z_k::Float64 = polynomialroots[k]
+    Pz_k::Float64 = abs(polynomial(z_k))
+    pz_k::Float64 = abs(wilkinson(z_k))
+    error::Float64 = abs(z_k - k)
+    println("k: $k; z_k: $z_k; P(z_k): $Pz_k; p(z_k): $pz_k; error: $error")
+end 
+
+println()
+
+wilkinsoncoefficients::Vector{Float64} = [1, -210.0 - 2.0^(-23.0), 20615.0,-1256850.0,
+         53327946.0,-1672280820.0, 40171771630.0, -756111184500.0,
+         11310276995381.0, -135585182899530.0,
+         1307535010540395.0,     -10142299865511450.0,
+         63030812099294896.0,     -311333643161390640.0,
+         1206647803780373360.0,     -3599979517947607200.0,
+         8037811822645051776.0,      -12870931245150988800.0,
+         13803759753640704000.0,      -8752948036761600000.0,
+         2432902008176640000.0]
+
+polynomialb::Polynomial = Polynomial(reverse(wilkinsoncoefficients))
+
+polynomialbroots::Vector{ComplexF64} = roots(polynomialb)
+
+wilkinsonb::Polynomial = fromroots(polynomialbroots)
+
+println("p(n):")
+
+for k in 1:20
+    z_k::ComplexF64 = polynomialbroots[k]
+    Pz_k::Float64 = abs(polynomialb(z_k))
+    pz_k::Float64 = abs(wilkinsonb(z_k))
+    error::Float64 = abs(z_k - k)
+    println("k: $k; z_k: $z_k; P(z_k): $Pz_k; p(z_k): $pz_k; error: $error")
+end 
--- a/l2/5.jl
+++ b/l2/5.jl
@ -0,0 +1,84 @@
+#!/usr/bin/env julia
+
+# Jacek Poziemski 272389
+
+"""
+    model(r::T, p::T)::T where T <: AbstractFloat 
+
+Calculate `p + rp(1 - p)` on a given IEEE 754 floating point type.
+
+# Arguments
+- `r::T`: the first argument
+- `p::T`: the second argument
+"""
+function model(r::T, p::T)::T where T <: AbstractFloat 
+    return p + r * p * (one(T) - p)
+end
+
+"""
+    iter10trunciter30()::Vector{Float32}
+
+Iterate on the model function 10 times, truncate
+the result and iterate 30 more times.
+"""
+function iter10trunciter30()::Vector{Float32}
+    ret = Vector{Float32}()
+    p::Float32 = 0.01
+    r::Float32 = 3.0
+    push!(ret, p)
+
+    for i in 1:10
+        p = model(r, p)
+        push!(ret, p)
+    end
+
+    p = trunc(p, digits = 3)
+
+    for i in 1:30
+        p = model(r, p)
+        push!(ret, p)
+    end
+
+    return ret
+end
+
+"""
+    iter40(T::Type{<: AbstractFloat})::Vector{T}
+
+Iterate on the model function 40 times.
+
+# Arguments
+- `T::Type{<: AbstractFloat}`: the IEEE 754 floating type to operate on
+"""
+function iter40(T::Type{<: AbstractFloat})::Vector{T}
+    ret = Vector{T}()
+    p::T = 0.01
+    r::T = 3.0
+    push!(ret, p)
+
+    for i in 1:40
+        p = model(r, p)
+        push!(ret, p)
+    end
+
+    return ret
+end
+
+p1::Vector{Float32} = iter40(Float32)
+p2::Vector{Float32} = iter10trunciter30()
+p3::Vector{Float64} = iter40(Float64)
+
+println("1.")
+println()
+
+for n in 1:41
+    println("n: $(n - 1); 40 iter: $(p1[n]); trunc: $(p2[n])")
+end
+
+println()
+println("2.")
+println()
+
+for n in 1:41
+    println("n: $(n - 1); Float32: $(p1[n]); Float64: $(p3[n])")
+end
--- a/l2/6.jl
+++ b/l2/6.jl
@ -0,0 +1,57 @@
+#!/usr/bin/env julia
+
+# Jacek Poziemski 272389
+
+import Pkg
+Pkg.add("Plots")
+using Plots
+
+"""
+    seq(x::Float64, c::Float64)::Float64
+
+Calculate `x^2 + c`.
+
+# Arguments
+- `x::Float64`: the first argument
+- `c::Float64`: the second argument
+"""
+function seq(x::Float64, c::Float64)::Float64
+    return x^2 + c
+end
+
+cs::Vector{Float64} = [-2.0, -2.0, -2.0, -1.0, -1.0, -1.0, -1.0]
+xs::Vector{Float64} = [1.0, 2.0, 1.99999999999999, 1.0, -1.0, 0.75, 0.25]
+
+"""
+    exp(x::Float64, c::Float64)::Vector{Float64}
+
+Iterate over the seq function 40 times.
+
+# Arguments
+- `x::Float64`: the first argument
+- `c::Float64`: the second argument
+"""
+function exp(x::Float64, c::Float64)::Vector{Float64}
+    ret::Vector{Float64} = []
+    push!(ret, x)
+
+    for i in 1:40
+        x = seq(x, c)
+        push!(ret, x)
+    end
+
+    return ret
+end
+
+sequences::Vector{Vector{Float64}} = []
+
+for i in 1:7
+    sequence::Vector{Float64} = exp(xs[i], cs[i])
+    push!(sequences, sequence)
+end
+
+for i in 1:length(sequences)
+    plot(title = "x_n² + c", xlabel = "n", ylabel = "x_n")
+    plot!(0:40, sequences[i], label = "x = $(xs[i]), c = $(cs[i])", lw = 2)
+    png("6.$i.png")
+end
--- a/l2/sprawozdanie.tex
+++ b/l2/sprawozdanie.tex
@ -0,0 +1,559 @@
+\documentclass[a4paper]{article}
+\usepackage[T1]{fontenc}
+\usepackage[polish]{babel}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{adjustbox}
+\usepackage{longtable}
+\usepackage{siunitx}
+\usepackage{graphicx}
+\graphicspath{ {./} }
+
+\title{Obliczenia naukowe – Lista 2}
+\author{Jacek Poziemski 272389}
+\date{10.11.2024}
+\begin{document}
+\maketitle
+
+\textbf{Zad. 1}
+
+Zadanie polega na powtórzeniu zadania 5. z listy 1.
+wprowadzając niewielkie zmiany danych, czyli na
+eksperymentalnym obliczaniu iloczynu skalarnego
+dwóch wektorów na 4 różne sposoby:
+
+\vspace{0.25cm}
+
+(a) w przód – od pierwszego do ostatniego elementu
+
+\vspace{0.25cm}
+
+(b) w tył – od ostatniego do pierwszego elementu
+
+\vspace{0.25cm}
+
+(c) od największego do najmniejszego – liczenie częściowych
+sum elementów dodatnich i ujemnych w porządku malejącym względem
+wartości absolutnej liczb, następnie dodanie do siebie sum częściowych
+
+\vspace{0.25cm}
+
+(d) od największego do najmniejszego – liczenie częściowych
+sum elementów dodatnich i ujemnych w porządku rosnącym względem
+wartości absolutnej liczb, następnie dodanie do siebie sum częściowych
+
+\vspace{0.25cm}
+
+używając typów zmiennopozycyjnych $Float32$ i $Float64$.
+
+\vspace{0.25cm}
+
+Poniżej przedstawiam dane i wyniki dla obu zadań:
+
+\vspace{0.25cm}
+
+Z5/L1:
+
+\begin{gather*}
+    x = [2.718281828, -3.141592654, 1.414213562, \boldsymbol{0.5772156649}, \boldsymbol{0.3010299957}] \\
+    y = [1486.2497, 878366.9879, -22.37492, 4773714.647, 0.000185049]
+\end{gather*}
+
+Poprawna wartość iloczynu skalarnego: $-1.00657107000000 \cdot 10^{-11}$
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|}
+        \hline
+        Sposób & Wynik dla $Float32$ & Wynik dla $Float64$ \\ \hline
+        (a) & -0.4999442994594574 & 1.0251881368296672e-10 \\
+        (b) & -0.454345703125 & -1.5643308870494366e-10 \\
+        (c) & -0.5 & 0.0 \\
+        (d) & -0.5 & 0.0 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+Z1/L2:
+
+\begin{gather*}
+    x = [2.718281828, -3.141592654, 1.414213562, \boldsymbol{0.577215664}, \boldsymbol{0.301029995}] \\
+    y = [1486.2497, 878366.9879, -22.37492, 4773714.647, 0.000185049]
+\end{gather*}
+
+Poprawna wartość iloczynu skalarnego: $-0.004296343192495245$
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|}
+        \hline
+        Sposób & Wynik dla $Float32$ & Wynik dla $Float64$ \\ \hline
+        (a) & -0.4999442994594574 & -0.004296342739891585 \\
+        (b) & -0.454345703125 & -0.004296342998713953 \\
+        (c) & -0.5 & -0.004296342842280865 \\
+        (d) & -0.5 & -0.004296342842280865 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+\vspace{0.25cm}
+
+Wartości dla typu $Float32$ są identyczne do zadania 5. z listy 1.,
+ponieważ zmiany w wartościach są zbyt małe, $Float32$ przez zbyt
+małą precyzję traci cyfry które usunęliśmy z oryginalnych wartości.
+Z kolei zmiana wartości dla typu $Float64$ jest znaczna – wartości
+dla wszystkich sposobów są znacznie bliższe wartości poprawnej.
+Jest tak dlatego, że zadanie jest źle uwarunkowane – przy
+pisaniu go nie wzięto pod uwagę błędów spowodowanych
+przez zbyt małą precyzję typów zmiennopozycyjnych.
+
+\vspace{0.5cm}
+
+\textbf{Zad. 2}
+
+Narysowanie wykresu funkcji $f(x) = e^x\ln(1 + e^{-x})$
+w dwóch programach do wizualizacji, obliczenie granicy funkcji
+$\lim_{x \to \infty} f(x)$, porównanie wykresu z obliczoną granicą.
+
+\vspace{0.25cm}
+
+Do rysowania wykresów wybrałem pakiet $Plots$ z języka Julia i silnik Wolfram Alpha.
+
+\vspace{0.25cm}
+
+Pakiet $Plots$ z języka Julia:
+
+\includegraphics[scale=0.5]{2-julia-plots}
+
+\newpage
+
+Wolfram Alpha:
+
+\includegraphics{2-wolfram}
+
+\vspace{0.25cm}
+
+Granica funkcji dla x dążącego do $\infty$ wynosi $1$.
+
+\vspace{0.25cm}
+
+Algorytm jest niestabilny numerycznie – dla $x \geq 32$
+wykres zaczyna odbiegać coraz bardziej od rzeczywistej
+granicy funkcji, po czym przy wartości około $37$ spada
+do $0$ i tam zostaje. Pierwsze zjawisko występuje z powodu
+eksponencjalnego wzrostu $e^x$ – mnożenie tej wartości z
+$ln(1 + e^{-x})$ powoduje utratę precyzji. $1 + e^{-x}$ wraz
+ze wzrostem $x$ dąży do $1$, przez co logarytm naturalny
+tej wartości dąży do $0$. Przez to najpierw funkcja oscyluje
+wokół $1$, następnie spada do $0$.
+
+\vspace{0.5cm}
+
+\textbf{Zad. 3}
+
+Rozwiązywanie układu równań liniowych $Ax = b$ dla
+macierzy współczynników $A \in \mathbb{R}^{n \times n}$
+i wektora prawych stron $b \in \mathbb{R}^n$.
+Macierze są generowane za pomocą funkcji $hilb(n)$
+(macierz Hilberta stopnia $n$) oraz $matcond(n, c)$
+(macierz losowa stopnia $n$ z zadanym wskaźnikiem
+uwarunkowania $c$). Równanie jest rozwiązywane za
+pomocą eliminacji Gaussa ($x = A \setminus b$)
+oraz macierzy odwrotnej ($x = A^{-1}b$), porównywane
+są wyniki obu sposobów z dokładnym rozwiązaniem, czyli
+$x = (1, ..., 1)^T$, aby uzyskać błędy względne.
+
+\vspace{0.25cm}
+
+Poniżej przedstawiam tabele z wynikami opisanymi powyżej dla macierzy
+Hilberta i losowych. Uwarunkowanie jest liczone za pomocą funkcji
+$cond()$ z pakietu $LinearAlgebra$ języka Julia, rząd jest
+liczony funkcją $rank()$ z tego samego pakietu.
+
+\vspace{0.25cm}
+
+\newpage
+
+Macierze Hilberta:
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|c|c|}
+        \hline
+        n & Uwarunkowanie & Rząd & Błąd metody Gaussa & Błąd metody macierzy odwrotnej \\ \hline
+        1 & 1.0 & 1 & 0.0 & 0.0 \\
+        2 & 19.281470067903967 & 2 & 5.661048867003676e-16 & 1.1240151438116956e-15 \\
+        3 & 524.0567775860627 & 3 & 8.351061872731819e-15 & 9.825526038180824e-15 \\
+        4 & 15513.738738929662 & 4 & 4.2267316576255873e-13 & 3.9600008750140806e-13 \\
+        5 & 476607.2502419338 & 5 & 1.256825919192874e-12 & 8.128168770215688e-12 \\
+        6 & 1.495105864177819e7 & 6 & 1.5435074657413347e-10 & 1.0423794065751672e-10 \\
+        7 & 4.753673568766496e8 & 7 & 6.520804933066021e-9 & 4.3299229851434615e-9 \\
+        8 & 1.5257575563722723e10 & 8 & 3.6010489197068436e-7 & 4.0236799996435915e-7 \\
+        9 & 4.9315332284138226e11 & 9 & 1.3216991540025553e-5 & 1.4626798972086921e-5 \\
+        10 & 1.6024980732174455e13 & 10 & 0.0004194170177181955 & 0.00040714905218460087 \\
+        11 & 5.224780779168285e14 & 10 & 0.01004906783345069 & 0.010645959401385671 \\
+        12 & 1.6425917529444498e16 & 11 & 0.5502106922296848 & 0.6697890564301745 \\
+        13 & 4.4936679531246986e18 & 11 & 70.1556197115221 & 82.66675811171989 \\
+        14 & 3.2198422552156205e17 & 11 & 9.649642437452474 & 10.094732062453225 \\
+        15 & 3.3660126672602944e17 & 12 & 692.4295360390742 & 715.740988667373 \\
+        16 & 2.249940193352714e18 & 12 & 10.414656083840297 & 8.442143351389534 \\
+        17 & 6.26204622473199e17 & 12 & 18.67581817300634 & 17.157982115668773 \\
+        18 & 3.266632306940269e18 & 12 & 5.40548300394664 & 3.742412802776696 \\
+        19 & 3.462302955915255e18 & 13 & 15.073941146224387 & 16.84769281513296 \\
+        20 & 6.806966421072721e18 & 13 & 28.79267493699834 & 30.751202239608727 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+Macierze losowe:
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|c|c|c|}
+        \hline
+        n & c & Uwarunkowanie & Rząd & Błąd metody Gaussa & Błąd metody macierzy odwrotnej \\ \hline
+        5 & $10^0$ & 1.0000000000000007 & 5 & 1.2161883888976234e-16 & 9.930136612989092e-17 \\
+        5 & $10^1$ & 10.000000000000009 & 5 & 1.9229626863835638e-16 & 1.4043333874306804e-16 \\
+        5 & $10^3$ & 999.9999999999479 & 5 & 1.2158944411806644e-14 & 1.7034743437620337e-14 \\
+        5 & $10^7$ & 9.999999998942768e6 & 5 & 3.779858573658035e-11 & 7.001100940383748e-11 \\
+        5 & $10^{12}$ & 1.0000358548219889e12 & 5 & 8.318028330255335e-6 & 2.412626388678268e-6 \\
+        5 & $10^{16}$ & 6.7112223576348e15 & 4 & 0.1468248218117339 & 0.19241602267287927 \\
+        10 & $10^0$ & 1.0000000000000007 & 10 & 3.293453726225543e-16 & 2.248030287623391e-16 \\
+        10 & $10^1$ & 10.000000000000004 & 10 & 2.8737410463596867e-16 & 2.696722356863272e-16 \\
+        10 & $10^3$ & 1000.0000000000464 & 10 & 2.804142933558009e-14 & 3.225353619740909e-14 \\
+        10 & $10^7$ & 1.000000000299259e7 & 10 & 3.9859081581065853e-10 & 4.391207697689116e-10 \\
+        10 & $10^{12}$ & 9.999295565588569e11 & 10 & 3.3540852774047696e-6 & 1.0634644618672672e-5 \\
+        10 & $10^{16}$ & 1.3146979480124638e16 & 9 & 0.009734949899136553 & 0.07859235212474557 \\
+        20 & $10^0$ & 1.0000000000000016 & 20 & 5.438959822042073e-16 & 4.3568297570458958e-16 \\
+        20 & $10^1$ & 9.999999999999996 & 20 & 6.843874359417885e-16 & 6.995286129029383e-16 \\
+        20 & $10^3$ & 1000.0000000000807 & 20 & 9.187657331404228e-15 & 3.275440170573378e-15 \\
+        20 & $10^7$ & 9.99999999397263e6 & 20 & 2.1966900086249582e-10 & 1.7889092637261268e-10 \\
+        20 & $10^{12}$ & 9.999571219238594e11 & 20 & 1.4222130831564009e-5 & 1.374375061162218e-5 \\
+        20 & $10^{16}$ & 2.508476826100777e16 & 19 & 0.06010750951624971 & 0.10225127023966499 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+Dla macierzy Hilberta oraz losowych wraz ze wzrostem uwarunkowania
+wzrasta również błąd dla obu metod. Z tabeli dla macierzy losowych widać
+również, że funkcja $cond()$ nie oblicza dokładnej wartości uwarunkowania,
+lecz jedynie ją przybliża. Dodatkowo wartości przez nią zwracane
+jak i wartości błędów dla obu metod zależą od mikroarchitektury procesora,
+prawdopodobnie ponieważ różne procesory inaczej aproksymują niektóre
+instrukcje assembly x86\_64.
+
+\vspace{0.25cm}
+
+Zadanie ma wysoki wskaźnik uwarunkowania, dla macierzy Hilberta wzrost
+stopnia macierzy mocno wpływa na wskaźnik uwarunkowania i co za tym
+idzie błędy dla obu metod. W macierzach losowych zachodzi to samo
+zjawisko, jednak wzrost błędów jest o wiele wolniejszy i nie monotoniczny.
+
+\vspace{0.5cm}
+
+\textbf{Zad. 4}
+
+Obliczenie pierwiastków $z_k$ ($1 \leq k \leq 20$)
+wielomianu Wilkinsona w postaci naturalnej
+($P(x)$, podana na stronie) i iloczynowej
+($p(x)$, stworzona za pomocą funkcji $fromroots()$)
+oraz obliczenie $|P(z_k)|$, $|p(z_k)|$ i $|z_k - k|$.
+
+\vspace{0.25cm}
+
+Następnie powtórzenie tego eksperymentu, z
+współczynnikiem $-210$ zmienionym na $-210 - 2^{-23}$.
+
+Pierwiastki zostały obliczone za pomocą funkcji $roots()$.
+
+\vspace{0.25cm}
+
+Wyniki dla oryginalnego wielomianu Wilkinsona:
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|c|c|}
+        \hline
+        $k$ & $z_k$ & $|P(z_k)|$ & $|p(z_k)|$ & $|z_k - k|$ \\ \hline
+        1 & 0.9999999999996989 & 35696.50964788257 & 368.50964789367345 & 3.0109248427834245e-13 \\
+        2 & 2.0000000000283182 & 176252.60026668405 & 15996.60026439321 & 2.8318236644508943e-11 \\
+        3 & 2.9999999995920965 & 279157.6968824087 & 100981.69690684375 & 4.0790348876384996e-10 \\
+        4 & 3.9999999837375317 & 3.0271092988991085e6 & 252581.31017303217 & 1.626246826091915e-8 \\
+        5 & 5.000000665769791 & 2.2917473756567076e7 & 152225.31504973918 & 6.657697912970661e-7 \\
+        6 & 5.999989245824773 & 1.2902417284205095e8 & 4.441356137271629e6 & 1.0754175226779239e-5 \\
+        7 & 7.000102002793008 & 4.805112754602064e8 & 4.510025884078405e7 & 0.00010200279300764947 \\
+        8 & 7.999355829607762 & 1.6379520218961136e9 & 2.309311180467704e8 & 0.0006441703922384079 \\
+        9 & 9.002915294362053 & 4.877071372550003e9 & 5.2519713947457147e8 & 0.002915294362052734 \\
+        10 & 9.990413042481725 & 1.3638638195458128e10 & 1.4705597374927537e9 & 0.009586957518274986 \\
+        11 & 11.025022932909318 & 3.585631295130865e10 & 2.257814747009822e9 & 0.025022932909317674 \\
+        12 & 11.953283253846857 & 7.533332360358197e10 & 5.776283226748977e9 & 0.04671674615314281 \\
+        13 & 13.07431403244734 & 1.9605988124330817e11 & 8.720084582957656e8 & 0.07431403244734014 \\
+        14 & 13.914755591802127 & 3.5751347823104315e11 & 2.100530498133618e10 & 0.08524440819787316 \\
+        15 & 15.075493799699476 & 8.21627123645597e11 & 9.0205643837176e10 & 0.07549379969947623 \\
+        16 & 15.946286716607972 & 1.5514978880494067e12 & 1.1093925108150577e11 & 0.05371328339202819 \\
+        17 & 17.025427146237412 & 3.694735918486229e12 & 5.420826950832621e11 & 0.025427146237412046 \\
+        18 & 17.99092135271648 & 7.650109016515867e12 & 2.0817615965429592e12 & 0.009078647283519814 \\
+        19 & 19.00190981829944 & 1.1435273749721195e13 & 4.420887520697798e12 & 0.0019098182994383706 \\
+        20 & 19.999809291236637 & 2.7924106393680727e13 & 3.2780945625202856e12 & 0.00019070876336257925 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+Wyniki dla wielomianu Wilkinsona ze zmienionym współczynnikiem:
+
+\begin{table}[h]
+    \begin{adjustbox}{max width=\textwidth}
+    \begin{tabular}{|c|c|c|c|c|}
+        \hline
+        $k$ & $z_k$ & $|P(z_k)|$ & $|p(z_k)|$ & $|z_k - k|$ \\ \hline
+        1 & 0.9999999999998357 + 0.0i & 20259.872313418207 & 5411.872313429985 & 1.6431300764452317e-13 \\
+        2 & 2.0000000000550373 + 0.0i & 346541.4137593836 & 65453.413724836006 & 5.503730804434781e-11 \\
+        3 & 2.99999999660342 + 0.0i & 2.2580597001197007e6 & 447115.71016096906 & 3.3965799062229962e-9 \\
+        4 & 4.000000089724362 + 0.0i & 1.0542631790395478e7 & 2.0101490631149793e6 & 8.972436216225788e-8 \\
+        5 & 4.99999857388791 + 0.0i & 3.757830916585153e7 & 1.0452670578285774e7 & 1.4261120897529622e-6 \\
+        6 & 6.000020476673031 + 0.0i & 1.3140943325569446e8 & 5.2837387075878106e7 & 2.0476673030955794e-5 \\
+        7 & 6.99960207042242 + 0.0i & 3.939355874647618e8 & 1.3630697385185716e8 & 0.00039792957757978087 \\
+        8 & 8.007772029099446 + 0.0i & 1.184986961371896e9 & 5.478192020926859e8 & 0.007772029099445632 \\
+        9 & 8.915816367932559 + 0.0i & 2.2255221233077707e9 & 1.2795423874534175e9 & 0.0841836320674414 \\
+        10 & 10.095455630535774 - 0.6449328236240688i & 1.0677921232930157e10 & 1.8009361907024696e9 & 0.6519586830380407 \\
+        11 & 10.095455630535774 + 0.6449328236240688i & 1.0677921232930157e10 & 1.8009361907024696e9 & 1.1109180272716561 \\
+        12 & 11.793890586174369 - 1.6524771364075785i & 3.1401962344429485e10 & 8.297365882456215e9 & 1.665281290598479 \\
+        13 & 11.793890586174369 + 1.6524771364075785i & 3.1401962344429485e10 & 8.297365882456215e9 & 2.0458202766784277 \\
+        14 & 13.992406684487216 - 2.5188244257108443i & 2.157665405951858e11 & 6.221054312666306e10 & 2.518835871190904 \\
+        15 & 13.992406684487216 + 2.5188244257108443i & 2.157665405951858e11 & 6.221054312666306e10 & 2.7128805312847097 \\
+        16 & 16.73074487979267 - 2.812624896721978i & 4.850110893921027e11 & 5.844684792788262e11 & 2.9060018735375106 \\
+        17 & 16.73074487979267 + 2.812624896721978i & 4.850110893921027e11 & 5.844684792788262e11 & 2.825483521349608 \\
+        18 & 19.5024423688181 - 1.940331978642903i & 4.557199223869993e12 & 2.209747866910055e12 & 2.4540214463129764 \\
+        19 & 19.5024423688181 + 1.940331978642903i & 4.557199223869993e12 & 2.209747866910055e12 & 2.0043294443099486 \\
+        20 & 20.84691021519479 + 0.0i & 8.756386551865696e12 & 2.2517830621461324e13 & 0.8469102151947894 \\
+        \hline
+    \end{tabular}
+    \end{adjustbox}
+\end{table}
+
+Dla wielomianu bez modyfikacji pierwiastki mają wartości zbliżone
+rzeczywistym, jednak nie dokładne. Te błędne wartości oczywiście
+powodują błędy w wartościach obu wielomianów
+dla tych pierwiastków – $P(z_k)$ i $p(z_k)$.
+
+\vspace{0.25cm}
+
+Zmiana współczynnika $-210$ na $-210 - 2^{-23}$ powoduje przejście
+pierwiastków od 10 do 19 z $\mathbb{R}$ do $\mathbb{C}$. Wszystkie
+pierwiastki w zmodyfikowanym wielomianie odbiegają o wiele mocniej
+od ich rzeczywistych wartości, szczególnie te, które są zespolone.
+Na nich widać również, że nie są rozmieszczone równomiernie, tak
+jak dla oryginalnego wielomianu. Tak jak w poprzednich zadaniach,
+to jest źle uwarunkowane.
+
+\vspace{0.5cm}
+
+\textbf{Zad. 5}
+
+Rozważamy równanie rekurencyjne
+$p_{n + 1} := p_n + rp_n(1 - p_n)$ dla $n = 0, 1, ...$.
+
+\vspace{0.25cm}
+
+Dla $p_0 = 0.01$ i $r = 3$ przeprowadzamy następujące eksperymenty:
+
+\vspace{0.25cm}
+
+1. Dla arytmetyki $Float32$ wykonujemy 40 iteracji
+równania, następnie wykonujemy 10 iteracji,
+obcinamy liczbę w tej iteracji do 3 miejsca po
+przecinku po czym wykonujemy kolejne 30 iteracji.
+
+\vspace{0.25cm}
+
+2. Tak jak wyżej wykonujemy 40 iteracji, porównujemy
+wyniki dla arytmetyki $Float32$ i $Float64$.
+
+\vspace{0.25cm}
+
+Eksperyment 1:
+
+\begin{longtable}{|c|c|c|}
+    \hline
+    $n$ & 40 iteracji & trunc \\ \hline
+    0 & 0.01 & 0.01 \\
+    1 & 0.0397 & 0.0397 \\
+    2 & 0.15407173 & 0.15407173 \\
+    3 & 0.5450726 & 0.5450726 \\
+    4 & 1.2889781 & 1.2889781 \\
+    5 & 0.1715188 & 0.1715188 \\
+    6 & 0.5978191 & 0.5978191 \\
+    7 & 1.3191134 & 1.3191134 \\
+    8 & 0.056273222 & 0.056273222 \\
+    9 & 0.21559286 & 0.21559286 \\
+    10 & 0.7229306 & 0.7229306 \\
+    11 & 1.3238364 & 1.3241479 \\
+    12 & 0.037716985 & 0.036488414 \\
+    13 & 0.14660022 & 0.14195944 \\
+    14 & 0.521926 & 0.50738037 \\
+    15 & 1.2704837 & 1.2572169 \\
+    16 & 0.2395482 & 0.28708452 \\
+    17 & 0.7860428 & 0.9010855 \\
+    18 & 1.2905813 & 1.1684768 \\
+    19 & 0.16552472 & 0.577893 \\
+    20 & 0.5799036 & 1.3096911 \\
+    21 & 1.3107498 & 0.09289217 \\
+    22 & 0.088804245 & 0.34568182 \\
+    23 & 0.3315584 & 1.0242395 \\
+    24 & 0.9964407 & 0.94975823 \\
+    25 & 1.0070806 & 1.0929108 \\
+    26 & 0.9856885 & 0.7882812 \\
+    27 & 1.0280086 & 1.2889631 \\
+    28 & 0.9416294 & 0.17157483 \\
+    29 & 1.1065198 & 0.59798557 \\
+    30 & 0.7529209 & 1.3191822 \\
+    31 & 1.3110139 & 0.05600393 \\
+    32 & 0.0877831 & 0.21460639 \\
+    33 & 0.3280148 & 0.7202578 \\
+    34 & 0.9892781 & 1.3247173 \\
+    35 & 1.021099 & 0.034241438 \\
+    36 & 0.95646656 & 0.13344833 \\
+    37 & 1.0813814 & 0.48036796 \\
+    38 & 0.81736827 & 1.2292118 \\
+    39 & 1.2652004 & 0.3839622 \\
+    40 & 0.25860548 & 1.093568 \\
+    \hline
+\end{longtable}
+
+Eksperyment 2:
+
+\begin{longtable}{|c|c|c|}
+    \hline
+    $n$ & $Float32$ & $Float64$ \\ \hline
+    0 & 0.01 & 0.01 \\
+    1 & 0.0397 & 0.0397 \\
+    2 & 0.15407173 & 0.15407173000000002 \\
+    3 & 0.5450726 & 0.5450726260444213 \\
+    4 & 1.2889781 & 1.2889780011888006 \\
+    5 & 0.1715188 & 0.17151914210917552 \\
+    6 & 0.5978191 & 0.5978201201070994 \\
+    7 & 1.3191134 & 1.3191137924137974 \\
+    8 & 0.056273222 & 0.056271577646256565 \\
+    9 & 0.21559286 & 0.21558683923263022 \\
+    10 & 0.7229306 & 0.722914301179573 \\
+    11 & 1.3238364 & 1.3238419441684408 \\
+    12 & 0.037716985 & 0.03769529725473175 \\
+    13 & 0.14660022 & 0.14651838271355924 \\
+    14 & 0.521926 & 0.521670621435246 \\
+    15 & 1.2704837 & 1.2702617739350768 \\
+    16 & 0.2395482 & 0.24035217277824272 \\
+    17 & 0.7860428 & 0.7881011902353041 \\
+    18 & 1.2905813 & 1.2890943027903075 \\
+    19 & 0.16552472 & 0.17108484670194324 \\
+    20 & 0.5799036 & 0.5965293124946907 \\
+    21 & 1.3107498 & 1.3185755879825978 \\
+    22 & 0.088804245 & 0.058377608259430724 \\
+    23 & 0.3315584 & 0.22328659759944824 \\
+    24 & 0.9964407 & 0.7435756763951792 \\
+    25 & 1.0070806 & 1.315588346001072 \\
+    26 & 0.9856885 & 0.07003529560277899 \\
+    27 & 1.0280086 & 0.26542635452061003 \\
+    28 & 0.9416294 & 0.8503519690601384 \\
+    29 & 1.1065198 & 1.2321124623871897 \\
+    30 & 0.7529209 & 0.37414648963928676 \\
+    31 & 1.3110139 & 1.0766291714289444 \\
+    32 & 0.0877831 & 0.8291255674004515 \\
+    33 & 0.3280148 & 1.2541546500504441 \\
+    34 & 0.9892781 & 0.29790694147232066 \\
+    35 & 1.021099 & 0.9253821285571046 \\
+    36 & 0.95646656 & 1.1325322626697856 \\
+    37 & 1.0813814 & 0.6822410727153098 \\
+    38 & 0.81736827 & 1.3326056469620293 \\
+    39 & 1.2652004 & 0.0029091569028512065 \\
+    40 & 0.25860548 & 0.011611238029748606 \\
+    \hline
+\end{longtable}
+
+W pierwszym eksperymencie ostateczna wartość po obcięciu
+wyniku po 10 iteracji jest około 4 razy większa od
+wartości otrzymanej po wykonaniu 40 iteracji bez zmian.
+
+\vspace{0.25cm}
+
+W drugim eksperymencie wykorzystanie arytmetyki $Float64$
+po 40 iteracjach dało nam wartość około 25 razy
+mniejszą od tej uzyskanej w arytmetyce $Float32$.
+
+\vspace{0.25cm}
+
+Oba eksperymenty wskazują na złe uwarunkowanie
+zadania, wyniki są bardzo czułe na utratę precyzji.
+
+\vspace{0.5cm}
+
+\textbf{Zad. 6}
+
+Rozważamy równanie rekurencyjne
+$x_{n + 1} := x_n^2 + c$ dla $n = 0, 1, ...$,
+gdzie $c$ jest stałą.
+
+\vspace{0.25cm}
+
+Wykonujemy 40 iteracji równania dla następujących danych:
+
+\vspace{0.25cm}
+
+1. $c = -2$ i $x_0 = 1$
+
+\includegraphics[scale=0.3]{6.1}
+
+2. $c = -2$ i $x_0 = 2$
+
+\includegraphics[scale=0.3]{6.2}
+
+3. $c = -2$ i $x_0 = 1.99999999999999$
+
+\includegraphics[scale=0.3]{6.3}
+
+4. $c = -1$ i $x_0 = 1$
+
+\includegraphics[scale=0.3]{6.4}
+
+5. $c = -1$ i $x_0 = -1$
+
+\includegraphics[scale=0.3]{6.5}
+
+6. $c = -1$ i $x_0 = 0.75$
+
+\includegraphics[scale=0.3]{6.6}
+
+7. $c = -1$ i $x_0 = 0.25$
+
+\includegraphics[scale=0.3]{6.7}
+
+\vspace{0.25cm}
+
+Wykresy 1. i 2. są stałe, na 3. wykresie początkowo otrzymujemy
+2, ale koło wartości 21 zaczynają się pojawiać dość duże błędy.
+Wartość kilkukrotnie zbliża się, lecz nigdy nie osiąga 2.
+Przez $x_0$ bardzo bliski 2, lecz nie równy błąd staje się
+coraz większy aż w końcu powoduje spadek wartości. Gdy $x_0$ jest
+liczbą całkowitą wyniki są zgodne z oczekiwaniami.
+
+\vspace{0.25cm}
+
+Na wykresach 4. i 5. wyniki oscylują wokół oczekiwanych wartości.
+Wykresy 6. i 7. po krótkim czasie zaczynają na zmianę przyjmować wartości -1 i 0.
+
+\vspace{0.5cm}
+
+\textbf{Wnioski z listy}
+
+Zadania były źle uwarunkowane, czyli bardzo czułe na
+utratę precyzji z powodu nieuwzględnienia rzędu wielkości
+wyników. Przy pracy z liczbami zmiennoprzecinkowymi należy
+pamiętać, aby dobrać odpowiedni typ do rozmiaru danych, z którymi
+pracujemy oraz o błędach wynikających z operacji na tych liczbach.
+
+\end{document}