Application Center - Maplesoft

App Preview:

Optimisation d'une fonction de deux variables: Méthode des multiplicateurs de Lagrange

You can switch back to the summary page by clicking here.

Learn about Maple
Download Application


 

lagrange.mw

[Inserted Image]Optimisation d'une fonction de deux variables:
mthode des multiplicateurs de Lagrange

Pierre Lantagne (mars 2001)

Collge de Maisonneuve

plantag@edu.cmaisonneuve.qc.ca

http://math.cmaisonneuve.qc.ca/plantagne

Cette feuille a pour objectif de montrer comment utiliser Maple pour optimiser une fonction de deux variables avec une contrainte d'galit, c'est--dire rsoudre le problme de trouver la plus grande et la plus petite valeur pour f(x,y) avec la restriction que le point (x,y) doit satisfaire la contrainte g(x, y) = 0 . La mthode des multiplicateurs de Lagrange est particulirement utile lorsque la fonction ne peut tre ramene une fonction de deux variables sans contrainte. Rappelons la condition ncessaire d'applicabilit de cette mthode: le gradiant de la fonction g ne doit aucunement s'annuler en quelque point (x,y) vrifiant g(x, y) = 0 .

> restart;

Le cas d'une fonction de deux variables

Rendons disponibles les macro-commandes ncessaires aux dveloppements de cette feuille Maple.

> with(plots,display,pointplot3d,spacecurve);

[display, pointplot3d, spacecurve]

De plus, initialisons la procdure ci-dessous. Cette procdure servira automatiser l'numration des points contrler dans le cas d'un nombre pas trop grand de points . On pourrait tout aussi bien les numrer manuellement et ne pas initialiser cette procdure.

> Listage:=proc(Ensemble::set)
global x,y,lambda;

local Sol,Points,k;

Sol:=Ensemble;

assign(Sol[1]);

Points:=[x,y];

x:='x';y:='y';lambda:='lambda';

for k from 2 to nops(Sol) do

assign(Sol[k]);

Points:=Points,[x,y];

x:='x':y:='y':lambda:='lambda':

od;

Points;

end:

>

Exemple 1

Soit la fonction f dfinie par f(x, y) = 2*x^2-y+y^2+5 . Optimisons cette fonction sur un disque de rayon 1 centr l'origine. Puisque la fonction f est continue sur un domaine ferm et born, la fonction f atteint son maximum et son minimum avec certains points de son domaine.

Commenons par crer la fonction f.

> f:=(x,y)->2*x^2-y+y^2+5;

f := proc (x, y) options operator, arrow; 2*x^2-y+y^2+5 end proc

>

Dans un mme graphique, superposons le trac de la surface d'quation z = f(x, y) et celui du domaine ferm d'optimisation.

Pour obtenir le trac de la frontire du domaine, soit le trac de l'quation x^2+y^2 = 1 , paramtrisons en posant x = cos(t) et y = sin(t) .

> Surface:=plot3d([x,y,f(x,y)],x=-2..2,y=-2..2):
Contrainte:=spacecurve([sin(t),cos(t),0],t=0..2*Pi,color=orange,thickness=3):

Domaine:=plot3d([x,y,0],x=-2..2,y=-2..2,style=PATCHNOGRID,color=plum):

Domaine_optimisation:=plot3d([x,y,0],x=-1..1,y=-sqrt(1-x^2)..sqrt(1-x^2),style=PATCHNOGRID,color=orange):

display([Surface,Contrainte,Domaine,Domaine_optimisation],axes=framed,orientation=[35,65]);

[Plot]

Pour mieux se convaincre que la fonction possde effectivement des extrma absolus avec des points du disque, projettons la frontire de ce disque sur la surface.

> Contrainte_S:=spacecurve([sin(t),cos(t),f(sin(t),cos(t))],t=0..2*Pi,color=orange,thickness=2):
L:=seq(plots[spacecurve]([[cos(k*Pi/12),sin(k*Pi/12),0],[cos(k*Pi/12),sin(k*Pi/12),f(cos(k*Pi/12),sin(k*Pi/12))]],

color=orange,thickness=1),k=0..24):

display([Surface,Contrainte,L,Contrainte_S,Domaine,Domaine_optimisation],axes=framed,

        style=patchnogrid,

        orientation=[53,63]);

[Plot]

>

En modifiant, avec la souris, l'orientation de cette surface, il est facile de se convaincre que la fonction f possde effectivement un maximun absolu et un minimum absolu sur ce domaine ferm. Mais, graphiquement, il est peut tre mme assez difficile de localiser sur la portion en cause de la surface, ces minimum et maximum absolus: sont-ils l'intrieur ou sur le bord ?

