Minimum d'une fonction

ccapucine

Bonjour,

j'ai du mal à trouver le min de la fonction suivante.

$$\frac{-(k+s_1)+\sqrt{(k+s_1)^2+(abU_0+x)}}{-u+\sqrt{u^2+4D(h+s_2+\nu_x-\frac{hk\nu_x}{x})}  } D,  \qquad\text{où}\quad\nu_x=\frac{-(k+s_1)+\sqrt{(k+s_1)^2+(abU_0+x)}}{2},$$ avec $a=0.01,\ b=800,\ s_1=s_2=1,\ U_0=1,\ k=1,\ h=0.001,\ D=0.001, \ u=1$.

J'ai essayé de faire un graphe avec Google mais je pense que j'ai mélangé tous les termes de cette fonction.

Merci d'avance pour votre aide.

[Merci à Chaurien et Mister Da pour l'aide apportée dans la correction du $\LaTeX$. AD]

ccapucine

Merci Mister Da!

D est au numérateur

Mister Da

Bonjour,

et c'est quoi les variables finalement ? $x$ et $u$ ?

Cordialement,

Mister Da

ccapucine

u=1 la variable est x

YvesM

Bonjour
La fonction est positive ou nulle puisque le numérateur et le dénominateur sont positifs ou nuls.
Le minimum est donc $0$ si cette fonction s’annule. Or, pour $ab U_0+x=0$, elle s’annule. 

Le minimum est donc $0$ en $x=-a b U_0.$

ccapucine

Est-ce qu'on peut voir son graphe? J'ai essayé de le faire avec Google mais à chaque fois j'ai un graphe différent

Mister Da

Bonjour,

ah ok, $u=1$ ce n'était pas précisé. Sommes-nous d'accord pour dire que le numérateur est tout simplement $2D\nu_x$ ?

En m'écartant un peu de $0$ j'obtiens le graphe suivant mais j'ai programmé vite, le trait vertical est un artefact. C'est ce que tu attends ?

Cordialement,

Mister Da

ccapucine

S'il vous plait, dans le cas où $u=\dfrac{H^2}{2}$ où H=0.001,

Mister Da

Bonjour,

voilà et j'arrête ici.

Cordialement,

Mister Da

ccapucine

Merci beaucoup Mister Da !

Donc le min est 0.017 ! C'est le résultat auquel je m'attendais !

S'il vous plaît j'aimerais savoir quel logiciel vous avez utilisé pour faire ce graphe. Ce n'est pas GeoGebra?

Mister Da

Bonjour,

heuu, $0,017$ ah ?

J'ai fait ça sous Matlab car c'était le logiciel qui était ouvert à ce moment là, mais tu peux faire la même chose gratuitement avec Octave, Scilab, python, libre office calc, etc

Cordialement,

Mister Da

ccapucine

oui parce qu'on cherche le min sur les x positifs. Du coup c'est $0.017$. Vous n'êtes pas d'accord?

gerard0

Le trait vertical étant un trait de raccord entre le dernier point d'abscisse négative et le premier d'abscisse positive, le minimum pour x>0 est nettement différent de 0,17.

ccapucine

Alors quel le min pour $x>0$?

gerard0

Refais tracer seulement sur les positifs, puis regarde.

Ça ne prouvera rien (un traceur se contente de relier des points approximativement sur la courbe), mais te donnera une idée.

Cordialement.

Mister Da

Bonjour

"parce qu'on cherche le min sur les x positifs"

après avoir deviné la formule, après avoir deviné que $u=1$ puis finalement $H^2/2$ il aurait fallu également deviner que le domaine de définition de la fonction était $\mathbb{R}^*_+$.

Bref, en traçant pour $10^{-3}\leq x\leq 0,25$ voici ce que l'on obtient.

On est déjà sur des grandes valeurs de $0,017$ quand même. Numériquement je trouve $0,0177$ comme minimum.

Cordialement,

Mister Da

gerard0

Le minimum sur $\mathbb R$ a été donné dans ce message de YvesM.

ccapucine

Bonjour,

non le domaine de définition n'est pas $\mathbb{R}_+^*$ c'est bien $\mathbb{R}$. Mais on cherche le min pour les x positifs.

C'est réglé maintenant merci beaucoup !

Pour le $u$, il est constant et on compare les graphiques pour différentes valeurs de $u$, c'est pour ça que c'était $u=1$ puis $u=H/2$.

S'il vous plaît, pouvez-vous poster le code du graphique ? Car j'aurai besoin des graphes pour $u=-0.5$, $u=-1$ et $u=-2$. Afin de comparer entre eux.

Je vous remercie pour toute votre aide.

Mister Da

Bonjour

close all;clear all;clc;
a = 0.01; b=800; s1=1; s2=1; U0=1; k=1; h=0.001; D=0.001; H = 0.001; u=H^2/2;
V =@(x)  (-(k+s1) + sqrt((k+s1)^2+a*b*U0+x) )/2; F =@(x)  2*D*V(x)./(-u+sqrt(u^2+4*D*(h+s2+V(x)-h*k*V(x)./x)));
x = linspace(0.001,1,1000);
plot(x,F(x));
grid on;

Cordialement,

Mister Da

ccapucine

Merci beaucoup!

Je ne comprends pas la présence de @ ?

Est-ce qu'on peut l'utiliser directement avec Scilab? (Je n'ai pas MatLab).

Merci beaucoup encore une fois.

ccapucine

Comment adapter ce code pour qu'il fonctionne avec Scilab? Stp

ccapucine

J'ai essayé d'utiliser MatLab en ligne mais il me signale qu'il y a une erreur dans la fonction

Rescassol

Bonjour
Compte les parenthèses !!!!
D'autre part, pour tester moi-même dans Matlab, je veux bien copier/coller mais pas me taper le recopiage d'une image.
Cordialement,
Rescassol

ccapucine

Rascacol

voici le code qu'a envoyé Mister Da

par ailleurs je ne comprends pas la présence de @

close all;clear all;clc;
a = 0.01; b=800; s1=1; s2=1; U0=1; k=1; h=0.001; D=0.001; H = 0.001; u=H^2/2;
V=@(x)  (-(k+s1) + sqrt((k+s1)^2+a*b*U0+x) )/2; F =@(x)  2*D*V(x)./(-u+sqrt(u^2+4*D*(h+s2+V(x)-h*k*V(x)./x)));
x = linspace(0.001,1,1000);
plot(x,F(x))
grid on

ccapucine

C'est bon ca marche!

Merci beaucoup! Merci infiniment pour votre aide

Rescassol

Bonjour,

Mon pseudo n'est pas "Rascacol".
Si tu recopies avec autant d'attention les codes, je comprends que tu aies des problèmes.

Cordialement,
Rescassol

Rescassol

Bonsoir
C'était l'ancienne manière de déclarer les foncions en ligne $V$ et $F$.
Avec un Matlab plus récent, ceci donne le même résultat:

close all;clear all;clc;
syms x
a = 0.01; b=800; s1=1; s2=1; U0=1; k=1; h=0.001; D=0.001; H = 0.001; u=H^2/2;
V(x)=(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x) )/2; F(x)=2*D*V(x)./(-u+sqrt(u^2+4*D*(h+s2+V(x)-h*k*V(x)./x)));
x = linspace(0.001,1,1000);
plot(x,F(x))
grid on

Je précise que j'ai aussi la bibliothèque "Symbolic Math Toolbox".

Cordialement,
Rescassol

paul18

Il y a longtemps que je n'avais pas fait ça, et cela a été un prétexte pour m'y remettre 
Scilab dispose de modules d'optimisation pour rechercher des minimums locaux ou globaux; j'ai choisi ici la méthode de Nelder-Mead qui est une solution aux problèmes bornés.
 La fonction n'est pas définie en zéro, et j'ai eu la flemme de calculer la borne inférieure en fonction des variables a, b, S1, etc; en toute rigueur il faudrait la calculer sous peine d'avoir une message du genre "optimbase_function : Type erroné de l'argument de sortie n°1 de la fonction utilisateur: Une matrice réelle attendue." quand Scilab retourne un complexe (décommenter tmp pour x=1e-7).
Le code ci-dessous permet de trouver un minimum à f=0.0177282 pour  x=0.0525404

mode(0); clear all;

// fonction à minimiser
function [f, index]=fct(x, index, a, b, s1, s2, U0, k, h, D, H, u)
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2;
    f = 2*D*Vx/(-u + sqrt(u^2 + 4*D*(h + s2 + Vx - h*k*Vx/x)));
endfunction

// paramètres
a = 0.01; 
b = 800.; 
s1 = 1.; 
s2 = 1.; 
U0 = 1.; 
k = 1.; 
h = 0.001; 
D = 0.001; 
H = 0.001; 
u = H^2/2.;

//x = 1e-7
//tmp = fct(x, a, b,s1, s2, U0, k, h, D, H, u)
//abort

// optimisation
Precision = 1e-6;
Valeur_initiale = [10.];
Borne_inf = [0.001];
Borne_sup = [1000.];

nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",1);
nm = neldermead_configure(nm,"-function",list(fct, a, b,s1, s2, U0, k, h, D, H, u));
nm = neldermead_configure(nm,"-x0",Valeur_initiale );
nm = neldermead_configure(nm,"-tolfunrelative", Precision);
nm = neldermead_configure(nm,"-tolxrelative", Precision);
nm = neldermead_configure(nm,"-maxiter",1000); 
nm = neldermead_configure(nm,"-maxfunevals",1000); 
nm = neldermead_configure(nm,"-boundsmin",Borne_inf);
nm = neldermead_configure(nm,"-boundsmax", Borne_sup);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-verbose",1);
nm = neldermead_search(nm);

// récupération des résultats
xopt = neldermead_get(nm,"-xopt");
fopt = neldermead_get(nm,"-fopt");
nm = neldermead_destroy(nm);

printf("Minimum : %g\n",xopt);
printf("Valeur fonction ; %g\n",fopt);

Mister Da

Bonjour,

@ccapucine, si jamais tu veux faire comme paul18 pour chercher un minimum local sous Matlab avec Nelder-Mead, voici un exemple de syntaxe :

[xmin,fmin] = fminsearch(F,0.1);

où on lui demande de chercher un minimum local autour de $x=0,1$. Par défaut la tolérance est de $10^{-4}$ et on comme résultat $x_\mathrm{min} = 0,0526$ et $f_\mathrm{min} = 0,0177$.

Si tu veux paramétrer avec ta variable $u$ , le mieux est de réécrire la fonction $F$ comme fonction de deux variables $x$ et $u$ d'utiliser la syntaxe

u=H^2/2;
[xmin,fmin] = fminsearch(@(x) F(x,u),0.1);

@Rescassol, je pense (mais je peux me planter) que ta syntaxe est propre à la bibliothèque "Symbolic Math Toolbox". Sans elle, il faut passer par le arobase pour expliquer que la variable est "muette" ou pour parler informaticien, locale à la fonction, même dans les versions récentes.

Cordialement,

Mister Da

Rescassol

Bonsoir,

Oui, Mister Da, tu dois avoir raison pour la bibliothèque.
Si on veut, éviter l'arobase qui est une spécificité Matlab, il faut passer par des fonctions dans des fichiers séparés.

Cordialement,
Rescassol

ccapucine

Quand j'ai essayé de modifier le code Scilab (en mettant k à la place de h dans la fonction),

j'ai tout de suite eu une erreur. Je ne comprends pas pourquoi.

mode(0); 
clear all; 

// fonction à minimiser 
function [f, index]=fct(x, index, a, b, s1, s2, U0, k, h, D, H, u)
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2; 
     f = 2*D*Vx/(-u + sqrt(u^2 + 4*D*(k + s2 + Vx - k^2*Vx/x))); 
endfunction

// paramètres 
a = 0.01; 
b = 800.; 
s1 = 1.;  
s2 = 1.; 
U0 = 1.; 
k = 1.; 
h = 0.001; 
D = 0.001; 
H = 0.001; 
u = H/2.; 
//x = 1e-7
//tmp = fct(x, a, b,s1, s2, U0, k, h, D, H, u)
//abort

// optimisation
Precision = 1e-6;
Valeur_initiale = [10.]; 
Borne_inf = [0.001];
Borne_sup = [1000.]; 
nm = neldermead_new ();
nm = neldermead_configure(nm,"-numberofvariables",1);
nm = neldermead_configure(nm,"-function",list(fct, a, b,s1, s2, U0, k, h, D, H, u));
nm = neldermead_configure(nm,"-x0",Valeur_initiale ); 
nm = neldermead_configure(nm,"-tolfunrelative", Precision);
nm = neldermead_configure(nm,"-tolxrelative", Precision); 
nm = neldermead_configure(nm,"-maxiter",1000); 
nm = neldermead_configure(nm,"-maxfunevals",1000); 
nm = neldermead_configure(nm,"-boundsmin",Borne_inf);
nm = neldermead_configure(nm,"-boundsmax", Borne_sup);
nm = neldermead_configure(nm,"-method","box"); 
nm = neldermead_configure(nm,"-verbose",1);
nm = neldermead_search(nm); 

// récupération des résultats
xopt = neldermead_get(nm,"-xopt");
fopt = neldermead_get(nm,"-fopt"); 
nm = neldermead_destroy(nm); 
printf("Minimum : %g\n",xopt);
printf("Valeur fonction ; %g\n",fopt); 
plot(x,f);

paul18

si l'erreur mentionnée est celle de mon post ("optimbase_function : Type erroné de l'argument de sortie n°1 de la fonction utilisateur: Une matrice réelle attendue.") alors l'explication y est aussi: la valeur initiale borne inférieure est dans un domaine non-défini de la fonction et Scilab retourne un complexe (en optimisation on travaille sur des réels voire des entiers dans certains cas).

Il faut que tu définisses les domaines de validité en fonction de a, b, etc et que tu entres une borne_inf légèrement supérieure (de $10^{-3}$ par exemple).

En revanche si le nombre de variables est de 2 ou plus, il faut modifier un peu le code (voir dans la doc les exemples)

paul18

Toujours la même flemme, avec quelques modifications mineures.

mode(0);
clear all;
// fonction à minimiser
function [f, index]=fct(x, index, a, b, s1, s2, U0, k, h, D, H, u) 
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2;
    f = 2*D*Vx/(-u + sqrt(u^2 + 4*D*(k + s2 + Vx - k^2*Vx/x)));
endfunction

// paramètres
a = 0.01;
b = 800.;
s1 = 1.;
s2 = 1.;
U0 = 1.;
k = 1.;
h = 0.001;
D = 0.001;
H = 0.001;
u = H/2.;
//x = 1e-7
//tmp = fct(x, a, b,s1, s2, U0, k, h, D, H, u)
//abort
// optimisation 
Precision = 1e-6; 
Valeur_initiale = [10.];
Borne_inf = [1.]; 
Borne_sup = [1000.];

nm = neldermead_new (); nm = neldermead_configure(nm,"-numberofvariables",1);
nm = neldermead_configure(nm,"-function",list(fct, a, b,s1, s2, U0, k, h, D, H, u));
nm = neldermead_configure(nm,"-x0",Valeur_initiale );
nm = neldermead_configure(nm,"-tolfunrelative", Precision);
nm = neldermead_configure(nm,"-tolxrelative", Precision);
nm = neldermead_configure(nm,"-maxiter",1000);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-boundsmin",Borne_inf);
nm = neldermead_configure(nm,"-boundsmax", Borne_sup);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-verbose",1); nm = neldermead_search(nm);
// récupération des résultats 
xopt = neldermead_get(nm,"-xopt");
fopt = neldermead_get(nm,"-fopt");
nm = neldermead_destroy(nm);
printf("Minimum : %g\n",xopt); printf("Valeur fonction ; %g\n",fopt);

//
function g=fct_plot(x, a, b, s1, s2, U0, k, h, D, H, u) 
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2;
    g = 2*D*Vx./(-u + sqrt(u^2 + 4*D*(k + s2 + Vx- k^2*Vx./x)));
endfunction
x = linspace(Borne_inf, 10*Borne_inf, 1000)';
plot(x,fct_plot(x));

Mister Da

Bonjour,

voici un dernier tracé de la fonction avec $0.001\leq x \leq 0.05$ et $-2\leq u \leq H^2/2$. Pour chaque $u$ fixé, on cherche le minimum de la fonction selon $x$ (j'ai utilisé la fonction fminbnd de Matlab qui permet de chercher sur tout un intervalle plutôt que fminsearch qui ne fait une recherche qu'au voisinage d'un point. Le résultat est la courbe rouge.

Cordialement,

Mister Da

ccapucine

Bonjour,

j'ai essayé de calculer le min de la fonction modifiée qui suit avec le code de Paul, puis j'ai essayé de faire ça avec Matlab

et je n'obtiens pas le même résultat

$$\frac{-(k+s_1)+\sqrt{(k+s_1)^2+(abU_0+x)}}{-u+\sqrt{u^2+4D(k+s_2+\nu_x-\frac{k^2\nu_x}{x})}  } D,  \qquad\text{où}\quad\nu_x=\frac{-(k+s_1)+\sqrt{(k+s_1)^2+(abU_0+x)}}{2},$$ avec $a=0.01,\ b=800,\ s_1=s_2=1,\ U_0=1,\ k=1.$

Mister Da

Bonjour,

vu l'avertissement il faudrait que tu vérifies le signe des quantités sous les racines carrées.

Cordialement,

Mister Da

paul18

Bonjour
Un petit bout de code Scilab qui devrait être utile pour définir automatiquement la borne inférieure du domaine d'étude (cela peut changer selon les constantes je suppose). La capture d'écran montre bien que les valeurs deviennent réelles aux alentours de $x=0.274$.

(La mémoire du précédent code n'était pas vidée, d'où des erreurs - j'ai apporté quelques modifications entre-temps)

Paul

 

mode(0);
clear all;

// #######################
// Remarques:
// on démontre facilement la racine du numérateur > 0 pour tout x > 0
// idem pour Vx
// Nul est la valeur qui annule le dénominateur
// Val_racine => la racine du dénominateur >= 0
// Nul > Val_racine => borne inférieure = Nul

// paramètres
a = 0.01;
b = 800.;
s1 = 1.;
s2 = 1.;
U0 = 1.;
k = 1.;
h = 0.001;
D = 0.001;
H = 0.001;
u = H/2.;

//
// calculs de vérification
function [g, Vx]=fct_plot(x, a, b, s1, s2, U0, k, h, D, H, u) 
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2;
    g = 2*D*Vx./(-u + sqrt(u^2 + 4*D*(k + s2 + Vx- k^2*Vx./x)));
endfunction

// Etape 1 : on supprime les valeurs complxes
x = linspace(0.01, 10., 2000.)';
[g, Vx] = fct_plot(x, a, b, s1, s2, U0, k, h, D, H, u);

n = size(g,'*')
gprime = zeros(n)
for i = 1:n
    gprime(i) = isreal(g(i));
end

gprime = [x gprime];
index = find(gprime(:,2) == 0);
gprime(index,:)= [];

// Etape 2 : on définit la borne inf
Borne_inf = min(gprime); 
x = linspace(Borne_inf, 30.*Borne_inf, 2000)';
[g, Vx] = fct_plot(x, a, b, s1, s2, U0, k, h, D, H, u);

// Etape 3 : Vérification
Nul = (k^2*Vx)./(k+s2+Vx);
Val_racine = (k^2*Vx)./(k+s2+Vx+0.25*u^2/D);

scf(1); clf;
subplot(2,2,1), plot(x,g), title("g");
subplot(2,2,2), plot(x,Vx), title("Vx");
subplot(2,2,3), plot(x,Nul), title("dénominateur nul");
subplot(2,2,4), plot(x,Val_racine), title("Racine dénominateur => 0");
sda();

// #####################
// fonction à minimiser
function [f, index]=fct(x, index, a, b, s1, s2, U0, k, h, D, H, u) 
    Vx =(-(k+s1) + sqrt((k+s1)^2+a*b*U0+x))/2;
    f = 2*D*Vx/(-u + sqrt(u^2 + 4*D*(k + s2 + Vx - k^2*Vx/x)));
endfunction

// optimisation 
Precision = 1e-4; 
Valeur_initiale = [10.];
//Borne_inf = [1.]; 
Borne_sup = [1000.];

nm = neldermead_new (); nm = neldermead_configure(nm,"-numberofvariables",1);
nm = neldermead_configure(nm,"-function",list(fct, a, b,s1, s2, U0, k, h, D, H, u));
nm = neldermead_configure(nm,"-x0",Valeur_initiale );
nm = neldermead_configure(nm,"-tolfunrelative", Precision);
nm = neldermead_configure(nm,"-tolxrelative", Precision);
nm = neldermead_configure(nm,"-maxiter",1000);
nm = neldermead_configure(nm,"-maxfunevals",1000);
nm = neldermead_configure(nm,"-boundsmin",Borne_inf);
nm = neldermead_configure(nm,"-boundsmax", Borne_sup);
nm = neldermead_configure(nm,"-method","box");
nm = neldermead_configure(nm,"-verbose",1); nm = neldermead_search(nm);
// récupération des résultats 
xopt = neldermead_get(nm,"-xopt");
fopt = neldermead_get(nm,"-fopt");
nm = neldermead_destroy(nm);

printf("#########\n");
printf("Minimum pour x = %g\n",xopt); 
printf("Valeur minimum fonction : f= %g\n",fopt);

printf("###################################################\n")
printf("La borne inférieure est égale à %g\n", Borne_inf);
printf("###################################################\n")

ccapucine

Bonsoir,

Donc, la borne inf est égale à 0.274876?  S'il vous plaît

ccapucine

Du coup le min est: 0.0179 ? C'est bien ça?

paul18

Résumons la situation:

• j'utilise ici l'algorithme de Nelder-Mead (optimisation) pour chercher le minimum (local) d'une fonction $f$,
• il n'y a ici qu'une seule variable, mais il pourrait y en avoir plusieurs (>3)
• le problème est ici borné, c'est-à-dire qu'on restreint la recherche du minimum entre les borne_inf et borne_sup, bornes qui seront testées
• on spécifie un point de départ (valeur_initiale) et l'algorithme peut balayer l'intervalle spécifié à la recherche d'un minimum.

Or comme tu as pu le constater, Scilab ou Matlab retourne un complexe si $x<0.27$ (fonction non définie - je te renvoie à ton dernier message du 06 janvier), et l'optimiseur n'accepte que des réels: l'idée est de chercher automatiquement la valeur de la borne_inf qui ne fera pas planter le programme.

Le minimum de la fonction reste $f=0.017$ pour $x=1.56$.

Si tu modifies les constantes $a$, $b$, $s1$, etc (dans un certaine mesure), le programme devrait aller jusqu'à fournir un minimum sans message d'erreur.

J'espère avoir été un peu plus clair.

ccapucine

Merci beaucoup pour tout!