Esercitazione 1

Esercizio 1

x = [pi pi/2]; %[3.1416,1.5708]

y = [0 pi/2]; %[0 ,1.5708]
v = sin(x) + cos(y);
% v(1)=sin(π)+cos(0)=0+1=1
% v(2)=sin(π/2)+cos(π/2)=1+0=1 Risultato: v = [1, 1].

x = [1 ; 4];
y = [2; 8];
t1 = x .* y; %t1 [2;32] 2×1 double
t2 = x * y; %Errore non si usa * per moltiplicare ma .*
t3 = x * y'; % [2,8;8,32] 2×2 double
t4 = x ./ y; % [0.5000;0.5000] 2×1 double

A = [-1 2; 5 4];
B = A .^ 2; %[1,4;25,16] 2×2 double
C = exp(A); %[0.3679, 7.3891 ;148.4132, 54.5982]
D = sqrt(A); %[0 + 1i,1.4142 + 0i;2.2361 + 0i,2 + 0i]

a = realmax * 10; %Inf

b = realmin / 1.e5; %2.2251e-313
c = 1 + eps / 4; %1
d = 0 / 0; %NaN
e = 1 / 0; %Inf

Esercizio 2

% Vettore z di dimensione 20
z_for = zeros(1, 20);
for k = 1:20
z_for(k) = k;
end
z_vec = 1:20;

% Vettore v di dimensione 100

v_for = zeros(1, 100);
 h = (10 - (-3)) / (100 - 1);
for i = 2:100
v_for(i) = -3 + h * (i - 1);
end
v_vec = -3 + h * (1:99);
%Vettore w
a = 0; % Puoi cambiare questo valore
n = 10; % Puoi cambiare n
h = 1 / (n - 1);
w_for = zeros(1, n);
for k = 1:n
w_for(k) = a + (k - 1) * h;
end
w_vec = a + (0:n-1) * h;

Esercizio 3

function n = norma2(x)
n = sqrt(sum(x.^2));
end
x = [5, -8, 7];
y = [-3.2, 5, 10^-4, 2.8, 3*10^2];
w = zeros(1, 30); % Inizializzazione di w
w(1) = 1;
for i = 2:30
w(i) = 3 * i / (i - 1); % Calcolo degli elementi di w
end
fprintf('Norma di x (funzione norma2): %.4f\n', norm_x);

Esercizio 4

function n = norma_p(x, p)
 % Controlla se p è minore di 1
if p < 1
error('Il valore di p deve essere maggiore o uguale a 1');
end

% Calcola la norma p
if p == inf
% Norma infinita: massimo valore assoluto degli elementi di x
n = max(abs(x));
else
% Norma p: (somma dei valori assoluti elevati a p)^(1/p)
n = (sum(abs(x).^p))^(1/p);
end
end
x = [3, -4, 5, -6];
esempio = norma_p(x, 2);
fprintf('Norma di x con p = inf: %.4f\n', esempio);

Esercizio 5

function [minA,rigaA,colA] = minimo_elemento(A)

minA=A(1,1);
rigaA = 1;
colA = 1;
[m,n]=size(A);

for i=1:m
for j=1:n
if(A(i,j)<minA)
minA=A(i,j);
rigaA=i;
colA=j;
end
end
end

end

A = [4,2,3;4,5,6;7,1,9];
[min_elem, row_idx, col_idx] = minimo_elemento(A);
fprintf('Il minimo elemento di A è: %.2f\n', min_elem);
fprintf('Posizione: (%d, %d)\n', row_idx, col_idx);
Esercizio 6

function maxA = elem_maggiore(A)

maxA=abs(A(1,1));
[m,n]=size(A);

for i=1:m
for j=1:n
if(A(i,j)<maxA)
maxA=abs(A(i,j));
end
end
end

end
A = [1.504e-33, 2, 1.550e-1;
3, 21, 5;
5, 1e-2, -4e2];
norma_inf_mia = elem_maggiore(A);
fprintf('La norma infinito di A è: %.2f\n', norma_inf_mia);
norma_inf_matlab =norm(A, inf);
fprintf('La norma infinito di A NATIVA è: %.2f\n', norma_inf_matlab);
fprintf('Errore relativo: %.4e\n', (abs(norma_inf_mia - norma_inf_matlab/norma_inf_matlab)));

Esercizio 7

