%

%
%
%
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Algoritmo di bisezione
Aggiunte:
-input parametri, funzione
-ctr e interrompe se precisione macchina raggiunta
-controllo iniziale f(a)*f(b)<0
*******************************************************

clc; clear;
funzione=input('inserisci la funzione: ','s');
f=inline(funzione);
%Intervallo e controllo cambiamento di segno
a=input('estremo inferiore a: ');
b=input('estremo superiore b: ');
if f(a)*f(b)<0
eps=input('tolleranza: ');
i=1;
c=(a+b)/2;
fprintf('\nN\t\t\ta\t\t\t\t\tb\t\t\t\t\tc\n');
while (abs(b-a)>eps && (a~=c && c~=b) && f(c)~=0)
if f(a)*f(c)<0
b=c;
else
a=c;
end
c=(a+b)/2;
fprintf('%d\t%19.16f\t%19.16f\t%19.16f\n',i,a,b,c);
i=i+1;
end
fprintf('xs = %.16f\n',c);
else
disp('estremi a e b non adeguati!');
end
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Algoritmo della secante
*******************************************************

clc; clear;
funzione=input('inserisci la funzione: ','s');

f=inline(funzione);
x0=input('valore iniziale x0: ');
x1=input('valore iniziale x1: ');
eps=input('tolleranza: ');
i=0;
fprintf('i\t\t\t\t\tx0\t\t\t\t\tx1\t\t\t\t\tx2\n\n');
while (abs(x1-x0)>eps && i<100)
x2=x1-f(x1)*(x1-x0)/(f(x1)-f(x0));
fprintf('%d\t%18.15f\t%18.15f\t%18.15f\n',i,x0,x1,x2);
i=i+1;
x0=x1; %aggiornamento
x1=x2;
end
%%
if abs(x1-x0)<eps
disp('soluzione');
disp(x2);
else
disp('nessuna soluzione trovata');
end
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Metodo di Newton
*******************************************************

clc; clear;
funzione=input('inserisci la funzione f(x): ','s');
f=inline(funzione);
derivata=input('inserisci la derivata f''(x): ','s');
f1=inline(derivata);
x0=input('valore iniziale x0: ');
eps=input('tolleranza: ');
i=1;
x1=x0-f(x0)/f1(x0);
fprintf('i\t\t\t x_i\t\t\t x_i-x_(i-1)\n\n');
fprintf('%d\t%20.15f\t%20.15f\n',i,x1,abs(x1-x0));
i=i+1;
while (abs(x1-x0)>eps)
x0=x1;
if abs(f1(x0))<10^-5
disp('Stop: zero al denominatore!!');
break;
end
x1=x0-f(x0)/f1(x0);

fprintf('%d\t%20.15f\t%20.15f\n',i,x1,abs(x1-x0));
i=i+1;
end
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Iterazione a punto fisso
*******************************************************

clc; clear;
funzione=input('inserisci la funzione g(x): ','s');
g=inline(funzione);
x0=input('valore iniziale x0: ');
%xs=input('soluzione esatta xs: ');
eps=input('tolleranza: ');
i=1;
x1=g(x0);
fprintf('i\t\t\t\t\txi\n\n');
while abs(x1-x0)>eps && i<50
fprintf('%d\t%.15f\n',i,x1);
x0=x1;
x1=g(x0);
i=i+1;
%pause;
end
fprintf('%d\t%.15f\n',i,x1);
////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
function c=bisect(f,a,b)
% *******************************************************
% Matematica numerica
% J.Barta
%
% Algoritmo di bisezione
% -function: dati input: funzione f, a,b,eps
% -controllo: break se f(c)=0 (sol.esatta)
% *******************************************************
c=(a+b)/2;
while ((a~=c && c~=b) && f(c)~=0)
if f(a)*f(c)<0
b=c;
else
a=c;
end
c=(a+b)/2;

end
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
function sol=eqsolver(f,I1,I2,h)
%
%
%
%
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Solver di equazioni (multistart)
-scansiona intervallo [I1,I2] con passo h
-lancia bisezione quando identifica un cambiamento di segno
-ricava molteplici radici dell'equazione
*******************************************************

format short
toll=10^-5; %eps per distinzione zeri/asintoti
k=1;
sol=[];
%Vettore dei nodi
x=(I1:h:I2);
n=length(x);
%Scansione dei sottointervalli
for i=1:n-1
a=x(i);
b=x(i+1);
if f(a)==0
sol(k)=a;
k=k+1;
%lancia bisezione
elseif f(a)*f(b)<0
c=bisect(f,a,b);
if abs(f(c)) < toll
sol(k)=c;
k=k+1;
%else
%
fprintf('discont = %f\n',c);
end
end
end

////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
% *********************************************************
% Matematica numerica

% J.Barta
%
% Funzione e dati di partenza per il problema
% del sistema meccanico con 4 aste
%
% Aggiunte:
% - Ciclo for per determinare le soluzioni per beta=k*pi/12
% *********************************************************
%%
%Inserimento di beta da tastiera
clf;clc;
beta=input('beta: ');
%%
%Definizione funzione (tramite handle @(x))
%f ? una funzione con variabile x e parametri beta,a1,a2,a3,a4
a1=10; a2=13; a3=8; a4=10;
f=@(x) (a1/a2)*cos(beta)-(a1/a4)*cos(x)-cos(beta-x)+(a1^2+a2^2-a3^2+a4^2)/(2*a2*
a4);

