From f8ded5004c06f1b11881fedccd9d2143a05bb717 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Wed, 2 Sep 2020 17:13:18 +0200 Subject: [PATCH] Fix some more stuff --- src/routes/ApprendimentoSistemiArtificiali.js | 4 - src/routes/CalcoloNumerico/00_Intro.js | 20 ++-- src/routes/CalcoloNumerico/00_Intro.less | 0 .../CalcoloNumerico/01_SistemiLineari.js | 111 ++++++++++++------ .../CalcoloNumerico/01_SistemiLineari.less | 0 .../CalcoloNumerico/02_ZeriDiFunzione.js | 99 +++++++++++----- .../CalcoloNumerico/02_ZeriDiFunzione.less | 0 .../CalcoloNumerico/03_Interpolazione.js | 54 +++++---- .../CalcoloNumerico/03_Interpolazione.less | 0 .../04_InterpolazioneATratti.js | 29 +++-- .../04_InterpolazioneATratti.less | 0 .../05_ApprossimazioneDatiSperimentali.js | 60 +++++++--- .../05_ApprossimazioneDatiSperimentali.less | 0 src/routes/RipassoDiAlgebraLineare.js | 6 - 14 files changed, 248 insertions(+), 135 deletions(-) delete mode 100644 src/routes/CalcoloNumerico/00_Intro.less delete mode 100644 src/routes/CalcoloNumerico/01_SistemiLineari.less delete mode 100644 src/routes/CalcoloNumerico/02_ZeriDiFunzione.less delete mode 100644 src/routes/CalcoloNumerico/03_Interpolazione.less delete mode 100644 src/routes/CalcoloNumerico/04_InterpolazioneATratti.less delete mode 100644 src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.less diff --git a/src/routes/ApprendimentoSistemiArtificiali.js b/src/routes/ApprendimentoSistemiArtificiali.js index ee0da59..8f19bc3 100644 --- a/src/routes/ApprendimentoSistemiArtificiali.js +++ b/src/routes/ApprendimentoSistemiArtificiali.js @@ -642,10 +642,6 @@ export default function (props) { Se è valida questa proprietà, si può dimostrare che l'energia del sistema è sempre decrescente, e che quindi che tenderà a un punto fisso!

-

- TODO: Dopo il prof dimostra la relazione tra input netto e overlap, e che il sistema - converge al pattern più simile. -

diff --git a/src/routes/CalcoloNumerico/00_Intro.js b/src/routes/CalcoloNumerico/00_Intro.js index 41d812b..1259136 100644 --- a/src/routes/CalcoloNumerico/00_Intro.js +++ b/src/routes/CalcoloNumerico/00_Intro.js @@ -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 () {

- 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:

  • - Ripasso di Algebra Lineare (per studenti sperduti di Calcolo Numerico) + Ripasso di Algebra Lineare (per + studenti sperduti di Calcolo Numerico)

    • - Ho provato a fare un deck Anki con tutte le formule di Calcolo numerico. + Ho provato a fare un deck Anki con tutte le + formule di Calcolo numerico.

    - Sappiatemi dire com'è! Io non l'ho usato moltissimo perchè ho studiato scrivendo questa pagina di Appuntiweb... + Sappiatemi dire com'è! Io non l'ho usato moltissimo perchè ho studiato scrivendo questa + pagina di Appuntiweb...

    -
  • Scarica il deck Anki
    • +
  • Scarica + il deck Anki
    •
    @@ -120,7 +125,8 @@ export default function () {

    - Un numero reale rappresentato in virgola mobile ha un errore relativo minore o uguale alla precisione + Un numero reale rappresentato in virgola mobile ha un errore relativo minore o + uguale alla precisione di macchina:

    diff --git a/src/routes/CalcoloNumerico/00_Intro.less b/src/routes/CalcoloNumerico/00_Intro.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/CalcoloNumerico/01_SistemiLineari.js b/src/routes/CalcoloNumerico/01_SistemiLineari.js index 58c23c5..f3887d4 100644 --- a/src/routes/CalcoloNumerico/01_SistemiLineari.js +++ b/src/routes/CalcoloNumerico/01_SistemiLineari.js @@ -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.

    - In forma matriciale, avrà una matrice dei coefficienti {r`A`}, un vettore dei termini noti {r`b`} e un vettore delle incognite {r`x`}. + In forma matriciale, avrà una matrice dei coefficienti {r`A`}, un vettore + dei termini noti {r`b`} e un vettore delle incognite + {r`x`}.

    L'equazione matriciale del sistema è: @@ -39,10 +40,12 @@ export default function () {

    - Metodi che trovano la soluzione esatta* di un sistema lineare. + Metodi che trovano la soluzione esatta* di un sistema lineare.

    - Tipicamente prevedono la fattorizzazione della matrice dei coefficienti in due sottomatrici più facili da risolvere. + Tipicamente prevedono la fattorizzazione della matrice dei coefficienti in due + sottomatrici più facili da risolvere.

    Generalmente hanno una complessità temporale {r`O(n^3)`}. @@ -50,10 +53,13 @@ export default function () {

    - Metodi che trovano una soluzione imperfetta* di un sistema lineare. + Metodi che trovano una soluzione imperfetta* di + un sistema lineare.

    - Tipicamente prevedono l'applicazione ripetuta di un metodo, in base al quale cambia la velocità di convergenza alla soluzione. + Tipicamente prevedono l'applicazione ripetuta di un metodo, in base al quale cambia + la velocità di convergenza alla soluzione.

    Generalmente hanno una complessità temporale {r`O(n^2)`}. @@ -63,13 +69,17 @@ export default function () {

    - Se la matrice dei coefficienti del sistema è diagonale, allora è possibile trovare la soluzione dividendo ogni termine noto per l'unico coefficiente diverso da zero presente nella sua riga: + Se la matrice dei coefficienti del sistema è diagonale, allora è possibile trovare la + soluzione dividendo ogni termine noto per l'unico coefficiente diverso da zero presente + nella sua riga:

    {r`x_i = \frac{b_i}{A_{ii}}`}

    - Se la matrice dei coefficienti del sistema è triangolare inferiore o superiore, allora è possibile trovare la soluzione effettuando una sostituzione all'avanti oppure all'indietro: + Se la matrice dei coefficienti del sistema è triangolare inferiore o superiore, allora è + possibile trovare la soluzione effettuando una sostituzione all'avanti oppure + all'indietro:

    {r`x_i = \frac{b_i - \sum_{k = 1}^{i - 1} (x_k \cdot A_{ik})}{A_{ii}}`} {r`x_i = \frac{b_i - \sum_{k = i - 1}^{n} (x_k \cdot A_{ik})}{A_{ii}}`} @@ -78,7 +88,10 @@ export default function () {
    Fattorizzazione {r`LU`}}>

    - Se tutti i valori sulla diagonale di {r`A`} sono diversi da 0 (eccetto l'ultimo) allora è possibile fattorizzarla in due matrici: una {r`L`} triangolare inferiore, e una {r`U`} triangolare superiore. + Se tutti i valori sulla diagonale di {r`A`} sono diversi da 0 (eccetto + l'ultimo) allora è possibile fattorizzarla in due matrici: + una {r`L`} triangolare inferiore, e una {r`U`} triangolare + superiore.

    {r`A = L \cdot U`} @@ -109,7 +122,8 @@ export default function () { È la parte triangolare superiore di {r`A`}!

    - 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):

    {r` \begin{cases} @@ -124,17 +138,21 @@ export default function () {     Fattorizzazione {r`LU`} con pivoting parziale}>

    - È possibile applicare la fattorizzazione {r`LU`} a qualsiasi matrice non-singolare permettendo lo scambio (pivoting) delle righe, potenzialmente aumentando la stabilità dell'algoritmo. + È possibile applicare la fattorizzazione {r`LU`} a qualsiasi matrice + non-singolare permettendo lo scambio (pivoting) delle righe, potenzialmente aumentando + la stabilità dell'algoritmo.

    Abbiamo fatto questo metodo in Algebra Lineare, chiamandolo metodo di Gauss-Jordan!

    - Alla formula precedente si aggiunge una matrice di permutazione che indica quali righe sono state scambiate: + Alla formula precedente si aggiunge una matrice di permutazione che indica quali righe + sono state scambiate:

    {r`P \cdot A = L \cdot U`}

    - Per massimizzare la stabilità, si cerca di usare come perno l'elemento più grande della colonna. + Per massimizzare la stabilità, si cerca di usare come perno l'elemento più grande della + colonna.

    Questo metodo ha costo computazionale: @@ -143,11 +161,13 @@ export default function () { Fattorizzazione {r`LU`} con pivoting totale}>

    - È possibile anche permettere il pivoting sulle colonne per aumentare ulteriormente la stabilità dell'algoritmo, a costo di maggiore costo computazionale: + È possibile anche permettere il pivoting sulle colonne per aumentare + ulteriormente la stabilità dell'algoritmo, a costo di maggiore costo computazionale:

    {r`P \cdot A \cdot Q = L \cdot U`}

    - Per massimizzare la stabilità, si cerca di ordinare in modo decrescente la diagonale, assicurandoci che il primo perno sia più grande del secondo e così via. + Per massimizzare la stabilità, si cerca di ordinare in modo decrescente la diagonale, + assicurandoci che il primo perno sia più grande del secondo e così via.

    Questo metodo ha costo computazionale: @@ -158,22 +178,28 @@ export default function () {

    Fattorizzazione {r`LU`} a banda}>

    - Se la matrice {r`A`} è a banda, è possibile risparmiare spazio durante la fattorizzazione, in quanto sia {r`L`} sia {r`U`} saranno a banda! + Se la matrice {r`A`} è a banda, è possibile risparmiare spazio durante + la fattorizzazione, in quanto sia {r`L`} sia {r`U`} saranno a + banda!

    Fattorizzazione {r`LU`} sparsa}>

    - Se la matrice {r`A`} è sparsa, non è detto che {r`L`} e {r`U`} siano sparse a loro volta. + Se la matrice {r`A`} è sparsa, non è detto + che {r`L`} e {r`U`} siano sparse a loro volta.

    - Per evitare il fill-in, è necessario riordinare la matrice {r`A`} in modo che sia il più possibile simile a una matrice a banda. TODO: Confermare? + Per evitare il fill-in, è necessario riordinare la + matrice {r`A`} in modo che sia il più possibile simile a una matrice a + banda.

    Fattorizzazione {r`LDL^{-1}`}}>

    - È possibile ridurre la complessità computazionale della fattorizzazione {r`LU`} se la matrice dei coefficienti è simmetrica: + È possibile ridurre la complessità computazionale della + fattorizzazione {r`LU`} se la matrice dei coefficienti è simmetrica:

    {r`A = L \cdot D \cdot L^{-1}`}

    @@ -215,7 +241,8 @@ export default function () { Fattorizzazione {r`\mathcal{L} \mathcal{L}^{-1}`}}>

    - È possibile dare stabilità forte alla fattorizzazione {r`LDL^{-1}`} se la matrice dei coefficienti è simmetrica definita positiva: + È possibile dare stabilità forte alla fattorizzazione {r`LDL^{-1}`} se + la matrice dei coefficienti è simmetrica definita positiva:

    {r`A = \mathcal{L} \cdot \mathcal{L}^{-1}`}

    @@ -237,11 +264,13 @@ export default function () {

    - Matrice ricavata dalla seguente formula, dove {r`v`} è la colonna di un'altra matrice: + Matrice ricavata dalla seguente formula, dove {r`v`} è la colonna di un'altra + matrice:

    {r`U(v) = \mathbf{I} - \frac{2 \cdot v \cdot v^T}{\| v \|_{(2)}^2}`}

    - Se moltiplicata per per la matrice da cui proviene {r`v`}, sostituirà la colonna {r`v`} con la colonna: + Se moltiplicata per per la matrice da cui proviene {r`v`}, sostituirà la + colonna {r`v`} con la colonna:

    {r` \begin{pmatrix} @@ -258,17 +287,23 @@ export default function () {     Fattorizzazione {r`QR`}}>

    - Metodo che fornisce una maggiore stabilità a costo di una maggiore complessità computazionale. + Metodo che fornisce una maggiore stabilità a costo di una maggiore complessità + computazionale.

    - La matrice {r`A`} viene fattorizzata in due matrici, una ortogonale {r`Q`} e una triangolare superiore {r`R`}: + La matrice {r`A`} viene fattorizzata in due matrici, + una ortogonale {r`Q`} e una triangolare superiore + {r`R`}:

    {r`A = Q \cdot R`}

    - Le matrici si ottengono dal prodotto delle trasformazioni di Householder (che concatenate formano {r`Q`}) sulla matrice {r`A`} necessarie a trasformarla in una matrice triangolare superiore ({r`R`}). + Le matrici si ottengono dal prodotto delle trasformazioni di Householder (che concatenate + formano {r`Q`}) sulla matrice {r`A`} necessarie a trasformarla + in una matrice triangolare superiore ({r`R`}).

    - C'è un bell'esempietto qui. + C'è un bell'esempietto qui.

    Una volta fattorizzata, il sistema si può risolvere con: @@ -301,11 +336,13 @@ export default function () {

    {r`x = G \cdot x + c`}

    - È particolarmente utile perchè ci permette di definire un algoritmo ricorsivo che trovi {r`x`}: + È particolarmente utile perchè ci permette di definire un algoritmo ricorsivo che + trovi {r`x`}:

    {r`x_{(i+1)} = G \cdot x_{(i)} + c`}

    - {r`G`} è il metodo, e in base ad esso cambiano stabilità e velocità di convergenza. + {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: @@ -327,15 +364,13 @@ export default function () {

    {r`\rho (M) < 1`}

    - (dove {r`\rho`} è il raggio spettrale, il massimo autovalore della matrice) + (dove {r`\rho`} è il raggio spettrale, il massimo autovalore della + matrice)

    Perchè un metodo sia convergente, è sufficiente che:

    {r`\| M \| < 1`} -

    - TODO: l'algoritmo con tau per le condizioni di arresto -

    @@ -350,10 +385,12 @@ export default function () { \end{cases} `}

    - Spostamenti simultanei: Permette di ottenere ogni componente di {r`x`} indipendentemente dagli altri: è parallelizzabile. + Spostamenti simultanei: Permette di ottenere ogni componente + di {r`x`} indipendentemente dagli altri: è parallelizzabile.

    - Se la matrice è diagonale dominante, allora il metodo di Jacobi converge sicuramente. + Se la matrice è diagonale dominante, allora il metodo di + Jacobi converge sicuramente.

    @@ -370,10 +407,12 @@ export default function () { Ha una velocità di convergenza maggiore o uguale rispetto al metodo di Jacobi.

    - Spostamenti successivi: Non è parallelizzabile, perchè ogni componente dipende da quelle calcolate in precedenza. + Spostamenti successivi: Non è parallelizzabile, perchè ogni componente dipende da + quelle calcolate in precedenza.

    - Se la matrice è diagonale dominante, allora il metodo di Gauss-Seidel converge sicuramente. + Se la matrice è diagonale dominante, allora il metodo di + Gauss-Seidel converge sicuramente.

    diff --git a/src/routes/CalcoloNumerico/01_SistemiLineari.less b/src/routes/CalcoloNumerico/01_SistemiLineari.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js index 26af01c..c9a1aad 100644 --- a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js +++ b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js @@ -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 (

    - Si vogliono trovare i punti (zeri) in cui una funzione continua f : [a, b] \to R vale 0. + Si vogliono trovare i punti (zeri) in cui una funzione continua f : [a, b] + \to R vale 0.

    - 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. + 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_{(\star)}`}. + Denominiamo il punto in cui la funzione + vale 0 come {r`x_{(\star)}`}.

    - Più la derivata prima della funzione si avvicina allo 0, peggio il problema sarà condizionato. + Più la derivata prima della funzione si avvicina allo 0, peggio il problema + sarà condizionato.

    {r`f'(x_{(\star)}) \simeq 0 \implies mal\ condizionato`}     @@ -31,14 +34,19 @@ export default function (props) {

    - Indice {r`{\color{Orange} p}`} di quanto in fretta una successione converge alla soluzione. + 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_{(\star)} \right| }{ \left| x_{(k)} - x_{(\star)} \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`}
      • +
    • 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`}
    • ...
     @@ -46,7 +54,8 @@ export default function (props) {

    - Sono metodi iterativi in grado di ridurre sempre di più l'intervallo in cui è definita la funzione, facendolo convergere allo zero desiderato. + Sono metodi iterativi in grado di ridurre sempre di più l'intervallo in cui è definita la + funzione, facendolo convergere allo zero desiderato.

    Alcuni di essi sono il metodo dicotomico e il metodo regula falsi. @@ -55,18 +64,22 @@ export default function (props) { Richiedono una valutazione di funzione non-lineare ad ogni iterazione.

    - Ad ogni iterazione, l'intervallo viene sempre almeno dimezzato; si ha, pertanto, che: + Ad ogni iterazione, l'intervallo viene sempre almeno dimezzato; si ha, pertanto, + che:

    {r`b_{(i)} - a_{(i)} = \frac{b - a}{2^{i - 1}}`}

    Hanno quindi convergenza lineare ({r`C = \frac{1}{2}, p = 1`}).

    - Il loro criterio di arresto è un numero di iterazioni prefissato che dipende dalla tolleranza sull'errore: + Il loro criterio di arresto è un numero di iterazioni prefissato che dipende + dalla tolleranza sull'errore:

    {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! + 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!
    @@ -76,7 +89,8 @@ export default function (props) {
  • Finchè non sono state compiute il numero di iterazioni prefissate:
    1. - Calcoliamo il punto medio dell'intervallo {r`[a_{(n)}, b_{(n)}]`}: + Calcoliamo il punto + medio dell'intervallo {r`[a_{(n)}, b_{(n)}]`}: {r`c_{(n)} = a_{(n)} + \frac{b_{(n)} - a_{(n)}}{2}`}
    2. @@ -87,7 +101,8 @@ export default function (props) {
    3. - Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}. + Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e + rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}.
    • @@ -98,7 +113,8 @@ export default function (props) {
  • Finchè non sono state compiute il numero di iterazioni prefissate:
    1. - Calcoliamo l'intersezione tra la retta che congiunge i due estremi {r`a_{(n)}, b_{(n)}`} e l'asse X: + 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)}}}`}
    2. @@ -109,7 +125,8 @@ export default function (props) {
    3. - Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}. + Teniamo l'intervallo in cui i valori della funzione ai due estremi sono discordi, e + rinominiamolo in {r`[a_{(n+1)}, b_{(n+1)}]`}.
    • @@ -119,7 +136,8 @@ export default function (props) {

    - Sono metodi iterativi che funzionano in modo molto simile ai metodi iterativi per i sistemi lineari, utilizzando una funzione {r`\phi`} come "metodo". + 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)`}

    @@ -127,8 +145,10 @@ export default function (props) {

    {r`x_{(k+1)} = g( x_{(k)} )`}

    - Sfruttano i punti fissi {r`g(x_{(\star)}) = x_{(\star)}`} della funzione {r`f`} per convergere:
    - se {r`\phi(x)`} non ha zeri, allora i punti fissi coincideranno con gli zeri della funzione {r`f`}. + Sfruttano i punti fissi {r`g(x_{(\star)}) = x_{(\star)}`} della + funzione {r`f`} per convergere:
    + se {r`\phi(x)`} non ha zeri, allora i punti fissi coincideranno con + gli zeri della funzione {r`f`}.

    {r`g(x) = x - \phi(x) \cdot f(x)`}

    @@ -136,11 +156,16 @@ export default function (props) {

    {r`x_{(k+1)} = g( x_{(k)} )`}

    - Non si conosce in anticipo il numero di iterazioni necessarie per soddisfare la tolleranza {r`\tau`}; ad ogni iterazione, si controlla se la tolleranza è soddisfatta: + Non si conosce in anticipo il numero di iterazioni necessarie per soddisfare la + tolleranza {r`\tau`}; ad ogni iterazione, si controlla se la tolleranza è + soddisfatta:

      -
    • Nella differenza tra due iterate: {r`\frac{\left| x_{(k+1)} - x_{(k)} \right|}{\left| x_{(k+1)} \right|} \leq \tau`}
      • -
    • Nel residuo del problema: {r`\left| f(x_{(k)}) \right| \leq \tau`}
      • +
    • Nella differenza tra due + iterate: {r`\frac{\left| x_{(k+1)} - x_{(k)} \right|}{\left| x_{(k+1)} \right|} \leq \tau`} +
      • +
    • Nel residuo del problema: {r`\left| f(x_{(k)}) \right| \leq \tau`} +
    @@ -149,12 +174,14 @@ export default function (props) {

    • - Tutti i valori restituiti dalla funzione {r`g`} rientrano nel suo stesso dominio: + Tutti i valori restituiti dalla funzione {r`g`} rientrano nel suo stesso + dominio: {r`g : [a, b] \to [a, b]`}

    • - La funzione {r`g`} è una contrazione, ovvero restringe l'intervallo {r`[a, b]`}: + La funzione {r`g`} è una contrazione, ovvero restringe + l'intervallo {r`[a, b]`}:

      {r`\forall (x, y) \in [a, b], | g(x) - g(y) | \leq L \cdot | x - y |`}

      @@ -186,7 +213,8 @@ export default function (props) { Più è piccolo L, più il metodo convergerà in fretta.

      - L è molto simile al raggio spettrale {r`\rho(M)`} dei metodi iterativi per i sistemi lineari! + L è molto simile al raggio spettrale {r`\rho(M)`} dei metodi + iterativi per i sistemi lineari!
    @@ -198,7 +226,10 @@ export default function (props) { {r`\phi (x) = \frac{1}{f' (x)}`} {r`x_{(k+1)} = x_{(k)} - \frac{ f(x_{(k)}) }{ f'(x_{(k)}) }`} - Geometricamente, corrisponde a prolungare una retta nel punto {r`(x_{(k)}, f(x_{(k)}))`} con pendenza {r`f'(x_{(k)})`}, 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 {r`(x_{(k)}, f(x_{(k)}))`} con pendenza {r`f'(x_{(k)})`}, + e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine + nella funzione.

    Ha costo computazionale di 2 valutazioni di funzione più 2 valutazioni di derivata. @@ -209,12 +240,16 @@ export default function (props) {

    - È come il metodo di Newton, ma usa il rapporto incrementale, in modo da poter essere applicato a funzioni non continue. + È come il metodo di Newton, ma usa il rapporto incrementale, in modo da poter essere + applicato a funzioni non continue.

    {r`\phi (x) = \frac{ 1 }{ \frac{ f(x_{(k)}) - f(x_{(k-1)}) }{ x_{(k)} - x_{(k-1)} } }`} {r`x_{(k+1)} = x_{(k)} - \frac{ f(x_{(k)}) }{ \frac{ f(x_{(k)}) - f(x_{(k-1)}) }{ x_{(k)} - x_{(k-1)} } }`} - Geometricamente, corrisponde a costruire una retta che attraversa i punti {r`(x_{(k)}, f(x_{(k)}))`} e {r`(x_{(k-1)}, f(x_{(k-1)}))`}, 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 {r`(x_{(k)}, f(x_{(k)}))`} e {r`(x_{(k-1)}, f(x_{(k-1)}))`}, + e prendendo come nuovo punto la sua intersezione con l'asse X e la sua corrispettiva immagine + nella funzione.

    Ha costo computazionale di 3 valutazioni di funzione. diff --git a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.less b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/CalcoloNumerico/03_Interpolazione.js b/src/routes/CalcoloNumerico/03_Interpolazione.js index 9a6e594..172d2df 100644 --- a/src/routes/CalcoloNumerico/03_Interpolazione.js +++ b/src/routes/CalcoloNumerico/03_Interpolazione.js @@ -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 (

    - Si vuole trovare una funzione in grado di approssimarne un'altra, di cui si conoscono però solo alcuni punti. + Si vuole trovare una funzione in grado di approssimarne un'altra, di cui si conoscono + però solo alcuni punti.

    È utile in un sacco di casi! Ad esempio, quando si vuole scalare un'immagine.

    - I punti sono detti nodi {r`(x_i, y_i)`}, mentre la funzione costruita su di essi è detta interpolante {r`g`}: + I punti sono detti nodi {r`(x_i, y_i)`}, mentre la funzione costruita su + di essi è detta interpolante {r`g`}:

    {r`g(x_i) = y_i`}

    @@ -27,10 +28,12 @@ export default function (props) {

    - Il teorema fondamentale dell'algebra dice che esiste una sola interpolante polinomiale che interpola un dato insieme di punti. + Il teorema fondamentale dell'algebra dice che esiste una sola + interpolante polinomiale che interpola un dato insieme di punti.

    - Con n+1 punti, l'interpolante sarà al massimo di grado n, e viene detta {r`p_n`}. + Con n+1 punti, l'interpolante sarà al massimo di grado n, e + viene detta {r`p_n`}.

    La sua forma canonica sarà: @@ -87,20 +90,25 @@ export default function (props) { Per trovare il polinomio di interpolazione è sufficiente risolvere il problema!

    - È efficace perchè una volta calcolati i coefficienti essi valgono per tutti i punti, ma ha come svantaggio che la matrice di Vandermonde è spesso malcondizionata. + È efficace perchè una volta calcolati i coefficienti essi valgono per tutti i punti, ma + ha come svantaggio che la matrice di Vandermonde è spesso malcondizionata.

    - È possibile scrivere il polinomio di interpolazione raccogliendo le {r`y`}: + È possibile scrivere il polinomio di interpolazione raccogliendo + le {r`y`}:

    {r`p_n (x) = y_0 L_0 + y_1 L_1 + y_2 L_2 + \dots + y_n L_n`}

    - I polinomi {r`L_k`} sono detti polinomi di Lagrange, e hanno le seguenti proprietà: + I polinomi {r`L_k`} sono detti polinomi di Lagrange, e hanno le seguenti + proprietà:

    • - Valgono 1 in corrispondenza del nodo con lo stesso indice, 0 in corrispondenza dei nodi con indice diverso e {r`0 < n < 1`} in tutti gli altri casi. + Valgono 1 in corrispondenza del nodo con lo stesso + indice, 0 in corrispondenza dei nodi con indice diverso + e {r`0 < n < 1`} in tutti gli altri casi. {r` \begin{cases} @@ -120,11 +128,13 @@ export default function (props) {

      Si chiama base perchè sono linearmente indipendenti!

      - Questo metodo permette di calcolare il valore del polinomio di interpolazione in un singolo punto: + Questo metodo permette di calcolare il valore del polinomio di interpolazione in un singolo + punto:

      - Si può risparmiare tempo di calcolo calcolando una singola volta il numeratore con tutti i termini: + Si può risparmiare tempo di calcolo calcolando una singola volta il numeratore + con tutti i termini:

      {r`\omega_n = (x - x_0) \cdot (x - x_1) \cdot \dots \cdot (x - x_n)`}

      @@ -147,17 +157,16 @@ export default function (props) {

      {r`R_n(x) = f(x) - p_n(x)`}

      - In particolare, è interessante la sua norma a infinito, {r`\| f - p_n \|_\infty`}, che corrisponde alla distanza massima tra le due funzioni. + In particolare, è interessante la sua norma a + infinito, {r`\| f - p_n \|_\infty`}, che corrisponde alla distanza massima tra + le due funzioni.

      - Un teorema dice che esso è uguale a: TODO: Non credo serva. + Un teorema dice che esso è uguale a:

      {r`R_n(x) = \frac{ \omega_n(x) }{ (n + 1)! } \cdot f^{(n+1)}(\xi)`} -

      - TODO: Tutta la dimostrazione di queste due affermazioni. -

      L'errore nell'interpolazione dipende principalmente da due fattori:

      @@ -170,10 +179,12 @@ export default function (props) {

      - Fenomeno che si verifica cercando di interpolare la funzione di Runge ({r`\frac{1}{1 + 25x^2}`}). + Fenomeno che si verifica cercando di interpolare la funzione di + Runge ({r`\frac{1}{1 + 25x^2}`}).

      - Scegliendo nodi equispaziati, l'errore di interpolazione sarà enorme vicino ai due estremi dell'intervallo. + Scegliendo nodi equispaziati, l'errore di interpolazione sarà enorme vicino ai due + estremi dell'intervallo.

      Addirittura, più nodi verranno scelti, più esso sarà alto! @@ -184,7 +195,8 @@ export default function (props) {

      - Nodi ottenuti partizionando una semicirconferenza, e proiettando le partizioni sul diametro. + Nodi ottenuti partizionando una semicirconferenza, e proiettando le partizioni sul + diametro.

      La formula usata per ottenere {r`n`} punti è: diff --git a/src/routes/CalcoloNumerico/03_Interpolazione.less b/src/routes/CalcoloNumerico/03_Interpolazione.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/CalcoloNumerico/04_InterpolazioneATratti.js b/src/routes/CalcoloNumerico/04_InterpolazioneATratti.js index fca8f30..3f56664 100644 --- a/src/routes/CalcoloNumerico/04_InterpolazioneATratti.js +++ b/src/routes/CalcoloNumerico/04_InterpolazioneATratti.js @@ -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 (

      - Invece che costruire una singola funzione che interpola tutti i punti, per ogni intervallo tra due punti (sottointervallo) si costruisce una funzione apposta. + Invece che costruire una singola funzione che interpola tutti i punti, per ogni intervallo + tra due punti (sottointervallo) si costruisce una funzione apposta.

      @@ -24,12 +24,15 @@ export default function (props) {
      • sono polinomiali di grado massimo {r`n`}
      • sono continue fino al grado {r`n - 1`}
        • -
      • connettono {r`m + 2`} punti, e hanno {r`m`} sottointervalli
        • +
      • connettono {r`m + 2`} punti, e + hanno {r`m`} sottointervalli +
      • hanno funzioni definite appositamente per ogni sottointervallo

      - Significa che agli estremi dell'intervallo, i valori di tutte le derivate fino al grado {r`n - 1`} devono essere uguali: + Significa che agli estremi dell'intervallo, i valori di tutte le derivate fino al + grado {r`n - 1`} devono essere uguali:

      {r`\forall \ k \leq n-1, \forall \ i \in \{intervalli\}, \quad s_i^{(k)} (x_{i+1}) = s_i^{(k)} (x_{i+1})`}       @@ -58,7 +61,8 @@ export default function (props) {

      {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`}

      - Ha come vantaggi complessità computazionale molto più bassa e l'assenza del fenomeno di Runge, ma allo stesso tempo si perde la derivabilità della funzione. + Ha come vantaggi complessità computazionale molto più bassa e l'assenza del + fenomeno di Runge, ma allo stesso tempo si perde la derivabilità della funzione.

      Non hanno gradi di libertà. @@ -87,7 +91,8 @@ export default function (props) {

      {r`s_i(x) = \alpha_i + \beta_i \ ( x - x_i ) + \gamma_i \ ( x - x_i )^2 + \delta_i \ ( x - x_i )^3`} - Spesso si indica con {r`h`} la distanza orizzontale tra due punti di un sottointervallo. + Spesso si indica con {r`h`} la distanza orizzontale tra due punti di un + sottointervallo.
      @@ -171,7 +176,10 @@ export default function (props) { Classe di spline cubiche in cui:

        -
      • Negli intervalli {r`[x_0, x_2]`} e {r`[x_{m-1}, x_{m+1}]`} si presenta obbligatoriamente un polinomio di grado 3.
        • +
      • Negli + intervalli {r`[x_0, x_2]`} e {r`[x_{m-1}, x_{m+1}]`} si + presenta obbligatoriamente un polinomio di grado 3. +

      È unica. @@ -181,7 +189,8 @@ export default function (props) {

      - 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".

      Per loro è valida la seguente proprietà: diff --git a/src/routes/CalcoloNumerico/04_InterpolazioneATratti.less b/src/routes/CalcoloNumerico/04_InterpolazioneATratti.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.js b/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.js index f280559..de029dd 100644 --- a/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.js +++ b/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.js @@ -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 (

      @@ -15,15 +14,21 @@ export default function (props) { Interpolare dati sperimentali non fornisce quasi mai un modello del fenomeno.

      - Vogliamo costruire una funzione di regressione 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 funzione di regressione 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.

      Denominiamo:

      • {r`{\color{Orange} f}`}: la funzione "effettiva" del fenomeno
        • -
      • {r`{\color{Yellow} q}`}: la funzione di regressione che costruiamo per approssimarlo
        • -
      • {r`{\color{Red} Q }`}: la funzione "errore di regressione" da minimizzare
        • +
      • {r`{\color{Yellow} q}`}: la funzione di regressione che costruiamo + per approssimarlo +
        • +
      • {r`{\color{Red} Q }`}: la funzione "errore di regressione" da + minimizzare +
      • {r`(\ x_i, f(x_i)\ )`}: i punti sperimentali

      @@ -35,10 +40,12 @@ export default function (props) {

      - Trova la retta {r`{\color{Yellow} q}`} che meglio approssima tutti gli {r`m`} dati sperimentali. + Trova la retta {r`{\color{Yellow} q}`} che meglio approssima tutti + gli {r`m`} dati sperimentali.

      - Essendo una retta, avrà due parametri: il termine noto {r`a_0`}, e la pendenza {`a_1`}. + Essendo una retta, avrà due parametri: il termine noto {r`a_0`}, e la + pendenza {`a_1`}.

      {r`{\color{Yellow} q(x) } = a_0 + a_1 \cdot {\color{Green} x}`}

      @@ -50,7 +57,8 @@ export default function (props) {

      - Possiamo costruire una matrice di regressione {r`A`} contenente tutti i punti sperimentali: + Possiamo costruire una matrice di regressione {r`A`} contenente tutti + i punti sperimentali:

      {r` A = @@ -84,7 +92,9 @@ export default function (props) {

      - Trova il polinomio {r`{\color{Yellow} q}`} di grado {r`n-1`} che meglio approssima tutti gli {r`m`} dati sperimentali. + Trova il polinomio {r`{\color{Yellow} q}`} di + grado {r`n-1`} che meglio approssima tutti gli {r`m`} dati + sperimentali.

      Essendo un polinomio di grado {r`n-1`}, avrà {r`n`} parametri. @@ -92,7 +102,8 @@ export default function (props) { {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}`}

      - 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!

      @@ -104,7 +115,8 @@ export default function (props) {

      - Possiamo costruire una matrice di regressione {r`A`} contenente tutti i punti sperimentali a tutti i gradi del polinomio: + Possiamo costruire una matrice di regressione {r`A`} contenente tutti + i punti sperimentali a tutti i gradi del polinomio:

      {r` A = @@ -136,14 +148,18 @@ export default function (props) {

      {r`{\color{Red} Q } = \| A \cdot \alpha - y \|^2`} - Normalmente, i dati sono molti di più, ma se il numero di parametri {r`n`} fosse uguale al numero di dati {r`m`}, allora si otterrebbe il polinomio di interpolazione! + Normalmente, i dati sono molti di più, ma se il numero di + parametri {r`n`} fosse uguale al numero di dati {r`m`}, allora + si otterrebbe il polinomio di interpolazione!

      - Trova i coefficienti della combinazione lineare {r`{\color{Yellow} q}`} che meglio approssima tutti gli {r`m`} dati sperimentali. + Trova i coefficienti della combinazione lineare + {r`{\color{Yellow} q}`} che meglio approssima tutti + gli {r`m`} dati sperimentali.

      {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)}`} @@ -161,7 +177,8 @@ export default function (props) {

      - Possiamo costruire una matrice di regressione {r`A`} contenente tutti i punti sperimentali a tutti i gradi del polinomio: + Possiamo costruire una matrice di regressione {r`A`} contenente tutti + i punti sperimentali a tutti i gradi del polinomio:

      {r` A = @@ -208,7 +225,9 @@ export default function (props) {
      • Fattorizziamo {r`A = Q \cdot \begin{pmatrix} R\\ 0 \end{pmatrix}`}.
      • Calcoliamo {r`w = Q^T \cdot y`}.
        • -
      • Teniamo solo i primi n valori di {r`w`} e mettiamoli in {r`w_1`}.
        • +
      • Teniamo solo i primi n valori di {r`w`} e mettiamoli + in {r`w_1`}. +
      • Calcoliamo {r`R \cdot \alpha = w_1`}.
       @@ -220,13 +239,15 @@ export default function (props) { Ci sono infinite soluzioni, con {`n-k`} gradi di libertà.

      - Si cerca sempre di trovare la soluzione di norma minima, che, se {r`k \leq n \leq m`}, allora è unica. + Si cerca sempre di trovare la soluzione di norma minima, che, + se {r`k \leq n \leq m`}, allora è unica.

      Per trovarla:

        -
      • Fattorizziamo {r`A = U \cdot \Sigma \cdot V^T`} con la fattorizzazione SVD
        • +
      • Fattorizziamo {r`A = U \cdot \Sigma \cdot V^T`} con la fattorizzazione + SVD
      • Calcoliamo {r`\zeta = U^T \cdot y`}

      • @@ -250,7 +271,8 @@ export default function (props) {

      • Calcoliamo {r`\alpha = V \cdot \gamma`}
      - Gli zeri nella {r`\gamma`} sono i gradi di libertà, sono zero in modo che essi diano la norma minima. + Gli zeri nella {r`\gamma`} sono i gradi di libertà, sono zero in modo che essi + diano la norma minima.
      diff --git a/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.less b/src/routes/CalcoloNumerico/05_ApprossimazioneDatiSperimentali.less deleted file mode 100644 index e69de29..0000000 diff --git a/src/routes/RipassoDiAlgebraLineare.js b/src/routes/RipassoDiAlgebraLineare.js index b34dda4..4ea85db 100644 --- a/src/routes/RipassoDiAlgebraLineare.js +++ b/src/routes/RipassoDiAlgebraLineare.js @@ -287,12 +287,6 @@ export default function () {

      {r`\| f \|_\infty = max | f(x) |`}       - - TODO: Esiste? - - - TODO: Esiste? -