function y = prodottoMatriceVettore(A,x)
[n,m] = size(A);
t = length(x);
if t~=n
error("devono avere lo stesso numero di riche o colonne");
end
 y = zeros(m,1); %1 column
for i = 1:n
sum = 0;
for j=1:m
sum=sum + A(i,j)*x(j);
end
y(i) = sum;
end
end

Esercizio 8

k = 0;
somma = 0;
N = 0;
% Ciclo while finché la somma non supera 2000
while somma <= 2000
somma = somma + 3 * k^2;
k = k + 1;
N = N + 1;
end
fprintf('Il numero minimo di termini richiesti è: %d\n', N);
fprintf('La somma finale è: %.0f\n', somma);

Esercizio 9

function y = approssima_esponenziale(x, n)
y = 0;
for k = 0:n
y = y + (x^k) / factorial(k);
end
end
y1_esatto = exp(x1);
errore_relativo1 = abs(y1_approssimato - y1_esatto) / abs(y1_esatto);
fprintf('Errore relativo per e^30: %.4e\n\n', errore_relativo1);
Esercitazione 2
Esercizio 1 solupper

function [x, detU] = solupper(U, b)

% Calcola la soluzione di un sistema lineare con matrice triangolare superiore
% U è la matrice triangolare superiore, b è il termine noto

n = length(b); % Numero di incognite

x = b; % Inizializza il vettore delle soluzioni con il termine noto

% Calcolo del determinante (prodotto degli elementi diagonali di U)

detU = 1;
for i = 1:n
% Controllo se l'elemento diagonale è nullo o molto piccolo
if abs(U(i, i)) < eps
disp("Matrice non invertibile (determinante zero)");
error('La matrice è singolare');
else
% Moltiplica il determinante per l'elemento diagonale
detU = detU * U(i, i);
end
end

% Controllo se il determinante è diverso da zero (matrice invertibile)

if detU ~= 0
disp(['Matrice invertibile, determinante = ', num2str(detU)]);

% Risoluzione del sistema usando il metodo di sostituzione all'indietro

 x(n) = b(n) / U(n, n); % Risolvi l'ultima incognita

% Ciclo di sostituzione all'indietro per le altre incognite

for i = n-1:-1:1 % Itera dalla penultima riga alla prima
% Calcola il contributo delle variabili già risolte
molt = b(i) - U(i, i+1:n) * x(i+1:n);
x(i) = molt / U(i, i); % Risolvi per x(i)
end

% Stampa il vettore delle soluzioni

disp('Il vettore delle soluzioni è:');
disp(x);
else
disp("La matrice non è invertibile");
end
end
% Esempio di matrice U e termine noto b
U = [1 2 3; 0 4 5; 0 0 6];
b = [9; 13; 18];

% Chiamata alla funzione

solupper(U, b);
%Output Il vettore delle soluzioni è:
1.0000
-0.5000
3.000
% Script per verificare la correttezza della funzione solupper
b1 = rand(5,1);
U1 = rand(5);
U1 = triu(U1);

[xc, d] = solupper(U1, b1);

x = U1 \ b1; %non e diviso
err = norm(x - xc) / norm(x);

fprintf('Errore relativo: %e \n', err);

Esercizio 2 sollower

function [x, detL] = solLpper(L, b)

% Calcola la soluzione di un sistema lineare con matrice triangolare inferiore
% L è la matrice triangolare inferiore, b è il termine noto
 n = length(b); % Numero di incognite
x = zeros(n, 1); % Inizializza il vettore delle soluzioni con zero

% Calcolo del determinante (prodotto degli elementi diagonali di L)

detL = 1;
for i = 1:n
% Controllo se l'elemento diagonale è nullo o molto piccolo (approssimazione numerica)
if abs(L(i, i)) < eps
disp("Matrice non invertibile (determinante zero)");
error('La matrice è singolare');
else
% Moltiplica il determinante per l'elemento diagonale
detL = detL * L(i, i);
end
end

% Controllo se il determinante è diverso da zero (matrice invertibile)

if detL ~= 0
disp(['Matrice invertibile, determinante = ', num2str(detL)]);

% Risoluzione del sistema usando il metodo di sostituzione in avanti

x(1) = b(1) / L(1, 1); % Risolvi la prima incognita

% Ciclo di sostituzione in avanti per le altre incognite

