From ea82a5995b7588eedb45b02ecfa64ec73aa39de7 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sun, 23 Aug 2020 18:03:16 +0200 Subject: [PATCH] Progress --- .../CalcoloNumerico/01_SistemiLineari.js | 4 +- .../CalcoloNumerico/02_ZeriDiFunzione.js | 112 ++++++++++++++++-- 2 files changed, 105 insertions(+), 11 deletions(-) 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