Esercizio in matlab

[bolrinidome]

ci è stato assegnato come primo esercizio in matlab questo:


io non so fare NULLA ma ho iniziato a fare questo

%definizione della funzione
f=inline('3*x.^4+10*x.^3+11*x.^2-4*x-2','x');
a=-1;
b=1;
%genera il vettore dei nodi di tabulazione
x=linspace(a,b);
%...e il vettore dei valori di f
y=f(x);
%esegue il grafico della funzione e traccia l'asse x
plot(x,y, [a b], [0 0], 'k')

poi ho questo che è un programma che è stato fatto in aula

%function[x]=newton2(x0,eps1,eps2,maxiter)

% x=newton(x0,eps1,eps2,maxiter): Programma per la ricerca degli zeri di una funzione   
% con il metodo di Newton.    (10-03)                
%
% Input:                                            
% - eps1: errore massimo su |x_(i+1) - x_i|   
% - eps2: errore massimo su |f(x_(i+1))|      
% - x0: approssimazione iniziale  
% - maxiter: numero massimo di iterazioni
% Output:
% - x: vettore della successione delle approssimazioni
%

% Variabili:                                        
% - err1: errore |x_(i+1) - x_i|              
% - err2: errore |f(x_(i+1))|                 
% - iter: numero di iterazione                
% - y:    f(x_i)                              
% - xn:   x_(i+1)                             
% - xv:   x_i                                 
% Function:                                         
% - f(x): funzione di cui si cercano gli zeri 
% - df(x): derivata di f(x)
%

%
% Funzione di cui si vogliono calcolare gli zeri (da modificare ogni volta) 
% e derivata
%
% f =inline('cosh(x).*cos(x)-1','x');
% df=inline('-cosh(x).*sin(x)-sinh(x).*cos(x)','x');
% f=inline('(x-1).^3','x');
% df=inline('3*(x-1).^2','x');
clear
f=inline('x+exp(x)+(10/(1+x^2))-5','x');
df=inline('1+exp(x)-(20*x/(1+x^2)^2)','x');

%    
% Inizializzazione variabili  
%
err1 = 100000;
err2 = 100000;
eps1=1e-6;
eps2=1e-6;
maxiter=1000;
%   
% Inizio ciclo iterativo: il ciclo viene interrotto quando        
% gli errori err1 e err2 sono minori delle tolleranze assegnate   
% eps1 e eps2 oppure quando viene raggiunto il numero di iterazioni 
% massimo maxiter  
%
x0=1.5;
iter = 1; x(1)=x0;
xv=x0;
while (err1 > eps1 | err2 > eps2 ) && iter < maxiter,
	iter = iter+1;
	xn = xv-f(xv)/df(xv);
	xv = xn;
	x(iter) = xn;
	err1 = abs(xn-xv); 
	y = f(xn);
	err2 = abs(y); 
end

chi mi può aiutare?
odio informatica

grazie a tutti!

[hastings1]

fai un vettore intervallo. Ad esempio scegli un intervallo: [-1 0.5]. Poi crea un vettore con un certo passo, ad esempio 0.01, così: v=[-1 : 0.01 : 0.5]. Fai un ciclo (while oppure for) che applichi ad ogni componente del vettore appena creato, il metodo iterativo indicato. Questa è un'idea base ma naturalmente se ci sono altri modi di risolverlo ben venga.

[cozzataddeo]

"bolrinidome":odio informatica

Beh, l'informatica di per sé è una scienza affascinante...è la programmazione che è insopportabile, in questo senso condivido appieno il tuo odio .
Purtroppo però molto spesso è utile sia in ambito di ricerca che in quello lavorativo...

Stringi i denti e tieni duro!

[bolrinidome]

grazie settembre

ma con quello che ho iniziato io, che dovrei fare? ve l'ho detto che non capisco nulla in matlab
e il procedimento di newton postato non c'entra nulla?

[matteopetti]

Sono nella stessa barca (Matteo - Ing. TLC 2006/2007 - "La Sapienza").
Appena sapete qualcosa di più dettagliato fatemelo sapere...

Io non odio l'informatica, odio MatLab...

[matteopetti]