for i = 2:n % Itera dalla seconda incognita alla n-esima
% Calcola il contributo delle variabili già risolte
molt = b(i) - L(i, 1:i-1) * x(1:i-1); % Sottrai il contributo delle variabili già
risolte
x(i) = molt / L(i, i); % Risolvi per x(i)
end

% Stampa il vettore delle soluzioni

disp('Il vettore delle soluzioni è:');
disp(x);
else
disp("La matrice non è invertibile");
end
end

% Esempio di matrice L e termine noto b

L = [1 0 0; 2 3 0; 4 5 6];
b = [9; 13; 18];

% Chiamata alla funzione

solLpper(L, b);
% Script per verificare la correttezza della funzione sollower

b1 = rand(5,1);
L1 = rand(5);
L1 = tril(L1);

[xc, d] = sollower(L1, b1);

x = L1 \ b1;
err = norm(x - xc) / norm(x);

fprintf('Errore relativo: %e \n', err);

L'errore relativo dovrebbe essere molto piccolo.

Esercizio 3 gauss1

function [L,U] = gauss1(A)

[m,n] = size(A);
if m ~= n
error('La matrice non è quadrata');
end

for k = 1:n-1
if abs(A(k,k)) < eps
error('Fattorizzazione non calcolabile: elemento diagonale zero');
else
for i = k+1:n
A(i,k) = A(i,k)/A(k,k);
for j = k+1:n
A(i,j) = A(i,j) - A(k,j)*A(i,k);
end
end
end
end

U = triu(A);
L = (A - U) + eye(n);
end
% Script per verificare la correttezza di gauss1

A = [1e-15 1 -2; 1 4 1; 2 5 6];

x = ones(3,1);
 b = A * x;

[L,U] = gauss1(A);

y = L \ b;
xc = U \ y;

err = norm(x - xc) / norm(x);

fprintf('Errore relativo: %e \n', err);

Esercizio 4 LU con pivoting parziale

function [L,U,p] = gauss2(A)

[m,n] = size(A);
if m ~= n
error('La matrice non è quadrata');
end
p = 1:n;
for k = 1:n-1
[amax, ind] = max(abs(A(k:n,k)));
ind = ind + k - 1;
if ind ~= k
aux = p(k);
p(k) = p(ind);
p(ind) = aux;

temp = A(k,:);
A(k,:) = A(ind,:);
A(ind,:) = temp;
end

if abs(A(k,k)) < eps

error('Fattorizzazione non calcolabile');
 else
A(k+1:n,k) = A(k+1:n,k)/A(k,k);
A(k+1:n,k+1:n) = A(k+1:n,k+1:n) - A(k+1:n,k)*A(k,k+1:n);
end
end

U = triu(A);
L = (A - U) + eye(n);
end
% Script per verificare la correttezza di gauss2

A = [-5 8 -7; 12 -5 -3; 1 10 14];

b = A * ones(3,1);

[L,U,p] = gauss2(A);

b = b(p);
y = L \ b;
x = U \ y;

err = norm(x - ones(3,1)) / norm(ones(3,1));

fprintf('Errore relativo: %e \n', err);

idx = 1:3;
if ~isequal(p, idx)
fprintf('Pivoting effettuato\n');
else
fprintf('No pivoting\n');
end

Esercizio 5 Matrice Hilbert

La matrice di Hilbert è definita come:

function A = hilbert(n)
A = zeros(n);
for i = 1:n
for j = 1:n
A(i,j) = 1/(i+j-1);
end
end
end
Esercizio 6 sol_sist

function [xc, ncond, normr, d] = sol_sist(A, b)

xc = A \ b;
ncond = cond(A, 2);
r = b - A*xc;
normr = norm(r);
d = ncond * normr / norm(b);
end
clear

for n = 4 : 2 : 10
A = hilbert(n);
x_es = ones(n, 1);
b = A * x_es;

[xc, ncond, normr, d] = sol_sist(A, b);

fprintf('Caso n = %d \n', n)
fprintf('Ncond = %e \n', ncond)
fprintf('Norma residuo = %e \n', normr)
fprintf('Stima errore = %e \n', d)
fprintf('Errore effettivo = %e \n\n', norm(xc - x_es)/norm(x_es))
end
Esercitazione 3
Esercizio 1 Cholesky

function [L, deter] = cholesky_decomposition(A)

% Verifica che la matrice sia quadrata
[m, n] = size(A);
if m ~= n
error("La matrice deve essere quadrata");
end

