diff --git a/src/routes/CalcoloNumerico/01_SistemiLineari.js b/src/routes/CalcoloNumerico/01_SistemiLineari.js
index 6d97891..f7ac393 100644
--- a/src/routes/CalcoloNumerico/01_SistemiLineari.js
+++ b/src/routes/CalcoloNumerico/01_SistemiLineari.js
@@ -256,14 +256,14 @@ export default function (props) {
È particolarmente utile perchè ci permette di definire un algoritmo ricorsivo che trovi {r`x`}:
- {r`x^{(i+1)} = G \cdot x^{(i)} + c`}
+ {r`x_{(i+1)} = G \cdot x_{(i)} + c`}
{r`G`} è il metodo, e in base ad esso cambiano stabilità e velocità di convergenza.
Ponendo {r`A = M - N`}, la formula può essere scritta anche in questo modo:
- {r`M \cdot x^{(i+1)} = N \cdot x^{(i)} + b`}
+ {r`M \cdot x_{(i+1)} = N \cdot x_{(i)} + b`}
Possiamo ottenere alcuni metodi separando A in tre matrici:
diff --git a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js
index bbc35c6..03dec7d 100644
--- a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js
+++ b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js
@@ -1,6 +1,7 @@
import style from "./02_ZeriDiFunzione.less";
import {Fragment} from "preact";
import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib";
+import Example from "../../components/Example";
const r = String.raw;
@@ -17,14 +18,29 @@ export default function (props) {
Per il teorema del valore medio, se {r`f(a) \cdot f(b) \leq 0`}, allora esiste sicuramente un punto in cui la funzione vale 0.
- Denominiamo il punto in cui la funzione vale 0 come {r`x^*`}.
+ Denominiamo il punto in cui la funzione vale 0 come {r`x_{(*)}`}.
Più la derivata prima della funzione si avvicina allo 0, peggio il problema sarà condizionato.
- {r`f'(x^*) \simeq 0 \implies mal\ condizionato`}
+ {r`f'(x_{(*)}) \simeq 0 \implies mal\ condizionato`}
+
+
+
+
+
+ Indice {r`{\color{Orange} p}`} di quanto in fretta una successione converge alla soluzione.
+
+ {r`\lim_{i \to +\infty} \frac{ \left| x_{(i+1)} - x_{(*)} \right| }{ \left| x_{(k)} - x_{(*)} \right|^{\color{Orange} p}}`}
+
+ - Convergenza lineare: {r`p = 1`} e {r`0 < C < 1`}
+ - Convergenza superlineare: {r`p = 1`} e {r`C = 0`}
+ - Convergenza quadratica: {r`p = 2`} e {r`0 < C < 1`}
+ - Convergenza superquadratica: {r`p = 2`} e {r`C = 0`}
+ - ...
+
@@ -38,31 +54,109 @@ export default function (props) {
Richiedono una valutazione di funzione non-lineare ad ogni iterazione.
-
-
- Sono metodi iterativi che sfruttano la derivabilità della funzione per ottenere velocità di convergenza più alte, a costo di maggiore complessità computazionale.
+ Hanno convergenza lineare.
- Sono metodi iterativi che TODO
+ Sono metodi iterativi che funzionano in modo molto simile ai metodi iterativi per i sistemi lineari, utilizzando una funzione {r`\phi`} come "metodo".
+
+ {r`x = x - \phi(x) \cdot f(x)`}
+
+ Che diventa:
+
+ {r`x_{(k+1)} = g( x_{(k)} )`}
+
+ Sfruttano i punti fissi {r`g(x_{(*)}) = x_{(*)}`} della funzione per convergere.
- TODO
+
+ Calcoliamo il punto medio dell'intervallo {r`[a_{(n)}, b_{(n)}]`}:
+
+ {r`c_{(n)} = a_{(n)} + \frac{b_{(n)} - a_{(n)}}{2}`}
+
+ Dividiamo l'intervallo in due parti, separate da {r`c_{(n)}`}:
+
+
+ - {r`[a_{(n)}, c_{(n)}]`} è la metà sinistra
+ - {r`[c_{(n)}, b_{(n)}]`} è la metà destra
+
+
+ Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}.
+
+
+ La dimensione dell'intervallo all'iterazione i è nota:
+
+ {r`b_{(i)} - a_{(i)} = \frac{b - a}{2^{i - 1}}`}
+
+ Il numero di iterazioni necessarie per soddisfare la tolleranza \tau sarà quindi:
+
+ {r`i \geq \log_2 \left( \frac{b - a}{\tau} \right)`}
+
+ Dividi l'intervallo {r`[a, b]`} in tante parti grandi quanto la tolleranza. L'algoritmo di bisezione ne escluderà metà ad ogni iterazione; la tolleranza sarà raggiunta quando rimarrà una parte sola!
+
+
+ Ha quindi convergenza lineare ({r`C = \frac{1}{2}`}).
+
- TODO
+
+ Calcoliamo l'intersezione tra la retta che congiunge i due estremi {r`a_{(n)}, b_{(n)}`} e l'asse X:
+
+ {r`c_{(n)} = b_{(n)} - \frac{f(b_{(n)})}{\frac{f(b_{(n)}) - f(a_{(n)})}{b_{(n)} - a_{(n)}}}`}
+
+ Dividiamo l'intervallo in due parti, separate da {r`c_{(n)}`}:
+
+
+ - {r`[a_{(n)}, c_{(n)}]`} è la parte sinistra
+ - {r`[c_{(n)}, b_{(n)}]`} è la parte destra
+
+
+ Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}.
+
+
+ La dimensione dell'intervallo all'iterazione {r`i`} non è nota, ma:
+
+ {r`b_{(i)} - a_{(i)} \leq \frac{b - a}{2^{i - 1}}`}
+
+ Il numero di iterazioni necessarie per soddisfare la tolleranza \tau sarà quindi:
+
+ {r`i \geq \log_2 \left( \frac{b - a}{\tau} \right)`}
+
+ Dividi l'intervallo {r`[a, b]`} in tante parti grandi quanto la tolleranza. L'algoritmo di bisezione ne escluderà almeno metà ad ogni iterazione; la tolleranza sarà raggiunta quando rimarrà una parte sola!
+
+
+ Ha quindi convergenza lineare ({r`C = \frac{1}{2}`}).
+
- TODO
+
+ Se {r`\forall x \in [a, b], \phi(x) \neq 0`}, allora i punti fissi della funzione {r`g`} coincideranno con gli zeri.
+
+ {r`g(x) = x - \phi(x) \cdot f(x)`}
+
+ È possibile avvicinarsi sempre di più ai punti fissi utilizzando TODO
+
+
+ Sfrutta la continuità delle funzioni per ottenere una convergenza di ordine più alto.
+
+ {r`\phi (x) = \frac{1}{f' (x)}`}
+
+ Geometricamente, corrisponde a prolungare una retta nel punto {r`(x, f(x))`} con pendenza {r`f'(x)`}, e prendendo come nuovo punto l'intersezione con l'asse X.
+
+
+ Ha costo computazionale di 4 valutazioni di funzioni e convergenza quadratica.
+
+
+
TODO