Affichage des articles dont le libellé est optimisation. Afficher tous les articles
Affichage des articles dont le libellé est optimisation. Afficher tous les articles

samedi 12 novembre 2016

la méthode de Dichotomie en matlab

la méthode de Dichotomie


Dans ce TP, nous nous intéressons à la résolution numérique des équations non linéaires de type f (x) = 0 ou g(x) = x, où f et g sont des fonctions non linéaires. Pour résoudre ce type de problème, deux  méthodes sont utilisées :
– La méthode de dichotomie (résolution d’équations du type f (x) = 0).
– La méthode de Newton (résolution d’équations du type f (x) = 0)

Toutes ces méthodes sont des méthodes itératives

Principe de la méthode de Dichotomie
Certaines équations ne pouvant pas être résolues algébriquement, on peut néanmoins trouver les valeurs approchées des solutions.
Supposons que l'équation f(x)= admette une solution unique asur l'intervalle [a ; b], et l'on veuille une valeur approchée de cette solution à 10-p près,
La fonction f est strictement monotone sur [a ; b], supposons par que f est strictement croissante.


Programmation de la méthode de dichotomie : ( en matlab )

% la méthode de dichotomi
clear all;
close all;
clc
tic;
f=inline('(x-(exp(sin(x))))');
d=iddinplutf(x);
%f=inline('cos(x)-x*3');
a=0;aa=a;
b=1;bb=b;
eps=1e-12;
err=1;
Iter=0;
while (err >= eps)
    x0=(a+b)/2;
    Iter=Iter +1;
    if f(a)*f(x0)<0
    b=x0;
    err=abs(a-x0);
    else
        a=x0;
        err=abs(b-x0);
end
fprintf('eps=%2.12f \t',eps);
fprintf('racine=%2.12f \t',x0);
fprintf('f(x0)=%2.12f \t',f(x0));
fprintf('erreur=%2.12f \t',err);
fprintf('Iter=%2.12f \t',Iter);
fprintf('\n');
fplot(f,[aa bb]);
hold all;
plot(x0,f(x0),'ro');
xlabel('x'),ylabel('f');
title(['iteration N°=',int2str(Iter),'x=',num2str(x0),]);
hold off;
grid on;
pause(1)
end
toc;


Méthode de Newton-Raphson en matlab

    Algorithme :

  Obtenir  racineAvant  (une racine de départ)
  nbIterations = 1
 
  Répéter
     Si (|fPrime(racineAvant)| <= EPSILON )
 On termine : ne peut pas diviser par zero
  Continuer = faux (pour quitter)
  Sinon
racine = racineAvant-( f(racineAvant) / fPrime(racineAvant))
continuer = |racine – racineAvant| > EPSILON
 Si (continuer)
  Incrémenter nbIterations
  racineAvant = racine
  Tant que (continuer ET nbIter <= MAX_ITER)
    
Si (nbIter > MAX_ITER)
Afficher "On n'a pas encore la convergence vers la racine"


Manipulation 


1-

   Cos(xy)=1/2

   x²-exp(-y)=3

Programme en matlab :
clear all; close all;  clc ;
x=10;
y=10;
variable=[x;y];
t=[0.5;3];
delta=1;
iteration=1;
while (abs(delta) > 1e-20)
    f=[cos(variable(1)*variable(2));
       variable(1)^2-exp(-variable(2))];
   jacop=[-variable(2)*sin(variable(1)*variable(2)) -variable(1)*sin(variable(1)*variable(2)); 2*variable(1) exp(-variable(2))];
    delta=(jacop)*(t-f);
    variable=variable+delta;
    iteration=iteration+1;
end
format long
x_optimise=variable(1)
y_optimise=variable(2)

résultat :

x =  -0.166656653479945


y =  -0.014807086255684


 2-     
   3x+cos(yz)-1/2=0

    x²-81(y+0.1)²+sin(z)+1.06=0

           
Programme en matlab :
clear all; close all;  clc ;
x=5;
y=5;
z=5;
variable=[x;y;z]; t=[0.5;-0.25;-9.4719];
delta=1; iteration=1;
while (abs(delta) > 1e-30)
    f=[3*variable(1)+cos(variable(2)*variable(3));
variable(1)^2-81*variable(2)*variable(2)-16.2*variable(2)+sin(variable(3));
 exp(-variable(1)*variable(2))+20*variable(3)];
  jacob=[3 variable(3)*sin(variable(2)*variable(3)) variable(2)*sin(variable(2)*variable(3));
  2*variable(1) -162*variable(2)-16.2 cos(variable(3));
  -variable(2)*exp(-variable(1)*variable(2)) -variable(1)*exp(-variable(1)*variable(2)) 20];
    delta=inv(jacob)*(t-f);
    variable=variable+delta;
    iteration=iteration+1;