L = zeros(n); % Inizializza L come matrice triangolare inferiore

deter = 1; % Determinante iniziale

for j = 1:n
for i = j:n
% Calcola il valore s
s = A(i, j) - L(i, 1:j-1) * L(j, 1:j-1)';
% Nota: L(i, 1:j-1) * L(j, 1:j-1)' rappresenta la somma per k = 1, ..., j-1

if i == j % Caso diagonale
if s <= 0
error("La matrice non è definita positiva");
else
L(j, j) = sqrt(s); % Calcola l'elemento diagonale
deter = deter * s; % Aggiorna il determinante
end
else % Caso non diagonale
L(i, j) = s / L(j, j); % Calcola l'elemento fuori diagonale
end
end
end
end
Esercizio 2 QR

function [Q, R] = myQR(A)

% INPUT:
% A - Matrice da fattorizzare (n x m, con n >= m).
% OUTPUT:
% Q - Matrice ortogonale (n x n).
% R - Matrice triangolare superiore (n x m).

[n, m] = size(A); % Determina le dimensioni della matrice A.

sigma = zeros(n, 1); % Inizializza un vettore per memorizzare le norme dei vettori
colonna.

for k = 1:n
% Calcolo del vettore di Householder per il k-esimo passo.
sigma(k) = sqrt(sum(A(k:n, k).^2)); % Calcola la norma 2 del vettore colonna k a
partire dalla riga k.
A(k, k) = A(k, k) + sigma(k); % Modifica il pivot per costruire il vettore di
Householder.
alpha = sigma(k) * A(k, k); % Calcola il parametro alpha per la normalizzazione.

for j = k+1:n
% Calcolo di tau per eliminare gli elementi sotto il pivot.
tau = (A(k:n, k)' * A(k:n, j)) / alpha; % Proiezione del vettore j lungo il
vettore di Householder.
A(k:n, j) = A(k:n, j) - tau * A(k:n, k); % Aggiorna il vettore colonna j.
end
end

R = triu(A); % Estrae la parte triangolare superiore della matrice risultante.

Q = eye(n) - 2 * (A * A') / alpha; % Calcola la matrice ortogonale Q (approssimazione).
end
Esercizio 3 Jacobi

function [x, err] = jacobi(A, b, kmax, x0, xes)

n = length(x0);
x = x0;

% Calcolare la diagonale di A
d = diag(A);
for i = 1:n
if abs(d(i)) < eps
error('Un elemento diagonale è nullo');
end
end

% Iterazioni di Jacobi
for k = 1:kmax
xold = x;
for i = 1:n
s = 0;
for j = 1:n
if j ~= i
s = s + A(i,j) * xold(j);
end
end
x(i) = (b(i) - s) / A(i,i);
end
err(k) = norm(x - xes) / norm(xes); % Calcolo errore relativo
end
end
% Script per testare il metodo di Jacobi
n = 20;
A = diag(-3*ones(1, n)) + diag(ones(1, n-1), 1) + diag(ones(1, n-1), -1);
b = ones(n, 1); % Vettore b di dimensione n

% Soluzione esatta con backslash

x_exact = A \ b;

% Esegui 10 iterazioni del metodo di Jacobi

x0 = zeros(n, 1); % Iterata iniziale
kmax = 10; % Numero massimo di iterazioni
[x, err] = jacobi(A, b, kmax, x0, x_exact);
Esercizio 4 Gauss-Seidel

function [x, err] = gaussSeidel(A, b, kmax, x0, xes)

n = length(x0);
x = x0;

d = diag(A);
for i = 1:n
if abs(d(i)) < eps
error('Un elemento diagonale è nullo');
end
end

for k = 1:kmax
for i = 1:n
% Calcola la somma dei termini prima dell'elemento diagonale
somma_prima = A(i, 1:i-1) * x(1:i-1);

% Calcola la somma dei termini dopo l'elemento diagonale

somma_dopo = A(i, i+1:n) * x(i+1:n);

% Aggiorna la componente i-esima di x

x(i) = (b(i) - somma_prima - somma_dopo) / A(i, i);
end

% Calcola l'errore relativo

err(k) = norm(x - xes) / norm(xes);
end

n = 20;
A = diag(-3*ones(1, n)) + diag(ones(1, n-1), 1) + diag(ones(1, n-1), -1); % Matrice
tridiagonale
b = ones(n, 1); % Vettore b di dimensione n

% Soluzione esatta con backslash

x_exact = A \ b;
 % Esegui 10 iterazioni del metodo di Gauss-Seidel
x0 = zeros(n, 1); % Iterata iniziale
kmax = 10; % Numero massimo di iterazioni
[x, err_GS] = gaussSeidel(A, b, kmax, x0, x_exact);

err_GS'

Esercitazione 4
1) Metodo di Bisezione per la Radice Quadrata

function [c, k] = bisezione_f0(f, a, b, Nmax, tolleranza)

% BISEZIONE_F0 Metodo di bisezione per trovare una radice di f in [a, b]
%
% INPUT:
% f - funzione per la quale trovare la radice
% a, b - estremi dell'intervallo iniziale (f(a)*f(b) < 0)
% Nmax - massimo numero di iterazioni consentite
% tolleranza - errore massimo accettabile
%
% OUTPUT:
% c - radice approssimata
% k - numero di iterazioni effettuate

% Verifica delle condizioni iniziali

if f(a) * f(b) >= 0
error("Il teorema di esistenza degli zeri non è soddisfatto: f(a)*f(b) >= 0");
end

% Valutazione iniziale
fa = f(a);
fb = f(b);

% Algoritmo di bisezione
for k = 1:Nmax
% Calcolo del punto medio
c = a + (b - a) / 2;
fc = f(c);

% Stampa dell'iterazione corrente

 fprintf('Iterazione %d: c = %.10f, f(c) = %.10f\n', k, c, fc);

% Controllo del criterio di arresto

if abs(fc) <= tolleranza
fprintf('Criterio d''arresto soddisfatto dopo %d iterazioni.\n', k);
return;
elseif k == Nmax
fprintf('Massimo numero di iterazioni raggiunto.\n');
return;
end

% Aggiornamento degli estremi

if fa * fc < 0
b = c;
fb = fc;
else
a = c;
fa = fc;
end
end
end
% Definizione della funzione
f = @(x) x^3 - x - 2;

% Intervallo iniziale e parametri

a = 1;
b = 2;
Nmax = 50;
tolleranza = 1e-6;

% Chiamata alla funzione

[c, k] = bisezione_f0(f, a, b, Nmax, tolleranza);

% Risultato
fprintf('La radice trovata è c = %.10f dopo %d iterazioni.\n', c, k);

2) Metodo di Newton per la Radice Quadrata

 %Soluzione:
function [x,k] = newton_radice(x,N,tau,Nmax)

if x <= 0
error('Dato iniziale non compatibile')
end

for k = 1 : Nmax

if x == 0
error('Metodo non applicabile, x = 0')
end

fx = x^2 - N;
dfx = 2*x;
xnew = x - fx/dfx;
fxnew = xnew^2 - N;

if abs(fxnew) <= tau & abs(x - xnew)/abs(xnew) <= tau

fprintf('Criterio di arresto raggiunto')
break;
end

x = xnew;
end

if k == Nmax
fprintf('Criterio di arresto non raggiunto')
end

3) Metodo di Bisezione per lo Zero di una Funzione

4) Metodo di Newton per lo Zero di una Funzione

Esercitazione 5
1) Matrice di Vandermonde

%Soluzione:
function V = vandermonde(x)

n = length(x);

x = x(:); % forzo x ad essere colonna

for i = 1 : n
V(:,i) = x.^(i-1);
end
2) Dato un Polinomio

function p = val_pol(a,x)
% val_pol - function per la valutazione di un polinomio
% p(x) = a(1)+a(2)x+...+a(n)x^n
% in un vettore di nodi x
% Input: a, vettore di n componenti contenente i coefficienti del
% polinomio
% x, vettore di m componenti contenente i nodi in cui
% valutare il polinomio
% Output: p, vettore di m componenti contenente i valori
% del polinomio in x_1,...,x_m

n = length(a);
p = a(1);
pot = x;

for i = 2 : n
p = p + a(i)*pot;
pot = pot.*x;
end

3) Polinomio Interpolante

Soluzione:
clear
close all % chiude tutte le finestre grafiche aperte

% Punti di interpolazione
x = (1:4)';
y = [3;5;6;4];
 % Coefficienti polinomio interpolante
a = interp(x,y);
pz = val_pol(a,3.5)

% Grafico dei punti di interpolazione