I. Optima sur les points intrieurs du domaine: points critiques

Commenons notre analyse avec les points intrieurs de ce disque. Recherchons donc les points critiques de la fonction f.

Rsolvons alors le systme S: {f[x] = 0, f[y] = 0}

> fx:=D[1](f);
fy:=D[2](f);

fx := proc (x, y) options operator, arrow; 4*x end proc

fy := proc (x, y) options operator, arrow; -1+2*y end proc

> solve({fx(x,y)=0,fy(x,y)=0},{x,y});

{x = 0, y = 1/2}

Bien sr, ce n'est pas un systme trs difficile rsoudre. Effectivement, on peut le faire sans l'aide de Maple, mais ce n'est pas l la question. On a donc l'intrieur du disque, qu'un seul point critique. Nous contrlerons ce point plus tard.

> Points_critiques:=[0,1/2];

Points_critiques := [0, 1/2]

II. Optima sur les points frontires: mthode des multiplicateurs de Lagrange

Affichons seulement la projection de la frontire du disque sur cette surface.

> display([Contrainte,Domaine,Domaine_optimisation,Contrainte_S],
        axes=framed,

        style=patchnogrid,

        orientation=[35,65]);

[Plot]

>

En modifiant l'orientation du graphique avec la souris, il semble que cette fonction possde sur la frontire du disque, un maximum absolu atteint avec deux points (x,y) diffrentes et un minimum absolu atteint avec un seul point.

Pour appliquer la mthode des multiplicateurs de Lagrange afin d'optimiser la fonction f sur le bord, nous limiterons donc le domaine d'optimisation de la fonction f celui de la frontire du disque, soit le cercle de rayon 1. La contrainte g(x, y) = 0 dans la mthode des multiplicateurs de Lagrange sera donc l'quation du cercle unit.

> g:=(x,y)->x^2+y^2-1;

g := proc (x, y) options operator, arrow; x^2+y^2-1 end proc

Formons maitenant la fonction F dfinie par F(x, y) = f(x, y)+lambda*g(x, y) . Le paramtre lambda est appel multiplicateur de Lagrange.

> F:=(x,y)->f(x,y)+lambda*g(x,y);

F := proc (x, y) options operator, arrow; f(x, y)+lambda*g(x, y) end proc

Rsolvons maintenant le systme S:{F[x](x, y) = 0, F[y](x, y) = 0, g(x, y) = 0} .

> Eq1:=diff(F(x,y),x)=0;
Eq2:=diff(F(x,y),y)=0;

Eq3:=g(x,y)=0;

Sol:=solve({Eq1,Eq2,Eq3},{x,y,lambda});

Eq1 := 4*x+2*lambda*x = 0

Eq2 := -1+2*y+2*lambda*y = 0

Eq3 := x^2+y^2-1 = 0

Sol := {lambda = (-1)/2, y = 1, x = 0}, {y = -1, lambda = (-3)/2, x = 0}, {x = 1/2*RootOf(_Z^2-3, label = _L3), lambda = -2, y = (-1)/2}

Explicitons tous les rsultats prcdents l'aide de la macro-commande allvalues .

> ### WARNING: allvalues now returns a list of symbolic values instead of a sequence of lists of numeric values
Sol:=`union`(allvalues({Sol}));

Sol := {{x = 1/2*3^(1/2), lambda = -2, y = (-1)/2}, {x = -1/2*3^(1/2), lambda = -2, y = (-1)/2}, {lambda = (-1)/2, y = 1, x = 0}, {y = -1, lambda = (-3)/2, x = 0}}

numrons tous les points de la frontire contrler. On pourrait, bien sr, tout aussi bien tablir cette liste manuellement.

> P:=Listage(Sol);

P := [1/2*3^(1/2), (-1)/2], [-1/2*3^(1/2), (-1)/2], [0, 1], [0, -1]

Ajoutons le point critique la liste des points tester. Donnons cette liste le nom Points_C.

> Points_C:=P,Points_critiques;

Points_C := [1/2*3^(1/2), (-1)/2], [-1/2*3^(1/2), (-1)/2], [0, 1], [0, -1], [0, 1/2]

Calculons les optima correspondant ces cinq points.

> printf(`\n                       Points tester      |      Valeurs de f    |\n`);
seq(printf("%40a    | %15a      |\n", [Points_C][k],f(op(1,op(k,[Points_C])),op(2,op(k,[Points_C])))),k=1..nops([Points_C]));

                      Points tester      |      Valeurs de f    |
                    [1/2*3^(1/2), -1/2]    |            29/4      |

                   [-1/2*3^(1/2), -1/2]    |            29/4      |

                                 [0, 1]    |               5      |

                                [0, -1]    |               7      |

                               [0, 1/2]    |            19/4      |