end
format long
x=variable(1)
y=variable(2)
z=variable(3)

résultat :

x =  -0.166656653479945


y =  -0.014807086255684



z = -0.523471767141206

la méthode de régula-falsi (fausse position ) en matlab

la méthode de régula-falsi
(fausse position )
But :
Dans ce TP nous allons programmer méthode de la méthode de régula-falsi (fausse position ) par matlab



 On appelle ainsi une méthode de résolution algébrique (régula) consistant à fournir une solution approchée (falsi) conduisant, par un algorithme approprié tirant parti de l'écart constaté, à la solution du problème considéré.
Programmation de la méthode de régula-falsi (fausse position ) : ( en matlab )

% la méthode de dichotomi
clear all;
close all;
clc
tic;
f=inline('(x-(exp(sin(x))))');
d=iddinplutf(x);
%f=inline('cos(x)-x*3');
a=0;aa=a;
b=1;bb=b;
eps=1e-12;
err=1;
Iter=0;
while (err >= eps)
    x0=(a+b)/2;
    Iter=Iter +1;
    if f(a)*f(x0)<0
    b=x0;
    err=abs(a-x0);
    else
        a=x0;
        err=abs(b-x0);
end
fprintf('eps=%2.12f \t',eps);
fprintf('racine=%2.12f \t',x0);
fprintf('f(x0)=%2.12f \t',f(x0));
fprintf('erreur=%2.12f \t',err);
fprintf('Iter=%2.12f \t',Iter);
fprintf('\n');
fplot(f,[aa bb]);
hold all;
plot(x0,f(x0),'ro');
xlabel('x'),ylabel('f');
title(['iteration N°=',int2str(Iter),'x=',num2str(x0),]);
hold off;
grid on;
pause(1)
end

méthode de fibonacci en matlab

Introudiction

Le codage de Fibonacci est un codage entropique utilisé essentiellement en compression de données. Il utilise les nombres de la suite de Fibonacci, dont chaque terme est la somme des deux termes consécutifs précédents, ce qui lui confère une robustesse aux erreurs.
Le code de Fibonacci produit est un code préfixe et universel. Dans ce code, la séquence « 11 » apparaît uniquement en fin de chaque nombre encodé, et sert ainsi de délimiteur.

Programmer en matlab 


clear all ;
close all ;
clc ;
f=inline('sqrt(exp((x-0.5).^2))-x');
n=15;
a=-2;
d=3;
F=zeros(1,n); F(1)=1; F(2)=1;
for i=3:n
    F(i)=F(i-1)+F(i-2);
end

for i=1:1:n-1
 d1=abs(d-a);
 d2=d1*F(n-i)/F(n-i+1);
 c=a+d2;
 b=d-d2;
    f1=f(a); f2=f(b); f3=f(c); f4=f(d);
   if f1 < f2 && f2 < f3 && f3 < f4
     a=a; d=b;
    end
    if f1 > f2 && f2 < f3 && f3 < f4
        a=a ; d=c ;
    end
    if f1 > f2 && f2 > f3 && f3 < f4
        a=b ; d=d ;
       
       end
    if f1 > f2 && f2 > f3 && f3 > f4
        a=c ; d=d ;
       
        end
  
   x=[a,  d];
    disp(x);
    % affichage de l'optimisation
    fplot(f,[-2 3]);
    hold all;
    plot(a,f(a),'r+'); plot(d,f(d),'ro');
    xlabel('x'), ylabel('f');
    title(['iteration N°=',int2str(i),', xmin=',num2str(d),', f(xmin)=',num2str(f(d))]);
        hold off;
        grid on;
        pause (1)
        % fin d'afichage
        end
        fprintf( 'le min de la fonction f=%2.4f\n',f(c));

résultat :
-0.0902    3.0000

   -0.0902    1.8197

    0.6393    1.8197

    1.0902    1.8197

    1.0902    1.5410

    1.0902    1.3689

    1.1967    1.3689

    1.1967    1.3033

    1.2377    1.3033

    1.2377    1.2787

    1.2377    1.2623

    1.2459    1.2623

    1.2459    1.2623

    1.2459    1.2623

le min de la fonction f=0.0749