plot(x,y,'rx','LineWidth',2)
hold on

% Grafico del polinomio interpolante

zz = linspace(1,4,50);
pzz = val_pol(a,zz);
plot(zz,pzz,'g')

4) Funzione di Runge

clear
close all

for n = 5 : 3 : 20

% Dati e funzione
%x = linspace(-1,1,n)'; % nodi equidistanti
i = (0 : n-1)';
x = cos( (2*i+1)*pi/(2*(n))); % nodi di Chebychev
y = 1./(1+25*x.^2);
figure % aprire una nuyova finestra grafica
plot(x,y,'rx','LineWidth',2)
hold on
fplot(@(x) 1./(1+25*x.^2),[-1,1])

% Polinomio interpolante
V = vander(x);
V = V(:,n:-1:1);
a = V \ y;

% Grafico del polinomio interpolante

z = linspace(-1,1,50);
a = a(n:-1:1);
pz = polyval(a,z);
plot(z,pz,'b')

end
5) Polinomio di Lagrange

clear
close all % chiude tutte le finestre grafiche aperte

% Punti di interpolazione
x = (1:4)';
y = [3;5;6;4];

% Grafico dei punti di interpolazione

plot(x,y,'rx','LineWidth',2)
hold on

% Grafico del polinomio interpolante

zz = linspace(1,4,50);
pzz = interp_lag(x,y,zz);
plot(zz,pzz,'g')

6) Interpolazione della Velocità di un Corpo

7) Interpolazione della Popolazione degli Stati Uniti

Soluzione:
clear
close all

% Dati
n = 10;
x = [1900 : 10: 1990]';
y = [76 92 105.7 122.8 131.7 150.7 179 205 226.5 248.7]';
plot(x,y,'x','LineWidth',3)
hold on

% Vandermonde
V = vander(x);
V = V(:,n:-1:1);
a = V \ y;
z = linspace(1900,1990,100);
pz = polyval(a(n:-1:1),z);
plot(z,pz,'b','LineWidth',1)

% Lagrange
pzz = interp_lag(x,y,z);
plot(z,pzz,'g','LineWidth',1)

8) Funzione di Runge

clear
close all

for n = 5 : 3 : 20
 % Dati e funzione
x = linspace(-1,1,n)'; % nodi equidistanti
y = 1./(1+25*x.^2);
figure % aprire una nuyova finestra grafica
plot(x,y,'rx','LineWidth',2)
hold on
fplot(@(x) 1./(1+25*x.^2),[-1,1])

% Grafico del polinomio interpolante

z = linspace(-1,1,50);
pz = interp_lag(x,y,z);
plot(z,pz,'b')

end

function lv = interp_lag(x,y,v)

if length(x)~=length(y)
error('Dimensioni di x e y incompatibili')
end
n = length(y);

lv = zeros(size(v));
for j = 1 : n

ljv = ones(size(v));
for i = 1 : n
if i ~=j
ljv = ljv.*(v-x(i))/(x(j)-x(i));
end
end
lv = lv + y(j)*ljv;

end

Esercitazione 6
1) Problema ai Minimi Quadrati

function alpha = my_minq(A,y)

% Controlli sugli input

[m,n] = size(A);
if n > m
error('n maggiore di m')
end

if rank(A) < n
error('Caso degenere')
end

% Calcolo della soluzione del problema ai minimi quadrati

y = y(:); % forzo y ad essere colonna
[Q,R] = qr(A);
R = R(1:n,1:n); % R = R(1:n,:)
ytilde = Q'*y;
alpha = R \ ytilde(1:n);
2) Tensione Superficiale in un Liquido

% Dati
t = [0 10 20 30 40 80 90 100]'; %x
s = [68.0 67.1 66.4 65.6 64.6 61.8 61.0 60.0]'; %y

%RETTA AI MINIMI QUADRATI

%calcolo dei coefficienti della retta ai miniumi quadrati
m = length(t);
A = [ones(m,1) t]; %è la struttura di A, ha tutti uni nella prima colonna
alpha = my_minq(A,s);

plot(t,s, 'ro'); %punti rappresentati come cerchi rossi

