mirror of
https://github.com/Steffo99/unisteffo.git
synced 2024-11-26 01:44:20 +00:00
Fix some more stuff
This commit is contained in:
parent
28922b1a3c
commit
f8ded5004c
14 changed files with 248 additions and 135 deletions
|
|
@ -642,10 +642,6 @@ export default function (props) {
|
|||
Se è valida questa proprietà, si può dimostrare che l'<b>energia del sistema è sempre
|
||||
decrescente</b>, e che quindi che tenderà a un punto fisso!
|
||||
</p>
|
||||
<p>
|
||||
<Todo>TODO: Dopo il prof dimostra la relazione tra input netto e overlap, e che il sistema
|
||||
converge al pattern più simile.</Todo>
|
||||
</p>
|
||||
</Panel>
|
||||
<Panel title={"Overlap di due pattern"}>
|
||||
<p>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
import style from "./00_Intro.less"
|
||||
import {ILatex, Panel, PLatex, Section} from "bluelib";
|
||||
import Link from "../../components/Link";
|
||||
import MenuList from "../../components/MenuList";
|
||||
|
|
@ -30,23 +29,29 @@ export default function () {
|
|||
<Section title={"Informazioni"}>
|
||||
<Panel title={"Ripasso di Algebra Lineare"}>
|
||||
<p>
|
||||
Prima di iniziare a studiare Calcolo Numerico, potrebbe essere una buona idea ripassare un pochino Algebra Lineare:
|
||||
Prima di iniziare a studiare Calcolo Numerico, potrebbe essere una buona idea ripassare un
|
||||
pochino Algebra Lineare:
|
||||
</p>
|
||||
<MenuList>
|
||||
<li>
|
||||
<a href={"/calcolonumerico/ripassodialgebralineare"}>Ripasso di Algebra Lineare</a> <small>(per studenti sperduti di Calcolo Numerico)</small>
|
||||
<a href={"/calcolonumerico/ripassodialgebralineare"}>Ripasso di Algebra Lineare</a> <small>(per
|
||||
studenti sperduti di Calcolo Numerico)</small>
|
||||
</li>
|
||||
</MenuList>
|
||||
</Panel>
|
||||
<Panel title={"Anki"}>
|
||||
<p>
|
||||
Ho provato a fare un deck <Link href={"https://apps.ankiweb.net/"}>Anki</Link> con tutte le formule di Calcolo numerico.
|
||||
Ho provato a fare un deck <Link href={"https://apps.ankiweb.net/"}>Anki</Link> con tutte le
|
||||
formule di Calcolo numerico.
|
||||
</p>
|
||||
<p>
|
||||
Sappiatemi dire com'è! <small>Io non l'ho usato moltissimo perchè ho studiato scrivendo questa pagina di Appuntiweb...</small>
|
||||
Sappiatemi dire com'è! <small>Io non l'ho usato moltissimo perchè ho studiato scrivendo questa
|
||||
pagina di Appuntiweb...</small>
|
||||
</p>
|
||||
<MenuList>
|
||||
<li><Link href={"https://ryg.s3.fr-par.scw.cloud/builds/anki-decks/formule-di-calcolo-numerico.apkg"}>Scarica il deck Anki</Link></li>
|
||||
<li><Link
|
||||
href={"https://ryg.s3.fr-par.scw.cloud/builds/anki-decks/formule-di-calcolo-numerico.apkg"}>Scarica
|
||||
il deck Anki</Link></li>
|
||||
</MenuList>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
@ -120,7 +125,8 @@ export default function () {
|
|||
<Section>
|
||||
<Panel title={"Precisione di macchina"}>
|
||||
<p>
|
||||
Un numero reale rappresentato in <b>virgola mobile</b> ha un <b>errore relativo</b> minore o uguale alla <i>precisione
|
||||
Un numero reale rappresentato in <b>virgola mobile</b> ha un <b>errore relativo</b> minore o
|
||||
uguale alla <i>precisione
|
||||
di macchina</i>:
|
||||
</p>
|
||||
<p>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
import style from "./01_SistemiLineari.less"
|
||||
import {ILatex, Panel, PLatex, Section, Todo} from "bluelib";
|
||||
import Link from "../../components/Link";
|
||||
import Example from "../../components/Example";
|
||||
|
|
@ -16,7 +15,9 @@ export default function () {
|
|||
Dato un sistema di equazioni lineari, si vuole trovare la sua soluzione.
|
||||
</p>
|
||||
<p>
|
||||
In forma matriciale, avrà una <b>matrice dei coefficienti</b> <ILatex>{r`A`}</ILatex>, un <b>vettore dei termini noti</b> <ILatex>{r`b`}</ILatex> e un <b>vettore delle incognite</b> <ILatex>{r`x`}</ILatex>.
|
||||
In forma matriciale, avrà una <b>matrice dei coefficienti</b> <ILatex>{r`A`}</ILatex>, un <b>vettore
|
||||
dei termini noti</b> <ILatex>{r`b`}</ILatex> e un <b>vettore delle incognite</b>
|
||||
<ILatex>{r`x`}</ILatex>.
|
||||
</p>
|
||||
<p>
|
||||
L'equazione matriciale del sistema è:
|
||||
|
|
@ -39,10 +40,12 @@ export default function () {
|
|||
<Section>
|
||||
<Panel title={"Metodi diretti"}>
|
||||
<p>
|
||||
Metodi che trovano la soluzione esatta<abbr title={"Per quanto possibile nell'algebra di macchina."}>*</abbr> di un sistema lineare.
|
||||
Metodi che trovano la soluzione esatta<abbr
|
||||
title={"Per quanto possibile nell'algebra di macchina."}>*</abbr> di un sistema lineare.
|
||||
</p>
|
||||
<p>
|
||||
Tipicamente prevedono la <b>fattorizzazione</b> della matrice dei coefficienti in due sottomatrici più facili da risolvere.
|
||||
Tipicamente prevedono la <b>fattorizzazione</b> della matrice dei coefficienti in due
|
||||
sottomatrici più facili da risolvere.
|
||||
</p>
|
||||
<p>
|
||||
Generalmente hanno una complessità temporale <ILatex>{r`O(n^3)`}</ILatex>.
|
||||
|
|
@ -50,10 +53,13 @@ export default function () {
|
|||
</Panel>
|
||||
<Panel title={"Metodi iterativi"}>
|
||||
<p>
|
||||
Metodi che trovano una soluzione imperfetta<abbr title={"Che però può essere la migliore ottenibile, considerando la precisione di macchina."}>*</abbr> di un sistema lineare.
|
||||
Metodi che trovano una soluzione imperfetta<abbr
|
||||
title={"Che però può essere la migliore ottenibile, considerando la precisione di macchina."}>*</abbr> di
|
||||
un sistema lineare.
|
||||
</p>
|
||||
<p>
|
||||
Tipicamente prevedono l'applicazione ripetuta di un <b>metodo</b>, in base al quale cambia la <b>velocità di convergenza</b> alla soluzione.
|
||||
Tipicamente prevedono l'applicazione ripetuta di un <b>metodo</b>, in base al quale cambia
|
||||
la <b>velocità di convergenza</b> alla soluzione.
|
||||
</p>
|
||||
<p>
|
||||
Generalmente hanno una complessità temporale <ILatex>{r`O(n^2)`}</ILatex>.
|
||||
|
|
@ -63,13 +69,17 @@ export default function () {
|
|||
<Section title={"Metodi diretti"}>
|
||||
<Panel title={"Divisione"}>
|
||||
<p>
|
||||
Se la matrice dei coefficienti del sistema è <b>diagonale</b>, allora è possibile trovare la soluzione <i>dividendo</i> ogni termine noto per l'unico coefficiente diverso da zero presente nella sua riga:
|
||||
Se la matrice dei coefficienti del sistema è <b>diagonale</b>, allora è possibile trovare la
|
||||
soluzione <i>dividendo</i> ogni termine noto per l'unico coefficiente diverso da zero presente
|
||||
nella sua riga:
|
||||
</p>
|
||||
<PLatex>{r`x_i = \frac{b_i}{A_{ii}}`}</PLatex>
|
||||
</Panel>
|
||||
<Panel title={"Sostituzione"}>
|
||||
<p>
|
||||
Se la matrice dei coefficienti del sistema è <b>triangolare</b> inferiore o superiore, allora è possibile trovare la soluzione effettuando una <i>sostituzione</i> all'avanti oppure all'indietro:
|
||||
Se la matrice dei coefficienti del sistema è <b>triangolare</b> inferiore o superiore, allora è
|
||||
possibile trovare la soluzione effettuando una <i>sostituzione</i> all'avanti oppure
|
||||
all'indietro:
|
||||
</p>
|
||||
<PLatex>{r`x_i = \frac{b_i - \sum_{k = 1}^{i - 1} (x_k \cdot A_{ik})}{A_{ii}}`}</PLatex>
|
||||
<PLatex>{r`x_i = \frac{b_i - \sum_{k = i - 1}^{n} (x_k \cdot A_{ik})}{A_{ii}}`}</PLatex>
|
||||
|
|
@ -78,7 +88,10 @@ export default function () {
|
|||
<Section>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LU`}</ILatex></span>}>
|
||||
<p>
|
||||
Se tutti i valori sulla diagonale di <ILatex>{r`A`}</ILatex> sono <b>diversi da 0 <small>(eccetto l'ultimo)</small></b> allora è possibile <i>fattorizzarla</i> in due matrici: una <ILatex>{r`L`}</ILatex> <b>triangolare inferiore</b>, e una <ILatex>{r`U`}</ILatex> <b>triangolare superiore</b>.
|
||||
Se tutti i valori sulla diagonale di <ILatex>{r`A`}</ILatex> sono <b>diversi da 0 <small>(eccetto
|
||||
l'ultimo)</small></b> allora è possibile <i>fattorizzarla</i> in due matrici:
|
||||
una <ILatex>{r`L`}</ILatex> <b>triangolare inferiore</b>, e una <ILatex>{r`U`}</ILatex> <b>triangolare
|
||||
superiore</b>.
|
||||
</p>
|
||||
<PLatex>{r`A = L \cdot U`}</PLatex>
|
||||
<Example>
|
||||
|
|
@ -109,7 +122,8 @@ export default function () {
|
|||
È la parte triangolare superiore di <ILatex>{r`A`}</ILatex>!
|
||||
</Example>
|
||||
<p>
|
||||
Il sistema può essere poi risolto applicando due volte il metodo di sostituzione (all'avanti e all'indietro):
|
||||
Il sistema può essere poi risolto applicando due volte il metodo di sostituzione (all'avanti e
|
||||
all'indietro):
|
||||
</p>
|
||||
<PLatex>{r`
|
||||
\begin{cases}
|
||||
|
|
@ -124,17 +138,21 @@ export default function () {
|
|||
</Panel>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LU`}</ILatex> con pivoting parziale</span>}>
|
||||
<p>
|
||||
È possibile applicare la fattorizzazione <ILatex>{r`LU`}</ILatex> a <b>qualsiasi matrice non-singolare</b> permettendo lo scambio (<i>pivoting</i>) delle righe, potenzialmente <b>aumentando la stabilità</b> dell'algoritmo.
|
||||
È possibile applicare la fattorizzazione <ILatex>{r`LU`}</ILatex> a <b>qualsiasi matrice
|
||||
non-singolare</b> permettendo lo scambio (<i>pivoting</i>) delle righe, potenzialmente <b>aumentando
|
||||
la stabilità</b> dell'algoritmo.
|
||||
</p>
|
||||
<Example>
|
||||
Abbiamo fatto questo metodo in Algebra Lineare, chiamandolo <b>metodo di Gauss-Jordan</b>!
|
||||
</Example>
|
||||
<p>
|
||||
Alla formula precedente si aggiunge una <b>matrice di permutazione</b> che indica quali righe sono state scambiate:
|
||||
Alla formula precedente si aggiunge una <b>matrice di permutazione</b> che indica quali righe
|
||||
sono state scambiate:
|
||||
</p>
|
||||
<PLatex>{r`P \cdot A = L \cdot U`}</PLatex>
|
||||
<p>
|
||||
Per massimizzare la stabilità, si cerca di <b>usare come perno l'elemento più grande</b> della colonna.
|
||||
Per massimizzare la stabilità, si cerca di <b>usare come perno l'elemento più grande</b> della
|
||||
colonna.
|
||||
</p>
|
||||
<p>
|
||||
Questo metodo ha costo computazionale:
|
||||
|
|
@ -143,11 +161,13 @@ export default function () {
|
|||
</Panel>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LU`}</ILatex> con pivoting totale</span>}>
|
||||
<p>
|
||||
È possibile anche permettere il <i>pivoting</i> <b>sulle colonne</b> per <b>aumentare ulteriormente la stabilità</b> dell'algoritmo, a costo di maggiore costo computazionale:
|
||||
È possibile anche permettere il <i>pivoting</i> <b>sulle colonne</b> per <b>aumentare
|
||||
ulteriormente la stabilità</b> dell'algoritmo, a costo di maggiore costo computazionale:
|
||||
</p>
|
||||
<PLatex>{r`P \cdot A \cdot Q = L \cdot U`}</PLatex>
|
||||
<p>
|
||||
Per massimizzare la stabilità, si cerca di <b>ordinare in modo decrescente la diagonale</b>, assicurandoci che il primo perno sia più grande del secondo e così via.
|
||||
Per massimizzare la stabilità, si cerca di <b>ordinare in modo decrescente la diagonale</b>,
|
||||
assicurandoci che il primo perno sia più grande del secondo e così via.
|
||||
</p>
|
||||
<p>
|
||||
Questo metodo ha costo computazionale:
|
||||
|
|
@ -158,22 +178,28 @@ export default function () {
|
|||
<Section>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LU`}</ILatex> a banda</span>}>
|
||||
<p>
|
||||
Se la matrice <ILatex>{r`A`}</ILatex> è <b>a banda</b>, è possibile risparmiare spazio durante la fattorizzazione, in quanto sia <ILatex>{r`L`}</ILatex> sia <ILatex>{r`U`}</ILatex> saranno a banda!
|
||||
Se la matrice <ILatex>{r`A`}</ILatex> è <b>a banda</b>, è possibile risparmiare spazio durante
|
||||
la fattorizzazione, in quanto sia <ILatex>{r`L`}</ILatex> sia <ILatex>{r`U`}</ILatex> saranno a
|
||||
banda!
|
||||
</p>
|
||||
</Panel>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LU`}</ILatex> sparsa</span>}>
|
||||
<p>
|
||||
Se la matrice <ILatex>{r`A`}</ILatex> è <b>sparsa</b>, non è detto che <ILatex>{r`L`}</ILatex> e <ILatex>{r`U`}</ILatex> siano sparse a loro volta.
|
||||
Se la matrice <ILatex>{r`A`}</ILatex> è <b>sparsa</b>, non è detto
|
||||
che <ILatex>{r`L`}</ILatex> e <ILatex>{r`U`}</ILatex> siano sparse a loro volta.
|
||||
</p>
|
||||
<p>
|
||||
Per evitare il <u>fill-in</u>, è necessario <b>riordinare</b> la matrice <ILatex>{r`A`}</ILatex> in modo che sia il più possibile simile a una matrice a banda. <Todo>TODO: Confermare?</Todo>
|
||||
Per evitare il <u>fill-in</u>, è necessario <b>riordinare</b> la
|
||||
matrice <ILatex>{r`A`}</ILatex> in modo che sia il più possibile simile a una matrice a
|
||||
banda.
|
||||
</p>
|
||||
</Panel>
|
||||
</Section>
|
||||
<Section>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`LDL^{-1}`}</ILatex></span>}>
|
||||
<p>
|
||||
È possibile <b>ridurre la complessità computazionale</b> della fattorizzazione <ILatex>{r`LU`}</ILatex> se la matrice dei coefficienti è <b>simmetrica</b>:
|
||||
È possibile <b>ridurre la complessità computazionale</b> della
|
||||
fattorizzazione <ILatex>{r`LU`}</ILatex> se la matrice dei coefficienti è <b>simmetrica</b>:
|
||||
</p>
|
||||
<PLatex>{r`A = L \cdot D \cdot L^{-1}`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -215,7 +241,8 @@ export default function () {
|
|||
</Panel>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`\mathcal{L} \mathcal{L}^{-1}`}</ILatex></span>}>
|
||||
<p>
|
||||
È possibile dare <b>stabilità forte</b> alla fattorizzazione <ILatex>{r`LDL^{-1}`}</ILatex> se la matrice dei coefficienti è <b>simmetrica definita positiva</b>:
|
||||
È possibile dare <b>stabilità forte</b> alla fattorizzazione <ILatex>{r`LDL^{-1}`}</ILatex> se
|
||||
la matrice dei coefficienti è <b>simmetrica definita positiva</b>:
|
||||
</p>
|
||||
<PLatex>{r`A = \mathcal{L} \cdot \mathcal{L}^{-1}`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -237,11 +264,13 @@ export default function () {
|
|||
<Section>
|
||||
<Panel title={"Trasformazione di Householder"}>
|
||||
<p>
|
||||
Matrice ricavata dalla seguente formula, dove <ILatex>{r`v`}</ILatex> è la colonna di un'altra matrice:
|
||||
Matrice ricavata dalla seguente formula, dove <ILatex>{r`v`}</ILatex> è la colonna di un'altra
|
||||
matrice:
|
||||
</p>
|
||||
<PLatex>{r`U(v) = \mathbf{I} - \frac{2 \cdot v \cdot v^T}{\| v \|_{(2)}^2}`}</PLatex>
|
||||
<p>
|
||||
Se moltiplicata per per la matrice da cui proviene <ILatex>{r`v`}</ILatex>, sostituirà la colonna <ILatex>{r`v`}</ILatex> con la colonna:
|
||||
Se moltiplicata per per la matrice da cui proviene <ILatex>{r`v`}</ILatex>, sostituirà la
|
||||
colonna <ILatex>{r`v`}</ILatex> con la colonna:
|
||||
</p>
|
||||
<PLatex>{r`
|
||||
\begin{pmatrix}
|
||||
|
|
@ -258,17 +287,23 @@ export default function () {
|
|||
</Panel>
|
||||
<Panel title={<span>Fattorizzazione <ILatex>{r`QR`}</ILatex></span>}>
|
||||
<p>
|
||||
Metodo che fornisce una <b>maggiore stabilità</b> a costo di una <b>maggiore complessità computazionale</b>.
|
||||
Metodo che fornisce una <b>maggiore stabilità</b> a costo di una <b>maggiore complessità
|
||||
computazionale</b>.
|
||||
</p>
|
||||
<p>
|
||||
La matrice <ILatex>{r`A`}</ILatex> viene <i>fattorizzata</i> in due matrici, una <b>ortogonale</b> <ILatex>{r`Q`}</ILatex> e una <b>triangolare superiore</b> <ILatex>{r`R`}</ILatex>:
|
||||
La matrice <ILatex>{r`A`}</ILatex> viene <i>fattorizzata</i> in due matrici,
|
||||
una <b>ortogonale</b> <ILatex>{r`Q`}</ILatex> e una <b>triangolare superiore</b>
|
||||
<ILatex>{r`R`}</ILatex>:
|
||||
</p>
|
||||
<PLatex>{r`A = Q \cdot R`}</PLatex>
|
||||
<p>
|
||||
Le matrici si ottengono dal <b>prodotto delle trasformazioni di Householder</b> (che concatenate formano <ILatex>{r`Q`}</ILatex>) sulla matrice <ILatex>{r`A`}</ILatex> necessarie a trasformarla in una matrice triangolare superiore (<ILatex>{r`R`}</ILatex>).
|
||||
Le matrici si ottengono dal <b>prodotto delle trasformazioni di Householder</b> (che concatenate
|
||||
formano <ILatex>{r`Q`}</ILatex>) sulla matrice <ILatex>{r`A`}</ILatex> necessarie a trasformarla
|
||||
in una matrice triangolare superiore (<ILatex>{r`R`}</ILatex>).
|
||||
</p>
|
||||
<Example>
|
||||
C'è un bell'esempietto <Link href={"https://web.archive.org/web/20200828003151/https://rpubs.com/aaronsc32/qr-decomposition-householder"}>qui</Link>.
|
||||
C'è un bell'esempietto <Link
|
||||
href={"https://web.archive.org/web/20200828003151/https://rpubs.com/aaronsc32/qr-decomposition-householder"}>qui</Link>.
|
||||
</Example>
|
||||
<p>
|
||||
Una volta fattorizzata, il sistema si può risolvere con:
|
||||
|
|
@ -301,11 +336,13 @@ export default function () {
|
|||
</p>
|
||||
<PLatex>{r`x = G \cdot x + c`}</PLatex>
|
||||
<p>
|
||||
È particolarmente utile perchè ci permette di definire un <b>algoritmo ricorsivo</b> che trovi <ILatex>{r`x`}</ILatex>:
|
||||
È particolarmente utile perchè ci permette di definire un <b>algoritmo ricorsivo</b> che
|
||||
trovi <ILatex>{r`x`}</ILatex>:
|
||||
</p>
|
||||
<PLatex>{r`x_{(i+1)} = G \cdot x_{(i)} + c`}</PLatex>
|
||||
<p>
|
||||
<ILatex>{r`G`}</ILatex> è il <b>metodo</b>, e in base ad esso cambiano stabilità e velocità di convergenza.
|
||||
<ILatex>{r`G`}</ILatex> è il <b>metodo</b>, e in base ad esso cambiano stabilità e velocità di
|
||||
convergenza.
|
||||
</p>
|
||||
<p>
|
||||
Ponendo <ILatex>{r`A = M - N`}</ILatex>, la formula può essere scritta anche in questo modo:
|
||||
|
|
@ -327,15 +364,13 @@ export default function () {
|
|||
</p>
|
||||
<PLatex>{r`\rho (M) < 1`}</PLatex>
|
||||
<p>
|
||||
(dove <ILatex>{r`\rho`}</ILatex> è il <b>raggio spettrale</b>, il massimo autovalore della matrice)
|
||||
(dove <ILatex>{r`\rho`}</ILatex> è il <b>raggio spettrale</b>, il massimo autovalore della
|
||||
matrice)
|
||||
</p>
|
||||
<p>
|
||||
Perchè un metodo sia convergente, è sufficiente che:
|
||||
</p>
|
||||
<PLatex>{r`\| M \| < 1`}</PLatex>
|
||||
<p>
|
||||
<Todo>TODO: l'algoritmo con tau per le condizioni di arresto</Todo>
|
||||
</p>
|
||||
</Panel>
|
||||
</Section>
|
||||
<Section>
|
||||
|
|
@ -350,10 +385,12 @@ export default function () {
|
|||
\end{cases}
|
||||
`}</PLatex>
|
||||
<p>
|
||||
<u>Spostamenti simultanei</u>: Permette di ottenere ogni componente di <ILatex>{r`x`}</ILatex> indipendentemente dagli altri: è <b>parallelizzabile</b>.
|
||||
<u>Spostamenti simultanei</u>: Permette di ottenere ogni componente
|
||||
di <ILatex>{r`x`}</ILatex> indipendentemente dagli altri: è <b>parallelizzabile</b>.
|
||||
</p>
|
||||
<p>
|
||||
Se la matrice è <b>diagonale dominante</b>, allora il metodo di Jacobi <b>converge</b> sicuramente.
|
||||
Se la matrice è <b>diagonale dominante</b>, allora il metodo di
|
||||
Jacobi <b>converge</b> sicuramente.
|
||||
</p>
|
||||
</Panel>
|
||||
<Panel title={"Metodo di Gauss-Seidel"}>
|
||||
|
|
@ -370,10 +407,12 @@ export default function () {
|
|||
Ha una velocità di convergenza <b>maggiore o uguale</b> rispetto al metodo di Jacobi.
|
||||
</p>
|
||||
<p>
|
||||
<u>Spostamenti successivi</u>: Non è parallelizzabile, perchè ogni componente <b>dipende da quelle calcolate in precedenza</b>.
|
||||
<u>Spostamenti successivi</u>: Non è parallelizzabile, perchè ogni componente <b>dipende da
|
||||
quelle calcolate in precedenza</b>.
|
||||
</p>
|
||||
<p>
|
||||
Se la matrice è <b>diagonale dominante</b>, allora il metodo di Gauss-Seidel <b>converge</b> sicuramente.
|
||||
Se la matrice è <b>diagonale dominante</b>, allora il metodo di
|
||||
Gauss-Seidel <b>converge</b> sicuramente.
|
||||
</p>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
|
|||
|
|
@ -1,29 +1,32 @@
|
|||
import style from "./02_ZeriDiFunzione.less";
|
||||
import {Fragment} from "preact";
|
||||
import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib";
|
||||
import {ILatex, Panel, PLatex, Section} from "bluelib";
|
||||
import Example from "../../components/Example";
|
||||
|
||||
const r = String.raw;
|
||||
|
||||
|
||||
export default function (props) {
|
||||
export default function () {
|
||||
return (
|
||||
<Fragment>
|
||||
<Section title={"Problema: Ricerca degli zeri di funzione"}>
|
||||
<Panel title={"Descrizione"}>
|
||||
<p>
|
||||
Si vogliono trovare i punti (<i>zeri</i>) in cui una funzione <b>continua</b> <ILatex>f : [a, b] \to R</ILatex> vale <ILatex>0</ILatex>.
|
||||
Si vogliono trovare i punti (<i>zeri</i>) in cui una funzione <b>continua</b> <ILatex>f : [a, b]
|
||||
\to R</ILatex> vale <ILatex>0</ILatex>.
|
||||
</p>
|
||||
<p>
|
||||
Per il <b>teorema del valore medio</b>, se <ILatex>{r`f(a) \cdot f(b) \leq 0`}</ILatex>, allora esiste sicuramente un punto in cui la funzione vale 0.
|
||||
Per il <b>teorema del valore medio</b>, se <ILatex>{r`f(a) \cdot f(b) \leq 0`}</ILatex>, allora
|
||||
esiste sicuramente un punto in cui la funzione vale 0.
|
||||
</p>
|
||||
<p>
|
||||
Denominiamo il punto in cui la funzione vale <ILatex>0</ILatex> come <ILatex>{r`x_{(\star)}`}</ILatex>.
|
||||
Denominiamo il punto in cui la funzione
|
||||
vale <ILatex>0</ILatex> come <ILatex>{r`x_{(\star)}`}</ILatex>.
|
||||
</p>
|
||||
</Panel>
|
||||
<Panel title={"Condizionamento"}>
|
||||
<p>
|
||||
Più la <b>derivata prima</b> della funzione <b>si avvicina allo 0</b>, <b>peggio</b> il problema sarà condizionato.
|
||||
Più la <b>derivata prima</b> della funzione <b>si avvicina allo 0</b>, <b>peggio</b> il problema
|
||||
sarà condizionato.
|
||||
</p>
|
||||
<PLatex>{r`f'(x_{(\star)}) \simeq 0 \implies mal\ condizionato`}</PLatex>
|
||||
</Panel>
|
||||
|
|
@ -31,14 +34,19 @@ export default function (props) {
|
|||
<Section>
|
||||
<Panel title={"Ordine di convergenza"}>
|
||||
<p>
|
||||
Indice <ILatex>{r`{\color{Orange} p}`}</ILatex> di quanto in fretta una successione converge alla soluzione.
|
||||
Indice <ILatex>{r`{\color{Orange} p}`}</ILatex> di quanto in fretta una successione converge
|
||||
alla soluzione.
|
||||
</p>
|
||||
<PLatex>{r`\lim_{i \to +\infty} \frac{ \left| x_{(i+1)} - x_{(\star)} \right| }{ \left| x_{(k)} - x_{(\star)} \right|^{\color{Orange} p}}`}</PLatex>
|
||||
<ul>
|
||||
<li><u>Convergenza lineare</u>: <ILatex>{r`p = 1`}</ILatex> e <ILatex>{r`0 < C < 1`}</ILatex></li>
|
||||
<li><u>Convergenza superlineare</u>: <ILatex>{r`p = 1`}</ILatex> e <ILatex>{r`C = 0`}</ILatex></li>
|
||||
<li><u>Convergenza quadratica</u>: <ILatex>{r`p = 2`}</ILatex> e <ILatex>{r`0 < C < 1`}</ILatex></li>
|
||||
<li><u>Convergenza superquadratica</u>: <ILatex>{r`p = 2`}</ILatex> e <ILatex>{r`C = 0`}</ILatex></li>
|
||||
<li><u>Convergenza lineare</u>: <ILatex>{r`p = 1`}</ILatex> e <ILatex>{r`0 < C < 1`}</ILatex>
|
||||
</li>
|
||||
<li><u>Convergenza superlineare</u>: <ILatex>{r`p = 1`}</ILatex> e <ILatex>{r`C = 0`}</ILatex>
|
||||
</li>
|
||||
<li><u>Convergenza quadratica</u>: <ILatex>{r`p = 2`}</ILatex> e <ILatex>{r`0 < C < 1`}</ILatex>
|
||||
</li>
|
||||
<li><u>Convergenza
|
||||
superquadratica</u>: <ILatex>{r`p = 2`}</ILatex> e <ILatex>{r`C = 0`}</ILatex></li>
|
||||
<li>...</li>
|
||||
</ul>
|
||||
</Panel>
|
||||
|
|
@ -46,7 +54,8 @@ export default function (props) {
|
|||
<Section title={"Metodi dicotomici"}>
|
||||
<Panel title={"Cosa sono?"}>
|
||||
<p>
|
||||
Sono <b>metodi iterativi</b> in grado di ridurre sempre di più l'intervallo in cui è definita la funzione, facendolo convergere allo zero desiderato.
|
||||
Sono <b>metodi iterativi</b> in grado di ridurre sempre di più l'intervallo in cui è definita la
|
||||
funzione, facendolo convergere allo zero desiderato.
|
||||
</p>
|
||||
<p>
|
||||
Alcuni di essi sono il <i>metodo dicotomico</i> e il <i>metodo regula falsi</i>.
|
||||
|
|
@ -55,18 +64,22 @@ export default function (props) {
|
|||
Richiedono <b>una valutazione di funzione non-lineare</b> ad ogni iterazione.
|
||||
</p>
|
||||
<p>
|
||||
Ad ogni iterazione, l'intervallo viene sempre <i>almeno</i> <b>dimezzato</b>; si ha, pertanto, che:
|
||||
Ad ogni iterazione, l'intervallo viene sempre <i>almeno</i> <b>dimezzato</b>; si ha, pertanto,
|
||||
che:
|
||||
</p>
|
||||
<PLatex>{r`b_{(i)} - a_{(i)} = \frac{b - a}{2^{i - 1}}`}</PLatex>
|
||||
<p>
|
||||
Hanno quindi <b>convergenza lineare</b> (<ILatex>{r`C = \frac{1}{2}, p = 1`}</ILatex>).
|
||||
</p>
|
||||
<p>
|
||||
Il loro <i>criterio di arresto</i> è un <b>numero di iterazioni prefissato</b> che dipende dalla <b>tolleranza</b> sull'errore:
|
||||
Il loro <i>criterio di arresto</i> è un <b>numero di iterazioni prefissato</b> che dipende
|
||||
dalla <b>tolleranza</b> sull'errore:
|
||||
</p>
|
||||
<PLatex>{r`i \geq \log_2 \left( \frac{b - a}{\tau} \right)`}</PLatex>
|
||||
<Example>
|
||||
Dividi l'intervallo <ILatex>{r`[a, b]`}</ILatex> 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!
|
||||
Dividi l'intervallo <ILatex>{r`[a, b]`}</ILatex> 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!
|
||||
</Example>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
@ -76,7 +89,8 @@ export default function (props) {
|
|||
<li>Finchè non sono state compiute il numero di iterazioni prefissate:
|
||||
<ol>
|
||||
<li>
|
||||
Calcoliamo il <b>punto medio</b> dell'intervallo <ILatex>{r`[a_{(n)}, b_{(n)}]`}</ILatex>:
|
||||
Calcoliamo il <b>punto
|
||||
medio</b> dell'intervallo <ILatex>{r`[a_{(n)}, b_{(n)}]`}</ILatex>:
|
||||
<PLatex>{r`c_{(n)} = a_{(n)} + \frac{b_{(n)} - a_{(n)}}{2}`}</PLatex>
|
||||
</li>
|
||||
<li>
|
||||
|
|
@ -87,7 +101,8 @@ export default function (props) {
|
|||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in <ILatex>{r`[a_{(n+1)}, b_{(n+1)}]`}</ILatex>.
|
||||
Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e
|
||||
rinominiamolo in <ILatex>{r`[a_{(n+1)}, b_{(n+1)}]`}</ILatex>.
|
||||
</li>
|
||||
</ol>
|
||||
</li>
|
||||
|
|
@ -98,7 +113,8 @@ export default function (props) {
|
|||
<li>Finchè non sono state compiute il numero di iterazioni prefissate:
|
||||
<ol>
|
||||
<li>
|
||||
Calcoliamo l'<b>intersezione</b> tra la <b>retta che congiunge i due estremi</b> <ILatex>{r`a_{(n)}, b_{(n)}`}</ILatex> e l'<b>asse X</b>:
|
||||
Calcoliamo l'<b>intersezione</b> tra la <b>retta che congiunge i due estremi</b>
|
||||
<ILatex>{r`a_{(n)}, b_{(n)}`}</ILatex> e l'<b>asse X</b>:
|
||||
<PLatex>{r`c_{(n)} = b_{(n)} - \frac{f(b_{(n)})}{\frac{f(b_{(n)}) - f(a_{(n)})}{b_{(n)} - a_{(n)}}}`}</PLatex>
|
||||
</li>
|
||||
<li>
|
||||
|
|
@ -109,7 +125,8 @@ export default function (props) {
|
|||
</ul>
|
||||
</li>
|
||||
<li>
|
||||
Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in <ILatex>{r`[a_{(n+1)}, b_{(n+1)}]`}</ILatex>.
|
||||
Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e
|
||||
rinominiamolo in <ILatex>{r`[a_{(n+1)}, b_{(n+1)}]`}</ILatex>.
|
||||
</li>
|
||||
</ol>
|
||||
</li>
|
||||
|
|
@ -119,7 +136,8 @@ export default function (props) {
|
|||
<Section title={"Metodo delle approssimazioni successive"}>
|
||||
<Panel title={"Metodi delle approssimazioni successive"}>
|
||||
<p>
|
||||
Sono <b>metodi iterativi</b> che funzionano in modo molto simile ai metodi iterativi per i sistemi lineari, utilizzando una funzione <ILatex>{r`\phi`}</ILatex> come "metodo".
|
||||
Sono <b>metodi iterativi</b> che funzionano in modo molto simile ai metodi iterativi per i
|
||||
sistemi lineari, utilizzando una funzione <ILatex>{r`\phi`}</ILatex> come "metodo".
|
||||
</p>
|
||||
<PLatex>{r`x = x - \phi(x) \cdot f(x)`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -127,8 +145,10 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`x_{(k+1)} = g( x_{(k)} )`}</PLatex>
|
||||
<p>
|
||||
Sfruttano i <b>punti fissi</b> <ILatex>{r`g(x_{(\star)}) = x_{(\star)}`}</ILatex> della funzione <ILatex>{r`f`}</ILatex> per convergere:<br/>
|
||||
se <ILatex>{r`\phi(x)`}</ILatex> non ha zeri, allora i punti fissi <b>coincideranno</b> con gli <b>zeri</b> della funzione <ILatex>{r`f`}</ILatex>.
|
||||
Sfruttano i <b>punti fissi</b> <ILatex>{r`g(x_{(\star)}) = x_{(\star)}`}</ILatex> della
|
||||
funzione <ILatex>{r`f`}</ILatex> per convergere:<br/>
|
||||
se <ILatex>{r`\phi(x)`}</ILatex> non ha zeri, allora i punti fissi <b>coincideranno</b> con
|
||||
gli <b>zeri</b> della funzione <ILatex>{r`f`}</ILatex>.
|
||||
</p>
|
||||
<PLatex>{r`g(x) = x - \phi(x) \cdot f(x)`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -136,11 +156,16 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`x_{(k+1)} = g( x_{(k)} )`}</PLatex>
|
||||
<p>
|
||||
Non si conosce in anticipo il numero di iterazioni necessarie per soddisfare la tolleranza <ILatex>{r`\tau`}</ILatex>; ad ogni iterazione, si controlla se la tolleranza è soddisfatta:
|
||||
Non si conosce in anticipo il numero di iterazioni necessarie per soddisfare la
|
||||
tolleranza <ILatex>{r`\tau`}</ILatex>; ad ogni iterazione, si controlla se la tolleranza è
|
||||
soddisfatta:
|
||||
</p>
|
||||
<ul>
|
||||
<li>Nella differenza tra due iterate: <ILatex>{r`\frac{\left| x_{(k+1)} - x_{(k)} \right|}{\left| x_{(k+1)} \right|} \leq \tau`}</ILatex></li>
|
||||
<li>Nel <i>residuo</i> del problema: <ILatex>{r`\left| f(x_{(k)}) \right| \leq \tau`}</ILatex></li>
|
||||
<li>Nella differenza tra due
|
||||
iterate: <ILatex>{r`\frac{\left| x_{(k+1)} - x_{(k)} \right|}{\left| x_{(k+1)} \right|} \leq \tau`}</ILatex>
|
||||
</li>
|
||||
<li>Nel <i>residuo</i> del problema: <ILatex>{r`\left| f(x_{(k)}) \right| \leq \tau`}</ILatex>
|
||||
</li>
|
||||
</ul>
|
||||
</Panel>
|
||||
<Panel title={"Teorema della mappa contrattiva"}>
|
||||
|
|
@ -149,12 +174,14 @@ export default function (props) {
|
|||
</p>
|
||||
<ul>
|
||||
<li>
|
||||
Tutti i valori restituiti dalla funzione <ILatex>{r`g`}</ILatex> rientrano nel suo stesso dominio:
|
||||
Tutti i valori restituiti dalla funzione <ILatex>{r`g`}</ILatex> rientrano nel suo stesso
|
||||
dominio:
|
||||
<PLatex>{r`g : [a, b] \to [a, b]`}</PLatex>
|
||||
</li>
|
||||
<li>
|
||||
<p>
|
||||
La funzione <ILatex>{r`g`}</ILatex> è una contrazione, ovvero restringe l'intervallo <ILatex>{r`[a, b]`}</ILatex>:
|
||||
La funzione <ILatex>{r`g`}</ILatex> è una contrazione, ovvero restringe
|
||||
l'intervallo <ILatex>{r`[a, b]`}</ILatex>:
|
||||
</p>
|
||||
<PLatex>{r`\forall (x, y) \in [a, b], | g(x) - g(y) | \leq L \cdot | x - y |`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -186,7 +213,8 @@ export default function (props) {
|
|||
Più è piccolo <ILatex>L</ILatex>, più il metodo convergerà in fretta.
|
||||
</p>
|
||||
<Example>
|
||||
<ILatex>L</ILatex> è molto simile al raggio spettrale <ILatex>{r`\rho(M)`}</ILatex> dei metodi iterativi per i sistemi lineari!
|
||||
<ILatex>L</ILatex> è molto simile al raggio spettrale <ILatex>{r`\rho(M)`}</ILatex> dei metodi
|
||||
iterativi per i sistemi lineari!
|
||||
</Example>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
@ -198,7 +226,10 @@ export default function (props) {
|
|||
<PLatex>{r`\phi (x) = \frac{1}{f' (x)}`}</PLatex>
|
||||
<PLatex>{r`x_{(k+1)} = x_{(k)} - \frac{ f(x_{(k)}) }{ f'(x_{(k)}) }`}</PLatex>
|
||||
<Example>
|
||||
Geometricamente, corrisponde a prolungare una retta nel punto <ILatex>{r`(x_{(k)}, f(x_{(k)}))`}</ILatex> con pendenza <ILatex>{r`f'(x_{(k)})`}</ILatex>, e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine nella funzione.
|
||||
Geometricamente, corrisponde a prolungare una retta nel
|
||||
punto <ILatex>{r`(x_{(k)}, f(x_{(k)}))`}</ILatex> con pendenza <ILatex>{r`f'(x_{(k)})`}</ILatex>,
|
||||
e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine
|
||||
nella funzione.
|
||||
</Example>
|
||||
<p>
|
||||
Ha costo computazionale di <b>2 valutazioni di funzione</b> più <b>2 valutazioni di derivata</b>.
|
||||
|
|
@ -209,12 +240,16 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Metodo delle secanti"}>
|
||||
<p>
|
||||
È come il metodo di Newton, ma usa il <b>rapporto incrementale</b>, in modo da poter essere applicato a funzioni non continue.
|
||||
È come il metodo di Newton, ma usa il <b>rapporto incrementale</b>, in modo da poter essere
|
||||
applicato a funzioni non continue.
|
||||
</p>
|
||||
<PLatex>{r`\phi (x) = \frac{ 1 }{ \frac{ f(x_{(k)}) - f(x_{(k-1)}) }{ x_{(k)} - x_{(k-1)} } }`}</PLatex>
|
||||
<PLatex>{r`x_{(k+1)} = x_{(k)} - \frac{ f(x_{(k)}) }{ \frac{ f(x_{(k)}) - f(x_{(k-1)}) }{ x_{(k)} - x_{(k-1)} } }`}</PLatex>
|
||||
<Example>
|
||||
Geometricamente, corrisponde a costruire una retta che attraversa i punti <ILatex>{r`(x_{(k)}, f(x_{(k)}))`}</ILatex> e <ILatex>{r`(x_{(k-1)}, f(x_{(k-1)}))`}</ILatex>, e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine nella funzione.
|
||||
Geometricamente, corrisponde a costruire una retta che attraversa i
|
||||
punti <ILatex>{r`(x_{(k)}, f(x_{(k)}))`}</ILatex> e <ILatex>{r`(x_{(k-1)}, f(x_{(k-1)}))`}</ILatex>,
|
||||
e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine
|
||||
nella funzione.
|
||||
</Example>
|
||||
<p>
|
||||
Ha costo computazionale di <b>3 valutazioni di funzione</b>.
|
||||
|
|
|
|||
|
|
@ -1,24 +1,25 @@
|
|||
import style from "./03_Interpolazione.less";
|
||||
import {Fragment} from "preact";
|
||||
import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib";
|
||||
import {ILatex, Panel, PLatex, Section, Todo} from "bluelib";
|
||||
import Example from "../../components/Example";
|
||||
|
||||
const r = String.raw;
|
||||
|
||||
|
||||
export default function (props) {
|
||||
export default function () {
|
||||
return (
|
||||
<Fragment>
|
||||
<Section title={"Problema: Interpolazione"}>
|
||||
<Panel title={"Descrizione"}>
|
||||
<p>
|
||||
Si vuole trovare una funzione in grado di <b>approssimarne</b> un'altra, di cui si conoscono però solo alcuni punti.
|
||||
Si vuole trovare una funzione in grado di <b>approssimarne</b> un'altra, di cui si conoscono
|
||||
però solo alcuni punti.
|
||||
</p>
|
||||
<Example>
|
||||
È utile in un sacco di casi! Ad esempio, quando si vuole scalare un'immagine.
|
||||
</Example>
|
||||
<p>
|
||||
I punti sono detti <b>nodi</b> <ILatex>{r`(x_i, y_i)`}</ILatex>, mentre la funzione costruita su di essi è detta <b>interpolante</b> <ILatex>{r`g`}</ILatex>:
|
||||
I punti sono detti <b>nodi</b> <ILatex>{r`(x_i, y_i)`}</ILatex>, mentre la funzione costruita su
|
||||
di essi è detta <b>interpolante</b> <ILatex>{r`g`}</ILatex>:
|
||||
</p>
|
||||
<PLatex>{r`g(x_i) = y_i`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -27,10 +28,12 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Interpolazione polinomiale"}>
|
||||
<p>
|
||||
Il <u>teorema fondamentale dell'algebra</u> dice che <b>esiste una sola interpolante <i>polinomiale</i></b> che interpola un dato insieme di punti.
|
||||
Il <u>teorema fondamentale dell'algebra</u> dice che <b>esiste una sola
|
||||
interpolante <i>polinomiale</i></b> che interpola un dato insieme di punti.
|
||||
</p>
|
||||
<p>
|
||||
Con <ILatex>n+1</ILatex> punti, l'interpolante sarà al massimo di grado <ILatex>n</ILatex>, e viene detta <ILatex>{r`p_n`}</ILatex>.
|
||||
Con <ILatex>n+1</ILatex> punti, l'interpolante sarà al massimo di grado <ILatex>n</ILatex>, e
|
||||
viene detta <ILatex>{r`p_n`}</ILatex>.
|
||||
</p>
|
||||
<p>
|
||||
La sua <b>forma canonica</b> sarà:
|
||||
|
|
@ -87,20 +90,25 @@ export default function (props) {
|
|||
Per trovare il polinomio di interpolazione è sufficiente risolvere il problema!
|
||||
</Example>
|
||||
<p>
|
||||
È efficace perchè una volta calcolati i coefficienti essi <b>valgono per tutti i punti</b>, ma ha come svantaggio che la matrice di Vandermonde è <b>spesso malcondizionata.</b>
|
||||
È efficace perchè una volta calcolati i coefficienti essi <b>valgono per tutti i punti</b>, ma
|
||||
ha come svantaggio che la matrice di Vandermonde è <b>spesso malcondizionata.</b>
|
||||
</p>
|
||||
</Panel>
|
||||
<Panel title={"Metodo di Lagrange"}>
|
||||
<p>
|
||||
È possibile scrivere il polinomio di interpolazione <b>raccogliendo le <ILatex>{r`y`}</ILatex></b>:
|
||||
È possibile scrivere il polinomio di interpolazione <b>raccogliendo
|
||||
le <ILatex>{r`y`}</ILatex></b>:
|
||||
</p>
|
||||
<PLatex>{r`p_n (x) = y_0 L_0 + y_1 L_1 + y_2 L_2 + \dots + y_n L_n`}</PLatex>
|
||||
<p>
|
||||
I polinomi <ILatex>{r`L_k`}</ILatex> sono detti <b>polinomi di Lagrange</b>, e hanno le seguenti proprietà:
|
||||
I polinomi <ILatex>{r`L_k`}</ILatex> sono detti <b>polinomi di Lagrange</b>, e hanno le seguenti
|
||||
proprietà:
|
||||
</p>
|
||||
<ul>
|
||||
<li>
|
||||
Valgono <ILatex>1</ILatex> in corrispondenza del nodo con lo stesso indice, <ILatex>0</ILatex> in corrispondenza dei nodi con indice diverso e <ILatex>{r`0 < n < 1`}</ILatex> in tutti gli altri casi.
|
||||
Valgono <ILatex>1</ILatex> in corrispondenza del nodo con lo stesso
|
||||
indice, <ILatex>0</ILatex> in corrispondenza dei nodi con indice diverso
|
||||
e <ILatex>{r`0 < n < 1`}</ILatex> in tutti gli altri casi.
|
||||
|
||||
<PLatex>{r`
|
||||
\begin{cases}
|
||||
|
|
@ -120,11 +128,13 @@ export default function (props) {
|
|||
</p>
|
||||
<Example>Si chiama base perchè sono <b>linearmente indipendenti</b>!</Example>
|
||||
<p>
|
||||
Questo metodo permette di calcolare il valore del polinomio di interpolazione <b>in un singolo punto</b>:
|
||||
Questo metodo permette di calcolare il valore del polinomio di interpolazione <b>in un singolo
|
||||
punto</b>:
|
||||
</p>
|
||||
<Example>
|
||||
<p>
|
||||
Si può risparmiare tempo di calcolo calcolando una singola volta il numeratore con <i>tutti</i> i termini:
|
||||
Si può risparmiare tempo di calcolo calcolando una singola volta il numeratore
|
||||
con <i>tutti</i> i termini:
|
||||
</p>
|
||||
<PLatex>{r`\omega_n = (x - x_0) \cdot (x - x_1) \cdot \dots \cdot (x - x_n)`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -147,17 +157,16 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`R_n(x) = f(x) - p_n(x)`}</PLatex>
|
||||
<p>
|
||||
In particolare, è interessante la sua norma a infinito, <ILatex>{r`\| f - p_n \|_\infty`}</ILatex>, che corrisponde alla distanza massima tra le due funzioni.
|
||||
In particolare, è interessante la sua norma a
|
||||
infinito, <ILatex>{r`\| f - p_n \|_\infty`}</ILatex>, che corrisponde alla distanza massima tra
|
||||
le due funzioni.
|
||||
</p>
|
||||
<p>
|
||||
Un teorema dice che esso è uguale a: <Todo>TODO: Non credo serva.</Todo>
|
||||
Un teorema dice che esso è uguale a:
|
||||
</p>
|
||||
<PLatex>{r`R_n(x) = \frac{ \omega_n(x) }{ (n + 1)! } \cdot f^{(n+1)}(\xi)`}</PLatex>
|
||||
</Panel>
|
||||
<Panel title={"Stima"}>
|
||||
<p>
|
||||
<Todo>TODO: Tutta la dimostrazione di queste due affermazioni.</Todo>
|
||||
</p>
|
||||
<p>
|
||||
L'errore nell'interpolazione dipende principalmente da due fattori:
|
||||
</p>
|
||||
|
|
@ -170,10 +179,12 @@ export default function (props) {
|
|||
<Section>
|
||||
<Panel title={"Fenomeno di Runge"}>
|
||||
<p>
|
||||
Fenomeno che si verifica cercando di interpolare la <i>funzione di Runge</i> (<ILatex>{r`\frac{1}{1 + 25x^2}`}</ILatex>).
|
||||
Fenomeno che si verifica cercando di interpolare la <i>funzione di
|
||||
Runge</i> (<ILatex>{r`\frac{1}{1 + 25x^2}`}</ILatex>).
|
||||
</p>
|
||||
<p>
|
||||
Scegliendo <b>nodi equispaziati</b>, l'errore di interpolazione sarà <b>enorme</b> vicino ai due estremi dell'intervallo.
|
||||
Scegliendo <b>nodi equispaziati</b>, l'errore di interpolazione sarà <b>enorme</b> vicino ai due
|
||||
estremi dell'intervallo.
|
||||
</p>
|
||||
<Example>
|
||||
Addirittura, più nodi verranno scelti, più esso sarà alto!
|
||||
|
|
@ -184,7 +195,8 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Nodi di Chebychev"}>
|
||||
<p>
|
||||
Nodi ottenuti partizionando una <b>semicirconferenza</b>, e proiettando le partizioni sul diametro.
|
||||
Nodi ottenuti partizionando una <b>semicirconferenza</b>, e proiettando le partizioni sul
|
||||
diametro.
|
||||
</p>
|
||||
<p>
|
||||
La formula usata per ottenere <ILatex>{r`n`}</ILatex> punti è:
|
||||
|
|
|
|||
|
|
@ -1,18 +1,18 @@
|
|||
import style from "./04_InterpolazioneATratti.less";
|
||||
import {Fragment} from "preact";
|
||||
import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib";
|
||||
import {ILatex, Panel, PLatex, Section} from "bluelib";
|
||||
import Example from "../../components/Example";
|
||||
|
||||
const r = String.raw;
|
||||
|
||||
|
||||
export default function (props) {
|
||||
export default function () {
|
||||
return (
|
||||
<Fragment>
|
||||
<Section title={"Problema: Interpolazione a tratti"}>
|
||||
<Panel title={"Come funziona?"}>
|
||||
<p>
|
||||
Invece che costruire una singola funzione che interpola tutti i punti, per <b>ogni intervallo tra due punti</b> (<i>sottointervallo</i>) si costruisce <b>una funzione apposta</b>.
|
||||
Invece che costruire una singola funzione che interpola tutti i punti, per <b>ogni intervallo
|
||||
tra due punti</b> (<i>sottointervallo</i>) si costruisce <b>una funzione apposta</b>.
|
||||
</p>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
@ -24,12 +24,15 @@ export default function (props) {
|
|||
<ul>
|
||||
<li>sono <b>polinomiali</b> di grado massimo <ILatex>{r`n`}</ILatex></li>
|
||||
<li>sono <b>continue</b> fino al grado <ILatex>{r`n - 1`}</ILatex></li>
|
||||
<li>connettono <ILatex>{r`m + 2`}</ILatex> punti, e hanno <ILatex>{r`m`}</ILatex> sottointervalli</li>
|
||||
<li>connettono <ILatex>{r`m + 2`}</ILatex> punti, e
|
||||
hanno <ILatex>{r`m`}</ILatex> sottointervalli
|
||||
</li>
|
||||
<li>hanno funzioni <b>definite appositamente</b> per ogni sottointervallo</li>
|
||||
</ul>
|
||||
<Example>
|
||||
<p>
|
||||
Significa che agli estremi dell'intervallo, i valori di tutte le derivate fino al grado <ILatex>{r`n - 1`}</ILatex> devono essere uguali:
|
||||
Significa che agli estremi dell'intervallo, i valori di tutte le derivate fino al
|
||||
grado <ILatex>{r`n - 1`}</ILatex> devono essere uguali:
|
||||
</p>
|
||||
<PLatex>{r`\forall \ k \leq n-1, \forall \ i \in \{intervalli\}, \quad s_i^{(k)} (x_{i+1}) = s_i^{(k)} (x_{i+1})`}</PLatex>
|
||||
</Example>
|
||||
|
|
@ -58,7 +61,8 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`\| R \|_\infty = \| f - s \|_\infty \leq \frac{1}{8} \cdot \max_{y \in [a, b]} \left| f''(y) \right| \cdot \left( \max_{i \in \{intervalli\}} (x_{i+1} - x_{i}) \right)^2`}</PLatex>
|
||||
<p>
|
||||
Ha come vantaggi complessità computazionale <b>molto più bassa</b> e l'<b>assenza</b> del fenomeno di Runge, ma allo stesso tempo si <b>perde la derivabilità della funzione.</b>
|
||||
Ha come vantaggi complessità computazionale <b>molto più bassa</b> e l'<b>assenza</b> del
|
||||
fenomeno di Runge, ma allo stesso tempo si <b>perde la derivabilità della funzione.</b>
|
||||
</p>
|
||||
<p>
|
||||
<b>Non</b> hanno gradi di libertà.
|
||||
|
|
@ -87,7 +91,8 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`s_i(x) = \alpha_i + \beta_i \ ( x - x_i ) + \gamma_i \ ( x - x_i )^2 + \delta_i \ ( x - x_i )^3`}</PLatex>
|
||||
<Example>
|
||||
Spesso si indica con <ILatex>{r`h`}</ILatex> la distanza orizzontale tra due punti di un sottointervallo.
|
||||
Spesso si indica con <ILatex>{r`h`}</ILatex> la distanza orizzontale tra due punti di un
|
||||
sottointervallo.
|
||||
</Example>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
@ -171,7 +176,10 @@ export default function (props) {
|
|||
Classe di spline cubiche in cui:
|
||||
</p>
|
||||
<ul>
|
||||
<li>Negli intervalli <ILatex>{r`[x_0, x_2]`}</ILatex> e <ILatex>{r`[x_{m-1}, x_{m+1}]`}</ILatex> si presenta <b>obbligatoriamente</b> un polinomio di <b>grado 3</b>.</li>
|
||||
<li>Negli
|
||||
intervalli <ILatex>{r`[x_0, x_2]`}</ILatex> e <ILatex>{r`[x_{m-1}, x_{m+1}]`}</ILatex> si
|
||||
presenta <b>obbligatoriamente</b> un polinomio di <b>grado 3</b>.
|
||||
</li>
|
||||
</ul>
|
||||
<p>
|
||||
È <b>unica</b>.
|
||||
|
|
@ -181,7 +189,8 @@ export default function (props) {
|
|||
<Section>
|
||||
<Panel title={"Proprietà di minima curvatura"}>
|
||||
<p>
|
||||
Tra tutte le funzioni che interpolano dei punti, le tre classi di funzioni sopraelencate sono quelle che interpolano la funzione più "dolcemente".
|
||||
Tra tutte le funzioni che interpolano dei punti, le tre classi di funzioni sopraelencate sono
|
||||
quelle che interpolano la funzione più "dolcemente".
|
||||
</p>
|
||||
<p>
|
||||
Per loro è valida la seguente proprietà:
|
||||
|
|
|
|||
|
|
@ -1,12 +1,11 @@
|
|||
import style from "./05_ApprossimazioneDatiSperimentali.less";
|
||||
import {Fragment} from "preact";
|
||||
import {Section, Panel, ILatex, BLatex, PLatex} from "bluelib";
|
||||
import {ILatex, Panel, PLatex, Section} from "bluelib";
|
||||
import Example from "../../components/Example";
|
||||
|
||||
const r = String.raw;
|
||||
|
||||
|
||||
export default function (props) {
|
||||
export default function () {
|
||||
return (
|
||||
<Fragment>
|
||||
<Section title={"Problema: Approssimazione di dati sperimentali"}>
|
||||
|
|
@ -15,15 +14,21 @@ export default function (props) {
|
|||
Interpolare dati sperimentali non fornisce quasi mai un modello del fenomeno.
|
||||
</p>
|
||||
<p>
|
||||
Vogliamo costruire una <b>funzione di regressione</b> che, dati molti più dati del grado della funzione, minimizzi il quadrato della distanza tra i punti sperimentali e i punti della funzione di regressione.
|
||||
Vogliamo costruire una <b>funzione di regressione</b> che, dati molti più dati del grado della
|
||||
funzione, minimizzi il quadrato della distanza tra i punti sperimentali e i punti della funzione
|
||||
di regressione.
|
||||
</p>
|
||||
<p>
|
||||
Denominiamo:
|
||||
</p>
|
||||
<ul>
|
||||
<li><ILatex>{r`{\color{Orange} f}`}</ILatex>: la <b>funzione "effettiva"</b> del fenomeno</li>
|
||||
<li><ILatex>{r`{\color{Yellow} q}`}</ILatex>: la <b>funzione di regressione</b> che costruiamo per approssimarlo</li>
|
||||
<li><ILatex>{r`{\color{Red} Q }`}</ILatex>: la <b>funzione "errore di regressione"</b> da minimizzare</li>
|
||||
<li><ILatex>{r`{\color{Yellow} q}`}</ILatex>: la <b>funzione di regressione</b> che costruiamo
|
||||
per approssimarlo
|
||||
</li>
|
||||
<li><ILatex>{r`{\color{Red} Q }`}</ILatex>: la <b>funzione "errore di regressione"</b> da
|
||||
minimizzare
|
||||
</li>
|
||||
<li><ILatex>{r`(\ x_i, f(x_i)\ )`}</ILatex>: i <b>punti sperimentali</b></li>
|
||||
</ul>
|
||||
<p>
|
||||
|
|
@ -35,10 +40,12 @@ export default function (props) {
|
|||
<Section>
|
||||
<Panel title={"Regressione lineare"}>
|
||||
<p>
|
||||
Trova la <b>retta</b> <ILatex>{r`{\color{Yellow} q}`}</ILatex> che meglio approssima tutti gli <ILatex>{r`m`}</ILatex> dati sperimentali.
|
||||
Trova la <b>retta</b> <ILatex>{r`{\color{Yellow} q}`}</ILatex> che meglio approssima tutti
|
||||
gli <ILatex>{r`m`}</ILatex> dati sperimentali.
|
||||
</p>
|
||||
<p>
|
||||
Essendo una retta, avrà <b>due parametri</b>: il termine noto <ILatex>{r`a_0`}</ILatex>, e la pendenza <ILatex>{`a_1`}</ILatex>.
|
||||
Essendo una retta, avrà <b>due parametri</b>: il termine noto <ILatex>{r`a_0`}</ILatex>, e la
|
||||
pendenza <ILatex>{`a_1`}</ILatex>.
|
||||
</p>
|
||||
<PLatex>{r`{\color{Yellow} q(x) } = a_0 + a_1 \cdot {\color{Green} x}`}</PLatex>
|
||||
<p>
|
||||
|
|
@ -50,7 +57,8 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Regressione lineare matriciale"}>
|
||||
<p>
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti i <b>punti sperimentali</b>:
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti
|
||||
i <b>punti sperimentali</b>:
|
||||
</p>
|
||||
<PLatex>{r`
|
||||
A =
|
||||
|
|
@ -84,7 +92,9 @@ export default function (props) {
|
|||
<Section>
|
||||
<Panel title={"Regressione polinomiale"}>
|
||||
<p>
|
||||
Trova il <b>polinomio</b> <ILatex>{r`{\color{Yellow} q}`}</ILatex> di grado <ILatex>{r`n-1`}</ILatex> che meglio approssima tutti gli <ILatex>{r`m`}</ILatex> dati sperimentali.
|
||||
Trova il <b>polinomio</b> <ILatex>{r`{\color{Yellow} q}`}</ILatex> di
|
||||
grado <ILatex>{r`n-1`}</ILatex> che meglio approssima tutti gli <ILatex>{r`m`}</ILatex> dati
|
||||
sperimentali.
|
||||
</p>
|
||||
<p>
|
||||
Essendo un polinomio di grado <ILatex>{r`n-1`}</ILatex>, avrà <ILatex>{r`n`}</ILatex> parametri.
|
||||
|
|
@ -92,7 +102,8 @@ export default function (props) {
|
|||
<PLatex>{r`{\color{Yellow} q(x) } = a_0 + a_1 \cdot {\color{Green} x} + a_2 \cdot {\color{Green} x^2} +\ \dots \ + a_{n-1} \cdot {\color{Green} x^{n-1}`}</PLatex>
|
||||
<Example>
|
||||
<p>
|
||||
La regressione lineare è un caso particolare di regressione generale in cui i parametri sono 2!
|
||||
La regressione lineare è un caso particolare di regressione generale in cui i parametri sono
|
||||
2!
|
||||
</p>
|
||||
</Example>
|
||||
<p>
|
||||
|
|
@ -104,7 +115,8 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Regressione polinomiale matriciale"}>
|
||||
<p>
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti i <b>punti sperimentali</b> a tutti i gradi del polinomio:
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti
|
||||
i <b>punti sperimentali</b> a tutti i gradi del polinomio:
|
||||
</p>
|
||||
<PLatex>{r`
|
||||
A =
|
||||
|
|
@ -136,14 +148,18 @@ export default function (props) {
|
|||
</p>
|
||||
<PLatex>{r`{\color{Red} Q } = \| A \cdot \alpha - y \|^2`}</PLatex>
|
||||
<Example>
|
||||
Normalmente, i dati sono molti di più, ma se il numero di parametri <ILatex>{r`n`}</ILatex> fosse uguale al numero di dati <ILatex>{r`m`}</ILatex>, allora si otterrebbe il <b>polinomio di interpolazione</b>!
|
||||
Normalmente, i dati sono molti di più, ma se il numero di
|
||||
parametri <ILatex>{r`n`}</ILatex> fosse uguale al numero di dati <ILatex>{r`m`}</ILatex>, allora
|
||||
si otterrebbe il <b>polinomio di interpolazione</b>!
|
||||
</Example>
|
||||
</Panel>
|
||||
</Section>
|
||||
<Section>
|
||||
<Panel title={"Regressione generale"}>
|
||||
<p>
|
||||
Trova i <b>coefficienti della combinazione lineare</b> <ILatex>{r`{\color{Yellow} q}`}</ILatex> che meglio approssima tutti gli <ILatex>{r`m`}</ILatex> dati sperimentali.
|
||||
Trova i <b>coefficienti della combinazione lineare</b>
|
||||
<ILatex>{r`{\color{Yellow} q}`}</ILatex> che meglio approssima tutti
|
||||
gli <ILatex>{r`m`}</ILatex> dati sperimentali.
|
||||
</p>
|
||||
<PLatex>{r`{\color{Yellow} q(x) } = a_0 \cdot {\color{Green} \phi_0 (x)} + a_1 \cdot {\color{Green} \phi_1 (x)} + \dots + a_2 \cdot {\color{Green} \phi_2 (x)} +\ \dots\ + a_{n-1} \cdot {\color{Green} \phi_{n-1} (x)}`}</PLatex>
|
||||
<Example>
|
||||
|
|
@ -161,7 +177,8 @@ export default function (props) {
|
|||
</Panel>
|
||||
<Panel title={"Regressione polinomiale generale"}>
|
||||
<p>
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti i <b>punti sperimentali</b> a tutti i gradi del polinomio:
|
||||
Possiamo costruire una <b>matrice di regressione</b> <ILatex>{r`A`}</ILatex> contenente tutti
|
||||
i <b>punti sperimentali</b> a tutti i gradi del polinomio:
|
||||
</p>
|
||||
<PLatex>{r`
|
||||
A =
|
||||
|
|
@ -208,7 +225,9 @@ export default function (props) {
|
|||
<ul>
|
||||
<li>Fattorizziamo <ILatex>{r`A = Q \cdot \begin{pmatrix} R\\ 0 \end{pmatrix}`}</ILatex>.</li>
|
||||
<li>Calcoliamo <ILatex>{r`w = Q^T \cdot y`}</ILatex>.</li>
|
||||
<li>Teniamo solo i primi <ILatex>n</ILatex> valori di <ILatex>{r`w`}</ILatex> e mettiamoli in <ILatex>{r`w_1`}</ILatex>.</li>
|
||||
<li>Teniamo solo i primi <ILatex>n</ILatex> valori di <ILatex>{r`w`}</ILatex> e mettiamoli
|
||||
in <ILatex>{r`w_1`}</ILatex>.
|
||||
</li>
|
||||
<li>Calcoliamo <ILatex>{r`R \cdot \alpha = w_1`}</ILatex>.</li>
|
||||
</ul>
|
||||
</Panel>
|
||||
|
|
@ -220,13 +239,15 @@ export default function (props) {
|
|||
Ci sono <b>infinite</b> soluzioni, con <ILatex>{`n-k`}</ILatex> gradi di libertà.
|
||||
</p>
|
||||
<p>
|
||||
Si cerca sempre di trovare la <i>soluzione di norma minima</i>, che, se <ILatex>{r`k \leq n \leq m`}</ILatex>, allora è <b>unica</b>.
|
||||
Si cerca sempre di trovare la <i>soluzione di norma minima</i>, che,
|
||||
se <ILatex>{r`k \leq n \leq m`}</ILatex>, allora è <b>unica</b>.
|
||||
</p>
|
||||
<p>
|
||||
Per trovarla:
|
||||
</p>
|
||||
<ul>
|
||||
<li>Fattorizziamo <ILatex>{r`A = U \cdot \Sigma \cdot V^T`}</ILatex> con la <i>fattorizzazione SVD</i></li>
|
||||
<li>Fattorizziamo <ILatex>{r`A = U \cdot \Sigma \cdot V^T`}</ILatex> con la <i>fattorizzazione
|
||||
SVD</i></li>
|
||||
<li>Calcoliamo <ILatex>{r`\zeta = U^T \cdot y`}</ILatex></li>
|
||||
<li>
|
||||
<p>
|
||||
|
|
@ -250,7 +271,8 @@ export default function (props) {
|
|||
<li>Calcoliamo <ILatex>{r`\alpha = V \cdot \gamma`}</ILatex></li>
|
||||
</ul>
|
||||
<Example>
|
||||
Gli zeri nella <ILatex>{r`\gamma`}</ILatex> sono i gradi di libertà, sono zero in modo che essi diano la norma minima.
|
||||
Gli zeri nella <ILatex>{r`\gamma`}</ILatex> sono i gradi di libertà, sono zero in modo che essi
|
||||
diano la norma minima.
|
||||
</Example>
|
||||
</Panel>
|
||||
</Section>
|
||||
|
|
|
|||
|
|
@ -287,12 +287,6 @@ export default function () {
|
|||
</p>
|
||||
<PLatex>{r`\| f \|_\infty = max | f(x) |`}</PLatex>
|
||||
</Panel>
|
||||
<Panel title={"Norma a 1"}>
|
||||
<Todo>TODO: Esiste?</Todo>
|
||||
</Panel>
|
||||
<Panel title={"Norma a 2"}>
|
||||
<Todo>TODO: Esiste?</Todo>
|
||||
</Panel>
|
||||
</Section>
|
||||
<Section title={"Errori"}>
|
||||
<Panel title={"Errore relativo tra vettori e matrici"}>
|
||||
|
|
|
|||
Loading…
Reference in a new issue