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)= l 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


Définition et explications sur le MPPT

Définition et explications sur le MPPT (Maximum Power Point Tracking) :

C'est un montage électronique au niveau du régulateur qui permet de tirer le maximum d'énergie d'une installation solaire photovoltaïque.

- Le régulateur MPPT permet d'optimiser le rendement des panneaux solaires jusqu'à 30% : pour un panneau photovoltaïque donné, les batteries recevront 30% d'électricité en plus par rapport à un régulateur solaire classique.
CONVERTISSEUR DC/DC :
La figure 2 montre la représentation d’un convertisseur DC/DC, qui peut être utilisé comme interface entre la source et la charge

Le rôle du convertisseur DC/DC (dans le cadre du PV) est de faire l’adaptation entre la source (GPV) et la charge pour un transfert de puissance maximal. Ceci est fait en maintenant le PF sur ou assez proche du MPP pour n’importe quelles conditions de fonctionnement (rayonnement, température, caractéristique de charge, etc.).
Contrairement au cas général où le convertisseur DC/DC est utilisé pour réguler la tension desortie, ici c’est plutôt la tension d’entrée qui est régulée. La tension de référence (consigne) est alorsconstante ou imposée par un algorithme de commande.


Principe de la Recherche du MPP :
La figure 2 représente le schéma de principe d’un convertisseur MPPT classique. La commande MPPT fait varier le rapport cyclique du convertisseur statique (CS), à l’aide d’un signal électrique approprié, pour tirer le maximum de puissance que le GPV peut fournir. L’algorithme MPPT peut être plus ou moins compliqué pour rechercher le MPP. En général, il est basé sur la variation du rapport cyclique du CS en fonction de l’évolution des paramètres d’entrée de ce dernier (I et V et par conséquent de la puissance du GPV) jusqu’à se placer sur le MPP. Plusieurs algorithmes sont disponibles.

LES ALGORITHMES MPPT :

Il existe dans la littérature plusieurs algorithmes MPPT. Les plus utilisés sont:
Algorithme de la Tension Constante (CV, Constant Voltage)
. Algorithme du Courant constant (Constant Current)
. Perturbation et Observation (P&O, Perturb and Observe)
. Conductance Incrémentale (IncCond, Incremental Conductance)
Les algorithmes P&O et IncCond font partie de la technique appelée Hill Climbing (monté de pente).

a-Algorithme Perturbation et Observation (P&O) :

La méthode P&O est généralement la plus utilisée en raison de sa simplicité et sa facilité de réalisation. Comme son nom l’indique, cette méthode fonctionne en pertu
rbant le système et observant l’impact sur la puissance à la sortie du GPV.
Sur la figure 5.14, on voit que si la tension de fonctionnement est perturbée dans une direction donnée et que la puissance augmente (dP=dV > 0), alors il estclair que la perturbation a déplacé le point de fonctionnement vers le MPP. L’algorithme P&O continuera à perturber la tension dans la même direction. Par contre, si la puissance diminue (dP=dV< 0), alors la perturbation a éloigné le point de fonctionnement du MPP. L’algorithme inversera la direction de la perturbation suivante. Cet algorithme est résumé sur  l’organigramme de la figure 5.
 L’algorithme peut être représenté mathématiquement par l’expression :


Le processus est répété périodiquement jusqu’à ce que le MPP soit atteint. Le système oscillealors autour du MPP, ce qui provoque des pertes de puissance. L’oscillation peut être minimisée en diminuant la taille de la perturbation. Cependant, une taille de perturbation trop petite ralentit considérablement la poursuite du MPP. Il existe alors un compromis entre précision et rapidité.

Dans  cette partie, nous avons entamé la partie la plus importante et la plus délicate de ce mini projet. Il s’agit de la description du convertisseur MPPT qui est un convertisseur de puissance (DC/DC)commandé par un algorithme MPPT. Nous avons expliqué le principe de recherche du MPP. Ensuite, nous avons étudié de manière approfondie le fonctionnement d’un convertisseur de type Buck aboutissant à un modèle mathématique linéarisé (modèle petits signaux).
 Enfin, nous avons cité les algorithmes MPPT existants dans la littérature.