Reste finalement conclure.

Le minimum absolu est atteint avec le point critique [0, 1/2]  et vaut 19/4 et le maximum absolu vaut 29/4 et est atteint en [sqrt(3)/2, -1/2] et en [-sqrt(3)/2, -1/2] .

Terminons cet exemple en illustrant ces optima sur la surface.

> Points_optima:=[[0, 1/2,f(0,1/2)],[1/2*sqrt(3), -1/2,f(1/2*sqrt(3), -1/2)],[-1/2*sqrt(3), -1/2,f(-1/2*sqrt(3), -1/2)]];

Points_optima := [[0, 1/2, 19/4], [1/2*3^(1/2), (-1)/2, 29/4], [-1/2*3^(1/2), (-1)/2, 29/4]]

> Points:=pointplot3d(Points_optima,symbol=circle,color=navy):
display([Contrainte,Domaine,Domaine_optimisation,Surface,Points,Contrainte_S],style=patchnogrid,axes=framed,orientation=[70,60]);

[Plot]

>

Question: Peut-on imaginer ici, un disque ferm de rayon r centr au point (0,0,0) dont le rayon sera assez petit de telle sorte que la fonction ne puisse possder de points critiques l'intrieur de ce disque ? Si oui, cela constiturerait un exemple de fonction o les extrma absolus seraient situs exclusivement sur la frontire de ce domaine ferm.

Exemple 2

Reprenons un problme que nous avons trait en classe.

Trouver les distances maximum et minimum entre l'origine et la courbe d'quation 5*x^2+6*x*y+5*y^2 = 8 .

Soit D la distance entre un point (x, y ) de la courbe d'quation 5*x^2+6*x*y+5*y^2 = 8 et l'origine (0,0)

Alors D = sqrt((x-0)^2+(y-0)^2)  = sqrt(x^2+y^2) .

Minimiser le carr de la distance D^2 est aussi minimiser la distance D puisque D > 0.

Soit donc la fonction f dfinie par f(x, y) = x^2+y^2 optimiser.

> f:=(x,y)->x^2+y^2;

f := proc (x, y) options operator, arrow; x^2+y^2 end proc

On recherche les extrma absolus de la fonction f sous la contrainte 5*x^2+6*x*y+5*y^2 = 8 .

I. Optima sur les points intrieurs

Le domaine d'optimisation tant le lieu des points (x,y) vrifiant l'quation 5*x^2+6*x*y+5*y^2 = 8 , il n'y a aucun point intrieur cette rgion. Il n'y a donc aucun point critique contrler.

II. Optima sur les points frontires: mthode des multiplicateurs de Lagrange

Appliquons la procdure des multiplicateurs de Lagrange la fonction f dfinie par f(x, y) = x^2+y^2 .

Formons la fonction F(x, y) = f(x, y)+lambda*g(x, y) .

> g:=(x,y)->5*x^2+6*x*y+5*y^2-8;
F:=(x,y)->f(x,y)+lambda*g(x,y);

g := proc (x, y) options operator, arrow; 5*x^2+6*x*y+5*y^2-8 end proc

F := proc (x, y) options operator, arrow; f(x, y)+lambda*g(x, y) end proc

La rgle de F est donc:

> F(x,y);

x^2+y^2+lambda*(5*x^2+6*x*y+5*y^2-8)

Rsolvons maintenant le systme S:{F[x](x, y) = 0, F[y](x, y) = 0, g(x, y) = 0} .

> Eq1:=diff(F(x,y),x)=0;
Eq2:=diff(F(x,y),y)=0;

Eq3:=g(x,y)=0;

Sol:=solve({Eq1,Eq2,Eq3},{x,y,lambda});

Eq1 := 2*x+lambda*(10*x+6*y) = 0

Eq2 := 2*y+lambda*(6*x+10*y) = 0

Eq3 := 5*x^2+6*x*y+5*y^2-8 = 0

Sol := {lambda = (-1)/2, x = -RootOf(_Z^2-2), y = RootOf(_Z^2-2)}, {lambda = (-1)/8, x = RootOf(2*_Z^2-1), y = RootOf(2*_Z^2-1)}

> ### WARNING: allvalues now returns a list of symbolic values instead of a sequence of lists of numeric values
Sol:=`union`(allvalues({Sol}));