Dimenticavo...
Quello che posso dirti io, se ti accontenti, è che per trovare l'intervallo delle soluzioni puoi utilizzare (vista la nostra fortuna ad avere un'equazione polinomiale!) il raggio di inclusione (sempre postato su un topic da "Taddeo Cozza" e "Settembre", da loro ho avuto l'ispirazione, GRANDI, e sempre già visto in aula!), non sò se può essere utile ma sicuramente è un passo avanti...

Alla prossima (spero a breve)...

[bolrinidome]

nessun'altro?

[matteopetti]

aiuto....!!!

[bolrinidome]

io dopo una giornata di sclero ho fatto

f=inline('3*x.^4+10*x.^3+11*x.^2-4*x-2','x');
df=inline('12*x^3+30*x^2+22*x-4','x');

%***** Polinomio (x-1)^7  *************************************************
% f=inline('-1+x.^7-7.*x.^6+21.*x.^5-35.*x.^4+35.*x.^3-21.*x.^2+7.*x','x');
% df=inline('7*x^6-42*x^5+105*x^4-140*x^3+105*x^2-42*x+7','x');
%**************************************************************************

%***** Polinomio con radice multipla ***************************************
%  f=inline('27*x.^7+2484*x.^6+30762*x.^5+143335*x.^4+277639*x.^3+219674*x.^2+203476*x+138411','x');
%  df=inline('189*x^6+14904*x^5+153810*x^4+573340*x^3+832917*x^2+439348*x+203476','x');
%**************************************************************************

%
%    
% Inizializzazione variabili  
%
x0=-0.31;
err1 = Inf;
err2 = Inf;
eps1=1.e-09;
eps2=eps1;
k = 0;
maxiter=50;
xv=x0;


%   
% Inizio ciclo iterativo: il ciclo viene interrotto quando        
% gli errori err1 e err2 sono minori delle tolleranze assegnate   
% eps1 e eps2 oppure quando viene raggiunto il numero di iterazioni 
% massimo maxiter  
%


while (err1 > eps1) && (err2 > eps2) && (k < maxiter)
%while ~(~(err1 > eps1) || ~(err2 > eps2) || ~(k < maxiter))	
	xn = xv-f(xv)/df(xv);
    err1 = abs(xn-xv);
	xv = xn;	 
	y = f(xn);
	err2 = abs(y);
    k=k+1;
    
    x(k) = xn;
    errore1(k)=err1;
    errore2(k)=err2;
end


% Stampa dei risultati


format compact;
f
disp(['Approssimazione iniziale: x0= ', num2str(x0)]);
disp(['Radice:',num2str(xn)]);
disp(['N. di iterazioni: k= ', num2str(k)]);
disp(['Errore1: |x(k)-x(k-1)|=', num2str(errore1(k))]);
disp(['Errore2: |f(x(k))|=', num2str(errore2(k))]);


%Plot degli errori

x1=[1:1:length(errore1)];
x2=[1:1:length(errore2)];
figure
plot(x1,errore1,'.r')
figure
plot(x2,errore2,'.')

e

f=inline('3*x.^4+10*x.^3+11*x.^2-4*x-2','x');
df=inline('12*x^3+30*x^2+22*x-4','x');
eps1=1.e-09;
eps2=eps1;
v=[-0.31:0.01:-0.30];
for k=1:length(v)
    x0=v(k);
    sol=fnewton(f,df,x0,eps1,eps2,maxiter);
    y(k)=sol;
end

che devo fare ora?

in Xo che valore ci va? sensato ciò che ho fatto? non mi da valori giusti

[daniele_cmp]

Tutti alle prese co 'sta relazione eh? Ma allora questo è un covo di chi si deve ancora liberare della Lo Cascio. Cmq l'idea è giusta. Ti trovi per via grafica un [a,b] in cui sono contenute tutte le radici, fai una linspace tra [a,b] con ad es 30 punti, ed usi ognuno di questi come valore di innesco, vedendo così per ogni valore di innesco a cosa converge Newton. Otterrai dei valori giusti (le radici), dei valori che non c'entrano niente (ma stanno sempre in [a,b]), e valori che addirittura starranno fuori da [a,b]. Poi restringi l'[a,b] solo nell'intorno delle zone dove Newton ha dei problemi a convergere, ovvero nell'intorno dei massimi, minimi e flessi, e vedi che risultati ti dà, e anche questi vanno commentati.

Il fatto di fare copia/incolla dai prog che girano in lab secondo me ti confonde solamente, meglio rifarlo da capo...

Ci si vede martedì

Ciao!