diff --git a/src/routes/CalcoloNumerico.js b/src/routes/CalcoloNumerico.js deleted file mode 100644 index 274d4c6..0000000 --- a/src/routes/CalcoloNumerico.js +++ /dev/null @@ -1,546 +0,0 @@ -import {ILatex, Panel, PLatex, Section, Timer, Todo} from "bluelib"; -import Example from "../components/Example"; -import Link from "../components/Link"; -import MenuList from "../components/MenuList"; - -const r = String.raw; - - -export default function (props) { - return ( -
-

Calcolo Numerico

-
- -
    -
  • Prof.ssa Silvia Bonettini
    • -
- - -

- E' composto da: -

-
    -
  • 2 domande sugli argomenti teorici
    • -
  • 1 domanda di implementazione algoritmo in MATLAB
    • -
- - -
    -
    2. -
    3. -
- -
-
- -

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

    - Particolari algoritmi che hanno: -

    -
      -
    • numeri reali in input e output
      • -
    • successioni delle quattro operazioni aritmetiche fondamentali come passi
      • -
    -     -
    -
    - -

    - Con i numeri floating point può capitare che un certo numero {r`\alpha`} non - sia rappresentato correttamente. -

    -

    - In tal caso, il numero si indica con {r`\alpha^*`}. -

    -     -
    -
    - -

    - È la differenza tra il numero desiderato e il numero rappresentato: -

    - {r`E_a = \left | \alpha - \alpha^* \right |`} -     - -

    - Indica quanto il numero rappresentato differisce dal numero desiderato: -

    - {r`\forall \alpha \neq 0, E_r = \frac{E_a}{\left | \alpha \right |}`} -     -
    -
    - -

    - Metodo con cui gestire gli underflow floating point: le cifre meno significative - vengono rimosse. -

    - - 
    -                            1.00  →  1.0
    
-                            1.01  →  1.0
    
-                            1.10  →  1.1
    
-                            1.11  →  1.1
-
    -     -     - -

    - Metodo con cui gestire gli underflow floating point: se la cifra più significativa di - quelle che devono essere rimosse è 1, allora aumenta di 1 anche quella meno signficativa - che viene tenuta. -

    - - 
    -                            1.00  →  1.0
    
-                            1.01  →  1.0
    
-                            1.10  →  1.1
    
-                            1.11  → 10.
-
    -     -     -
    -
    - -

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

    -

    - {r`E_r \leq k \cdot \beta^{1-t}`} -

    -
      -
    • - \beta è uguale alla base utilizzata (solitamente 2). -
      • -
    • - t è uguale al numero di cifre della mantissa. -
      • -
    • - k è uguale a 1 se il numero viene rappresentato per - troncamento oppure a {r`\frac{1}{2}`} se viene rappresentato per - arrotondamento. -
      • -
    -     - -

    - Associa un valore reale al suo corrispondente valore floating point, utilizzando uno dei - due metodi di gestione dell'undeflow. -

    - {r`fl(x) = (x)(1 + \epsilon_x)`} - - Indica che un valore è soggetto alla precisione di macchina. - {r`fl(1.11) = 1.1`} - -     -
    -
    - -

    - L'insieme {r`\mathbb{F}`} è il sottoinsieme dei numeri reali rappresentabili in - floating point dalla macchina che stiamo usando. -

    -

    - Operazioni tra elementi di {r`\mathbb{F}`} producono risultati - in {r`\mathbb{R}`}, che però decaderanno nuovamente a elementi - di {r`\mathbb{F}`}, perdendo informazioni. -

    -

    - Il teorema della precisione di macchina si applica quindi anche ai risultati delle operazioni. -

    -     - -
      -
    • Hanno più elementi neutri.
      • -
    • Un numero ha più opposti.
      • -
    • Non sono associative.
      • -
    • Non sono distributive.
      • -
    • Non vale la legge di annullamento del prodotto.
      • -
    -     -
    -
    - -

    - Errore derivato da underflow sui dati. -

    -

    - Si indica con {r`\epsilon_{nome\_var}`}. -

    - - L'errore sulla variabile x si indica con {r`\epsilon_{x}`}. - -     - -

    - Errore derivato da underflow durante l'esecuzione dell'algoritmo. -

    -

    - Si indica con {r`\epsilon_{num\_passo}`}. -

    - - L'errore al primo passo dell'algoritmo si indica con {r`\epsilon_{1}`}. - -     -
    -
    - -

    - Sensibilità di un problema all'errore inerente. -

    - - {r`y = \frac{1}{x}`} è mal condizionato intorno allo 0 e ben condizionato - lontano dallo 0. - -     - -

    - Sensibilità di un problema all'errore algoritmico. -

    - -

    - Cerchiamo un algoritmo che risolva {r`2x^* = 4`}. -

    -

    - Calcolare prima {r`t = fl \left( \frac{1}{4} \right)`} e - poi {r`x = fl ( 2 \cdot t )`} porta a una perdita di precisione. -

    -

    - Calcolare direttamente {r`x = fl \left( \frac{2}{4} \right)`} non ha alcuna - perdita di precisione e rende l'algoritmo più stabile del precedente. -

    -     -     -
    -
    - -

    - È il coefficiente di proporzionalità tra i dati e l'errore inerente. -

    -

    - Essendo sempre maggiore di uno, si può dire che sia un coefficiente di amplificazione. -

    -

    - Minore è l'indice di condizionamento, meglio condizionato è un problema. -

    -     - -

    - È il coefficiente di proporzionalità tra i dati e l'errore algoritmico. -

    -

    - Essendo sempre maggiore di uno, si può dire che sia un coefficiente di amplificazione. -

    -     -
    -
    - - TODO - - -

    - Il condizionamento della risoluzione di sistemi lineari è: -

    - {r`\frac{{\color{yellow} \|A\| \cdot \|A^{-1}\|} \cdot \| \Delta b \|}{\| b \|}`} -

    - In particolare, è segnato in giallo nella formula il numero di condizionamento: -

    - - {r`k(A) = \| A \| \cdot \| A^{-1} \|`} - -     -
    -
    - -

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

    -

    - Generalmente hanno una complessità temporale {r`O(n^3)`}. -

    -     - -

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

    -

    - Generalmente hanno una complessità temporale {r`O(n^2)`}. -

    -     -
    -
    - -

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

    - {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}}`} -     -
    -
    - Fattorizzazione {r`LU`}}> -

    - Se la matrice dei coefficienti del sistema non ha minori uguali a 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`} - - Abbiamo fatto questo metodo in Algebra Lineare, chiamandolo metodo di Gauss. - -

    - La matrice {r`L`} è così composta: -

    - {r` - \begin{cases} - L_{ii} = 1 \qquad \qquad (diagonale)\\ - L_{ik} = -\frac{A_{ik}}{A_{kk}} \qquad (tri.\ infer.) - \end{cases} - `} - - Sono i moltiplicatori usati per rendere annullare il triangolo inferiore! - -

    - La matrice {r`U`} è così composta: -

    - {r` - \begin{cases} - U_{ik} = A_{ik} \quad se\ i \leq k \quad (tri.\ super.)\\ - U_{ik} = 0 \qquad se\ i > k \quad (tri.\ infer.) - \end{cases} - `} -

    - Il sistema può essere poi risolto applicando due volte il metodo di sostituzione: -

    - {r` - \begin{cases} - L \cdot y = b\\ - U \cdot x = y - \end{cases} - `} -

    - Questo metodo ha costo computazionale: -

    - {r`{\color{Yellow} O\left(\frac{n^3}{3}\right)} + 2 \cdot O\left(\frac{n^2}{2}\right)`} -     - 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. -

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

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

    - Questo metodo ha costo computazionale: -

    - {r`{\color{Yellow} O\left(\frac{n^2}{2}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} -     - 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: -

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

    - Questo metodo ha costo computazionale: -

    - {r`{\color{Yellow} O\left(\frac{n^3}{3}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} -     -
    -
    - Fattorizzazione {r`LDL^{-1}`}}> -

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

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

    - In questo caso, si calcola solo la matrice L, utilizzando il metodo di pavimentazione. -

    - {r` - \begin{cases} - d_{ii} = A_{ii} - \sum_{k=1}^{i-1} ( d_{kk} \cdot (l_{jk})^2 )\\ - l_{ij} = \frac{A_{ij} - \sum_{k=1}^{j-1} l_{ik} \cdot d_{kk} \cdot l_{jk}}{d_ii} - \end{cases} - `} - -

    - La prima colonna della matrice sarà: -

    - {r` - \begin{cases} - d_{11} = A_{11} - l_{i1} = \frac{A_{i1}}{d_{11}} - \end{cases} - `} -

    - La seconda colonna della matrice sarà: -

    - {r` - \begin{cases} - d_{22} = A_{22} - d_{11} \cdot (l_{21})^2\\ - l_{i2} = \frac{A_{i2} - l_{i1} \cdot d_{11} \cdot l_{21}}{d_ii} - \end{cases} - `} -     -

    - Questo metodo ha costo computazionale: -

    - {r`{\color{Yellow} O\left(\frac{n^3}{6}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} -     - Fattorizzazione {r`\mathcal{L} \mathcal{L}^{-1}`}}> -

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

    - Il metodo di pavimentazione diventa: -

    - {r` - \begin{cases} - l_{ii} = \sqrt{A_{ii} - \sum_{k=1}^{i-1} (l_{ik})^2 }\\ - l_{ij} = \frac{A_{ij} - \sum_{k=1}^{j-1} l_{ik} \cdot l_{jk}}{l_ii} - \end{cases} - `} -

    - Questo metodo ha costo computazionale: -

    - {r`O\left(\frac{n^3}{3}\right) + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} -     -
    -
    - -

    - Matrice ricavata dalla seguente formula: -

    - {r`U(v) = I - \frac{1}{\alpha} \cdot v \cdot v^T`} - {r`\alpha = \frac{1}{2} \| v \|_{(2)}^2`} -     - Fattorizzazione {r`QR`}}> -

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

    - {r`A = Q \cdot R`} -

    - Le matrici si ottengono dal prodotto delle trasformazioni di Householder ({r`Q`} sulle colonne della matrice {r`A`}, trasformandola in una matrice triangolare superiore ({r`R`}). -

    -

    - Una volta fattorizzata, il sistema si può risolvere con: -

    - {r` - \begin{cases} - y = Q^T \cdot b\\ - R \cdot x = y - \end{cases} - `} -

    - Questo metodo ha costo computazionale: -

    - {r`{\color{Yellow} O\left(\frac{2 \cdot n^3}{3}\right)} + 2 \cdot O\left(\frac{n^2}{2}\right)`} -

    - TODO: l'algoritmo con tau per ricavare la q se non è in memoria -

    -     -
    -
    - - TODO - - - TODO - -
    -
    - - TODO - - - TODO - -
    -
    - - TODO - - - TODO - -
    -
    - - TODO - - - TODO - -
    -
    - - TODO - - - TODO - -
    -
    - -

    - 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. - -     -
    -
    - - TODO - - - TODO - -
    -
    - - TODO - - - TODO - - - TODO - - - TODO - -
    -
    - ) -} diff --git a/src/routes/CalcoloNumerico/00_Intro.js b/src/routes/CalcoloNumerico/00_Intro.js new file mode 100644 index 0000000..cecaf65 --- /dev/null +++ b/src/routes/CalcoloNumerico/00_Intro.js @@ -0,0 +1,251 @@ +import style from "./00_Intro.less" +import {ILatex, Panel, PLatex, Section, Timer} from "bluelib"; +import Link from "../../components/Link"; +import MenuList from "../../components/MenuList"; +import Example from "../../components/Example"; +import {Fragment} from "preact"; + +const r = String.raw; + + +export default function (props) { + return ( + +
    + +
      +
    • Prof.ssa Silvia Bonettini
      • +
    +     + +

    + E' composto da: +

    +
      +
    • 2 domande sugli argomenti teorici
      • +
    • 1 domanda di implementazione algoritmo in MATLAB
      • +
    +     + +
      +
      2. +
      3. +
    +     +
    +
    + +

    + 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) +
    • +     +     +
    +
    + +

    + Particolari algoritmi che hanno: +

    +
      +
    • numeri reali in input e output
      • +
    • successioni delle quattro operazioni aritmetiche fondamentali come passi
      • +
    +     +
    +
    + +

    + Con i numeri floating point può capitare che un certo numero {r`\alpha`} non + sia rappresentato correttamente. +

    +

    + In tal caso, il numero si indica con {r`\alpha^*`}. +

    +     +
    +
    + +

    + È la differenza tra il numero desiderato e il numero rappresentato: +

    + {r`E_a = \left | \alpha - \alpha^* \right |`} +     + +

    + Indica quanto il numero rappresentato differisce dal numero desiderato: +

    + {r`\forall \alpha \neq 0, E_r = \frac{E_a}{\left | \alpha \right |}`} +     +
    +
    + +

    + Metodo con cui gestire gli underflow floating point: le cifre meno significative + vengono rimosse. +

    + + 
    +                            1.00  →  1.0
    
+                            1.01  →  1.0
    
+                            1.10  →  1.1
    
+                            1.11  →  1.1
+
    +     +     + +

    + Metodo con cui gestire gli underflow floating point: se la cifra più significativa di + quelle che devono essere rimosse è 1, allora aumenta di 1 anche quella meno signficativa + che viene tenuta. +

    + + 
    +                            1.00  →  1.0
    
+                            1.01  →  1.0
    
+                            1.10  →  1.1
    
+                            1.11  → 10.
+
    +     +     +
    +
    + +

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

    +

    + {r`E_r \leq k \cdot \beta^{1-t}`} +

    +
      +
    • + \beta è uguale alla base utilizzata (solitamente 2). +
      • +
    • + t è uguale al numero di cifre della mantissa. +
      • +
    • + k è uguale a 1 se il numero viene rappresentato per + troncamento oppure a {r`\frac{1}{2}`} se viene rappresentato per + arrotondamento. +
      • +
    +     + +

    + Associa un valore reale al suo corrispondente valore floating point, utilizzando uno dei + due metodi di gestione dell'undeflow. +

    + {r`fl(x) = (x)(1 + \epsilon_x)`} + + Indica che un valore è soggetto alla precisione di macchina. + {r`fl(1.11) = 1.1`} + +     +
    +
    + +

    + L'insieme {r`\mathbb{F}`} è il sottoinsieme dei numeri reali rappresentabili in + floating point dalla macchina che stiamo usando. +

    +

    + Operazioni tra elementi di {r`\mathbb{F}`} producono risultati + in {r`\mathbb{R}`}, che però decaderanno nuovamente a elementi + di {r`\mathbb{F}`}, perdendo informazioni. +

    +

    + Il teorema della precisione di macchina si applica quindi anche ai risultati delle operazioni. +

    +     + +
      +
    • Hanno più elementi neutri.
      • +
    • Un numero ha più opposti.
      • +
    • Non sono associative.
      • +
    • Non sono distributive.
      • +
    • Non vale la legge di annullamento del prodotto.
      • +
    +     +
    +
    + +

    + Errore derivato da underflow sui dati. +

    +

    + Si indica con {r`\epsilon_{nome\_var}`}. +

    + + L'errore sulla variabile x si indica con {r`\epsilon_{x}`}. + +     + +

    + Errore derivato da underflow durante l'esecuzione dell'algoritmo. +

    +

    + Si indica con {r`\epsilon_{num\_passo}`}. +

    + + L'errore al primo passo dell'algoritmo si indica con {r`\epsilon_{1}`}. + +     +
    +
    + +

    + Sensibilità di un problema all'errore inerente. +

    + + {r`y = \frac{1}{x}`} è mal condizionato intorno allo 0 e ben condizionato + lontano dallo 0. + +     + +

    + Sensibilità di un problema all'errore algoritmico. +

    + +

    + Cerchiamo un algoritmo che risolva {r`2x^* = 4`}. +

    +

    + Calcolare prima {r`t = fl \left( \frac{1}{4} \right)`} e + poi {r`x = fl ( 2 \cdot t )`} porta a una perdita di precisione. +

    +

    + Calcolare direttamente {r`x = fl \left( \frac{2}{4} \right)`} non ha alcuna + perdita di precisione e rende l'algoritmo più stabile del precedente. +

    +     +     +
    +
    + +

    + È il coefficiente di proporzionalità tra i dati e l'errore inerente. +

    +

    + Essendo sempre maggiore di uno, si può dire che sia un coefficiente di amplificazione. +

    +

    + Minore è l'indice di condizionamento, meglio condizionato è un problema. +

    +     + +

    + È il coefficiente di proporzionalità tra i dati e l'errore algoritmico. +

    +

    + Essendo sempre maggiore di uno, si può dire che sia un coefficiente di amplificazione. +

    +     +
    +     + ) +} diff --git a/src/routes/CalcoloNumerico/00_Intro.less b/src/routes/CalcoloNumerico/00_Intro.less new file mode 100644 index 0000000..e69de29 diff --git a/src/routes/CalcoloNumerico/01_SistemiLineari.js b/src/routes/CalcoloNumerico/01_SistemiLineari.js new file mode 100644 index 0000000..0dabcae --- /dev/null +++ b/src/routes/CalcoloNumerico/01_SistemiLineari.js @@ -0,0 +1,247 @@ +import style from "./01_SistemiLineari.less" +import {ILatex, Panel, PLatex, Section, Todo} from "bluelib"; +import Link from "../../components/Link"; +import Example from "../../components/Example"; +import {Fragment} from "preact"; + +const r = String.raw; + + +export default function (props) { + return ( + +
    + + TODO + + +

    + Il condizionamento della risoluzione di sistemi lineari è: +

    + {r`\frac{{\color{yellow} \|A\| \cdot \|A^{-1}\|} \cdot \| \Delta b \|}{\| b \|}`} +

    + In particolare, è segnato in giallo nella formula il numero di condizionamento: +

    + + {r`k(A) = \| A \| \cdot \| A^{-1} \|`} + +     +
    +
    + +

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

    +

    + Generalmente hanno una complessità temporale {r`O(n^3)`}. +

    +     + +

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

    +

    + Generalmente hanno una complessità temporale {r`O(n^2)`}. +

    +     +
    +
    + +

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

    + {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}}`} +     +
    +
    + Fattorizzazione {r`LU`}}> +

    + Se la matrice dei coefficienti del sistema non ha minori uguali a 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`} + + Abbiamo fatto questo metodo in Algebra Lineare, chiamandolo metodo di Gauss. + +

    + La matrice {r`L`} è così composta: +

    + {r` + \begin{cases} + L_{ii} = 1 \qquad \qquad (diagonale)\\ + L_{ik} = -\frac{A_{ik}}{A_{kk}} \qquad (tri.\ infer.) + \end{cases} + `} + + Sono i moltiplicatori usati per rendere annullare il triangolo inferiore! + +

    + La matrice {r`U`} è così composta: +

    + {r` + \begin{cases} + U_{ik} = A_{ik} \quad se\ i \leq k \quad (tri.\ super.)\\ + U_{ik} = 0 \qquad se\ i > k \quad (tri.\ infer.) + \end{cases} + `} +

    + Il sistema può essere poi risolto applicando due volte il metodo di sostituzione: +

    + {r` + \begin{cases} + L \cdot y = b\\ + U \cdot x = y + \end{cases} + `} +

    + Questo metodo ha costo computazionale: +

    + {r`{\color{Yellow} O\left(\frac{n^3}{3}\right)} + 2 \cdot O\left(\frac{n^2}{2}\right)`} +     + 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. +

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

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

    + Questo metodo ha costo computazionale: +

    + {r`{\color{Yellow} O\left(\frac{n^2}{2}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} +     + 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: +

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

    + Questo metodo ha costo computazionale: +

    + {r`{\color{Yellow} O\left(\frac{n^3}{3}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} +     +
    +
    + Fattorizzazione {r`LDL^{-1}`}}> +

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

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

    + In questo caso, si calcola solo la matrice L, utilizzando il metodo di pavimentazione. +

    + {r` + \begin{cases} + d_{ii} = A_{ii} - \sum_{k=1}^{i-1} ( d_{kk} \cdot (l_{jk})^2 )\\ + l_{ij} = \frac{A_{ij} - \sum_{k=1}^{j-1} l_{ik} \cdot d_{kk} \cdot l_{jk}}{d_ii} + \end{cases} + `} + +

    + La prima colonna della matrice sarà: +

    + {r` + \begin{cases} + d_{11} = A_{11} + l_{i1} = \frac{A_{i1}}{d_{11}} + \end{cases} + `} +

    + La seconda colonna della matrice sarà: +

    + {r` + \begin{cases} + d_{22} = A_{22} - d_{11} \cdot (l_{21})^2\\ + l_{i2} = \frac{A_{i2} - l_{i1} \cdot d_{11} \cdot l_{21}}{d_ii} + \end{cases} + `} +     +

    + Questo metodo ha costo computazionale: +

    + {r`{\color{Yellow} O\left(\frac{n^3}{6}\right)} + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} +     + Fattorizzazione {r`\mathcal{L} \mathcal{L}^{-1}`}}> +

    + È 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}`} +

    + Il metodo di pavimentazione diventa: +

    + {r` + \begin{cases} + l_{ii} = \sqrt{A_{ii} - \sum_{k=1}^{i-1} (l_{ik})^2 }\\ + l_{ij} = \frac{A_{ij} - \sum_{k=1}^{j-1} l_{ik} \cdot l_{jk}}{l_ii} + \end{cases} + `} +

    + Questo metodo ha costo computazionale: +

    + {r`O\left(\frac{n^3}{3}\right) + O\left(\frac{n^3}{3}\right) + 2 \cdot O\left(\frac{n^2}{2}\right)`} +     +
    +
    + +

    + Matrice ricavata dalla seguente formula: +

    + {r`U(v) = I - \frac{1}{\alpha} \cdot v \cdot v^T`} + {r`\alpha = \frac{1}{2} \| v \|_{(2)}^2`} +     + Fattorizzazione {r`QR`}}> +

    + 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`}: +

    + {r`A = Q \cdot R`} +

    + Le matrici si ottengono dal prodotto delle trasformazioni di Householder ({r`Q`} sulle colonne della matrice {r`A`}, trasformandola in una matrice triangolare superiore ({r`R`}). +

    +

    + Una volta fattorizzata, il sistema si può risolvere con: +

    + {r` + \begin{cases} + y = Q^T \cdot b\\ + R \cdot x = y + \end{cases} + `} +

    + Questo metodo ha costo computazionale: +

    + {r`{\color{Yellow} O\left(\frac{2 \cdot n^3}{3}\right)} + 2 \cdot O\left(\frac{n^2}{2}\right)`} +

    + TODO: l'algoritmo con tau per ricavare la q se non è in memoria +

    +     +
    +
    + + TODO + + + TODO + +
    +     + ) +} diff --git a/src/routes/CalcoloNumerico/01_SistemiLineari.less b/src/routes/CalcoloNumerico/01_SistemiLineari.less new file mode 100644 index 0000000..e69de29 diff --git a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js new file mode 100644 index 0000000..0a405dd --- /dev/null +++ b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.js @@ -0,0 +1,45 @@ +import style from "./02_ZeriDiFunzione.less"; +import {Fragment} from "preact"; +import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib"; + +const r = String.raw; + + +export default function (props) { + return ( + +
    + + TODO + + + TODO + +
    +
    + + TODO + + + TODO + +
    +
    + + TODO + + + TODO + +
    +
    + + TODO + + + TODO + +
    +     + ) +} diff --git a/src/routes/CalcoloNumerico/02_ZeriDiFunzione.less b/src/routes/CalcoloNumerico/02_ZeriDiFunzione.less new file mode 100644 index 0000000..e69de29 diff --git a/src/routes/CalcoloNumerico/03_Interpolazione.js b/src/routes/CalcoloNumerico/03_Interpolazione.js new file mode 100644 index 0000000..31a0889 --- /dev/null +++ b/src/routes/CalcoloNumerico/03_Interpolazione.js @@ -0,0 +1,46 @@ +import style from "./03_Interpolazione.less"; +import {Fragment} from "preact"; +import {Section, Panel, ILatex, BLatex, PLatex, Todo} from "bluelib"; +import Example from "../../components/Example"; + +const r = String.raw; + + +export default function (props) { + return ( + +
    + +

    + 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. + +     +
    +
    + + TODO + + + TODO + +
    +
    + + TODO + + + TODO + + + TODO + + + TODO + +
    +     + ) +} diff --git a/src/routes/CalcoloNumerico/03_Interpolazione.less b/src/routes/CalcoloNumerico/03_Interpolazione.less new file mode 100644 index 0000000..e69de29 diff --git a/src/routes/CalcoloNumerico/index.js b/src/routes/CalcoloNumerico/index.js new file mode 100644 index 0000000..41816d2 --- /dev/null +++ b/src/routes/CalcoloNumerico/index.js @@ -0,0 +1,23 @@ +import {ILatex, Panel, PLatex, Section, Timer, Todo} from "bluelib"; +import Example from "../../components/Example"; +import Link from "../../components/Link"; +import MenuList from "../../components/MenuList"; +import Intro from "./00_Intro"; +import SistemiLineari from "./01_SistemiLineari"; +import ZeriDiFunzione from "./02_ZeriDiFunzione"; +import Interpolazione from "./03_Interpolazione"; + +const r = String.raw; + + +export default function (props) { + return ( +
    +

    Calcolo Numerico

    + + + + +
    + ) +}