Sol := {{lambda = (-1)/2, x = 2^(1/2), y = -2^(1/2)}, {lambda = (-1)/2, x = -2^(1/2), y = 2^(1/2)}, {lambda = (-1)/8, x = 1/2*2^(1/2), y = 1/2*2^(1/2)}, {lambda = (-1)/8, x = -1/2*2^(1/2), y = -1/2*2^...

> Points_C:=Listage(Sol);

Points_C := [2^(1/2), -2^(1/2)], [-2^(1/2), 2^(1/2)], [1/2*2^(1/2), 1/2*2^(1/2)], [-1/2*2^(1/2), -1/2*2^(1/2)]

Calculs des valeurs de la fonction f en ces points.

> printf(`\n                   Points tester          |  Valeurs de f   |\n`);
seq(printf("%40a    |  %8a       |\n", [Points_C][k],f(op(1,op(k,[Points_C])),op(2,op(k,[Points_C])))),k=1..nops([Points_C]));

                  Points tester          |  Valeurs de f   |
                    [2^(1/2), -2^(1/2)]    |         4       |

                    [-2^(1/2), 2^(1/2)]    |         4       |

             [1/2*2^(1/2), 1/2*2^(1/2)]    |         1       |

           [-1/2*2^(1/2), -1/2*2^(1/2)]    |         1       |

>

Reste alors conclure.

Avec la contrainte 5*x^2+6*x*y+5*y^2 = 8 , la valeur maximale de f(x, y) est 4 et la valeur minimale de f(x, y) est 1:

Ainsi,   la valeur maximale de D^2 est 4 et la valeur minimal de D^2 est 1.

           la valeur maximale de D est 2 et la valeur minimale de D est 1.

Donc, les distances maximum et minimum entre l'origine et la courbe d'quation 5*x^2+6*x*y+5*y^2 = 8 , sont respectivement 2 et 1.

La macro-commande extrema

La macro-commande extrema de la bibliothque principale applique la mthode des multiplicateurs de Lagrange pour optimiser une fonction avec une contrainte d'galit. Pour la rendre disponible (en Maple V), il est ncessaire d'excuter un readlib ou bien la rendre disponible via l'extension student.

> with(student);

[D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar, completesquare, distance, equate, integrand, intercept, intparts, leftbox, leftsum, makeproc, middlebox, middlesum, midpoi...[D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar, completesquare, distance, equate, integrand, intercept, intparts, leftbox, leftsum, makeproc, middlebox, middlesum, midpoi...

Illustrons l'usage de cette macro-commande qui automatise la recherche des optima de f(x, y) = 2*x^2-y+y^2+5 avec la contrainte g(x, y) = x^2+y^2-1 .

> f:=(x,y)->2*x^2-y+y^2+5;
g:=(x,y)->x^2+y^2-1;

f := proc (x, y) options operator, arrow; 2*x^2-y+y^2+5 end proc

g := proc (x, y) options operator, arrow; x^2+y^2-1 end proc

> extrema(f(x,y),g(x,y)=0);

{5, 29/4}

Pour obtenir le dtail des couples (x,y) permettant d'atteindre ces optima  (avec la contrainte en cause), il faut donner la macro-commande deux arguments supplmentaires. D'abord l'ensemble des variables impliques dans les quations et un nom Maple pointant vers l'ensemble-solution du systme d'quation que cette macro-commande rsoud. Il est recommand de mettre entre apostrophes droits ce nom car ce nom devient une variable informatique.

> extrema(f(x,y), g(x,y)=0, {x,y}, 'Sol');

{5, 29/4}

> Sol;

{{y = 1, x = 0}, {y = -1, x = 0}, {x = 1/2*RootOf(_Z^2-3, label = _L13), y = (-1)/2}}

Pour obtenir explicitement l'ensemble-solution, on utilisera la macro-commande allvalues.

> `union`(allvalues(Sol));

{{y = 1, x = 0}, {y = -1, x = 0}, {x = 1/2*3^(1/2), y = (-1)/2}, {x = -1/2*3^(1/2), y = (-1)/2}}

>

ATTENTION:  Pour obtenir une approximation dcimale de chaque lment de solution dans le cas o les racines sont formules avec la macro-commande RootOf, il faut noncer la requte evalf(allvalues(Sol)) et non pas evalf(Sol).

> evalf(Sol);
evalf(allvalues(Sol));

{{y = 1., x = 0.}, {y = -.5000000000, x = .8660254040}, {x = 0., y = -1.}}

{{y = 1., x = 0.}, {y = -.5000000000, x = .8660254040}, {x = 0., y = -1.}}, {{y = 1., x = 0.}, {x = 0., y = -1.}, {y = -.5000000000, x = -.8660254040}}

>