hold on
z = linspace(t(1),t(m)); %creo un vettore di punti equispaziati
% z rapprsenta i punti su cui verranno valutate le funzioni. viene usato
% per traccuare le curve in modo continuo tra i valori dei dati discreti
pz = alpha(1) + alpha(2)*z; %calolca i valore della retta interpolante
% in corrispondenza dei punti del vettore z
% p(z) a1 + a2*z , insomma serve a calocare i valori della retta
% interpolante nei punti del vettore
plot(z,pz,'b'); %b indica che la retta sarà blu

%POLINOMIO
%calcolo dei coefficienti del polinomio interpolante
V = vander(t);
V = V(:,m:-1:1);%significa che stai prendendo tutte le righe, ma le colonne in ordine inverso
a = V \s;
%l'ordine degli elementi è inverso, volgiamo da t^0 a t^m-1
a = a(m:-1:1); %vettore dei coefficineti del polinomio interpolante

pz_interp = polyval(a,z);%a è il vettore deu coefficienti del polinomio

% valutiamo il polinomio nei punti del vettore z
% in sostanza calcola i valori della funzione polinomiale interpolante nei
% punti di < generando un curva fatta meglio per approssimare i dati

plot(z, pz_interp, 'k'); %k indica che la curva sarà nera

% Stima dei valori di S

 s50 = alpha(1) + alpha(2)*50; %p(z) = a1 + a2z
s60 = alpha(1) + alpha(2)*60;
s70 = alpha(1) + alpha(2)*70;%

3) Legge Oraria del Moto Rettilineo Uniformemente

Accelerato

% Dati
t = [0 1 1.5 2 2.5 3 3.5 4]';
s = [0 1.2 3.0 3.7 7.9 11.6 15.5 19.8]';

% Calcolo coefficienti della parabola ai minimi quadrati

m = length(t);
A = [ones(m,1) t t.^2]; % parabola ai minimi quadrati
alpha = my_minq(A,s); % vettore dei coefficienti della retta ai minimi quadrati

% Calcolo dei coefficienti del polinomio interpolante

V = vander(t);
V = V(:,m:-1:1);
a = V \ s;
a = a(m:-1:1); % vettore dei coefficienti del polinomio interpolante

% Grafico
plot(t,s,'ro')
hold on
z = linspace(t(1),t(m));
pz = alpha(1) + alpha(2)*z + alpha(3)*z.^2;
plot(z,pz,'b')
pz_interp = polyval(a,z);
plot(z,pz_interp,'k')

% Stima dei valori di s

 s50 = alpha(1) + alpha(2)*1.3 + alpha(3)*(1.3)^2
s60 = alpha(1) + alpha(2)*2.4 + alpha(3)*(2.4)^2
s70 = alpha(1) alpha(2)*3.7 + alpha(3)*(3.7)^2

4) Legge di Moore

% Script es_4

close all
clear

% Dati
t = [0 3 7 10 14 18 20]';
y = [4500 29000 90000 229000 1200000 3100000 5500000]';

% Calcolo dei coefficienti del modello esponenziale

m = length(t);
A = [ones(m,1) t];
alpha = my_minq(A,log(y)); % alpha(1) = c_1, alpha(2) = c_2

% Grafico della curva esponenziale

plot(t,y,'rx')
hold on
z = linspace(t(1),t(m));
expz = exp(alpha(1)+alpha(2)*z); % y = e^c_1*e^{c_2t} = e^(c_1+c_2*t)
plot(z,expz,'b');

% Stima del numero dei transistor nel 1987

y87 = exp(alpha(1)+alpha(2)*13)
5) Crescita dei Contagi da Covid-19

% Dati covid:
1 229
2 322
3 400
4 650
5 888
6 1128
7 1694
8 2036
9 2502
10 3089
% Dati
dati_covid = importdata("dati_covid.txt");
t = dati_covid(:,1);
y = dati_covid(:,2);

% Calcolo dei coefficienti del modello esponenziale

m = length(t);
A = [ones(m,1) t];
alpha = my_minq(A,log(y)); % alpha(1) = c_1, alpha(2) = c_2

% Grafico della curva esponenziale

plot(t,y,'rx')
hold on
z = linspace(t(1),t(m));
expz = exp(alpha(1)+alpha(2)*z); % y = e^c_1*e^{c_2t} = e^(c_1+c_2*t)
plot(z,expz,'b');

% Stima del numero dei contagiati dopo 11 giorni

y11 = exp(alpha(1)+alpha(2)*11)
err = abs((y11-3858)/3858)
save("stime_covid.txt","y11","-ascii")