%%
%Lancia eqsolver
I1=-pi;
I2=pi;
h=0.011;
disp('alfa:');
sol=eqsolver(f,I1,I2,h);
disp(sol);
%%
%Grafico funzione f(x)
x=linspace(-pi,pi,100);
for i=1:100
y(i)=f(x(i));
end
%Plot funzione f(x)
plot(x,y);
grid on
title('Funzione f(x)')
xlabel('alfa')
ylabel('f(alfa)')

////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////
%
%
%
%
%

*********************************************************
Matematica numerica
J.Barta
Funzione e dati di partenza per il problema

% del sistema meccanico con 4 aste

%
% Aggiunte:
% - Ciclo for per determinare le soluzioni per beta=k*pi/12
% *********************************************************
%%
clc;
clf;
tab=[];
vettbeta=(-pi:pi/24:pi)';
n=length(vettbeta);
i=1;
for k=1:n
%Crea funzione f in 1 variabile
a1=10; a2=13; a3=8; a4=10;
beta=vettbeta(k);
f=@(x) (a1/a2)*cos(beta)-(a1/a4)*cos(x)-cos(beta-x)+(a1^2+a2^2-a3^2+a4^2)/(2
*a2*a4);
%Lancia eqsolver
I1=-pi;
I2=pi;
h=0.011;
sol=eqsolver(f,I1,I2,h);
if length(sol)>0
tab(i,:)=[beta,sol];
i=i+1;
end
end
tab
%%
%Creo due tabelle beta-alfa e tabtot
tab1=[tab(:,1),tab(:,2)];
tab2=[tab(:,1),tab(:,3)];
tab2=flipud(tab2);
tabtot=[tab1;tab2]
%salvo tabtot in angoli.mat
save angoli tabtot;
%%
%plot punti beta-alfa
plot(tab(:,1),tab(:,2),'r.',tab(:,1),tab(:,3),'b.')
xlabel('beta');
ylabel('alfa');
title('Grafico della curva alfa(beta)');
grid on

////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////

% *********************************************************
% Matematica numerica
% J.Barta
%
% Simulazione del movimento del sistema meccanico
% Angoli (beta,alfa) caricati dal file angoli.mat nella matrice tabtot
% *********************************************************
clc; clf;
%%
%Carica i dati da angoli.mat
load angoli tabtot
%%
for volte=1:10
for k=1:size(tabtot,1)
beta=tabtot(k,1);
alpha=tabtot(k,2);
a1=10; a2=13; a3=8; a4=10;
Ax=0; Ay=0;
Bx=10; By=0;
Cx=a1+a4*cos(beta); Cy=a4*sin(beta);
Dx=a2*cos(alpha); Dy=a2*sin(alpha);
x=[Ax,Bx,Cx,Dx,Ax];
y=[Ay,By,Cy,Dy,Ay];
plot(x,y,'ko',x,y,'g','LineWidth',3);
axis([-10,20,-15,15])
grid on
title('Sistema meccanico: simulazione')
axis square;
pause(0.05);
end
end
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
%
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Algoritmo di Gauss - versione base
Porta in forma a gradini il sistema Ax=b.
*******************************************************

function gaussbase(A,b)
clc;
M=[A,b];
disp(M);
n=size(M,1); %m=numero di righe/colonne
%passo di eliminazione i (perno=M(i,i))

for i=1:n-1
perno=M(i,i);
%scorre le righe j (sotto il perno)
for j=i+1:n
%riduzione riga j
M(j, : )=M(j, : )-(M(j,i)/perno)*M(i, : );
disp(M);
end
end
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
%
%
%
%
%
%
%

*******************************************************
Matematica numerica
J.Barta
Esegue la sostituzione a ritroso su una matrice M ridotta
a gradini e restituisce la soluzione x
*******************************************************

function x=sostritroso(M)
n=size(M,1);
%scorre le righe della matrice dall'ultima alla prima (step=-1)
for i=n:-1:1
%calcola la sommatoria (v.formula)
somma=0;
for j=i+1:n
somma=somma+M(i,j)*x(j);
end
%calcola x(i)
if M(i,i)~=0
x(i)=(M(i,n+1)-somma)/M(i,i);
else
disp('sistema non determinato.');
break;
end
end
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
function gaussperno(A,b)
% Sistemi n x n
%Riduzione in forma a gradini
%Scambio di righe se M(i,i)=0
M=[A,b];
disp(M);
n=size(A,1);

for i=1:n-1
%*********************************************
%Controllo perno ed eventuale scambio di righe
%val = massimo (in val assoluto) nella colonna del perno
%i+k-1 = indice riga del massimo
[val,k]=max(abs(M(i:n,i)));
%scambio riga i e (i+k-1)
M([i,i+k-1], : ) = M([i+k-1,i], : );
disp(M);
%******************************************************
% Passo di riduzione con perno M(i,i)
if M(i,i)~=0
perno=M(i,i);
for j=i+1:n
M(j,: )=M(j, : )-(M(j,i)/perno)*M(i, : );
disp(M);
end
end
end
%******************************************************
% x=sostritroso(M);
% disp('soluzione sistema');
% disp(x);